加载中...

Swift

其中 Y=swift

源代码下载： learnswift-cn.swift

Swift 是 Apple 开发的用于 iOS 和 OS X 开发的编程语言。Swift 于2014年 Apple WWDC （全球开发者大会）中被引入，用以与 Objective-C 共存，同时对错误代码更具弹性。Swift 由 Xcode 6 beta 中包含的 LLVM 编译器编译。

Swift 的官方语言教程 Swift Programming Language 可以从 iBooks 免费下载.

亦可参阅：Apple’s getting started guide ——一个完整的Swift 教程

  1. // 导入外部模块
  2. import UIKit
  4. // 
  5. // MARK: 基础
  6. //
  8. // XCODE 支持给注释代码作标记，这些标记会列在 XCODE 的跳转栏里，支持的标记为
  9. // MARK: 普通标记
  10. // TODO: TODO 标记
  11. // FIXME: FIXME 标记
  13. println("Hello, world")
  15. // 变量 (var) 的值设置后可以随意改变
  16. // 常量 (let) 的值设置后不能改变
  17. var myVariable = 42
  18. let øπΩ = "value" // 可以支持 unicode 变量名 
  19. let π = 3.1415926
  20. let myConstant = 3.1415926
  21. let explicitDouble: Double = 70   // 明确指定变量类型为 Double ，否则编译器将自动推断变量类型
  22. let weak = "keyword"; let override = "another keyword" // 语句之间可以用分号隔开，语句未尾不需要分号
  23. let intValue = 0007 // 7
  24. let largeIntValue = 77_000 // 77000
  25. let label = "some text " + String(myVariable) // 类型转换
  26. let piText = "Pi = \(π), Pi 2 = \(π * 2)" // 格式化字符串
  28. // 条件编译
  29. // 使用 -D 定义编译开关
  30. #if false
  31.     println("Not printed")
  32.     let buildValue = 3
  33. #else
  34.     let buildValue = 7
  35. #endif
  36. println("Build value: \(buildValue)") // Build value: 7
  38. /*
  39.     Optionals 是 Swift 的新特性，它允许你存储两种状态的值给 Optional 变量：有效值或 None
  41.     Swift 要求所有的 Optinal 属性都必须有明确的值，如果为空，则必须明确设定为 nil
  43.     Optional<T> 是个枚举类型
  44. */
  45. var someOptionalString: String? = "optional" // 可以是 nil
  46. // 下面的语句和上面完全等价，上面的写法更推荐，因为它更简洁，问号 (?) 是 Swift 提供的语法糖
  47. var someOptionalString2: Optional<String> = "optional"
  49. if someOptionalString != nil {
  50.     // 变量不为空
  51.     if someOptionalString!.hasPrefix("opt") {
  52.         println("has the prefix")
  53.     }
  55.     let empty = someOptionalString?.isEmpty
  56. }
  57. someOptionalString = nil
  59. // 显式解包 optional 变量
  60. var unwrappedString: String! = "Value is expected."
  61. // 下面语句和上面完全等价，感叹号 (!) 是个后缀运算符，这也是个语法糖
  62. var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Value is expected."
  64. if let someOptionalStringConstant = someOptionalString {
  65.     // 由于变量 someOptinalString 有值，不为空，所以 if 条件为真
  66.     if !someOptionalStringConstant.hasPrefix("ok") {
  67.         // does not have the prefix
  68.     }
  69. }
  71. // Swift 支持可保存任何数据类型的变量
  72. // AnyObject == id
  73. // 和 Objective-C `id` 不一样, AnyObject 可以保存任何类型的值 (Class, Int, struct, 等)
  74. var anyObjectVar: AnyObject = 7
  75. anyObjectVar = "Changed value to a string, not good practice, but possible."
  77. /*
  78.     这里是注释
  80.     /*
  81.         支持嵌套的注释
  82.     */
  83. */
  85. //
  86. // Mark: 数组与字典（关联数组）
  87. //
  89. /*
  90.     Array 和 Dictionary 是结构体，不是类，他们作为函数参数时，是用值传递而不是指针传递。
  91.     可以用 `var` 和 `let` 来定义变量和常量。
  92. */
  94. // Array
  95. var shoppingList = ["catfish", "water", "lemons"]
  96. shoppingList[1] = "bottle of water"
  97. let emptyArray = [String]() // 使用 let 定义常量，此时 emptyArray 数组不能添加或删除内容
  98. let emptyArray2 = Array<String>() // 与上一语句等价，上一语句更常用
  99. var emptyMutableArray = [String]() // 使用 var 定义变量，可以向 emptyMutableArray 添加数组元素
  101. // 字典
  102. var occupations = [
  103.     "Malcolm": "Captain",
  104.     "kaylee": "Mechanic"
  105. ]
  106. occupations["Jayne"] = "Public Relations"   // 修改字典，如果 key 不存在，自动添加一个字典元素
  107. let emptyDictionary = [String: Float]() // 使用 let 定义字典常量，字典常量不能修改里面的值
  108. let emptyDictionary2 = Dictionary<String, Float>() // 与上一语句类型等价，上一语句更常用
  109. var emptyMutableDictionary = [String: Float]() // 使用 var 定义字典变量
  111. //
  112. // MARK: 控制流
  113. //
  115. // 数组的 for 循环
  116. let myArray = [1, 1, 2, 3, 5]
  117. for value in myArray {
  118.     if value == 1 {
  119.         println("One!")
  120.     } else {
  121.         println("Not one!")
  122.     }
  123. }
  125. // 字典的 for 循环
  126. var dict = ["one": 1, "two": 2]
  127. for (key, value) in dict {
  128.     println("\(key): \(value)")
  129. }
  131. // 区间的 loop 循环：其中 `...` 表示闭环区间，即[-1, 3]；`..<` 表示半开闭区间，即[-1,3)
  132. for i in -1...shoppingList.count {
  133.     println(i)
  134. }
  135. shoppingList[1...2] = ["steak", "peacons"]
  136. // 可以使用 `..<` 来去掉最后一个元素
  138. // while 循环
  139. var i = 1
  140. while i < 1000 {
  141.     i *= 2
  142. }
  144. // do-while 循环
  145. do {
  146.     println("hello")
  147. } while 1 == 2
  149. // Switch 语句
  150. // Swift 里的 Switch 语句功能异常强大，结合枚举类型，可以实现非常简洁的代码，可以把 switch 语句想象成 `if` 的语法糖
  151. // 它支持字符串，类实例或原生数据类型 (Int, Double, etc)
  152. let vegetable = "red pepper"
  153. switch vegetable {
  154. case "celery":
  155.     let vegetableComment = "Add some raisins and make ants on a log."
  156. case "cucumber", "watercress":
  157.     let vegetableComment = "That would make a good tea sandwich."
  158. case let localScopeValue where localScopeValue.hasSuffix("pepper"):
  159.     let vegetableComment = "Is it a spicy \(localScopeValue)?"
  160. default: // 在 Swift 里，switch 语句的 case 必须处理所有可能的情况，如果 case 无法全部处理，则必须包含 default语句 
  161.     let vegetableComment = "Everything tastes good in soup."
  162. }
  164. //
  165. // MARK: 函数
  166. //
  168. // 函数是一个 first-class 类型，他们可以嵌套，可以作为函数参数传递
  170. // 函数文档可使用 reStructedText 格式直接写在函数的头部
  171. /**
  172.     A greet operation
  174.     - A bullet in docs
  175.     - Another bullet in the docs
  177.     :param: name A name
  178.     :param: day A day
  179.     :returns: A string containing the name and day value.
  180. */
  181. func greet(name: String, day: String) -> String {
  182.     return "Hello \(name), today is \(day)."
  183. }
  184. greet("Bob", "Tuesday")
  186. // 函数参数前带 `#` 表示外部参数名和内部参数名使用同一个名称。
  187. // 第二个参数表示外部参数名使用 `externalParamName` ，内部参数名使用 `localParamName`
  188. func greet2(#requiredName: String, externalParamName localParamName: String) -> String {
  189.     return "Hello \(requiredName), the day is \(localParamName)"
  190. }
  191. greet2(requiredName:"John", externalParamName: "Sunday")    // 调用时，使用命名参数来指定参数的值
  193. // 函数可以通过元组 (tuple) 返回多个值
  194. func getGasPrices() -> (Double, Double, Double) {
  195.     return (3.59, 3.69, 3.79)
  196. }
  197. let pricesTuple = getGasPrices()
  198. let price = pricesTuple.2 // 3.79
  199. // 通过下划线 (_) 来忽略不关心的值
  200. let (_, price1, _) = pricesTuple // price1 == 3.69
  201. println(price1 == pricesTuple.1) // true
  202. println("Gas price: \(price)")
  204. // 可变参数
  205. func setup(numbers: Int...) {
  206.     // 可变参数是个数组
  207.     let number = numbers[0]
  208.     let argCount = numbers.count
  209. }
  211. // 函数变量以及函数作为返回值返回
  212. func makeIncrementer() -> (Int -> Int) {
  213.     func addOne(number: Int) -> Int {
  214.         return 1 + number
  215.     }
  216.     return addOne
  217. }
  218. var increment = makeIncrementer()
  219. increment(7)
  221. // 强制进行指针传递 (引用传递)，使用 `inout` 关键字修饰函数参数
  222. func swapTwoInts(inout a: Int, inout b: Int) {
  223.     let tempA = a
  224.     a = b
  225.     b = tempA
  226. }
  227. var someIntA = 7
  228. var someIntB = 3
  229. swapTwoInts(&someIntA, &someIntB)
  230. println(someIntB) // 7
  232. //
  233. // MARK: 闭包
  234. //
  235. var numbers = [1, 2, 6]
  237. // 函数是闭包的一个特例
  239. // 闭包实例
  240. // `->` 分隔了闭包的参数和返回值
  241. // `in` 分隔了闭包头 (包括参数及返回值) 和闭包体
  242. // 下面例子中，`map` 的参数是一个函数类型，它的功能是把数组里的元素作为参数，逐个调用 `map` 参数传递进来的函数。
  243. numbers.map({
  244.     (number: Int) -> Int in
  245.     let result = 3 * number
  246.     return result
  247. })
  249. // 当闭包的参数类型和返回值都是己知的情况下，且只有一个语句作为其返回值时，我们可以简化闭包的写法
  250. numbers = numbers.map({ number in 3 * number })
  251. // 我们也可以使用 $0, $1 来指代第 1 个，第 2 个参数，上面的语句最终可简写为如下形式
  252. // numbers = numbers.map({ $0 * 3 })
  254. print(numbers) // [3, 6, 18]
  256. // 简洁的闭包
  257. numbers = sorted(numbers) { $0 > $1 }
  258. // 函数的最后一个参数可以放在括号之外，上面的语句是这个语句的简写形式
  259. // numbers = sorted(numbers, { $0 > $1 })
  261. print(numbers) // [18, 6, 3]
  263. // 超级简洁的闭包，因为 `<` 是个操作符函数
  264. numbers = sorted(numbers, < )
  266. print(numbers) // [3, 6, 18]
  268. //
  269. // MARK: 结构体
  270. //
  272. // 结构体和类非常类似，可以有属性和方法
  274. struct NamesTable {
  275.     let names = [String]()
  277.     // 自定义下标运算符
  278.     subscript(index: Int) -> String {
  279.         return names[index]
  280.     }
  281. }
  283. // 结构体有一个自动生成的隐含的命名构造函数
  284. let namesTable = NamesTable(names: ["Me", "Them"])
  285. let name = namesTable[1]
  286. println("Name is \(name)") // Name is Them
  288. //
  289. // MARK: 类
  290. //
  292. // 类和结构体的有三个访问控制级别，他们分别是 internal (默认), public, private
  293. // internal: 模块内部可以访问
  294. // public: 其他模块可以访问
  295. // private: 只有定义这个类或结构体的源文件才能访问
  297. public class Shape {
  298.     public func getArea() -> Int {
  299.         return 0;
  300.     }
  301. }
  303. // 类的所有方法和属性都是 public 的
  304. // 如果你只是需要把数据保存在一个结构化的实例里面，应该用结构体
  306. internal class Rect: Shape {
  307.     // 值属性 (Stored properties)
  308.     var sideLength: Int = 1
  310.     // 计算属性 (Computed properties)
  311.     private var perimeter: Int {
  312.         get {
  313.             return 4 * sideLength
  314.         }
  315.         set {
  316.             // `newValue` 是个隐含的变量，它表示将要设置进来的新值
  317.             sideLength = newValue / 4
  318.         }
  319.     }
  321.     // 延时加载的属性，只有这个属性第一次被引用时才进行初始化，而不是定义时就初始化
  322.     // subShape 值为 nil ，直到 subShape 第一次被引用时才初始化为一个 Rect 实例
  323.     lazy var subShape = Rect(sideLength: 4)
  325.     // 监控属性值的变化。
  326.     // 当我们需要在属性值改变时做一些事情，可以使用 `willSet` 和 `didSet` 来设置监控函数
  327.     // `willSet`: 值改变之前被调用
  328.     // `didSet`: 值改变之后被调用
  329.     var identifier: String = "defaultID" {
  330.         // `willSet` 的参数是即将设置的新值，参数名可以指定，如果没有指定，就是 `newValue`
  331.         willSet(someIdentifier) {
  332.             println(someIdentifier)
  333.         }
  334.         // `didSet` 的参数是已经被覆盖掉的旧的值，参数名也可以指定，如果没有指定，就是 `oldValue`
  335.         didSet {
  336.             println(oldValue)
  337.         }
  338.     }
  340.     // 命名构造函数 (designated inits)，它必须初始化所有的成员变量，
  341.     // 然后调用父类的命名构造函数继续初始化父类的所有变量。
  342.     init(sideLength: Int) {
  343.         self.sideLength = sideLength
  344.         // 必须显式地在构造函数最后调用父类的构造函数 super.init
  345.         super.init()
  346.     }
  348.     func shrink() {
  349.         if sideLength > 0 {
  350.             --sideLength
  351.         }
  352.     }
  354.     // 函数重载使用 override 关键字
  355.     override func getArea() -> Int {
  356.         return sideLength * sideLength
  357.     }
  358. }
  360. // 类 `Square` 从 `Rect` 继承
  361. class Square: Rect {
  362.     // 便捷构造函数 (convenience inits) 是调用自己的命名构造函数 (designated inits) 的构造函数
  363.     // Square 自动继承了父类的命名构造函数
  364.     convenience init() {
  365.         self.init(sideLength: 5)
  366.     }
  367.     // 关于构造函数的继承，有以下几个规则：
  368.     // 1\. 如果你没有实现任何命名构造函数，那么你就继承了父类的所有命名构造函数
  369.     // 2\. 如果你重载了父类的所有命名构造函数，那么你就自动继承了所有的父类快捷构造函数
  370.     // 3\. 如果你没有实现任何构造函数，那么你继承了父类的所有构造函数，包括命名构造函数和便捷构造函数
  371. }
  373. var mySquare = Square()
  374. println(mySquare.getArea()) // 25
  375. mySquare.shrink()
  376. println(mySquare.sideLength) // 4
  378. // 类型转换
  379. let aShape = mySquare as Shape
  381. // 使用三个等号来比较是不是同一个实例
  382. if mySquare === aShape {
  383.     println("Yep, it's mySquare")
  384. }
  386. class Circle: Shape {
  387.     var radius: Int
  388.     override func getArea() -> Int {
  389.         return 3 * radius * radius
  390.     }
  392.     // optional 构造函数，可能会返回 nil
  393.     init?(radius: Int) {
  394.         self.radius = radius
  395.         super.init()
  397.         if radius <= 0 {
  398.             return nil
  399.         }
  400.     }
  401. }
  403. // 根据 Swift 类型推断，myCircle 是 Optional<Circle> 类型的变量
  404. var myCircle = Circle(radius: 1)
  405. println(myCircle?.getArea())    // Optional(3)
  406. println(myCircle!.getArea())    // 3
  407. var myEmptyCircle = Circle(radius: -1)
  408. println(myEmptyCircle?.getArea())    // "nil"
  409. if let circle = myEmptyCircle {
  410.     // 此语句不会输出，因为 myEmptyCircle 变量值为 nil
  411.     println("circle is not nil")
  412. }
  414. //
  415. // MARK: 枚举
  416. //
  418. // 枚举可以像类一样，拥有方法
  420. enum Suit {
  421.     case Spades, Hearts, Diamonds, Clubs
  422.     func getIcon() -> String {
  423.         switch self {
  424.         case .Spades: return "♤"
  425.         case .Hearts: return "♡"
  426.         case .Diamonds: return "♢"
  427.         case .Clubs: return "♧"
  428.         }
  429.     }
  430. }
  432. // 当变量类型明确指定为某个枚举类型时，赋值时可以省略枚举类型
  433. var suitValue: Suit = .Hearts
  435. // 非整型的枚举类型需要在定义时赋值
  436. enum BookName: String {
  437.     case John = "John"
  438.     case Luke = "Luke"
  439. }
  440. println("Name: \(BookName.John.rawValue)")
  442. // 与特定数据类型关联的枚举
  443. enum Furniture {
  444.     // 和 Int 型数据关联的枚举记录
  445.     case Desk(height: Int)
  446.     // 和 String, Int 关联的枚举记录
  447.     case Chair(brand: String, height: Int)
  449.     func description() -> String {
  450.         switch self {
  451.         case .Desk(let height):
  452.             return "Desk with \(height) cm"
  453.         case .Chair(let brand, let height):
  454.             return "Chair of \(brand) with \(height) cm"
  455.         }
  456.     }
  457. }
  459. var desk: Furniture = .Desk(height: 80)
  460. println(desk.description())     // "Desk with 80 cm"
  461. var chair = Furniture.Chair(brand: "Foo", height: 40)
  462. println(chair.description())    // "Chair of Foo with 40 cm"
  464. //
  465. // MARK: 协议
  466. // 与 Java 的 interface 类似
  467. //
  469. // 协议可以让遵循同一协议的类型实例拥有相同的属性，方法，类方法，操作符或下标运算符等
  470. // 下面代码定义一个协议，这个协议包含一个名为 enabled 的计算属性且包含 buildShape 方法
  471. protocol ShapeGenerator {
  472.     var enabled: Bool { get set }
  473.     func buildShape() -> Shape
  474. }
  476. // 协议声明时可以添加 @objc 前缀，添加 @objc 前缀后，
  477. // 可以使用 is, as, as? 等来检查协议兼容性
  478. // 需要注意，添加 @objc 前缀后，协议就只能被类来实现，
  479. // 结构体和枚举不能实现加了 @objc 的前缀
  480. // 只有添加了 @objc 前缀的协议才能声明 optional 方法
  481. // 一个类实现一个带 optional 方法的协议时，可以实现或不实现这个方法
  482. // optional 方法可以使用 optional 规则来调用
  483. @objc protocol TransformShape {
  484.     optional func reshaped()
  485.     optional func canReshape() -> Bool
  486. }
  488. class MyShape: Rect {
  489.     var delegate: TransformShape?
  491.     func grow() {
  492.         sideLength += 2
  494.         // 在 optional 属性，方法或下标运算符后面加一个问号，可以优雅地忽略 nil 值，返回 nil。
  495.         // 这样就不会引起运行时错误 (runtime error)
  496.         if let allow = self.delegate?.canReshape?() {
  497.             // 注意语句中的问号
  498.             self.delegate?.reshaped?()
  499.         }
  500.     }
  501. }
  503. //
  504. // MARK: 其它
  505. //
  507. // 扩展: 给一个已经存在的数据类型添加功能
  509. // 给 Square 类添加 `Printable` 协议的实现，现在其支持 `Printable` 协议
  510. extension Square: Printable {
  511.     var description: String {
  512.         return "Area: \(self.getArea()) - ID: \(self.identifier)"
  513.     }
  514. }
  516. println("Square: \(mySquare)")  // Area: 16 - ID: defaultID
  518. // 也可以给系统内置类型添加功能支持
  519. extension Int {
  520.     var customProperty: String {
  521.         return "This is \(self)"
  522.     }
  524.     func multiplyBy(num: Int) -> Int {
  525.         return num * self
  526.     }
  527. }
  529. println(7.customProperty) // "This is 7"
  530. println(14.multiplyBy(3)) // 42
  532. // 泛型: 和 Java 及 C# 的泛型类似，使用 `where` 关键字来限制类型。
  533. // 如果只有一个类型限制，可以省略 `where` 关键字
  534. func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
  535.     for (index, value) in enumerate(array) {
  536.         if value == valueToFind {
  537.             return index
  538.         }
  539.     }
  540.     return nil
  541. }
  542. let foundAtIndex = findIndex([1, 2, 3, 4], 3)
  543. println(foundAtIndex == 2) // true
  545. // 自定义运算符:
  546. // 自定义运算符可以以下面的字符打头:
  547. //      / = - + * % < > ! & | ^ . ~
  548. // 甚至是 Unicode 的数学运算符等
  549. prefix operator !!! {}
  551. // 定义一个前缀运算符，使矩形的边长放大三倍
  552. prefix func !!! (inout shape: Square) -> Square {
  553.     shape.sideLength *= 3
  554.     return shape
  555. }
  557. // 当前值
  558. println(mySquare.sideLength) // 4
  560. // 使用自定义的 !!! 运算符来把矩形边长放大三倍
  561. !!!mySquare
  562. println(mySquare.sideLength) // 12
还没有评论.