swift基礎學習

基礎教程參考

對於純白色的小白可以完全參照下面swift菜鳥教程和Swift 中文手冊(3.0)去學習一遍。

一些容易忽視的注意點

識別符號、資料型別

• 如果一定要使用關鍵字作為識別符號，可以在關鍵字前後新增重音符號（`），例如：

let `class` = "ssss"

• 在Swift中，運算子不能直接跟在變數或常量的後面。例如下面的程式碼會報錯：

//等號與a沒有空開
let a= 1 + 2

• 資料型別包括：Int、UInt、Float、Double、Bool、String、Array、Dictionary、Character（字元）、Optional（可選型別）、Struct、Class等

• 類型別名對當前的型別定義了另一個名字，類型別名通過使用 typealias 關鍵字來定義。語法格式如下：

typealias newname = type

//定義了 Int 的類型別名為 Feet：
typealias Feet = Int

• 型別安全:Swift 是一個型別安全（type safe）的語言。由於 Swift 是型別安全的，所以它會在編譯你的程式碼時進行型別檢查（type checks），並把不匹配的型別標記為錯誤。這可以讓你在開發的時候儘早發現並修復錯誤。

• 型別推斷:當你要處理不同型別的值時，型別檢查可以幫你避免錯誤。然而，這並不是說你每次宣告常量和變數的時候都需要顯式指定型別。如果你沒有顯式指定型別，Swift 會使用型別推斷（type inference）來選擇合適的型別。

let meaningOfLife = 42
// meaningOfLife 會被推測為 Int 型別

• 型別標註：你宣告常量或者變數的時候可以加上型別標註（type annotation），說明常量或者變數中要儲存的值的型別。如果要新增型別標註，需要在常量或者變數名後面加上一個冒號和空格，然後加上型別名稱。

var constantName:<data type> = <optional initial value>

//例如
var str : String = "sss"
let num : Int = 10

可選型別、強制解析、自動解析、可選繫結

• Swift 的可選（Optional）型別：用於處理值缺失的情況。可選表示"那兒有一個值，並且它等於 x “或者"那兒沒有值”。Swfit語言定義字尾？作為命名型別Optional的簡寫，換句話說，以下兩種宣告是相等的：

var optionalInteger: Int?
var optionalInteger: Optional<Int>

Optional 是一個含有兩種情況的列舉，None 和 Some(T)，用來表示可能有或可能沒有值。任何型別都可以明確宣告為（或者隱式轉換）可選型別。當宣告一個可選型別的時候，要確保用括號給 ? 操作符一個合適的範圍。當你宣告一個可選變數或者可選屬性的時候沒有提供初始值，它的值會預設為 nil。可選項遵照 LogicValue 協議，因此可以出現在布林環境中。在這種情況下，如果可選型別T?包含型別為T的任何值（也就是說它的值是 Optional.Some(T) ），這個可選型別等於 true，反之為 false。如果一個可選型別的例項包含一個值，你可以用字尾操作符 ！來訪問這個值.使用操作符！去獲取值為nil的可選變數會有執行時錯誤。可選型別類似於Objective-C中指標的nil值，但是nil只對類(class)有用，而可選型別對所有的型別都可用，並且更安全。

• 強制解析：當你確定可選型別確實包含值之後，你可以在可選的名字後面加一個感嘆號（!）來獲取值。這個感嘆號表示"我知道這個可選有值，請使用它。"這被稱為可選值的強制解析（forced unwrapping）。

var myString : String?
myString = "Hello, Swift!"
if myString != nil {
    print(myString)
    print(myString!)
}else{
    print("myString 值為 nil")
}
var myString2 : Optional<String>

執行結果分別為：

Optional("Hello, Swift!")
Hello, Swift!

注意：使用!來獲取一個不存在的可選值會導致執行時錯誤。使用!來強制解析值之前，一定要確定可選包含一個非nil的值。

• 自動解析:你可以在宣告可選變數時使用感嘆號（!）替換問號（?）。這樣可選變數在使用時就不需要再加一個感嘆號（!）來獲取值，它會自動解析。

var myString3 : String!
myString3 = "Hello, Swift!"
if myString3 != nil {
    print(myString3)
}else{
    print("myString3 值為 nil")
}

• 可選繫結 : 使用可選繫結（optional binding）來判斷可選型別是否包含值，如果包含就把值賦給一個臨時常量或者變數。可選繫結可以用在if和while語句中來對可選型別的值進行判斷並把值賦給一個常量或者變數。像下面這樣在if語句中寫一個可選繫結：

if let constantName = someOptional {
    statements
}

你可以一行程式碼中包含多個可選值的繫結 用‘where’引起一個bool的判斷條件 如果這些繫結可選值中的任何一個是nil 或者條件判斷是nil 那麼整個可選繫結值就被視為是不成功的

var myString:String?
myString = "Hello, Swift!"
if let yourString = myString {//如果myString有值，即不為nil,這時候預設解包了
    print("你的字串值為 - \(yourString)")
}else{
    print("你的字串沒有值")
}

if let firstValue = Int("22222"),let secondValue = Int("452") , firstValue < secondValue {
    print("\(firstValue) < \(secondValue)")
    
}else{
    print("判斷條件不成立")
}

注意:nil 不能用於非可選的常量和變數。如果你的程式碼中有常量或者變數需要處理值缺失 的情況,請把它們宣告成對應的可選型別。

運算子

• Swift 提供了兩個區間的運算子：

1. 閉區間運算子：閉區間運算子（a…b）定義一個包含從a到b(包括a和b)的所有值的區間，b必須大於等於a。 ‌ 閉區間運算子在迭代一個區間的所有值時是非常有用的，如在for-in迴圈中。
2. 半開區間運算子：半開區間（a…

 print("閉區間運算子:")
for index in 1...5 {
    print("\(index) * 5 = \(index * 5)")
}

print("半開區間運算子:")
for index in 1..<5 {
    print("\(index) * 5 = \(index * 5)")
}

• 運算子優先順序:

指標最優，單目運算優於雙目運算。如正負號。

先乘除（模），後加減。

先算術運算，後移位運算，最後位運算。請特別注意：1 << 3 + 2 & 7 等價於 (1 << (3 + 2))&7。

邏輯運算最後計算。

陣列、字典

• 陣列使用有序列表儲存同一型別的多個值。相同的值可以多次出現在一個數組的不同位置中。

//建立
let arr = ["s1","s2"]
let arr1:[String] = ["s1","s2"]
let arr2:Array<String> = ["s1","s2"]
//取值
arr[0]
arr2[1]

• 字典用來儲存無序的相同型別資料的集合，Swift字典會強制檢測元素的型別，如果型別不同則會報錯。字典每個值（value）都關聯唯一的鍵（key），鍵作為字典中的這個值資料的識別符號。字典的key沒有型別限制可以是整型或字串，但必須是唯一的。(key的型別必須唯一，值可以宣告未任意型別)

let dic = [1:"標題",2:[1,2,3],] as [Int : Any]
let dic2: [String : Any] = ["title":"標題","data":[1,2,3],]
dic[1]
dic2["title"]

元組

• 元組（tuples）是由其它型別組合而成的型別。元組可能包含零或多個型別，比如 字串、整數、字元、布林、陣列、字典以及其它元組等。同時請注意，元組是值傳遞，而不是引用。在Swift中建立元組的方式很簡單，元組型別是用括號包圍，由一個逗號分隔的零個或多個型別的列表。

let tuples1 = ("Mary", 9001,18.0,[12,13,14],[1:"字典"],(1,"其他元組"))

在建立元組時你還可以給元組中的元素命名(可以部分命名也可以全部命名)

let tuples2 = (str : "Mary", 9001,18.0,arr : [12,13,14],dic : [1:"字典"],tuples : (1,"其他元組"))

你只需要把你想用的、任何型別的值放在圓括號內，用逗號隔開即可。如果你願意你還可以給每個元素命名，提高元組使用效率。

• 從元組中讀元素

如果我們沒有給元組的元素命名，我們可以用點語法，通過定義好的元組變數或常量獲取它的第1個到第n個元素

//獲取匿名元素
tuples1.0
tuples1.5
//獲取命名元素（可以通過名稱取出也可以通過腳表取出）
tuples2.str
tuples2.0
tuples2.tuples.1

如果你覺得上述這種方法會造成語義的不明確，那麼我們還可以將元組賦值給一個帶有元素名稱的元組（元素名稱個數要對應）:

let (a,b,c,d,e,f) = tuples1
print(a)
print(e)

如果你只需要一部分元組值，分解的時候可以把要忽略的部分用下劃線（_）標記：

let (_,b,_,d,e,_) = tuples1
print(b)
print(d)

• 元組作為函式返回值
  當一個函式有多個返回值時，可以用元組作為函式返回值：

func minMax(array: [Int]) -> (min: Int, max: Int) {
     if array.isEmpty { return nil }//避免腳標越界
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("最小值為 \(bounds.min) ，最大值為 \(bounds.max)")

如果你不確定返回的元組一定不為nil，那麼你可以返回一個可選的元組型別。你可以通過在元組型別的右括號後放置一個問號來定義一個可選元組，例如(Int, Int)?或(String, Int, Bool)?
注意:可選元組型別如(Int, Int)?與元組包含可選型別如(Int?, Int?)是不同的.可個元組是可選的選的元組型別，整，而不只是元組中的每個元素值。

//可能沒值
func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}
//可選繫結元組返回值,自動解包
if let bounds = minMax(array: []) {
    print("最小值為 \(bounds.min)，組大值為 \(bounds.max)")
}else{
    print("傳進來的事一個空陣列,返回值未nil")
}

閉包

• 閉包(Closures)是自包含的功能程式碼塊，可以在程式碼中使用或者用來作為引數傳值。全域性函式和巢狀函式其實就是特殊的閉包。
• 以下定義了一個接收引數並返回指定型別的閉包語法：

{(parameters) -> return type in
   statements
}

let studname = { print("Swift 閉包例項。") }
studname()

//類似函式
let divide = {(val1: Int, val2: Int) -> Int in
    return val1 / val2
}
let result = divide(200, 20)
print (result)

• 尾隨閉包
  尾隨閉包是一個書寫在函式括號之後的閉包表示式，函式支援將其作為最後一個引數呼叫。

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // 函式體部分
}

// 以下是不使用尾隨閉包進行函式呼叫
someFunctionThatTakesAClosure({
    // 閉包主體部分
})

// 以下是使用尾隨閉包進行函式呼叫
someFunctionThatTakesAClosure() {
  // 閉包主體部分
}

• 捕獲值

閉包可以在其定義的上下文中捕獲常量或變數。即使定義這些常量和變數的原域已經不存在，閉包仍然可以在閉包函式體內引用和修改這些值。Swift最簡單的閉包形式是巢狀函式，也就是定義在其他函式的函式體內的函式。巢狀函式可以捕獲其外部函式所有的引數以及定義的常量和變數。

func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementor
}

let incrementByTen = makeIncrementor(forIncrement: 10)
// 返回的值為10
print(incrementByTen())
// 返回的值為20
print(incrementByTen())
// 返回的值為30
print(incrementByTen())
//閉包和函式一樣都是引用型別，
let alsoIncrementByTen = incrementByTen
// 返回的值和incrementByTen一樣都是30
print(alsoIncrementByTen())

列舉

• 列舉簡單的說也是一種資料型別，只不過是這種資料型別只包含自定義的特定資料，它是一組有共同特性的資料的集合。
  Swift 的列舉類似於 Objective C 和 C 的結構，列舉的功能為:

1. 它宣告在類中，可以通過例項化類來訪問它的值。
2. 列舉也可以定義建構函式（initializers）來提供一個初始成員值；可以在原始的實現基礎上擴充套件它們的功能。
3. 可以遵守協議（protocols）來提供標準的功能。

• Swift 中使用 enum 關鍵詞來建立列舉並且把它們的整個定義放在一對大括號內：

enum enumname {
   // 列舉定義放在這裡
}

// 定義列舉
enum DaysofaWeek {
    case Sunday
    case Monday
    case TUESDAY
    case WEDNESDAY
    case THURSDAY
    case FRIDAY
    case Saturday
}

var weekDay = DaysofaWeek.THURSDAY
weekDay = .THURSDAY
switch weekDay
{
case .Sunday:
    print("星期天")
case .Monday:
    print("星期一")
case .TUESDAY:
    print("星期二")
case .WEDNESDAY:
    print("星期三")
case .THURSDAY:
    print("星期四")
case .FRIDAY:
    print("星期五")
case .Saturday:
    print("星期六")

列舉中定義的值（如 Sunday，Monday，……和Saturday）是這個列舉的成員值（或成員）。case關鍵詞表示一行新的成員值將被定義。

注意： 和 C 和 Objective-C 不同，Swift 的列舉成員在被建立時不會被賦予一個預設的整型值。在上面的DaysofaWeek例子中，Sunday，Monday，……和Saturday不會隱式地賦值為0，1，……和6。相反，這些列舉成員本身就有完備的值，這些值是已經明確定義好的DaysofaWeek型別。

• 相關值:是當你在建立一個基於列舉成員的新常量或變數時才會被設定，並且每次當你這麼做得時候，它的值可以是不同的。
  以下例項中我們定義一個名為 Student 的列舉型別，它可以是 Name 的一個字串（String），或者是 Mark 的一個相關值（Int，Int，Int）。

import Cocoa

enum Student{
    case Name(String)
    case Mark(Int,Int,Int)
}
var studDetails = Student.Name("Runoob")
var studMarks = Student.Mark(98,97,95)
switch studMarks {
case .Name(let studName):
    print("學生的名字是: \(studName)。")
case .Mark(let Mark1, let Mark2, let Mark3):
    print("學生的成績是: \(Mark1),\(Mark2),\(Mark3)。")
}

• 原始值:原始值可以是字串，字元，或者任何整型值或浮點型值。每個原始值在它的列舉宣告中必須是唯一的。在原始值為整數的列舉時，不需要顯式的為每一個成員賦值，Swift會自動為你賦值。例如，當使用整數作為原始值時，隱式賦值的值依次遞增1。如果第一個值沒有被賦初值，將會被自動置為0。

enum Month: Int {
    case January = 1, February, March, April, May, June, July, August, September, October, November, December
}

let yearMonth = Month.May.rawValue
//數字月份為:5
print("數字月份為: \(yearMonth)。")

類

• Swift類是構建程式碼所用的一種通用且靈活的構造體。我們可以為類定義屬性（常量、變數）和方法。與其他程式語言所不同的是，Swift 並不要求你為自定義類去建立獨立的介面和實現檔案。你所要做的是在一個單一檔案中定義一個類，系統會自動生成面向其它程式碼的外部介面。
• Swift中類和結構體有很多共同點。共同處在於：
  1. 定義屬性用於儲存值
  2. 定義方法用於提供功能
  3. 定義附屬指令碼用於訪問值
  4. 定義構造器用於生成初始化值
  5. 通過擴充套件以增加預設實現的功能
  6. 符合協議以對某類提供標準功能
• 與結構體相比，類還有如下的附加功能：

1. 繼承允許一個類繼承另一個類的特徵
2. 型別轉換允許在執行時檢查和解釋一個類例項的型別
3. 解構器允許一個類例項釋放任何其所被分配的資源
4. 引用計數允許對一個類的多次引用

• 語法

class classname {
   Definition 1
   Definition 2
   ……
   Definition N
}

//定義類
class SampleClass: Equatable {
    let myProperty: String
    let parm : Int
    //可以用建構函式在初始化時，給屬性設定一些預設的值
    init(s: String ,p: Int) {
        myProperty = s
        self.parm = p
    }
    func test() {
        print("SampleClass類中的方法")
    }
}
//定義一個方法比較是不是同一個類
func ==(lhs: SampleClass, rhs: SampleClass) -> Bool {
    return lhs.myProperty == rhs.myProperty
}

let spClass1 = SampleClass(s: "Hello",p:1)
let spClass2 = SampleClass(s: "Hello",p:1)
let spClass3 = spClass1
//恆等運算子 ：如果兩個常量或者變數引用同一個類例項則返回 true
if spClass1 === spClass2 {// false
    print("引用相同的類例項 \(spClass1)")
}
//不恆等運算子 : 如果兩個常量或者變數引用不同一個類例項則返回 true
if spClass1 !== spClass2 {// true
    print("引用不相同的類例項 \(spClass2)")
}
if spClass1 === spClass3 {// true
    print("引用相同的類例項 \(spClass1)")
}

//訪問類中的屬性
spClass3.parm
//訪問類中的方法
spClass3.test()

屬性

• Swift屬性將值跟特定的類、結構或列舉關聯。屬性可分為儲存屬性和計算屬性,儲屬性和計算屬性通常用於特定型別的例項;屬性也可以直接用於型別本身，這種屬性稱為型別屬性。
• 儲存屬性:簡單來說，一個儲存屬性就是儲存在特定類或結構體的例項裡的一個常量或變數。儲存屬性可以是變數儲存屬性（用關鍵字var定義），也可以是常量儲存屬性（用關鍵字let定義）。

//結構體
struct Number
{
    var digits: Int
    let pi = 3.1415
}
var n = Number(digits: 12345)
n.digits = 67
n.pi
//類

class Test
{
    var digits: Int = 0
    var s: Float
    init(x:Float) {
        s = x
    }
    
    let pi = 3.1415
}
let t = Test(x: 20)
t.digits = 20

• 延遲儲存屬性：延遲儲存屬性是指當第一次被呼叫的時候才會計算其初始值的屬性。在屬性宣告前使用lazy來標示一個延遲儲存屬性。
  注意：必須將延遲儲存屬性宣告成變數（使用var關鍵字），因為屬性的值在例項構造完成之前可能無法得到。而常量屬性在構造過程完成之前必須要有初始值，因此無法宣告成延遲屬性。
  延遲儲存屬性一般用於：延遲物件的建立、當屬性的值依賴於其他未知類。

class sample {
    lazy var no = number() // `var` 關鍵字是必須的
}

class number {
    var name = "Runoob Swift 教程"
}

var firstsample = sample()
print(firstsample.no.name)

• 計算屬性:除儲存屬性外，類、結構體和列舉可以定義計算屬性，計算屬性不直接儲存值，而是提供一個 getter 來獲取值，一個可選的 setter 來間接設定其他屬性或變數的值。

class sample {
    var no1 = 0.0, no2 = 0.0,length = 300.0, breadth = 150.0
    //只傳前兩個屬性
    var middle: (Double, Double) {
        get{
            return (length / 2, breadth / 2)
        }
        set(axis){
            //axis.0 等價與no1，axis.1等價於no2
            no1 = axis.0 - (length / 2)
            no2 = axis.1 - (breadth / 2)
        }
    }
}

var result = sample()
print(result.middle)
result.middle = (0.0, 10.0)
print(result.no1)
print(result.no2)

• 只讀計算屬性:只有 getter 沒有 setter 的計算屬性就是隻讀計算屬性。只讀計算屬性總是返回一個值，可以通過點(.)運算子訪問，但不能設定新的值。

class film {
    var head = "sss"
    var duration = 0.0
    //metaInfo是一個只讀屬性
    var metaInfo: [String:String]{//閉包
        return [
            "head": self.head,
            "duration":"\(self.duration)"
        ]
    }
}
var movie = film()
movie.head = "Swift 屬性"
movie.duration = 3.09

print(movie.metaInfo["head"]!)
print(movie.metaInfo["duration"]!)

• 屬性觀察器:屬性觀察器監控和響應屬性值的變化，每次屬性被設定值的時候都會呼叫屬性觀察器，甚至新的值和現在的值相同的時候也不例外。可以為除了延遲儲存屬性之外的其他儲存屬性新增屬性觀察器，也可以通過過載屬性的方式為繼承的屬性（包括儲存屬性和計算屬性）新增屬性觀察器。不需要為無法過載的計算屬性新增屬性觀察器，因為可以通過 setter 直接監控和響應值的變化。
  1. willSet在設定新的值之前呼叫(可以呼叫newTotal)
  2. didSet在新的值被設定之後立即呼叫（可以呼叫oldValue）
  3. willSet和didSet觀察器在屬性初始化過程中不會被呼叫

 class Samplepgm {
   var counter: Int = 0{
       willSet(newTotal){
           print("計數器新值: \(newTotal)")
       }
       didSet{
           print("新增數舊值 \(oldValue)")
           if counter > oldValue {
               print("新增數 \(counter - oldValue)")
           }
       }
   }
}
let NewCounter = Samplepgm()
NewCounter.counter = 100
NewCounter.counter = 800

• 型別屬性:型別屬性是作為型別定義的一部分寫在型別最外層的花括號（{}）內。使用關鍵字 static 來定義值型別的型別屬性，關鍵字 class 來為類定義型別屬性。

struct Structname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // 這裡返回一個 Int 值
   }
}

enum Enumname {
   static var storedTypeProperty = " "
   static var computedTypeProperty: Int {
      // 這裡返回一個 Int 值
   }
}

class Classname {
   class var computedTypeProperty: Int {
      // 這裡返回一個 Int 值
   }
}

struct StudMarks {
    //類屬性
    static let markCount = 97
    static var totalCount = 0
    //例項屬性
    var InternalMarks: Int = 0 {
        didSet {
            if InternalMarks > StudMarks.markCount {
                InternalMarks = StudMarks.markCount
            }
            if InternalMarks > StudMarks.totalCount {
                StudMarks.totalCount = InternalMarks
            }
        }
    }
}

var stud1Mark1 = StudMarks()
var stud1Mark2 = StudMarks()
//設定例項屬性
stud1Mark1.InternalMarks = 98
//設定類屬性
StudMarks.totalCount = 100
//獲取例項屬性
print(stud1Mark1.InternalMarks)
//獲取類屬性
print(StudMarks.markCount)
print(StudMarks.totalCount)

方法

• Swift方法是與某些特定型別相關聯的函式，在 Objective-C 中，類是唯一能定義方法的型別。但在 Swift 中，你不僅能選擇是否要定義一個類/結構體/列舉，還能靈活的在你建立的型別（類/結構體/列舉）上定義方法。

• 例項方法 : 於某個特定類、結構體或者列舉型別例項的方法。方法的區域性引數名稱和外部引數名稱,可以使用下劃線_做匿名引數

func funcname(Parameters) -> returntype
{
    Statement1
    Statement2
    ……
    Statement N
    return parameters
}

struct area {
    var length = 1
    var breadth = 1
    
    func area() -> Int {
        return length * breadth
    }
    //Swift 語言中結構體和列舉是值型別。一般情況下，值型別的屬性不能在它的例項方法中被修改。你可以選擇變異(mutating)這個方法，然後方法就可以從方法內部改變它的屬性
    mutating func scaleBy(res: Int) {
        length *= res
        self.breadth *= res
        
        print(length)
        print(breadth)
    }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

• 型別方法：例項方法是被型別的某個例項呼叫的方法，你也可以定義型別本身呼叫的方法，這種方法就叫做型別方法。宣告結構體和列舉的型別方法，在方法的func關鍵字之前加上關鍵字static。類可能會用關鍵字class來允許子類重寫父類的實現方法。型別方法和例項方法一樣用點號(.)語法呼叫。

struct absno
{
    static func abs(number: Int) -> Int
    {
        if number < 0
        {
            return (-number)
        }
        else
        {
            return number
        }
    }
}
let num = absno.abs(number: -5)
print(num)

• 下標指令碼語法及應用:下標指令碼 可以定義在類（Class）、結構體（structure）和列舉（enumeration）這些目標中，可以認為是訪問物件、集合或序列的快捷方式，不需要再呼叫例項的特定的賦值和訪問方法。與定義例項方法類似，定義下標指令碼使用subscript關鍵字，顯式宣告入參（一個或多個）和返回型別。

struct subexample {
    let decrementer: Int
    subscript(index: Int) -> Int {
        return decrementer / index
    }
}
let division = subexample(decrementer: 100)

print("100 除以 9 等於 \(division[9])")
print("100 除以 2 等於 \(division[2])")
print("100 除以 3 等於 \(division[3])")
print("100 除以 5 等於 \(division[5])")
print("100 除以 7 等於 \(division[7])")

• 通常下標指令碼是用來訪問集合（collection），列表（list）或序列（sequence）中元素的快捷方式。

class daysofaweek {
    private var days = ["Sunday", "Monday", "Tuesday", "Wednesday",
                        "Thursday", "Friday", "saturday"]
    subscript(index: Int) -> String {
        get {
            return days[index]   // 宣告下標指令碼的值
        }
        set(newValue) {
            self.days[index] = newValue   // 執行賦值操作
        }
    }
}
var p = daysofaweek()

print(p[0])
print(p[1])
print(p[2])
print(p[3])