var greeting: String = "Hello"
var numberOfToys: Int = 8
var isMorning: Bool = true
var price: Double = 8.99

var apples = 6
print("I have \(apples) apples!")
// 打印: I have 6 apples!

let myLongString = """
Swift?
這是我最喜歡的語言！
"""

// 這一行表示 Swift 中的注釋。
/*
這都被注釋掉了。
沒有一個(gè)會(huì)跑！
*/

let player = (name: "Maya", level: 5)
let (currentName, curLevel) = player
print("\(currentName): level \(curLevel)")
// 打印: Maya: level 5

// MARK: - 查看設(shè)置

MARK 可用于在欄中顯示評(píng)論

// TODO: 更新邏輯以適應(yīng)數(shù)據(jù)更改

TODO 用于顯示需要完成的事情的提醒

// FIXME: 修復(fù)對(duì)現(xiàn)有條目進(jìn)行更改時(shí)的故障行為

FIXME 用于顯示需要修復(fù)的內(nèi)容的提醒

變量用 var 聲明：

var greeting = "你好"
var numberOfToys = 8
var isMorning = true

為了清楚起見，變量聲明可以包含類型注釋：

var greeting: String = "你好"
var numberOfToys: Int = 8
var isMorning: Bool = true

變量是可變的。 它們的值可以改變：

var numberOfToys: Int = 8
numberOfToys += 1
print(numberOfToys) // 打印“9”

常量用 let 聲明：

let greeting = "Hello"
let numberOfToys = 8
let isMorning = true

為清楚起見，常量聲明可以包含類型注釋：

let greeting: String = "Hello"
let numberOfToys: Int = 8
let isMorning: Bool = true

常量是不可變的。它們的值不能改變：

let numberOfToys: Int = 8
numberOfToys += 1
// ? 錯(cuò)誤：numberOfToys 不可變

var distance = 5 {
  didSet {
    print("距離設(shè)置為 \(distance)")
    print("它的舊值是： \(oldValue)")
  }
}
distance = 10 // 打印: 距離將被設(shè)置 10
              // 打印: 它的舊值是：5

var distance = 5 {
  willSet(newDistance) {
    print("距離將設(shè)置為 \(newDistance)")
  }
  didSet {
    print("距離設(shè)置為 \(distance)")
    print("它的舊值是： \(oldValue)")
  }
}
distance = 10

var halloween = true 
if halloween {
  print("不給糖就搗蛋！")
}
// 打印: 不給糖就搗蛋！ 
if 5 > 3 {
  print("5 大于 3")
} else {
  print("5 不超過 3")
}
// 輸出: "5 大于 3"

var turbulence = false

if turbulence {
  print("請(qǐng)坐好。")
} else {
  print("你可以自由地四處走動(dòng)。")
}
// 打印: 你可以自由地四處走動(dòng)。

var weather = "rainy"
if weather == "sunny" {
  print("拿點(diǎn)防曬霜")
} else if weather == "rainy" {
  print("拿一把雨傘")
} else if weather == "snowing" {
  print("穿上你的雪地靴")
} else {
  print("無效天氣")
}
// 打印: 拿一把雨傘

5 > 1          // true 
6 < 10         // true 
2 >= 3         // false
3 <= 5         // true
"A" == "a"     // false
"B" != "b"     // true

• < 小于
• > 大于
• <= 小于或等于
• >= 大于或等于
• == 等于
• != 不等于

var driverLicense = true

driverLicense 
    ? print("駕駛座") : print("乘客座位") 
// 打印: 駕駛座

var secondaryColor = "green"

switch secondaryColor {
  case "orange":
    print("紅色和黃色的混合")
  case "purple":
    print("紅色和藍(lán)色的混合") 
  default: 
    print("這可能不是輔助顏色") 
}
// 打印: 藍(lán)色和黃色的混合

let year = 1905
var artPeriod: String

switch year {
  case 1860...1885:
    artPeriod = "印象派"
  case 1886...1910:
    artPeriod = "后印象派"
  default:  
    artPeriod = "未知"
}
// 打印: 后印象派

let service = "Seamless"

switch service {
  case "Uber", "Lyft":
    print("旅行")
  case "DoorDash", "Seamless", "GrubHub":
    print("餐廳送餐")
  case "Instacart", "FreshDirect":
    print("雜貨配送")
  default: 
    print("未知服務(wù)")
}
// 打印: 餐廳外賣

let num = 7

switch num {
  case let x where x % 2 == 0:
    print("\(num) 是偶數(shù)")
  case let x where x % 2 == 1:
    print("\(num) 奇數(shù)")
  default:
    print("\(num) 無效")
}

// 打印: 7 奇數(shù)

!true          // false
!false         // true

true && true    // true
true && false   // false 
false && true   // false 
false && false  // false

true || true    // true
true || false   // true
false || true   // true 
false || false  // false

!false && true || false // true

!false && true 首先計(jì)算并返回 true 然后，表達(dá)式，true || false 評(píng)估并返回最終結(jié)果 true

false || true && false  // false

true && false 首先計(jì)算返回 false 然后，表達(dá)式，false || false 評(píng)估并返回最終結(jié)果 false

// 沒有括號(hào)：
true || true && false || false
// ---->  true 

// 帶括號(hào)：
(true || true) && (false || false)
// ---->  false 

func greet(name: String?) {
  guard let unwrapped = name else {
    print("Hello guest!")
    return
  }
  print("Hello \(unwrapped)!")
}
greet(name: "Asma") // 輸出：Hello Asma!
greet(name: nil)    // 輸出：Hello guest!

let zeroToThree = 0...3
// zeroToThree: 0, 1, 2, 3

for oddNum in stride(from: 1, to: 5, by: 2) {
  print(oddNum)
}
// 打印: 1
// 打印: 3

for char in "hehe" {
  print(char)
}
// 打印: h
// 打印: e
// 打印: h
// 打印: e

for num in 0...5 {
  if num % 2 == 0 {
    continue
  }
  print(num)
}
// 打印: 1
// 打印: 3
// 打印: 5

continue 關(guān)鍵字將強(qiáng)制循環(huán)繼續(xù)進(jìn)行下一次迭代

for char in "supercalifragilistice" {
  if char == "c" {
    break
  }
  print(char)
}
// 打印: s
// 打印: u
// 打印: p
// 打印: e
// 打印: r

for _ in 1...3 {
  print("Olé")
}
// 打印: Olé
// 打印: Olé
// 打印: Olé

var counter = 1
var stopNum = Int.random(in: 1...10)

while counter < stopNum {
  print(counter)
  counter += 1
}
// 循環(huán)打印，直到滿足停止條件

while 循環(huán)接受一個(gè)條件，并在所提供的條件為 true 時(shí)持續(xù)執(zhí)行其主體代碼。如果條件從不為假，則循環(huán)將繼續(xù)運(yùn)行，程序?qū)⑾萑?code>無限循環(huán)

var scores = [Int]()
// 數(shù)組為空：[]

var grocery = ["??", "??", "??", "??", "??"]
print(grocery.count)
// 打印: 5

// 使用類型推斷：
var snowfall = [2.4, 3.6, 3.4, 1.8, 0.0]
// 明確類型：
var temp: [Int] = [33, 31, 30, 38, 44]

var gymBadges = ["Boulder", "Cascade"]
gymBadges.append("Thunder")
gymBadges += ["Rainbow", "Soul"]
// ["Boulder", "Cascade", "Thunder",
//   "Rainbow", "Soul"]

var moon = ["??", "??", "??", "??"]
moon.insert("??", at: 0)
// ["??", "??", "??", "??", "??"]

moon.remove(at: 4)
// ["??", "??", "??", "??"]

var employees = ["小王", "張三", "王五"]
for person in employees {
  print(person)
}
// 打印: 小王
// 打印: 張三
// 打印: 王五

var paintingsInMOMA: Set = [
  "The Dream",
  "The Starry Night",
  "The False Mirror"
]

我們可以使用集合(Set)來存儲(chǔ)相同數(shù)據(jù)類型的唯一元素

var team = Set<String>()

print(team)
// 打印: [] 

var vowels: Set = ["a", "e", "i", "o","u"]

要?jiǎng)?chuàng)建一個(gè)填充有值的集合，請(qǐng)?jiān)谫x值運(yùn)算符之前使用 Set 關(guān)鍵字。

var cookieJar: Set = [
  "Chocolate Chip",
  "Oatmeal Raisin"
]
// 添加一個(gè)新元素
cookieJar.insert("Peanut Butter Chip")

var oddNumbers: Set = [1, 2, 3, 5]

// 移除現(xiàn)有元素
oddNumbers.remove(2)
// 刪除所有元素
oddNumbers.removeAll()

var names: Set = ["Rosa", "Doug", "Waldo"]
print(names.contains("Lola")) //打印: false

if names.contains("Waldo"){
  print("There's Waldo!")
} else {
  print("Where's Waldo?")
}
// 打印: There's Waldo!

var recipe: Set = ["蛋", "面粉", "糖"]

for ingredient in recipe {
  print ("在配方中包含\(ingredient)")
}

var emptySet = Set<String>()
print(emptySet.isEmpty)  // 打印: true

var populatedSet: Set = [1, 2, 3]
print(populatedSet.isEmpty) // 打印: false

var band: Set = ["張三", "王五", "趙六"]

print("樂隊(duì)有 \(band.count) 名演奏者。")
// 打印: 樂隊(duì)有 4 名演奏者。

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]

var setC = setA.intersection(setB)
print(setC)  // 打印: ["D", "C"]

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]

var setC = setA.union(setB)
print(setC) 
// 打印: ["B", "A", "D", "F", "C", "E"]

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D", "E", "F"]

var setC = setA.symmetricDifference(setB)
print(setC) 
// 打印: ["B", "E", "F", "A"]

var setA: Set = ["A", "B", "C", "D"]
var setB: Set = ["C", "D"]

var setC = setA.subtracting(setB)
print(setC) 
// 打印: ["B", "A"]

var dictionaryName = [
  "Key1": "Value1",
  "Key2": "Value2",
  "Key3": "Value3"
]

成對(duì)數(shù)據(jù)或鍵值對(duì)的無序集合

var fruitStand = [
  "Coconuts": 12,
  "Pineapples": 12,
  "Papaya": 12
]

每個(gè)鍵都是唯一的，即使它們都包含相同的值

var numberOfSides = [
  "triangle": 3,
  "square": 4,
  "rectangle": 4
]

僅包含 String 鍵和 Int 值

var employeeID = [
  "Hamlet": 1367,
  "Horatio": 8261,
  "Ophelia": 9318
]

// 初始化器語法：
var yearlyFishPopulation = [Int: Int]()

// 空字典字面量語法：
var yearlyBirdPopulation: [Int: Int] = [:]

var pronunciation = [
  "library": "lai·breh·ree",
  "apple": "a·pl"
]
// 新鍵：“programming”，新值：“prow·gra”
pronunciation["programming"] = "prow·gra"

var bakery = [String:Int]()

// 檢查字典是否為空
print(bakery.isEmpty)    // 打印 true
bakery["Cupcakes"] = 12
// 檢查字典是否為空
print(bakery.isEmpty)    // 打印 false

var fruitStand = [
  "Apples": 12,
  "Oranges", 17
]
print(fruitStand.count)  // 打印: 2

var hex = [
  "red": "#ff0000",
  "yellow": "#ffff00",
  "blue": "#0000ff",
]

print("藍(lán)色十六進(jìn)制代碼 \(hex["blue"])")
// 打印: 藍(lán)色十六進(jìn)制代碼 Optional("#0000ff")

if let redHex = hex["red"] {
  print("紅色的十六進(jìn)制代碼 \(redHex)")
}
// 打印: 紅色的十六進(jìn)制代碼 #ff0000

將鍵值對(duì)的值分配給變量將返回一個(gè)可選值。要提取值，請(qǐng)使用可選的展開

var emojiMeaning = [
  "??": "Thinking Face",
  "??": "Sleepy Face",
  "??": "Dizzy Face"
]
// 遍歷鍵和值
for (emoji, meaning) in emojiMeaning {
  print("\(emoji)被稱為'\(meaning)Emoji'")
}
// 僅通過鍵迭代
for emoji in emojiMeaning.keys {
  print(emoji)
}
// 僅通過值迭代
for meaning in emojiMeaning.values {
  print(meaning)
}

func washCar() -> Void {
  print("Soap")
  print("Scrub")
  print("Rinse")
  print("Dry")
}

func greetLearner() {
 print("歡迎來到 Quick Reference!")
}
// 函數(shù)調(diào)用：
greetLearner()
// 打印: 歡迎來到 Quick Reference!

let birthYear = 1994
var currentYear = 2020

func findAge() -> Int {
  return currentYear - birthYear
}

print(findAge()) // 打印: 26

func findDiff(_ a: Int, b: Int) -> Int {
  return a - b
}

print(findDiff(6, b: 4)) // 打印: 2

func findSquarePerimet(side: Int) -> Int {
  return side * 4
} 

let perimeter = findSquarePerimet(side: 5)
print(perimeter) // 打印: 20

// Parameter: side
// Argument:  5

func nextTotalSolarEclipse() -> String {
  "April 8th, 2024 ??"
}

print(nextTotalSolarEclipse())
// 打印: April 8th, 2024 ??

func greet(person: String = "guest") {
  print("Hello \(person)")
}
greet() // Hello guest
greet(person: "Aliya") // Hello Aliya

func totalStudent(data: String...) -> Int {
  let numStudents = data.count
  return numStudents
}

print(totalStudent(data: "王五", "張三"))
// 打印: 2

func getFirstInitial(from name: String?) -> String? {
  return name?.first
}

函數(shù)可以接受可選類型并返回可選類型。當(dāng)一個(gè)函數(shù)不能返回請(qǐng)求類型的合理實(shí)例時(shí)，它應(yīng)該返回 nil

struct Building {
  var address: String
  var floors: Int

  init(address: String, floors: Int) {
    self.address = address
    self.floors = floors
  }
}

結(jié)構(gòu)或結(jié)構(gòu)用于以編程方式在代碼中表示現(xiàn)實(shí)生活中的對(duì)象。結(jié)構(gòu)是使用 struct 關(guān)鍵字創(chuàng)建的，后跟其名稱，然后是包含其屬性和方法的主體

struct Car {
  var numOfWheels = 4
  var topSpeed = 80
}

var reliantRobin = Car(numOfWheels: 3)

print(reliantRobin.numOfWheels) // 打印: 3
print(reliantRobin.topSpeed)    // 打印: 80

struct Person {
  var name: String
  var age: Int

  init(name: String, age: Int) {
    self.name = name
    self.age = age
  }
}

// Person 實(shí)例：
var morty = Person(name: "張三", age: 14)

print(type(of: "abc")) // 打印: String
print(type(of: 123))   // 打印: 123

struct Dog {
  func bark() {
    print("Woof")
  }
}
let fido = Dog()
fido.bark() // 打印: Woof

class Person {
  var name = ""
  var age = 0
}

var sonny = Person()
// sonny 現(xiàn)在是 Person 的一個(gè)實(shí)例

var ferris = Student()

ferris.name = "Ferris Bueller"
ferris.year = 12
ferris.gpa = 3.81
ferris.honors = false

使用數(shù)據(jù)類型

class Student {
  var name: String
  var year: Int
  var gpa: Double
  var honors: Bool
}

使用默認(rèn)屬性值

class Student {
  var name = ""
  var gpa = 0.0
  var honors = false
}

struct Resolution {
  var width = 0
  var height = 0
}
class VideoMode {
  var resolution = Resolution()
  var interlaced = false
  var frameRate = 0.0
  var name: String?
}

Resolution 結(jié)構(gòu)定義和 VideoMode 類定義僅描述 Resolution 或 VideoMode 的外觀，創(chuàng)建結(jié)構(gòu)或類的實(shí)例：

let resolution = Resolution(width: 1920)
let someVideoMode = VideoMode()

enum Day {
  case monday
  case tuesday
  case wednesday
  case thursday
  case friday
  case saturday
  case sunday
}

let casualWorkday: Day = .friday

enum Dessert {
  case cake(flavor: String)
  case vanillaIceCream(scoops: Int)
  case brownie
}

let customerOrder: Dessert = .cake(flavor: "紅色天鵝絨")
switch customerOrder {
  case let .cake(flavor):
    print("你點(diǎn)了一個(gè) \(flavor) 蛋糕")
  case .brownie: 
    print("你點(diǎn)了一塊巧克力蛋糕")
}
// 打印: "你點(diǎn)了一個(gè)紅色天鵝絨蛋糕"

enum Season: CaseIterable {
  case winter
  case spring
  case summer
  case fall
}

for season in Season.allCases {
  print(season)
}

添加對(duì) CaseIterable 協(xié)議的一致性以訪問 allCases 屬性，該屬性返回枚舉的所有案例的數(shù)組

enum Beatle: String {
  case john, paul, george, ringo
}

print("披頭士是 \(Beatle.john.rawValue).")
// 打印: 披頭士是 john.

enum Dessert {
  case cake(flavor: String)
  case vanillaIceCream(scoops: Int)
  case brownie
}

let order: Dessert = .cake(flavor: "紅色天鵝絨")

enum Hello: String {
  case english = "Hello"
  case japanese = "你好呀！"
  case emoji = "??"
}
let hello1 = Hello(rawValue: "你好呀！")
let hello2 = Hello(rawValue: "Привет")
print(hello1) // Optional(Hello.japanese)
print(hello2) // nil

enum ShirtSize: String {
  case small = "S"
  case medium = "M"
  case large = "L"
  case extraLarge = "XL"
  var description: String {
    return "這件襯衫尺碼是 \(self.rawValue)"
  }
}