Swift4.2_基础语法（上）

官方文档

1.基础语法:

• 常量和变量（Constants and Variables）

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0
var x = 0.0, y = 0.0, z = 0.0

NOTE
If a stored value in your code won’t change, always declare it as a constant with the let keyword. Use variables only for storing values that need to be able to change.

• 类型标注 (Type Annotations)

var welcomeMessage: String
var red, green, blue: Double

• 命名常量和变量 (Naming Constants and Variables)
  Constant and variable names can contain almost any character, including Unicode characters:

let π = 3.14159
let 你好 = "你好世界"
let  = "dogcow"

You can change the value of an existing variable to another value of a compatible type. In this example, the value of friendlyWelcome is changed from "Hello!" to "Bonjour!":

var friendlyWelcome = "Hello!"
friendlyWelcome = "Bonjour!"
// friendlyWelcome is now "Bonjour!"

Unlike a variable, the value of a constant can’t be changed after it’s set. Attempting to do so is reported as an error when your code is compiled:

let languageName = "Swift"
languageName = "Swift++"
// This is a compile-time error: languageName cannot be changed.

• 输出常量和变量 (Printing Constants and Variables)

print(friendlyWelcome)
// Prints "Bonjour!"
print("The current value of friendlyWelcome is \(friendlyWelcome)")
// Prints "The current value of friendlyWelcome is Bonjour!"

• 注释 (Comments)

// This is a comment.

/* This is also a comment
but is written over multiple lines. */

/* 这是第一个多行注释的开头
/* 这是第二个被嵌套的多行注释 */
  这是第一个多行注释的结尾 */

• 分号（Semicolons）

let cat = ""; print(cat)
// Prints ""

• 整数（Integers）

整数就是没有小数部分的数字，比如 42和 -23 。整数可以是 有符号（正数、零和负数）或者无符号（正数、零）。

Swift 提供了8，16，32和64位的有符号和无符号整数类型。这些整数类型和 C 语言的命名方式很像，比如8位无符号整数类型是UInt8，32位有符号整数类型是Int32。就像 Swift 的其他类型一样，整数类型采用大写命名法。

• 整数范围 (Integer Bounds)

 let minValue = UInt8.min  // minValue 为 0，是 UInt8 类型
 let maxValue = UInt8.max  // maxValue 为 255，是 UInt8 类型

• Int

大多数情况下，你不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型Int，长度与当前平台的原生字长相同：

在32位平台上，Int和Int32长度相同。
在64位平台上，Int和 Int64长度相同。

除非你需要特定长度的整数，一般来说使用 Int就够了。这可以提高代码一致性和可复用性。即使是在32位平台上，Int 可以存储的整数范围也可以达到-2,147,483,648 ~ 2,147,483,647，大多数时候这已经足够大了。

• UInt

Swift也提供了一个特殊的无符号类型 UInt，长度与当前平台的原生字长相同：

在32位平台上，UInt 和 UInt32长度相同。
在64位平台上，UInt 和 UInt64长度相同。

Note：尽量不要使用UInt，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用Int，即使你要存储的值已知是非负的。统一使用Int可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推断，请参考类型安全和类型推断。

• 浮点数 (Floating-Point Numbers)
  浮点数是有小数部分的数字，比如 3.14159，0.1 和 -273.15。
  浮点类型比整数类型表示的范围更广，可以存储比Int
  类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：

  Double表示64位浮点数。
  Float表示32位浮点数。

  Note：Double精确度很高，至少有15位数字，而Float只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围，在两种类型都可以选择的情况下，将优先选择Double。

• 类型安全和类型推断 (Type Safety and Type Inference)

Swift 是一个类型安全（type-safe）的语言。类型安全的语言可以让你清楚地知道代码要处理的值的类型。如果你的代码需要一个String，你绝对不可能错误地传进去一个Int。

由于 Swift 是类型安全的，所以它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。

当你要处理不同类型的值时，类型检查可以帮你避免错误。然而，这并不是说你每次声明常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使用类型推断（type inference）来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。

let meaningOfLife = 42// meaningOfLife 会被推测为 Int 类型
let pi = 3.14159// pi 会被推测为 Double 类型
let anotherPi = 3 + 0.14159  // anotherPi 会被推测为 Double 类型

• 数值型字面量 (Numeric Literals)

整数字面量可以被写作：
一个十进制数，没有前缀
一个二进制数，前缀是0b
一个八进制数，前缀是0o
一个十六进制数，前缀是0x
下面的所有整数字面量的十进制值都是17

let decimalInteger = 17
let binaryInteger = 0b10001   // 二进制的17
let octalInteger = 0o21   // 八进制的17
let hexadecimalInteger = 0x11   // 十六进制的17

浮点字面量可以是十进制（没有前缀）或者是十六进制（前缀是 0x ）。小数点两边必须有至少一个十进制数字（或者是十六进制的数字）。十进制浮点数也可以有一个可选的指数（ exponent)，通过大写或者小写的 e来指定；十六进制浮点数必须有一个指数，通过大写或者小写的 p来指定。如果一个十进制数的指数为 exp，那这个数相当于基数和 10^exp的乘积：

1.25e2 表示 1.25 × 10^2，等于 125.0
1.25e-2 表示 1.25 × 10^-2，等于 0.0125

如果一个十六进制数的指数为exp，那这个数相当于基数和2^exp的乘积：

0xFp2 表示 15 × 2^2，等于 60.0
0xFp-2 表示 15 × 2^-2，等于 3.75

下面的这些浮点字面量都等于十进制的 12.1875：

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0

数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量：

let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1

• 数值型类型转换 (Numeric Type Conversion)

通常来讲，即使代码中的整数常量和变量已知非负，也请使用Int类型。总是使用默认的整数类型可以保证你的整数常量和变量可以直接被复用并且可以匹配整数类字面量的类型推断。

只有在必要的时候才使用其他整数类型，比如要处理外部的长度明确的数据或者为了优化性能、内存占用等等。使用显式指定长度的类型可以及时发现值溢出并且可以暗示正在处理特殊数据。

• 整数转换 (Integer Conversion)

不同整数类型的变量和常量可以存储不同范围的数字。Int8类型的常量或者变量可以存储的数字范围是-128 ~ 127，而UInt8类型的常量或者变量能存储的数字范围是0~255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：

let cannotBeNegative: UInt8 = -1// UInt8 类型不能存储负数，所以会报错
let tooBig: Int8 = Int8.max + 1// Int8 类型不能存储超过最大值的数，所以会报错

由于每种整数类型都可以存储不同范围的值，所以你必须根据不同情况选择性使用数值型类型转换。这种选择性使用的方式，可以预防隐式转换的错误并让你的代码中的类型转换意图变得清晰。

为了将一种数字类型转换成另一种，你要用当前值来初始化一个期望类型的新数字，这个数字的类型就是你的目标类型。在下面的例子中，常量twoThousand是UInt16类型，然而常量one是UInt8类型。它们不能直接相加，因为它们类型不同。所以要调用UInt16(one)来创建一个新的UInt16数字并用one的值来初始化，然后使用这个新数字来计算：

  let twoThousand: UInt16 = 2_000
  let one: UInt8 = 1
  let twoThousandAndOne = twoThousand + UInt16(one)

• 整数和浮点数转换 (Integer and Floating-Point Conversion)

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine  // pi 等于 3.14159，所以被推测为 Double 类型

let integerPi = Int(pi)// integerPi 等于 3，所以被推测为 Int 类型

当用浮点类型来初始化一个新的整数值时，浮点值会被截断。也就是说 4.75会变成 4，-3.9会变成-3。

• 类型别名 (Type Aliases)

类型别名type aliases就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。

当你想要给现有类型起一个更合适的名字时，类型别名非常有用。比如你正在处理特定长度的外部资源的数据：

typealias AudioSample = UInt16

定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名：

var maxAmplitudeFound = AudioSample.min// maxAmplitudeFound 现在是 0

• 布尔值 (Booleans)

Swift有一个基本的布尔Boolean类型，叫做Bool。布尔值指逻辑上的值，因为它们只能是真或者假。Swift有两个布尔常量，true和false：

let orangesAreOrange = true
let turnipsAreDelicious = false

初始化常量或者变量的时候如果所赋的值类型已知，就可以触发类型推断，这让 Swift 代码更加简洁并且可读性更高。当你编写条件语句比如 if 语句的时候，布尔值非常有用：

if turnipsAreDelicious {
    print("Mmm, tasty turnips!")
} else {
    print("Eww, turnips are horrible.")
}
// Prints "Eww, turnips are horrible."

如果你在需要使用Bool类型的地方使用了非布尔值，Swift 的类型安全机制会报错。下面的例子会报告一个编译时错误：

let i = 1
if i {
    // this example will not compile, and will report an error
}

然而，下面的例子是合法的：

let i = 1
if i == 1 {
    // this example will compile successfully
}

• 元组 (Tuples)

元组tuples把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。

下面这个例子中，(404, "Not Found")是一个描述 HTTP 状态码HTTP status code的元组。HTTP 状态码是当你请求网页的时候 web 服务器返回的一个特定值。如果你请求的网页不存在就会返回一个 404 Not Found 状态码。

let http404Error = (404, "Not Found")
// http404Error is of type (Int, String), and equals (404, "Not Found")

404,"Not Found"元组把一个 Int 值和一个String值组合起来表示HTTP状态码的两个部分：一个数字和一个人类可读的描述。这个元组被定义为“一个类型为 (Int, String)的元组”。
你可以把任意顺序的类型组合成一个元组，这个元组可以包含所有类型。你可以创建任何一个类型为(Int, Int, Int)或者 (String, Bool) 或者其他任何你想要的组合的元组。你可以将一个元组内容分解（decompose）成单独的常量和变量，然后你就可以正常使用它们了：

let (statusCode, statusMessage) = http404Error
print("The status code is \(statusCode)")
// Prints "The status code is 404"
print("The status message is \(statusMessage)")
// Prints "The status message is Not Found"

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_ ）表示：

let (justTheStatusCode, _) = http404Error
print("The status code is \(justTheStatusCode)")
// Prints "The status code is 404"

此外，你还可以通过下标来访问元组中的单个元素，下标从零开始：

print("The status code is \(http404Error.0)")
// Prints "The status code is 404"
print("The status message is \(http404Error.1)")
// Prints "The status message is Not Found"

你可以在定义元组的时候给单个元素命名：

let http200Status = (statusCode: 200, description: "OK")

给元组中的元素命名后，你可以通过名字来获取这些元素的值：

print("The status code is \(http200Status.statusCode)")
// Prints "The status code is 200"
print("The status message is \(http200Status.description)")
// Prints "The status message is OK"

作为函数返回值时，元组非常有用。一个用来获取网页的函数可能会返回一个(Int, String) 元组来描述是否获取成功。和只能返回一个类型的值比较起来，一个包含两个不同类型值的元组可以让函数的返回信息更有用。