2.Swift初探-基本文法

1.if 表達式

var optionalString: String? = "Hello"
print(optionalString == nil)

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

在

if

語句中，條件必須是一個布爾表達式——這意味着像

if score { ... }

這樣的代碼将報錯，而不會隐形地與 0 做對比。你可以一起使用

if

和

let

來處理值缺失的情況。這些值可由可選值來代表。一個可選的值是一個具體的值或者是

nil

以表示值缺失。在類型後面加一個問号來标記這個變量的值是可選的。

2.switch表達式

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

switch

支援任意類型的資料以及各種比較操作——不僅僅是整數以及測試相等。注意

let

在上述例子的等式中是如何使用的，它将比對等式的值賦給常量

。運作

switch

中比對到的子句之後，程式會退出

switch

語句，并不會繼續向下運作，是以不需要在每個子句結尾寫

break

。

3.for循環

var largest = 0
for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)

var firstForLoop = 0
for i in 0..<4 {
    firstForLoop += i
}
print(firstForLoop)

周遊字典或者疊代都可以使用for in語句，使用

..<

建立的範圍不包含上界，如果想包含的話需要使用

...

4.函數

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
    var min = scores[0]
    var max = scores[0]
    var sum = 0
    
    for score in scores {
        if score > max {
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }
    
    return (min, max, sum)
}
let statistics = calculateStatistics([5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)

上例可以使用元組作為傳回值

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

上例函數有不等個參數時，參數在函數内部表現為數組形式

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, condition: lessThanTen)

函數實際上是一種特殊的閉包:它是一段能之後被調取的代碼。閉包中的代碼能通路閉包所建作用域中能得到的變量和函數，即使閉包是在一個不同的作用域被執行的 - 你已經在嵌套函數例子中所看到。你可以使用

{}

來建立一個匿名閉包。使用

in

将參數和傳回值類型聲明與閉包函數體進行分離。

5.對象和類

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()

上例即是一個正常的類。

注意

self

被用來差別執行個體變量。當你建立執行個體的時候，像傳入函數參數一樣給類傳入構造器的參數。每個屬性都需要指派——無論是通過聲明（就像

numberOfSides

）還是通過構造器（就像

name

）。

如果你需要在删除對象之前進行一些清理工作，使用

deinit

建立一個析構函數。

子類的定義方法是在它們的類名後面加上父類的名字，用冒号分割。建立類的時候并不需要一個标準的根類，是以你可以忽略父類。

子類如果要重寫父類的方法的話，需要用

override

标記——如果沒有添加

override

就重寫父類方法的話編譯器會報錯。編譯器同樣會檢測

override

标記的方法是否确實在父類中。

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")
print(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)

除了儲存簡單的屬性之外，屬性可以有 getter 和 setter 。

注意

EquilateralTriangle

類的構造器執行了三步：

設定子類聲明的屬性值
調用父類的構造器
改變父類定義的屬性值。其他的工作比如調用方法、getters和setters也可以在這個階段完成。

6.枚舉和結構體

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.rawValue)
        }
    }
}
let ace = Rank.Ace
let aceRawValue = ace.rawValue

使用

enum

來建立一個枚舉。就像類和其他所有命名類型一樣，枚舉可以包含方法。

在上面的例子中，枚舉原始值的類型是

Int

，是以你隻需要設定第一個原始值。剩下的原始值會按照順序指派。你也可以使用字元串或者浮點數作為枚舉的原始值。使用

rawValue

屬性來通路一個枚舉成員的原始值。

使用

init?(rawValue:)

初始化構造器在原始值和枚舉值之間進行轉換。

7.結構體

使用

struct

來建立一個結構體。結構體和類有很多相同的地方，比如方法和構造器。它們之間最大的一個差別就是結構體是傳值，類是傳引用。

<span style="font-size:10px;">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()</span>

8.協定和擴充

使用 `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

的聲明不需要标記任何方法，因為類中的方法通常可以修改類屬性（類的性質）。

使用

extension

來為現有的類型添加功能，比如新的方法和計算屬性。你可以使用擴充在别處修改定義，甚至是從外部庫或者架構引入的一個類型，使得這個類型遵循某個協定。

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

你可以像使用其他命名類型一樣使用協定名——例如，建立一個有不同類型但是都實作一個協定的對象集合。當你處理類型是協定的值時，協定外定義的方法不可用。即：聲明為協定類型的對象，隻能調用協定内部聲明的方法，對象本身類裡面的不在協定裡的方法無法調用。

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

2.Swift初探-基本文法

1.if 表達式

2.switch表達式

3.for循環

4.函數

5.對象和類

6.枚舉和結構體

7.結構體

8.協定和擴充

使用 `protocol` 來聲明一個協定。類、枚舉和結構體都可以實作協定。

繼續閱讀

Openstack (keystone 身份認證)keystone基本架構

[Swift]擴充String類：實作find()查找子字元串在父字元串中的位置

Swift 字元串是否包含某子串或字元

ios中判斷textView中的内容是否為空和去掉空字元的方法以及swift的for循環

swift 判斷輸入的字元串是否為數字

Why used the RxSwift

三十二 Swift5.0之記憶體相關

用“可選鍊”而不用“強制解包”

【iOS 開發】基礎控件：UILabeliOS 開發之基礎控件 UILabel

iOS 開發中控件擷取焦點（swift 開發）

UIProgressView之純Swift建立及其常見方法

UIStepper之純Swift建立及其常見方法

用swift開發儀表盤控件（二）

告别2016迎接2017，分享一些第三方插件

IOS Swift 5.0 擷取通訊錄清單撥打電話

swift資料合集

2.Swift初探-基本文法

1.if 表達式

2.switch表達式

3.for循環

4.函數

5.對象和類

6.枚舉和結構體

7.結構體

8.協定和擴充

使用 protocol 來聲明一個協定。類、枚舉和結構體都可以實作協定。

繼續閱讀

使用 `protocol` 來聲明一個協定。類、枚舉和結構體都可以實作協定。