swift编码规范

代码格式

• 使用Tab(四个空格)进行缩进
• 文件的结尾应该留一空白行
• 左大括号不用另起一行

func someMethod() {
        if x == y {
            /* ... */
        } else if x == z {
            /* ... */
        } else {
            /* ... */
        }
}

• 当在写一个变量类型，一个字典里的主键，一个函数的参数，遵从一个协议，或一个父类，不用在分号前添加空格

// 指定类型
let pirateViewController: PirateViewController
// 字典语法(注意这里是向左对齐而不是分号对齐)
let ninjaDictionary: [String: AnyObject] = [
    "fightLikeDairyFarmer": false,
    "disgusting": true
]
// 声明函数
func myFunction(firstArgument: U, secondArgument: T) {
    /* ... */
}
// 调用函数
someFunction(someArgument: "Kitten")
// 父类
class PirateViewController: UIViewController {
    /* ... */
}
// 协议
extension PirateViewController: UITableViewDataSource {
    /* ... */
}

• 逗号、二元运算符（+, -, /, = , ->)的前后都需要添加空格

let myValue = 20 + (30 / 2) * 3
if 1 + 1 == 3 {
    fatalError("The universe is broken.")
}
func pancake() -> Pancake {
    /* ... */
}

• 每个函数之间需要换一行，函数内切勿盲目换行，一般有关联的作为一部分空格，一般return之前添加空一行

命名

• 能准确直观的表达意图

// 推荐
class RoundAnimatingButton: UIButton { /* ... */ }
// 不推荐
class CustomButton: UIButton { /* ... */ }

• 在Swift中不需要如Objective-C式 一样添加前缀

//不推荐
class MGLoginIMServices

//推荐
class LoginIMServices

• 命名符合项目上下文命名习惯
  在命名时最好能符合整个项目的命名习惯，比如大家都用selectXXX表示查询的话，就不要用queryXXX，当大家都用insertXXX表示插入数据的话，就不要用addXXX，当大家都用getXXX表示获取数据的时候，就不要用fetchXXX。其目的是要要与实际项目命名统一。
• 尽量不用英文缩写
  当然对于一些大众熟知的缩写还是可以用的比如URL、Http、ID等，但是比如Button就没必要写缩写Btn了

// 推荐
class RoundAnimatingButton: UIButton {
    let animationDuration: NSTimeInterval
    func startAnimating() {
        let firstSubview = subviews.first
    }
}
// 不推荐
class RoundAnimating: UIButton {
    let aniDur: NSTimeInterval
    func srtAnmating() {
        let v = subviews.first
    }
}

• 使用小骆驼拼写法 (首字母小写) 为函数，方法，变量，常量，参数等命名
  一般函数的命名开头一般为动词
• 使用大骆驼拼写法为类型命名
  如struct, enum, class, typedef, associatedtype等，一般以名词开头来命名
• 利用上下文简化命名

// 不推荐
struct User {
    private var userName: String
    private var userPassword: String
    private var userAvatarUrl: String
}

//推荐
struct User {
    private var name: String
    private var password: String
    private var avatarUrl: String
}

• 使用前缀k+大骆驼命名法为所有非单例的静态常量命名

class MyClassName {
    // 基元常量使用 k 作为前缀
    static let kSomeConstantHeight: CGFloat = 80.0
    // 非基元常量也是用 k 作为前缀
    static let kDeleteButtonColor = UIColor.redColor()
    // 对于单例不要使用k作为前缀
    static let sharedInstance = MyClassName()
    /* ... */
}

• 如果协议描述的是协议做的事应该命名为名词(如Collection) ，如果描述的是行为，需添加后缀 able 或 ing (如Equatable 和 ProgressReporting)。 如果上述两者都不能满足需求，可以添加Protocol作为后缀

// 这个协议描述的是协议能做的事，应该命名为名词。
protocol TableViewSectionProvider {
    func rowHeight(atRow row: Int) -> CGFloat
    var numberOfRows: Int { get }
    /* ... */
}
// 这个协议表达的是行为, 以able最为后缀
protocol Loggable {
    func logCurrentState()
    /* ... */
}
// 因为已经定义类InputTextView，如果依然需要定义相关协议，可以添加Protocol作为后缀。
protocol InputTextViewProtocol {
    func sendTrackingEvent()
    func inputText() -> String
    /* ... */
}

• 对于以UI控件作为属性的命名需要包含类型信息

// 推荐
class ConnectionTableViewCell: UITableViewCell {
    let personImageView: UIImageView
    let animationDuration: NSTimeInterval
    // 作为属性名的firstName，很明显是字符串类型，所以不用在命名里不用包含String
    let firstName: String
    // 虽然不推荐, 这里用 Controller 代替 ViewController 也可以。
    let popupController: UIViewController
    let popupViewController: UIViewController
    // 如果需要使用UIViewController的子类，如TableViewController, CollectionViewController, SplitViewController, 等，需要在命名里标名类型。
    let popupTableViewController: UITableViewController
    // 当使用outlets时, 确保命名中标注类型。
    @IBOutlet weak var submitButton: UIButton!
    @IBOutlet weak var emailTextField: UITextField!
    @IBOutlet weak var nameLabel: UILabel!
}

// 不推荐
class ConnectionTableViewCell: UITableViewCell {
    // 这个不是 UIImage, 不应该以Image 为结尾命名。
    // 建议使用 personImageView
    let personImage: UIImageView
    // 这个不是String，应该命名为 textLabel
    let text: UILabel
    // animation 不能清晰表达出时间间隔
    // 建议使用 animationDuration 或 animationTimeInterval
    let animation: NSTimeInterval
    // transition 不能清晰表达出是String
    // 建议使用 transitionText 或 transitionString
    let transition: String
    // 这个是ViewController，不是View
    let popupView: UIViewController
    // 由于不建议使用缩写，这里建议使用 ViewController替换 VC
    let popupVC: UIViewController
    // 技术上讲这个变量是 UIViewController, 但应该表达出这个变量是TableViewController
    let popupViewController: UITableViewController
    // 为了保持一致性，建议把类型放到变量的结尾，而不是开始，如submitButton
    @IBOutlet weak var btnSubmit: UIButton!
    @IBOutlet weak var buttonSubmit: UIButton!
    // 在使用outlets 时，变量名内应包含类型名。
    // 这里建议使用 firstNameLabel
    @IBOutlet weak var firstName: UILabel!
}

代码风格

• 常量取代魔法数字

    //推荐
    private static let PI = 3.14159
    func calculateCircularArea(radius: Double) -> Double {
        return PI * radius * radius
    }
    //不推荐
    func calculateCircularArea(radius: Double) -> Double {
        return 3.14159 * radius * radius
    }

• 尽可能的多使用let，少使用var
  尽可能的用 let foo = ... 而不是 var foo = ... （并且包括你疑惑的时候）。万不得已的时候，再用 var （就是说：你 知道 这个值会改变，比如：有 weak 修饰的存储变量）。
• 如果变量类型可以依靠推断得出，不建议声明变量时指明类型
• 当需要遍历一个集合并变形成另一个集合时，推荐使用函数 map, filter 和 reduce

// 推荐
let stringOfInts = [1, 2, 3].flatMap { String($0) }
// ["1", "2", "3"]
// 不推荐
var stringOfInts: [String] = []
for integer in [1, 2, 3] {
    stringOfInts.append(String(integer))
}
// 推荐
let evenNumbers = [4, 8, 15, 16, 23, 42].filter { $0 % 2 == 0 }
// [4, 8, 16, 42]
// 不推荐
var evenNumbers: [Int] = []
for integer in [4, 8, 15, 16, 23, 42] {
    if integer % 2 == 0 {
        evenNumbers(integer)
    }
}

• 在写枚举类型的时候，尽量用简写

// 推荐
imageView.setImageWithURL(url, type: .person)
// 不推荐
imageView.setImageWithURL(url, type: AsyncImageView.Type.person)

• 只有在需要的情况下才使用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 的时候要注意出现循环引用，使用捕获列表可以避免这一点
  以下列举了两种方案作为参考

myFunctionWithClosure() { [weak self] (error) -> Void in
    // 方案 1
    self?.doSomething()
    // 或方案 2
    guard let strongSelf = self else {
        return
    }
    strongSelf.doSomething()
}

• switch-case里不用显式添加break
• 函数最多包含4个参数
  当我们不得不需要输入多个参数的时候，可以有以下2种方式处理：
  1、考虑函数是否职责单一，是否能通过拆分成多个函数的方式来减少参数；
  2、把函数的参数封装成对象。
• 函数有多个返回值，推荐使用元组，如果返回的元组有三个或多于三个以上的元素，建议使用结构体或类
• 如果需要把访问修饰符放到第一个位置

// 推荐
private static let kMyPrivateNumber: Int
// 不推荐
static private let kMyPrivateNumber: Int

• 避免闭包的内循环
  闭包中对任何其他元素的引用都是会被闭包自动持有的。如果我们在闭包中写了 self 这样的东西的话，那我们其实也就在闭包内持有了当前的对象。这里就出现了一个在实际开发中比较隐蔽的陷阱：如果当前的实例直接或者间接地对这个闭包又有引用的话，就形成了一个 self -> 闭包 -> self 的循环引用，简单例子：

class Person {
    let name: String
    lazy var printName: ()->() = {
        print("The name is \(self.name)")
    }

    init(name: String) {
        self.name = name
    }

    deinit {
        print("Person deinit \(self.name)")
    }
}

var xiaoMing: Person? = Person(name: "XiaoMing")
xiaoMing!.printName()
xiaoMing = nil
// 输出:
// The name is XiaoMing，没有被释放

//推荐做法
lazy var printName: ()->() = {
    [weak self] in
    if let strongSelf = self {
        print("The name is \(strongSelf.name)")
    }
}

• 避免对可选类型强解包
  如果你有个 FooType? 或 FooType! 的 foo，尽量不要强行展开它（foo!）以得到它的关联值。取而代之的，推荐这样：

//推荐1:if let
if let foo = foo {
    // Use unwrapped `foo` value in here
} else {
    // If appropriate, handle the case where the optional is nil
}

//推荐2:使用可选链
// Call the function if `foo` is not nil. If `foo` is nil, ignore we ever tried to make the call
foo?.callSomethingIfFooIsNotNil()

• 避免隐式解析的可选类型
  唯一使用隐式拆包可选型（implicitly unwrapped optionals）的场景是结合@IBOutlets
  在其他场景使用非可选类型和常规可选类型，即使有的场景你确定有的变量使用的时候永远不会为nil，但这样做可以保持一致性和程序更加健壮, 隐式解析的可选类型存在运行时崩溃的风险。
• 实现协议的方式
  1、使用 // MARK: 注释来分割协议实现和其他代码。
  2、使用 extension 在 类/结构体已有代码外，但在推荐在同一个文件内。
• 在创建类常量的时候，使用 static 关键词修饰

class MyTableViewCell: UITableViewCell {
    static let kReuseIdentifier = String(MyTableViewCell)
    static let kCellHeight: CGFloat = 80.0
}

• 推荐定义单例的方式

class PirateManager {
    static let sharedInstance = PirateManager()
    /* ... */
}

• 尽早地 return 或者 break
  当你遇到某些操作需要通过条件判断去执行，应当尽早地退出判断条件：

//不推荐
if n.isNumber {
    // Use n here
} else {
    return
}

//推荐
guard n.isNumber else {
    return
}
// Use n here