• 一、第一部分：

• 1.Playgrounds overview

76EC2ADC-AA6C-43AD-9A57-2C08844F059C.png

• 1.Source edit：r這是你要寫你的Swift代碼的地方。它就像一個文本編輯器，如記事本或TextEdit。您會注意到使用了所謂的單空間字體，這意味著所有的字符都是相同的寬度。這使得代碼更易于閱讀和格式化。
• 2.Results sidebar：結果側欄將是您將確認您的代碼是否正常工作的主要地方
• 3.Execution control：默認情況下，playground會自動執行，這意味著你可以編寫代碼并立即看到輸出。這個控制允許你再次執行操場。按住按鈕允許您在自動執行和手動執行模式之間切換。
• 4.Activity viewer：這顯示了playground的狀態。在Inthescreenshot中，它顯示了操場已經完成了，并且準備在源代碼編輯器中處理更多的代碼。當操場執行時，這個觀察者將用一個旋轉器來表示這個。
• 5.Panel controls：這些切換開關顯示并隱藏了三個面板，一個出現在左邊，一個在底部，一個在右邊。這些面板顯示了您可能需要不時訪問的額外信息。你通常會把它們隱藏起來，就像它們在截圖中一樣。

• 二、第二部分Expressions

• 1.The operators for these two operations are as follows:

  • 1.操作符

  • Shiftleft:<<

  • Shiftright:>>

• 2.Math functions

sin(45 * Double.pi / 180)
// 0.7071067811865475
cos(135 * Double.pi / 180)
// -0.7071067811865475
 sqrt(2.0)              //根號
// 1.414213562373095
max(5, 10)             // 兩者中取最大值
// 10
min(-5, -10)           // 兩者中取最小值
// -10
 max(sqrt(2.0), Double.pi / 2)
// 1.570796326794897

如果一個字符串0的個數太多你很難數出寫了幾個0的話，你可以這樣

5A7DBBB1-1734-4B99-9127-D093FD231018.png

• 三、第三部分：Types & Operations類型和操作

• Tuples元組

tuple是表示由任何類型的多個值組成的數據的類型。您可以在tuple中擁有任意多的值。
例如，您可以定義一對2D坐標，其中每個軸值都是一個整數，如下所描述的:

• Dictionary(字典)

var namesAndScores = ["Anna": 2, "Brian": 2, "Craig": 8, "Donna": 6]
namesAndScores.isEmpty  //  false
namesAndScores.count    //  4
Array(namesAndScores.keys) // ["Craig", "Anna", "Donna","Brian"]
Array(namesAndScores.values)   // [8, 2, 6, 2]
// 根據key更新值
namesAndScores.updateValue(6, forKey: "Brian") // 
print(namesAndScores["Brian"]) // 6
// There’s even a shorter way to add pairs, using subscripting: 添加鍵值對
bobData["city"] = "San Francisco"
// Removing pairs：移除鍵值對
namesAndScores.removeValue(forKey: "Anna")
// 該方法將從字典中刪除鍵狀態及其關聯值。
// 如您所料，使用下標更短的方法來實現這一點:
namesAndScores["Donna"] = nil

• Iterating through dictionaries（字典遍歷）

var namesAndScores = ["Anna": 2, "Brian": 2, "Craig": 8, "Donna": 6]
for (player, score) in namesAndScores {
      print("\(player) - \(score)")
}
// > Craig - 8
// > Anna - 2
// > Donna - 6
// > Brian - 2
for player in namesAndScores.keys {
  print("\(player)") 
}
// > Craig, Anna, Donna, Brian

• 四、第四部分：Basic Control Flow(流程控制)

• Bool：TRUE AND FALSE

let a = 5
let b = 10
let min: Int
if a < b { min = a } else {   min = b }
let max: Int
if a > b { max = a } else {max = b }

• 三目運算符：(<CONDITION>) ? <TRUE VALUE> : <FALSE VALUE>

let a = 5
let b = 10
let min = a < b ? a : b
let max = a > b ? a : b

• While loops(循環)先判斷條件再執行

while <CONDITION> {
        <LOOP CODE>
 }
var sum = 1
while sum < 1000 {
        sum = sum + (sum + 1)  // 1023
}

解釋：

? Afteriteration2:sum=7,loopcondition=true?
? Afteriteration3:sum=15,loopcondition=true ? ?Afteriteration4:sum=31,loopcondition=true ? ?Afteriteration5:sum=63,loopcondition=true ? ?Afteriteration6:sum=127,loopcondition=true?
? Afteriteration7:sum=255,loopcondition=true?
? Afteriteration8:sum=511,loopcondition=true?
? Afteriteration9:sum=1023,loopcondition=false?

• Repeat-while loops (先執行再判斷條件)

repeat {
        <LOOP CODE>
} while <CONDITION>
var sum = 1
repeat {
        sum = sum + (sum + 1)  // 1023
} while sum < 1000

• Breaking out of a loop

var sum = 1
while true {
      sum = sum + (sum + 1)
      if sum >= 1000 {
          break  // 當sum >= 1000調出循環
      } 
}

• For loops

for <CONSTANT> in <RANGE> {
      <LOOP CODE> 
}

• eg1: for

  
  

var sum = 0
for row in 0..<8 {
          if row % 2 == 0 {
            continue
        }
        for column in 0..<8 {
            sum += row * column
        }
}

• eg2: for

  
  

var sum = 0
rowLoop: for row in 0..<8 {  // 給行循環起一個名字rowLoop
        columnLoop: for column in 0..<8 {  // 給列循環起一個名字columnLoop
            if row == column {  // 如果行數等于列數
              continue rowLoop // 不執行此次行的循環
            }
            sum += row * column
         }
}

• eg3: for遍歷

for index in stride(from: 10, to: 22, by: 4) {
          print(index)
}
// prints 10, 14, 18
for index in stride(from: 10, through: 22, by: 4) {
          print(index)
}
// prints 10, 14, 18, and 22

• Switch statements

let number = 10
switch number {
      case 0:
        print("Zero")
      default:
        print("Non-zero")
}

• Advanced switch statements

let hourOfDay = 12
let timeOfDay: String
switch hourOfDay {
        case 0, 1, 2, 3, 4, 5:
           timeOfDay = "Early morning"
        case 6, 7, 8, 9, 10, 11:
           timeOfDay = "Morning"
        case 12, 13, 14, 15, 16:
          timeOfDay = "Afternoon"
        case 17, 18, 19:
          timeOfDay = "Evening"
        case 20, 21, 22, 23:
          timeOfDay = "Late evening"
        default:
          timeOfDay = "INVALID HOUR!"
}
// 優化寫法
switch hourOfDay {
        case 0...5:
           timeOfDay = "Early morning"
        case 6...11:
           timeOfDay = "Morning"
        case 12...16:
           timeOfDay = "Afternoon"
        case 17...19:
           timeOfDay = "Evening"
        case 20..<24:
           timeOfDay = "Late evening"
        default:
           timeOfDay = "INVALID HOUR!"
}

• Partial matching（部分匹配）

let coordinates = (x: 3, y: 2, z: 5)
switch coordinates {
       case (0, 0, 0): // 1
           print("Origin")
       case (_, 0, 0): // 2
           print("On the x-axis.")
       case (0, _, 0): // 3
           print("On the y-axis.")
       case (0, 0, _): // 4
           print("On the z-axis.")
       default:        // 5
           print("Somewhere in space")
}
// 更進一步
let coordinates1 = (x: 3, y: 6, z: 4)
switch coordinates1 {
       case (0, 0, 0):
          print("Origin")
       case (let x, 0, 0):
          print("On the x-axis at x = \(x)")
       case (0, let y, 0):
          print("On the y-axis at y = \(y)")
       case (0, 0, let z):
          print("On the z-axis at z = \(z)")
       case let (x, y, z):
          print("Somewhere in space at x = \(x), y = \(y), z = \(z)")
}
// Somewhere in space at x = 3, y = 6, z = 4
// let coordinates1 = (x: 3, y: 0, z: 0)  On the x-axis at x = 3
// let coordinates1 = (x: 0, y: 6, z: 0)  On the y-axis at y = 6
// let coordinates1 = (x: 0, y: 0, z: 4)  On the z-axis at z = 4

• 五、第五部分：Function(函數)

• Function parameters(帶參函數)

func printMultipleOf(multiplier: Int, andValue: Int) {
          print("\(multiplier) * \(andValue) = \(multiplier * andValue)")
}
printMultipleOf(multiplier: 4, andValue: 2) // 4 * 2 = 8

• default values to parameters（默認參數）

func printMultipleOf(_ multiplier: Int, _ value: Int = 1) {
          print("\(multiplier) * \(value) = \(multiplier * value)")
}
printMultipleOf(4)// 4 * 1 = 4

• Return values（返回參數）

func multiply(_ number: Int, by multiplier: Int) -> Int {
          return number * multiplier
}
let result = multiply(4, by: 2) // 8

• Advanced parameter handling

// 錯誤示范
 func incrementAndPrint(_ value: Int) {
            value += 1
            print(value)
}
var value = 5
incrementAndPrint(value)  // 報錯了，如下
This results in an error:
Left side of mutating operator isn't mutable: 'value' is a 'let' constant

func incrementAndPrint(_ value: inout Int) {
            value += 1
            print(value)
}
var value = 5
incrementAndPrint(&value)
print(value)  // 6

• Overloading（重載,OC不行吶）

  • eg1：舉個栗子

func printMultipleOf(multiplier: Int, andValue: Int){}
func printMultipleOf(multiplier: Int, and value: Int){}
func printMultipleOf(_ multiplier: Int, and value: Int){}
func printMultipleOf(_ multiplier: Int, _ value: Int){}

• eg2：舉個??

func getValue() -> Int {
          return 31; 
}
func getValue() -> String {
          return "Matt Galloway"
}
let value = getValue()
// 報錯
error: ambiguous use of 'getValue()'
// 需明確類型
let valueInt: Int = getValue() // 31
let valueString: String = getValue() // "Matt Galloway"

• Functions as variables（給方法取個名字）

func add(_ a: Int, _ b: Int) -> Int {
          return a + b 
}
var function = add
function(4, 2) // 6
func subtract(_ a: Int, _ b: Int) -> Int {
          return a - b 
}
function = subtract
function(4, 2) // 2
func printResult(_ function: (Int, Int) -> Int, _ a: Int, _ b: Int) {
          let result = function(a, b)  // 6
          print(result)
}
printResult(add, 4, 2) // 6

• 輕輕點擊，關注我簡書

輕輕點擊，關注我簡書

輕輕點擊，關注我微博

瀏覽我的GitHub

• 掃一掃，關注我

掃一掃，關注我.jpg