目錄[-]

• Hello world - Swift
• 簡單賦值
• 控制流
• 函數與閉包
• 對象和類
• 枚舉與結構
• 協議和擴展
• 泛型

2014.6.3日，蘋果公布最新編程語言Swift，Swift是一種新的編程語言，用于iOS和OS X應用的開發，沒有C的兼容性限制，Swift采用安全的編程模式，增加了現代功能，使編程變得容易，更靈活，更有趣，Swift的重新設計，依靠成熟和 備受喜愛的Cocoa, Cocoa Touch 框架，是重新構想軟件如何開發的機會。

• Swift官網
• 關于Swift

?

以下為語法介紹

原文：A Swift Tour

翻譯：http://blog.qunee.com/2014/06/swift語法介紹/?

?

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 == nilvar 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 } nvar m = 2 do {m = m * 2 } while m < 100 m

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

var firstForLoop = 0 for i in 0..3 {firstForLoop += i } firstForLoopvar 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 = 0for number in numbers {sum += number}return sum } sumOf() sumOf(42, 597, 12)

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

func returnFifteen() -> Int {var y = 10func 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 inlet result = 3 * numberreturn result})

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

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

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

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

?

對象和類

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

class Shape {var numberOfSides = 0func 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 = 0var name: Stringinit(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: Doubleinit(sideLength: Double, name: String) {self.sideLength = sideLengthsuper.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.0init(sideLength: Double, name: String) {self.sideLength = sideLengthsuper.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 = 0func 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 = 1case Two, Three, Four, Five, Six, Seven, Eight, Nine, Tencase Jack, Queen, Kingfunc 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, Clubsfunc 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: Rankvar suit: Suitfunc 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 = 69105func adjust() {simpleDescription += " Now 100% adjusted."} } var a = SimpleClass() a.adjust() let aDescription = a.simpleDescriptionstruct 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 Nonecase 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，在括號后面簡單的寫一個協議名或者類型，比如，<T: Equatable> 與<T where T: Equatable>是相同的效果

參考：http://my.oschina.net/nosand/blog/272018#OSC_h3_2

?

轉載于:https://www.cnblogs.com/langtianya/p/3766483.html

總結

以上是生活随笔為你收集整理的Swift翻译之-Swift语法入门 Swift语法介绍的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。