今日凌晨，蘋果在WWDC 2014發布最新編程語言Swift，也在其開發者中心放出了Xcode 6 Beta版。Swift是一種新的編程語言，用于iOS和OS X應用的開發，沒有C的兼容性限制，Swift采用安全的編程模式，增加了現代功能，使編程變得容易，更靈活，更有趣，Swift的重新設計，依靠成熟和備受喜愛的Cocoa。

 

以下為語法介紹

原文：

翻譯：

Hello world - Swift

傳統建議新語言的第一個程序是打印“Hello world”，對于Swift是下面的一行代碼

println("Hello, world")

如果你用C或者Objective-C編寫過代碼，這段句法會感覺熟悉，在Swift中，這是一行完整的代碼，不需要引入單獨的庫比如輸入輸出或者字符串 操作，在全局作用域下編寫的代碼會作為程序的入口，所以你也不需要main函數，你同樣不需要在每段代碼后面寫分號 這次tour將教你使用Swift編程的足夠信息，完成各種編程任務，如果你有不理解也不用擔心，本次演示的任何內容在后面的章節中都有詳細的介紹

簡單賦值

使用 let定義常量，使用var定義變量，常量的值不需要在編譯的時候知道，但你必須只設置一次，這意味著你可以使用常量來定義這樣的數值：一次決定，多處使用

var myVariable = 42
myVariable = 50
let myConstant = 42

常量和變量必須為你指定的類型，但是你并不需要總是顯示的指定類型，創建變量或者常量時，直接提供一個數值讓編譯器知道他的類型，下面的例子中，編譯器指 定myVariable為整型，因為他的初始值是一個整型 如果初始值沒有足夠的信息（比如沒有初始值），可以在變量后面指定一個類型，通過冒號分割

let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70

數值不會隱式的轉換成另一種類型，你必須轉換成另一種類型，顯式的指定類型

let label = "The width is "
let width = 94
let widthLabel = label + String(width)

有更簡單的方式讓字符串中包含數值：在小括號中編寫數值，并在括號之前寫上（\），如下例：

let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

使用中括號[]創建數組和字典，通過序號或者key來訪問集合中的元素

var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"

var occupations = [
  "Malcolm": "Captain",
  "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

創建一個空的數組或者字典，使用下面的初始化語法

let emptyArray = String[]()
let emptyDictionary = Dictionary<String, Float>()

如果類型信息可以被斷定，你可以寫一個空數組[]，或者一個空的字典[:]，比如當你為一個變量設置新的值，或者給函數傳遞一個參數

shoppingList = []   // Went shopping and bought everything.

控制流

使用if和switch判斷條件，使用for-in, for, while和do-while 循環，條件或者循環參數的小括號是可選的，但是主體的花括號是必須的

let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
  if score > 50 {
    teamScore += 3
  } else {
    teamScore += 1
  }
}
teamScore

if聲明中，條件必須是Boolean表達式，這意味著類似 if score{…}de的寫法是錯誤的，不會隱式的與0比較 你可以將if和let結合使用，這意味著數值為可選，可選值可能是一個數值也可能是nil表示值缺失，在類型后面標記問號（?）表示這個值為可選

var optionalString: String? = "Hello"
optionalString == nil

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
  greeting = "Hello, \(name)"
}

如果可選值為nil，條件為flase，代碼會被跳過，否則會進入并設置常量，使得變量在代碼體中可用 Switch支持任何類型和多種操作符，不限于整型和相等操作

let vegetable = "red pepper"
switch vegetable {
case "celery":
  let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
  let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"):
  let vegetableComment = "Is it a spicy \(x)?"
default:
  let vegetableComment = "Everything tastes good in soup."
}

在執行完匹配的條件后，程序將跳出選擇條件，不會繼續到下一個條件，所以不需要在每個條件中指定break

let interestingNumbers = [
  "Prime": [2, 3, 5, 7, 11, 13],
  "Fibonacci": [1, 1, 2, 3, 5, 8],
  "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
  for number in numbers {
    if number > largest {
      largest = number
    }
  }
}
largest

使用while重復一段代碼塊知道條件改變，循環條件也可以放在后面，這樣可以確保循環被至少調用一次

var n = 2
while n < 100 {
  n = n * 2
}
n

var m = 2
do {
  m = m * 2
} while m < 100
m

可以使用序號遍歷，既可以使用.. 指定序號范圍，也可以寫完整的表達式

var firstForLoop = 0
for i in 0..3 {
  firstForLoop += i
}
firstForLoop

var secondForLoop = 0
for var i = 0; i < 3; ++i {
  secondForLoop += 1
}
secondForLoop

函數與閉包

使用 func聲明一個函數，通過函數名和參數調用一個函數，使用 -> 聲明函數返回類型

func greet(name: String, day: String) -> String {
  return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")

使用值組表示多個數值返回

func getGasPrices() -> (Double, Double, Double) {
  return (3.59, 3.69, 3.79)
}
getGasPrices()

函數還可以設置可變參數，會將他們整合到一個數組中

func sumOf(numbers: Int...) -> Int {
  var sum = 0
  for number in numbers {
    sum += number
  }
  return sum
}
sumOf()
sumOf(42, 597, 12)

函數可以嵌套，嵌套函數可以訪問外部函數的聲明的變量，對于很長或者復雜的函數，你可以使用嵌套函數來組織代碼

func returnFifteen() -> Int {
  var y = 10
  func add() {
    y += 5
  }
  add()
  return y
}
returnFifteen()

函數也是一種類型（第一等類型），這意味著你可以返回一個函數作為函數返回值

func makeIncrementer() -> (Int -> Int) {
  func addOne(number: Int) -> Int {
    return 1 + number
  }
  return addOne
}
var increment = makeIncrementer()
increment(7)

函數還可以作為另一個函數的參數

func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
  for item in list {
    if condition(item) {
      return true
    }
  }
  return false
}
func lessThanTen(number: Int) -> Bool {
  return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, lessThanTen)

閉包實際上是函數的一種特殊形式，你可以寫一個閉包，使用花括號（{}）包裹代碼，沒有函數名，使用 in 來分隔傳入參數和返回類型

numbers.map({
  (number: Int) -> Int in
  let result = 3 * number
  return result
  })

你可以選擇更簡潔的閉包方式，當一個閉包類型已知，比如某個委托的回調函數，你可以省略它的參數和返回類型，單聲明的閉包默認會返回這個唯一的聲明變量

numbers.map({ number in 3 * number })

你可以通過序號替代名稱來訪問參數，這種方式尤其適合非常短的閉包

sort([1, 5, 3, 12, 2]) { $0 > $1 }

對象和類

使用class創建類，類中的屬性聲明與常量和變量聲明一樣，只是他位于這個類的上下文中，同樣的函數和方法聲明也一樣

class Shape {
  var numberOfSides = 0
  func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
  }
}

創建一個類實例，使用類名加括號，使用點操作符訪問實例的屬性和方法

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

這個版本的Shape類缺少一些重要的東西：用于初始化這個類的構造器，可以使用init來創建

class NamedShape {
  var numberOfSides: Int = 0
  var name: String

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

  func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
  }
}

注意，使用self來就區別傳入參數的name和自身的name屬性，構造器中的構造參數與函數參數的傳遞方式一樣，所有的屬性都需要指定值，可以在聲明 時指定（如numberOfSides）也可以在構造函數中指定（如name） 如果你希望在對象被回收時執行清除動作，可以使用deinit創建一個析構器 子類名包含在父類名稱之后，使用冒號分隔，類不需要從任何標準的根類繼承，所以你可以包含或者忽略父類 子類中的重寫方法需要標記上override，如果沒有 override，會被編譯器檢查出錯，同樣編譯器還會檢測帶override標志的函數是否真的存在于父類中

class Square: NamedShape {
  var sideLength: Double

  init(sideLength: Double, name: String) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 4
  }

  func area() ->  Double {
    return sideLength * sideLength
  }

  override func simpleDescription() -> String {
    return "A square with sides of length \(sideLength)."
  }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

除了簡單屬性外，屬性還可以具備getter和setter方法

class EquilateralTriangle: NamedShape {
  var sideLength: Double = 0.0

  init(sideLength: Double, name: String) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 3
  }

  var perimeter: Double {
  get {
    return 3.0 * sideLength
  }
  set {
    sideLength = newValue / 3.0
  }
  }

  override func simpleDescription() -> String {
    return "An equilateral triagle with sides of length \(sideLength)."
  }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
triangle.perimeter
triangle.perimeter = 9.9
triangle.sideLength

在perimeter的setter函數中，新值隱式的命名為newValue，你也可以在set后面的括號中提供一個顯式的名稱 注意EquilateralTriangle類的構造函數有三步： 1、為子類聲明的屬性設置值 2、調用父類構造器 3、改變父類定義的屬性值，如何用到方法或者getter, setter的工作可以在這之后執行 如果你不需要控制屬性，但需要在屬性設置前后做些處理，可以使用willSet和didSet，舉例，下面的類中可以確保三角形邊長與方形邊長相同

class TriangleAndSquare {
  var triangle: EquilateralTriangle {
  willSet {
    square.sideLength = newValue.sideLength
  }
  }
  var square: Square {
  willSet {
    triangle.sideLength = newValue.sideLength
  }
  }
  init(size: Double, name: String) {
    square = Square(sideLength: size, name: name)
    triangle = EquilateralTriangle(sideLength: size, name: name)
  }
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
triangleAndSquare.square.sideLength
triangleAndSquare.triangle.sideLength
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
triangleAndSquare.triangle.sideLength

類中的方法與函數有一個重要區別，函數參數名只在函數體中使用，但方法的參數名在調用方法時也需要（除了第一個參數），默認不論是調用方法時還是在方法內，方法的參數名都是相同的，你可以指定另一個名稱用于方法內

class Counter {
  var count: Int = 0
  func incrementBy(amount: Int, numberOfTimes times: Int) {
    count += amount * times
  }
}
var counter = Counter()
counter.incrementBy(2, numberOfTimes: 7)

當使用可選參數時，可以在方法或者屬性操作符前加上（?），如果？前是nil，所有?后面的內容都會忽略，整個表達式的值為nil

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

枚舉與結構

使用enum創建枚舉，與類或者其他可命名的類型一樣，枚舉可以定義方法

enum Rank: Int {
  case Ace = 1
  case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
  case Jack, Queen, King
  func simpleDescription() -> String {
    switch self {
    case .Ace:
      return "ace"
    case .Jack:
      return "jack"
    case .Queen:
      return "queen"
    case .King:
      return "king"
    default:
      return String(self.toRaw())
    }
  }
}
let ace = Rank.Ace
let aceRawValue = ace.toRaw()

上面的例子中，枚舉中的原始值類型是int，所以你必須指定第一個原始值，余下的會按順序指定，你也可以使用浮點數或者字符串作為枚舉的原始類型 使用toRaw和fromRaw函數轉換枚舉值和原始值

if let convertedRank = Rank.fromRaw(3) {
  let threeDescription = convertedRank.simpleDescription()
}

枚舉中的成員數值必須是實際的值，不能通過其他方式設置，實際上對于沒有原始值的情況，你也不能為他設置一個

enum Suit {
  case Spades, Hearts, Diamonds, Clubs
  func simpleDescription() -> String {
    switch self {
    case .Spades:
      return "spades"
    case .Hearts:
      return "hearts"
    case .Diamonds:
      return "diamonds"
    case .Clubs:
      return "clubs"
    }
  }
}
let hearts = Suit.Hearts
let heartsDescription = hearts.simpleDescription()

注意枚舉中的Hearts成員引用的兩種方式：當指派給常量hearts時，使用了Suit.Hearts全名稱，而在switch中，使用 了.Hearts，因為self 已經知道是suit，在知道類型時，你可以使用這種縮寫 使用struct創建結構，結構支持許多類似類的功能，比如方法和構造函數，兩者最大的區別是，結構是值傳遞，類為引用傳遞

struct Card {
  var rank: Rank
  var suit: Suit
  func simpleDescription() -> String {
    return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
  }
}
let threeOfSpades = Card(rank: .Three, suit: .Spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

枚舉成員實例可以擁有關聯值，相同枚舉成員可以有不同的關聯值，你可以在創建實例時設置關聯值，關聯值與原始值不同，同一個枚舉成員的所有實例有相同的原始值，但可以有不同的關聯值 舉個例子，考慮從服務中獲取日升日落的時間，服務可以響應這些信息或者一些異常信息

enum ServerResponse {
  case Result(String, String)
  case Error(String)
}

let success = ServerResponse.Result("6:00 am", "8:09 pm")
let failure = ServerResponse.Error("Out of cheese.")

switch success {
case let .Result(sunrise, sunset):
  let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
  let serverResponse = "Failure...  \(error)"
}

注意從VerverResponse中獲取的日升日落的具體數值可以在switch條件中獲取

協議和擴展

使用protocol聲明一個協議

protocol ExampleProtocol {
  var simpleDescription: String { get }
  mutating func adjust()
}

類，枚舉，結構都可以使用協議

class SimpleClass: ExampleProtocol {
  var simpleDescription: String = "A very simple class."
  var anotherProperty: Int = 69105
  func adjust() {
    simpleDescription += "  Now 100% adjusted."
  }
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription

struct SimpleStructure: ExampleProtocol {
  var simpleDescription: String = "A simple structure"
  mutating func adjust() {
    simpleDescription += " (adjusted)"
  }
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription

注意，在SimpleStructure聲明中使用mutating關鍵詞用于標示這個方法會修改結構，而SimpleClass中不需要設置 mutating標志，是因為類中的方法總是會修改這個類 使用extension為一個已存在的類型增加函數，比如新的方法或者計算屬性，你可以使用擴展，保證任意類型具有相同的協議，不管這個類型是從框架還是 類庫中來的

extension Int: ExampleProtocol {
  var simpleDescription: String {
  return "The number \(self)"
  }
  mutating func adjust() {
    self += 42
  }
}
7.simpleDescription

你可以像其他命名類型一樣使用協議名稱，比如，創建一個由類型不同但使用相同協議的對象組成的集合，當你使用這些類型時，可以當做一個協議類型來使用，協議以外的方法將不可用

let protocolValue: ExampleProtocol = a
protocolValue.simpleDescription
// protocolValue.anotherProperty  // Uncomment to see the error

雖然protocolValue在運行時是SimpleClass類型，但編譯器會以ExampleProtocol對待，這意味你可以避免訪問協議以外的方法

泛型

尖括號中的名稱用于創建一個泛型的函數和類型

func repeat(item: ItemType, times: Int) -> ItemType[] {
  var result = ItemType[]()
  for i in 0..times {
    result += item
  }
  return result
}
repeat("knock", 4)

也可以用同樣的方式在類，枚舉，結構中使用泛型

// Reimplement the Swift standard library's optional type
enum OptionalValue {
  case None
  case Some(T)
}
var possibleInteger: OptionalValue = .None
possibleInteger = .Some(100)

在類型名后使用where指定需求列表，比如指定類型必須實現某個協議，或者要求兩種類型相同，或者要求具有某個特定的超類

func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
  for lhsItem in lhs {
    for rhsItem in rhs {
      if lhsItem == rhsItem {
        return true
      }
    }
  }
  return false
}
anyCommonElements([1, 2, 3], [3])

一般情況下，你可以忽略where，在括號后面簡單的寫一個協議名或者類型。