Swift开发篇 --- 编码规范

1.常量和变量

1.1 声明常量和变量

• 常量和变量必须在使用前声明，用 let 来声明常量，用 var 来声明变量：

  let maximumNumberOfLoginAttempts = 10
  var currentLoginAttempt = 0
  

• 可以在一行中声明多个常量或者多个变量，用逗号隔开：

  var x = 0.0, y = 0.0, z = 0.0
  

  注意：如果代码中有不需要改变的值，请使用 let 关键字将它声明为常量。只将需要改变的值声明为变量。

1.2 类型注解

在声明常量或变量的时候，在常量或变量名后面加上一个冒号和空格，然后加上类型名称：

var welcomeMessage: String = "Heollo"
//一行中定义多个同样类型的变量
var red, green, blue: Double

1.3 常量和变量的命名

• 常量和变量名可以包含任何字符，包括 Unicode 字符：

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

• 常量与变量名不能包含数学符号、箭头、保留的（或者非法的）Unicode 码位、连线与制表符
• 不能以数字开头，但是可以在常量与变量名的其他地方包含数字

1.4 输出常量和变量

可以用 print(_:separator:terminator:) 函数来输出当前常量或变量的值：

print(friendlyWelcome)
// 输出“Bonjour!”

2.注释

2.1 单行注释

// 这是一个注释

2.2 多行注释

/* 这也是一个注释，
但是是多行的 */

2.3 嵌套多行注释

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

3.分号

Swift 并不强制要求在每条语句的结尾处使用分号（;），有一种情况下必须要用分号，即打算在同一行内写多条独立的语句：

let cat = "🐱"; print(cat)
// 输出“🐱”

4.整数

Swift 提供了8、16、32和64位的有符号和无符号整数类型，分别为：

• Int8、Int16、Int32、Int64
• UInt8、UInt16、UInt32、UInt64

一般来说，不需要专门指定整数的长度。Swift 提供了一个特殊的整数类型 Int，长度与当前平台的原生字长相同:

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

除非需要特定长度的整数，一般来说使用 Int 就可以了，可以访问不同整数类型的 min 和 max 属性来获取对应类型的最小值和最大值：

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

5.浮点数

Swift 提供了两种有符号浮点数类型：

• Double 表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。
• Float 表示32位浮点数。精度要求不高的话可以使用此类型。

  Double 精确度很高，至少有 15 位小数，而 Float 只有 6 位小数

6.类型安全和类型推断

• 声明常量或者变量时如果赋初始值，Swift根据初始值判断常量或者变量的类型
• 当推断浮点数的类型时，Swift 总是会选择 Double 而不是 Float
• 如果表达式中同时出现了整数和浮点数，会被推断为 Double 类型

7.数值型字面量

整数字面量可以被写作：

• 一个十进制数，没有前缀
• 一个二进制数，前缀是 0b
• 一个八进制数，前缀是 0o
• 一个十六进制数，前缀是 0x

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

  浮点字面量可以被写作：
• 十进制，没有前缀，可选指数（e）
• 十六进制，前缀是0x，可选指数（p）

  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
  

8.数值型类型转换

8.1 整数转换 SomeType(ofInitialValue)

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

8.2 整数和浮点数转换

整数和浮点数的转换必须显示指定类型：

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

浮点数到整数的反向转换同样行，整数类型可以用 Double 或者 Float 类型来初始化：

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

9.类型别名

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

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

10.布尔值

Swift 有一个基本的布尔（Boolean）类型，叫做 Bool，有两个布尔常量：true 和 false

11.元组

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

  let http404Error = (404, "Not Found")
  // http404Error 的类型是 (Int, String)，值是 (404, "Not Found")
  

• 可以将一个元组的内容分解（decompose）成单独的常量和变量：

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

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

  let (justTheStatusCode, _) = http404Error
  print("The status code is \(justTheStatusCode)")
  // 输出“The status code is 404”
  

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

  print("The status code is \(http404Error.0)")
  // 输出“The status code is 404”
  print("The status message is \(http404Error.1)")
  // 输出“The status message is Not Found”
  

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

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

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

  print("The status code is \(http200Status.statusCode)")
  // 输出“The status code is 200”
  print("The status message is \(http200Status.description)")
  // 输出“The status message is OK”
  

12.可选类型

使用可选类型（optionals）来处理值可能缺失的情况。可选类型表示两种可能：或者有值，你可以解析可选类型访问这个值，或者根本没有值。

let possibleNumber = "123"
let convertedNumber = Int(possibleNumber)
// convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int"

C 和 Objective-C 中并没有可选类型这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回 nil，nil 表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如 NSNotFound）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选类型可以让你暗示任意类型的值缺失，并不需要一个特殊值。

12.1 nil

• 可以给可选变量赋值为 nil 来表示它没有值：

  var serverResponseCode: Int? = 404
  // serverResponseCode 包含一个可选的 Int 值 404
  serverResponseCode = nil
  // serverResponseCode 现在不包含值
  

• 如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为 nil：

  var surveyAnswer: String?
  // surveyAnswer 被自动设置为 nil
  

  注意：Swift 的 nil 和 Objective-C 中的 nil 并不一样。在 Objective-C 中，nil 是一个指向不存在对象的指针。在 Swift 中，nil 不是指针——它是一个确定的值，用来表示值缺失。任何类型的可选状态都可以被设置为 nil，不只是对象类型。

  12.2 if 语句以及强制解析

• 你可以使用 if 语句和 nil 比较来判断一个可选值是否包含值

  if convertedNumber != nil {
    print("convertedNumber contains some integer value.")
  }
  // 输出“convertedNumber contains some integer value.”
  

• 当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这被称为可选值的强制解析

  if convertedNumber != nil {
    print("convertedNumber has an integer value of \(convertedNumber!).")
  }
  // 输出“convertedNumber has an integer value of 123.”
  

12.3 可选绑定

使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在 if 和 while 语句中，这条语句不仅可以用来判断可选类型中是否有值，同时可以将可选类型中的值赋给一个常量或者变量。

if let constantName = someOptional {
    statements
}

12.4 隐式解析可选类型

在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。在这种情况下可以把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）来声明一个隐式解析可选类型

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要感叹号来获取值

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString  // 不需要感叹号