swift 专题三 swift 规范一

一、Swift编码命名规范

• 对类、结构体、枚举和协议等类型的命名应该采用大驼峰法，如 SplitViewController。

• 文件名采用大驼峰法，如BlockOperation.swift。

• 对于扩展文件，有时扩展定义在一个独立的文件中，用“原始类型名 + 扩展名”作为扩展文件名，如NSOperation + Operations.swift。

• 变量和属性采用小驼峰法，如studentNumber。

• 常量采用大驼峰法， 如MaxStudentNumber。

• 枚举成员与常量类似，采用大驼峰法，如ExecutionFailed。

• 函数和方法采用小驼峰法，如balanceAccount、isButtonPressed等。

二、注释规范

注释规范有：

• 文件规范
• 文档注释
• 代码注释
• 使用地标注释

2.1、文件注释

文件注释就是在每一个文件开头添加注释。文件注释通常包括如下信息：版权信息、文件名、所在模块、作者信息、历史版本信息、文件内容和作用等。

2.2、文档注释

文档注释是指这种注释内容能够生成API帮助文档。文档注释主要对类型、属性、方法或函数等进行注释。

• 单行文档注释（///）
• 多行文档注释（/*.../）

如下图：

2.3、代码注释

程序代码中处理文档注释还需要在一些关键的地方添加代码注释，文档注释一般是给一些看不到源代码的人看的帮助文档，而代码注释是给阅读源代码的人参考的。

• 单行注释（ // ）
• 多行注释 ( /.../ )

使用地标注释

• MARK， 用于方法或函数的注释；
• TODO， 表示这里的代码有没有完成或者还要处理；
• FIXME，表示这里修改了代码。

三、声明

• 变量或常量声明
• 属性声明

3.1 、变量或常量声明时，每行声明变量或常量的数量推荐一行一个，因为这样有利于写注释。

​
推荐使用：

let level = 0
var size = 10

不推荐使用：

let level,   le2,   le3 = 0;   var size = 10



​

3.2 、还有变量或常量的数据类型，如果有可能应尽量采用类型推断，这样代码更简洁。
推荐使用：

推荐使用：
let level = 0
var size = 10
不推荐使用：
let level: Int = 0
var size: Int = 10

3.3、如果不是默认数据类型，我们需要声明变量或常量的数据类型，示例代码如下：

let level: Int8 = 0
var size: Int64 = 10

3.4、指定数据类型时需要使用冒号(:)，变量或常量与冒号之间没有空格，冒号和数据类型之间要有一个空格。示例代码如下：

推荐使用：
let level: Int8 = 0
var size: Int64 = 10
不推荐使用：

let level : Int8 = 0
var size: Int64=10

3.5、使用数据类型时应尽可能使用Swift本身的数据类型

推荐使用：
let width = 120.0
let widthString = "Hello."
var deviceModels: [String]
var employees: [Int: String]
不推荐使用：
let width:  NsNumber = 120.0
let widthString: NSString = "Hello."
var deviceModels: NSArray
var employees: NSDictionary

3.6 计算属性的规范

• 如果是存储属性，声明规范与变量或常量声明的规范一样。
• 如果是计算属性，声明规范类似于代码块，特别是在使用只读计算属性时，应尽量省略get语句。

推荐使用：
var fullName: String  {
    return firstName + "." + lastName
}
不推荐使用：
var fullName: String  {
     get {
           return  firstName  +  "."  +  lastName
      }
}

四、代码排版

• 类型声明之前
• import语句前后
• 两个方法或函数之间
• 块注释或单行注释之前
• 一个源文件的两个片段之间

4.1、空格

1、赋值符号“=”前后各有一个空格。var 或let 与标识符之间有一个空格。所有的二元运算符都应该使用空格与操作符分开。一元操作符和操作数之间不应该有空格，如++、--等。
示例如下

var a = 10
var c = 10
a += c + d

2、(2)小左括号“("之后，小右括号“)”之前不应该有空。
示例如下：

a = (a + b) / (c * d)

3、大左括号“{”之前有一个空格，示例如下

while a == d {
    n++
}

4、在方法或函数名与第一参数之间没有空格，后面的参数前应该有一个空格，参数冒号与数据类型之间也有一个空格。
 

推荐使用：
 func tableView(_ tableView: UITableView, didSelectRowAt   indexPath: IndexPath) {
     ...
}
不推荐使用：
func tableView ( _ tableView: UITableView, didSelectRowAt   indexPath: IndexPath) {
     ...
}

五、缩进

• 在函数、方法、闭包、控制语句、计算属性等包含大括号“{}”的代码块中，代码块的内容相对于首行缩进一个级别（4个空格）。

• 如果是if语句中条件表达式的断行，那么新的一行应该相对于上一行缩进两个级别（8个空格），再往后的断行要与第一次的断行对齐

• 

六、if let

if let 绑定可选类型产生了更安全的代码，强行展开很可能导致运行时崩溃，避免使用强解

七、避免隐式解析的可选类型

如果 foo 可能为  nil ，尽可能的用  let foo: FooType? 代替  let foo: FooType!（注意：一般情况下， ? 可以代替  !） 理由： 明确的可选类型产生了更安全的代码。隐式解析的可选类型也可能会挂。

八、对于只读属性和 subscript，选用隐式的 getters 方法

如果可以，省略只读属性和  subscript 的  get 关键字

应该这样写：
var myGreatProperty: Int {

return 4

}
subscript(index: Int) -> T {

return objects[index]

}
而不是
var myGreatProperty: Int {

get {

return 4
 }

}
subscript(index: Int) -> T {
get {

return objects[index]
  }
}

理由： 第一个版本的代码意图已经很清楚了，并且用了更少的代码

九、对于顶级定义，永远明确的列出权限控制

顶级函数，类型和变量，永远应该有着详尽的权限控制说明符

public var whoopsGlobalState: Int

internal struct TheFez {}

private func doTheThings(things: [Thing]) {}

然而在这些函数/类型的内部，可以在合适的地方使用隐式权限控制：

internal struct TheFez {

var owner: Person = Joshaber()

}

理由： 顶级定义指定为  internal 很少有恰当的，要明确的确保经过了仔细的判断。在定义的内部重用同样的权限控制说明符就显得重复，而且默认的通常是合理的。

十、当指定一个类型时，把 冒号和标识符 连在一起

当指定标示符的类型时，冒号要紧跟着标示符，然后空一格再写类型

class SmallBatchSustainableFairtrade: Coffee { … }

let timeToCoffee: NSTimeInterval = 2

func makeCoffee(type: CoffeeType) -> Coffee { … }

理由： 类型区分号是对于标示符来说的，所以要跟它连在一起。

此外，指定字典类型时，键类型后紧跟着冒号，接着加一个空格，之后才是值类型。

let capitals: [Country: City] = [sweden: stockholm]

十一、需要时才写上 self

当调用  self 的属性或方法时，默认隐式引用 self：

private class History {

var events: [Event]

func rewrite() {

events = []

  }

}

必要的时候再加上  self, 比如在（逃逸）闭包里，或者 参数名冲突了：

extension History {

init(events: [Event]) {

self.events = events

}
var whenVictorious: () -> () {

return {

self.rewrite()
   }
 
  }

}

原因: 在闭包里用  self 更加凸显它捕获  self 的语义，别处避免了冗长

十二、首选 struct 而非 class

除非你需要  class 才能提供的功能（比如 identity 或  deinitializers），不然就用  struct要注意到继承通常  不 是用 类 的好理由，因为 多态 可以通过 协议 实现，重用 可以通过 组合 实现。比如，这个类的分级

class Vehicle {

let numberOfWheels: Int

init(numberOfWheels: Int) {

self.numberOfWheels = numberOfWheels

}

func maximumTotalTirePressure(pressurePerWheel: Float) -> Float {

return pressurePerWheel * Float(numberOfWheels)

}

}
class Bicycle: Vehicle {

init() {

super.init(numberOfWheels: 2)

}

}
class Car: Vehicle {

init() {

super.init(numberOfWheels: 4)

}

}

可以重构成酱紫：

protocol Vehicle {

var numberOfWheels: Int { get }

}

func maximumTotalTirePressure(vehicle: Vehicle, pressurePerWheel: Float) -> Float {

return pressurePerWheel * Float(vehicle.numberOfWheels)

}

struct Bicycle: Vehicle {

let numberOfWheels = 2

}

struct Car: Vehicle {

let numberOfWheels = 4

}
理由： 值类型更简单，容易分析，并且  let 关键字的行为符合预期。