没有合适的资源?快使用搜索试试~ 我知道了~
首页苹果Swift编程语言官方教程
"The Swift Programming Language.pdf 是一份关于苹果公司推出的Swift编程语言的官方文档教程,以英文形式呈现。这份教程旨在介绍Swift编程语言的主要特点、优势以及如何使用它来开发iOS和OSX应用程序。Swift结合了C和Objective-C的优点,同时摒弃了与C兼容性的限制,引入了更安全的编程模式和现代语言特性,使编程过程更加简便、灵活且有趣。"
在Swift编程语言中,有以下几个关键知识点:
1. **安全性**:Swift 强调安全性,通过类型安全(type safety)和内存安全(memory safety)来避免程序中的常见错误。例如,Swift 使用自动引用计数(Automatic Reference Counting, ARC)来管理内存,防止内存泄漏和过早释放。
2. **现代语言特性**:Swift 包含了许多现代编程语言的特性,如可选值(Optionals)、模式匹配(Pattern Matching)、泛型(Generics)、闭包(Closures)、枚举(Enumerations)和结构体(Structures)等,这些特性使得代码更加简洁且易于理解。
3. **与Objective-C的互操作性**:尽管Swift 是一种新的语言,但它与Objective-C有很好的兼容性。开发者可以在同一个项目中混合使用Swift和Objective-C代码,这得益于Swift支持Objective-C的消息传递机制和桥接头文件(Bridging Header)。
4. **Playgrounds**:Swift 提供了Playgrounds功能,这是一个实时的编程环境,允许开发者在不需编译的情况下快速测试代码,极大地提高了开发效率和学习过程的互动性。
5. **模块系统**:Swift 的模块系统使得代码组织更加有序,方便代码重用和库的构建。每个独立的源文件都可以视为一个模块,通过导入(import)语句可以访问其他模块的公共接口。
6. **Swift Package Manager**:为了管理和分发Swift代码,苹果提供了Swift Package Manager,它是语言的一部分,可以用来创建、管理和分享软件包,简化依赖管理。
7. **SwiftUI**:随着Swift的发展,苹果推出了SwiftUI框架,这是一套用于构建iOS、macOS、watchOS和tvOS用户界面的声明式编程工具,让开发者可以更直观地描述UI设计,而无需关心底层实现细节。
8. **持续更新和社区支持**:Swift 语言持续进行版本迭代,不断引入新的特性和优化。此外,Swift有一个活跃的开源社区,贡献了许多第三方库和工具,如Alamofire、SwiftyJSON等,丰富了Swift的生态系统。
Swift是苹果为未来软件开发打造的新语言,它结合了现代编程的最佳实践,为开发者带来了高效、可靠的编程体验。通过深入学习和掌握Swift,开发者可以更好地构建高质量的iOS和OSX应用。
Type Aliases
Type aliases
define an alternative name for an existing type. You define type aliases with the typealias keyword.
Type aliases are useful when you want to refer to an existing type by a name that is contextually more appropriate, such as when working with data of a specific size from an external source:
typealias AudioSample = UInt16
Once you define a type alias, you can use the alias anywhere you might use the original name:
1 v ar maxAmplitudeFound = AudioSample.min
2 // maxAmplitudeFound is now 0
Here, AudioSample is defined as an alias for UInt16. Because it is an alias, the call to AudioSample.min actually calls UInt16.min, which provides an initial value of 0 for the maxAmplitudeFound variable.
Booleans
Swift has a basic
Boolean
type, called Bool. Boolean values are referred to as
logical
, because they can only ever be true or false. Swift provides two Boolean constant values, true and false:
1 let orangesAreOrange = true
2 let turnipsAreDelicious = false
The types of orangesAreO range and turnipsAreDelicious have been inferred as Bool from the fact that they were initialized with Boolean literal values. As with Int and Double above, you don’t need to declare constants or variables as Bool if you set
them to true or false as soon as you create them. Type inference helps make Swift code more concise and readable when it initializes constants or variables with other values whose type is already known.
Boolean values are particularly useful when you work with conditional statements such as the if statement:
1 if turnipsAreDelicious {
2 println("Mmm, tasty turnips!")
3 } else {
4 println("Eww, turnips are horrible.")
5 }
6 // prints "Eww, turnips are horrible."
Conditional statements such as the if statement are covered in more detail in Control Flow.
Swift’s type safety prevents non-Boolean values from being be substituted for Bool. The following example reports a compile-time error:
1 let i = 1
2 if i {
3 // this example will not compile, and will report an error
4 }
However, the alternative example below is valid:
1 let i = 1
2 if i == 1 {
3 // this example will compile successfully
4 }
The result of the i == 1 comparison is of type Bool, and so this second example passes the type-check. Comparisons like i == 1 are discussed in Basic Operators.
As with other examples of type safety in Swift, this approach avoids accidental errors and ensures that the intention of a particular section of code is always clear.
Tuples
Tuples
group multiple values into a single compound value. The values within a tuple can be of any type and do not have to be of the same type as each other.
In this example, (404, "Not Found") is a tuple that describes an
HTTP status code
. An HTTP status code is a special value returned by a web server whenever you request a web page. A status code of 404 Not Found is returned if you request a
webpage that doesn’t exist.
1 let http404Error = (404, "Not Found")
2 // http404Error is of type (Int, String), and equals (404, "Not Found")
The (404, "Not Found") tuple groups together an Int and a String to give the HTTP status code two separate values: a number and a human-readable description. It can be described as “a tuple of type (Int, String)”.
You can create tuples from any permutation of types, and they can contain as many different types as you like. There’s nothing stopping you from having a tuple of type (Int, Int, Int), or (String, Bool), or indeed any other permutation you require.
You can
decompose
a tuple’s contents into separate constants or variables, which you then access as usual:
1 let (statusCode, statusMessage) = http404Error
2 println("The status code is \(statusCode)")
3 // prints "The status code is 404"
4 println("The status message is \(statusMessage)")
5 // prints "The status message is Not Found"
If you only need some of the tuple’s values, ignore parts of the tuple with an underscore (_) when you decompose the tuple:
1 let (justTheStatusCode, _) = http404Error
2 println("The status code is \(justTheStatusCode)")
3 // prints "The status code is 404"
Alternatively, access the individual element values in a tuple using index numbers starting at zero:
1 println("The status code is \(http404Error.0)")
2 // prints "The status code is 404"
3 println("The status message is \(http404Error.1)")
4 // prints "The status message is Not Found"
You can name the individual elements in a tuple when the tuple is defined:
let http200Status = (statusCode: 200, description: "O K")
If you name the elements in a tuple, you can use the element names to access the values of those elements:
1 println("The status code is \(http200Status.statusCode)")
2 // prints "The status code is 200"
3 println("The status message is \(http200Status.description)")
4 // prints "The status message is OK"
Tuples are particularly useful as the return values of functions. A function that tries to retrieve a web page might return the (Int, String) tuple type to describe the success or failure of the page retrieval. By returning a tuple with two distinct values,
each of a different type, the function provides more useful information about its outcome than if it could only return a single value of a single type. For more information, see Functions with Multiple Return Values.
N O T E
Tuples are useful for temporary groups of related v alues. They are not suited to the creation of complex data structures. If your data structure is likely to persist beyond a temporary scope, model it as a class or structure, rather than as a
tuple. For more information, see Classes and Structures.
Optionals
You use
optionals
in situations where a value may be absent. An optional says:
or
N O T E
The concept of optionals doesn’t exist in C or O bjective-C. The nearest thing in O bjective-C is the ability to return nil from a method that would otherwise return an object, with nil meaning “the absence of a valid object.” However, this only
works for objects—it doesn’t work for structs, basic C types, or enumeration v alues. For these types, Objective-C methods typically return a special value (such as NSNotF ound) to indicate the absence of a value. This approach assumes that
the method’s caller knows there is a special value to test against and remembers to check for it. Swift’s optionals let you indicate the absence of a value for
any type at all
, without the need for special constants.
Here’s an example. Swift’s String type has a method called toInt, which tries to convert a String value into an Int value. However, not every string can be converted into an integer. The string "123" can be converted into the numeric value 123, but the
string "hello, world" does not have an obvious numeric value to convert to.
The example below uses the toInt method to try to convert a String into an Int:
1 let possibleNumber = "123"
2 let convertedNumber = possibleNumber.toInt()
3 // convertedNumber is inferred to be of type "Int?", or "optional Int"
Because the toInt method might fail, it returns an
optional
Int, rather than an Int. An optional Int is written as Int?, not Int. The question mark indicates that the value it contains is optional, meaning that it might contain
some
Int value, or it might
contain
no value at all
. (It can’t contain anything else, such as a Bool value or a String value. It’s either an Int, or it’s nothing at all.)
If Statements and Forced Unwrapping
You can use an if statement to find out whether an optional contains a value. If an optional does have a value, it evaluates to true; if it has no value at all, it evaluates to false.
Once you’re sure that the optional
does
contain a value, you can access its underlying value by adding an exclamation mark (!) to the end of the optional’s name. The exclamation mark effectively says, “I know that this optional definitely has a value;
please use it.” This is known as
forced unwrapping
of the optional’s value:
1 if conv ertedNumber {
2 println("\(possibleNumber) has an integer value of \(conv ertedNumber!)")
3 } else {
4 println("\(possibleNumber) could not be conv erted to an integer")
5 }
6 // prints "123 has an integer v alue of 123"
For more on the if statement, see Control Flow.
N O T E
Trying to use ! to access a non-existent optional value triggers a runtime error. Alway s make sure that an optional contains a non-nil value before using ! to force-unwrap its value.
Opt ional Binding
You use
optional binding
to find out whether an optional contains a value, and if so, to make that value available as a temporary constant or variable. Optional binding can be used with if and while statements to check for a value inside an optional,
and to extract that value into a constant or variable, as part of a single action. if and while statements are described in more detail in Control Flow.
Write optional bindings for the if statement as follows:
if let constantName = someOptional {
statements
}
You can rewrite the possibleNumber example from above to use optional binding rather than forced unwrapping:
1 if let actualNumber = possibleNumber.toInt() {
2 println("\(possibleNumber) has an integer value of \(actualNumber)")
3 } else {
4 println("\(possibleNumber) could not be conv erted to an integer")
5 }
6 // prints "123 has an integer v alue of 123"
This can be read as:
“If the optional Int returned by possibleNumber.toInt contains a value, set a new constant called actualNumber to the value contained in the optional.”
There
is
a value, and it equals
x
•
There
isn’t
a value at all•
If the conversion is successful, the actualNumber constant becomes available for use within the first branch of the if statement. It has already been initialized with the value contained
within
the optional, and so there is no need to use the ! suffix to
access its value. In this example, actualNumber is simply used to print the result of the conversion.
You can use both constants and variables with optional binding. If you wanted to manipulate the value of actualNumber within the first branch of the if statement, you could write if var actualNumber instead, and the value contained within the optional
would be made available as a variable rather than a constant.
nil
You set an optional variable to a valueless state by assigning it the special value nil:
1 v ar serv erResponseCode: Int? = 404
2 // serverResponseCode contains an actual Int value of 404
3 serv erResponseCode = nil
4 // serverResponseCode now contains no v alue
N O T E
nil cannot be used with non-optional constants and v ariables. If a constant or v ariable in your code needs to be able to cope with the absence of a value under certain conditions, alway s declare it as an optional value of the appropriate type.
If you define an optional constant or variable without providing a default value, the constant or variable is automatically set to nil for you:
1 v ar surv eyA nswer: String?
2 // surveyA nswer is automatically set to nil
N O T E
Swift’s nil is not the same as nil in Objective-C . In O bjective-C, nil is a pointer to a non-existent object. In Swift, nil is not a pointer—it is the absence of a value of a certain type. Optionals of
any
type can be set to nil, not just object types.
Implicitly Unwrapped Opt ionals
As described above, optionals indicate that a constant or variable is allowed to have “no value”. Optionals can be checked with an if statement to see if a value exists, and can be conditionally unwrapped with optional binding to access the optional’s
value if it does exist.
Sometimes it is clear from a program’s structure that an optional will
always
have a value, after that value is first set. In these cases, it is useful to remove the need to check and unwrap the optional’s value every time it is accessed, because it can be
safely assumed to have a value all of the time.
These kinds of optionals are defined as
implicitly unwrapped optionals
. You write an implicitly unwrapped optional by placing an exclamation mark (String!) rather than a question mark (String?) after the type that you want to make optional.
Implicitly unwrapped optionals are useful when an optional’s value is confirmed to exist immediately after the optional is first defined and can definitely be assumed to exist at every point thereafter. The primary use of implicitly unwrapped optionals in
Swift is during class initialization, as described in Unowned References and Implicitly Unwrapped Optional Properties.
An implicitly unwrapped optional is a normal optional behind the scenes, but can also be used like a nonoptional value, without the need to unwrap the optional value each time it is accessed. The following example shows the difference in behavior
between an optional String and an implicitly unwrapped optional String:
1 let possibleString: String? = "An optional string."
2 println(possibleString!) // requires an exclamation mark to access its value
3 // prints "An optional string."
4
5 let assumedString: String! = "An implicitly unwrapped optional string."
6 println(assumedString) // no exclamation mark is needed to access its value
7 // prints "An implicitly unwrapped optional string."
You can think of an implicitly unwrapped optional as giving permission for the optional to be unwrapped automatically whenever it is used. Rather than placing an exclamation mark after the optional’s name each time you use it, you place an
exclamation mark after the optional’s type when you declare it.
N O T E
If you try to access an implicitly unwrapped optional when it does not contain a value, you will trigger a runtime error. The result is exactly the same as if you place an exclamation mark after a normal optional that does not contain a value.
You can still treat an implicitly unwrapped optional like a normal optional, to check if it contains a value:
1 if assumedString {
2 println(assumedString)
3 }
4 // prints "An implicitly unwrapped optional string."
You can also use an implicitly unwrapped optional with optional binding, to check and unwrap its value in a single statement:
1 if let definiteString = assumedString {
2 println(definiteString)
3 }
4 // prints "An implicitly unwrapped optional string."
N O T E
Implicitly unwrapped optionals should not be used when there is a possibility of a variable becoming nil at a later point. Always use a normal optional type if you need to check for a nil value during the lifetime of a variable.
Assertions
Optionals enable you to check for values that may or may not exist, and to write code that copes gracefully with the absence of a value. In some cases, however, it is simply not possible for your code to continue execution if a value does not exist,
or if a provided value does not satisfy certain conditions. In these situations, you can trigger an
assertion
in your code to end code execution and to provide an opportunity to debug the cause of the absent or invalid value.
Debugging with A ssertions
An assertion is a runtime check that a logical condition definitely evaluates to true. Literally put, an assertion “asserts” that a condition is true. You use an assertion to make sure that an essential condition is satisfied before executing any further
code. If the condition evaluates to true, code execution continues as usual; if the condition evaluates to false, code execution ends, and your app is terminated.
If your code triggers an assertion while running in a debug environment, such as when you build and run an app in Xcode, you can see exactly where the invalid state occurred and query the state of your app at the time that the assertion was
triggered. An assertion also lets you provide a suitable debug message as to the nature of the assert.
You write an assertion by calling the global assert function. You pass the assert function an expression that evaluates to true or false and a message that should be displayed if the result of the condition is false:
1 let age = -3
2 assert(age >= 0, "A person's age cannot be less than zero")
3 // this causes the assertion to trigger, because age is not >= 0
In this example, code execution will continue only if age >= 0 evaluates to true, that is, if the value of age is non-negative. If the value of age
is
negative, as in the code above, then age >= 0 evaluates to false, and the assertion is triggered,
terminating the application.
Assertion messages cannot use string interpolation. The assertion message can be omitted if desired, as in the following example:
assert(age >= 0)
When t o Use A ssertions
Use an assertion whenever a condition has the potential to be false, but must
definitely
be true in order for your code to continue execution. Suitable scenarios for an assertion check include:
See also Subscripts and Functions.
N O T E
Assertions cause your app to terminate and are not a substitute for designing y our code in such a way that inv alid conditions are unlikely to arise. Nonetheless, in situations where inv alid conditions are possible, an assertion is an effective way
to ensure that such conditions are highlighted and noticed during development, before y our app is published.
An integer subscript index is passed to a custom subscript implementation, but the subscript index value could be too low or too high.•
A value is passed to a function, but an invalid value means that the function cannot fulfill its task.•
An optional value is currently nil, but a non-nil value is essential for subsequent code to execute successfully.•
Basic Operators
An
operator
is a special symbol or phrase that you use to check, change, or combine values. For example, the addition operator (+) adds two numbers together (as in let i = 1 + 2). More complex examples include the logical AND operator && (as in if
enteredDoorC ode && passedRetinaScan) and the increment operator ++i, which is a shortcut to increase the value of i by 1.
Swift supports most standard C operators and improves several capabilities to eliminate common coding errors. The assignment operator (=) does not return a value, to prevent it from being mistakenly used when the equal to operator (==) is
intended. Arithmetic operators (+, -, *, /, % and so forth) detect and disallow value overflow, to avoid unexpected results when working with numbers that become larger or smaller than the allowed value range of the type that stores them. You can
opt in to value overflow behavior by using Swift’s overflow operators, as described in Overflow Operators.
Unlike C, Swift lets you perform remainder (%) calculations on floating-point numbers. Swift also provides two range operators (a..b and a...b) not found in C, as a shortcut for expressing a range of values.
This chapter describes the common operators in Swift. Advanced Operators covers Swift’s advanced operators, and describes how to define your own custom operators and implement the standard operators for your own custom types.
Terminology
Operators are unary, binary, or ternary:
The values that operators affect are
operands
. In the expression 1 + 2, the + symbol is a binary operator and its two operands are the values 1 and 2.
Assignment Operator
The
assignment operator
(a = b) initializes or updates the value of a with the value of b:
1 let b = 10
2 v ar a = 5
3 a = b
4 // a is now equal to 10
If the right side of the assignment is a tuple with multiple values, its elements can be decomposed into multiple constants or variables at once:
1 let (x, y) = (1, 2)
2 // x is equal to 1, and y is equal to 2
Unlike the assignment operator in C and Objective-C, the assignment operator in Swift does not itself return a value. The following statement is not valid:
1 if x = y {
2 // this is not valid, because x = y does not return a value
3 }
This feature prevents the assignment operator (=) from being used by accident when the equal to operator (==) is actually intended. By making if x = y invalid, Swift helps you to avoid these kinds of errors in your code.
Arithmetic Operators
Swift supports the four standard
arithmetic operators
for all number types:
1 1 + 2 // equals 3
2 5 - 3 // equals 2
3 2 * 3 // equals 6
4 10.0 / 2.5 // equals 4.0
Unlike the arithmetic operators in C and Objective-C, the Swift arithmetic operators do not allow values to overflow by default. You can opt in to value overflow behavior by using Swift’s overflow operators (such as a &+ b). See Overflow Operators.
The addition operator is also supported for String concatenation:
"hello, " + "world" // equals "hello, world"
Two Character values, or one Character value and one String value, can be added together to make a new String value:
1 let dog: Character = ""
2 let cow: Character = ""
3 let dogCow = dog + cow
4 // dogCow is equal to ""
See also Concatenating Strings and Characters.
Remainder Operator
The
remainder operator
(a % b) works out how many multiples of b will fit inside a and returns the value that is left over (known as the
remainder
).
N O T E
The remainder operator (% ) is also known as a
modulo operator
in other languages. However, its behavior in Swift for negative numbers means that it is, strictly speaking, a remainder rather than a modulo operation.
Here’s how the remainder operator works. To calculate 9 % 4, you first work out how many 4s will fit inside 9:
Unary
operators operate on a single target (such as -a). Unary
prefix
operators appear immediately before their target (such as !b), and unary
postfix
operators appear immediately after their target (such as i++).•
Binary
operators operate on two targets (such as 2 + 3) and are
infix
because they appear in between their two targets.•
Ternary
operators operate on three targets. Like C, Swift has only one ternary operator, the ternary conditional operator (a ? b : c).•
Addition (+)•
Subtraction (-)•
Multiplication (*)•
Division (/)•
剩余168页未读,继续阅读
3843 浏览量
2014-06-04 上传
2024-10-15 上传
2024-10-15 上传
lisqwork
- 粉丝: 4
- 资源: 52
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
最新资源
- C语言快速排序算法的实现与应用
- KityFormula 编辑器压缩包功能解析
- 离线搭建Kubernetes 1.17.0集群教程与资源包分享
- Java毕业设计教学平台完整教程与源码
- 综合数据集汇总:浏览记录与市场研究分析
- STM32智能家居控制系统:创新设计与无线通讯
- 深入浅出C++20标准:四大新特性解析
- Real-ESRGAN: 开源项目提升图像超分辨率技术
- 植物大战僵尸杂交版v2.0.88:新元素新挑战
- 掌握数据分析核心模型,预测未来不是梦
- Android平台蓝牙HC-06/08模块数据交互技巧
- Python源码分享:计算100至200之间的所有素数
- 免费视频修复利器:Digital Video Repair
- Chrome浏览器新版本Adblock Plus插件发布
- GifSplitter:Linux下GIF转BMP的核心工具
- Vue.js开发教程:全面学习资源指南
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功