Swift

(1, "zebra") < (2, "apple")   // true because 1 is less than 2; "zebra" and "apple" are not compared
(3, "apple") < (3, "bird")    // true because 3 is equal to 3, and "apple" is less than "bird"
(4, "dog") == (4, "dog")      // true because 4 is equal to 4, and "dog" is equal to "dog"

("blue", false) < ("purple", true)  // Error because < can't compare Boolean values

var myString: String?

myString = "abcd";

if myString != nil {
   print(myString)                       // 输出 Optional("abcd")
   print(myString!)                      // 输出 abcd
} else {
   print("myString has nil value")
}

let possibleString: String? = "An optional string."
let forcedString: String = possibleString!          // 需要一个感叹号，不方便
print(forcedString)

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString          // 不再需要一个额外的感叹号了，方便多了！
print(implicitString)

if let constantName = someOptional {      // Optional Binding
   statements
}

var myString:String? = "Hello, Swift 4!"

if let yourString = myString {      // 注：不能写为 `myString!` 即无需Unwrap操作（不用感叹号）
   print(yourString)                // 输出 Hello, Swift 4!
} else {
   print("Your string does not have a value")
}

func f1() -> String? {
    let a: String? = nil

    return a?.uppercased()  // 如果 a 是 nil，则 f1 返回 nil；如果 a 是 String，则 f1 返回其大写形式
}

let someString:String = "Some string literal value"

let quotation = """
The White Rabbit put on his spectacles.  "Where shall I begin,
please your Majesty?" he asked.

"Begin at the beginning," the King said gravely, "and go on
till you come to the end; then stop."
"""

print(quotation)

let quotation = """
    The White Rabbit put on his spectacles.  "Where shall I begin,
    please your Majesty?" he asked.

    "Begin at the beginning," the King said gravely, "and go on
    till you come to the end; then stop."
    """

print(quotation)

let c:Character = "a"

print(c)

let c:Character = "a"

var s = "abc"
s.append(c);          // 方法append可以在“字符串”后增加“字符”

print(c)
print(s)

let apples = 3
let oranges = 5

let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."

print(appleSummary)    // I have 3 apples.
print(fruitSummary)    // I have 8 pieces of fruit.

var s = Set<String>()

s.insert("abc")
s.insert("edf")

print(s)                  // ["abc", "edf"]

var someSet: Set = ["x", "y", "z"]

// "count" method can be used to show the number of elements in the set.
someSet.count           // the number of elements

// "insert" method can be used to insert values in set.
someSet.insert("c")     // adds the element to Set.

// Similarly, isEmpty can be used to check if set is empty.
someSet.isEmpty         // returns true or false depending on the set Elements.

// "remove" method can be used to remove value in set.
someSet.remove("c")     // removes a element , removeAll() can be used to remove all elements

// "contains" method can be used to check existence of value in a set.
someSet.contains("c")   // to check if set contains this value.

for items in someSet {
   print(someSet)
}

// Swift sets are not in an ordered way, to iterate over a set in ordered way use
for items in someSet.sorted() {
   print(someSet)
}

let evens: Set = [10,12,14,16,18]
let odds: Set = [5,7,9,11,13]
let primes = [2,3,5,7]

print(odds.union(evens).sorted())
// [5,7,9,10,11,12,13,14,16,18]

print(odds.intersection(evens).sorted())
//[]

print(odds.subtracting(primes).sorted())
//[9, 11, 13]

for index in 1...5 {
    print(index)        // 按行分别输出 1 2 3 4 5
}

for index in 1..<5 {
    print(index)        // 按行分别输出 1 2 3 4
}

let names = ["Anna", "Alex", "Brian", "Jack"]

for name in names[2...] {
    print(name)
}
// Brian
// Jack

for name in names[...2] {
    print(name)
}
// Anna
// Alex
// Brian

for name in names[..<2] {
    print(name)
}
// Anna
// Alex

func pow(firstArg a: Int, secondArg b: Int) -> Int {
    var res = a
    for _ in 1..<b {
        res = res * a
    }
    return res
}

var i = pow(firstArg:5, secondArg:3)    // 函数内部使用 a,b 调用它时使用 firstArg, secondArg

print(i)

func pow(_ a: Int, _ b: Int) -> Int {    // 参数 label 为 _ ，这样调用函数时不用指定参数名
    var res = a
    for _ in 1..<b {
        res = res * a
    }
    return res
}

var i = pow(5, 3)

print(i)

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {  // incrementer是嵌套函数，它捕获了外围环境中的变量runningTotal和amount
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let incrementByTen = makeIncrementer(forIncrement: 10)

print(incrementByTen()) // 输出10
print(incrementByTen()) // 输出20
print(incrementByTen()) // 输出30

let incrementBySeven = makeIncrementer(forIncrement: 7)
print(incrementBySeven()) // 输出7

print(incrementByTen()) // 输出40

var nums: Set = [2, 5, 10, 30, 60]

var biggerThanTen = nums.filter({(item) -> Bool in
    return (item > 10)
})

print(biggerThanTen)      // [30, 60]

var nums: Set = [2, 5, 10, 30, 60]

var biggerThanTen = nums.filter({ $0 > 10 })          // 代码更简洁
// var biggerThanTen = nums.filter{ $0 > 10 }         // 同上，省略了小括号。

print(biggerThanTen)      // [30, 60]

var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(closure: @escaping () -> Void) {
    completionHandlers.append(closure)  // 函数返回前没有调用 closure
}

func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure() // 函数返回前调用了 closure
}

class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure(closure: { () -> Void in self.x = 100 }) // 由于 closure 使用 @escaping 修饰，访问 x 时必须使用 self
        someFunctionWithNonescapingClosure(closure: { () -> Void in x = 200 }) // 访问 x 时可以省略 self（当然加上也行）
        // 上面两行可以写为 Trailing Closures 的形式，即写为：
        // someFunctionWithEscapingClosure { self.x = 100 }
        // someFunctionWithNonescapingClosure { x = 200 }
    }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x)
// Prints "200"

completionHandlers.first?()
print(instance.x)
// Prints "100"

enum Planet: Int {
    case mercury, venus, earth, mars, jupiter, saturn, uranus = 100, neptune
}

print(Planet.mercury.rawValue)        // 输出 0
print(Planet.neptune.rawValue)        // 输出 101。由于前一个（uranus）设置的 raw value为100，所以它为 101


enum CompassPoint: String {
    case north, south, east, west = "WEST"
}

print(CompassPoint.north.rawValue)    // 输出 north
print(CompassPoint.west.rawValue)     // 输出 WEST

enum Planet: Int {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

let possiblePlanet = Planet(rawValue: 2)   // 从 Raw Value 初始化枚举变量，这相当于 let possiblePlanet = Planet.earth

struct FixedLengthRange {
    var firstValue: Int             // Stored Property, 用 var 定义，它是变量
    let length: Int                 // Stored Property, 用 let 定义，它是常量
    // 结构体自动有 memberwise initializer，可不定义 init
}

var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
rangeOfThreeItems.firstValue = 6    // 可以修改 rangeOfThreeItems 的属性 firstValue，但不能修改属性 length
// rangeOfThreeItems.length = 2        // 这里会报错，因为 length 是常量


let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
// rangeOfFourItems.firstValue = 6     // 这里会报错，因为 rangeOfFourItems 本身是常量（由 let 定义）

class FixedLengthRange {
    var firstValue: Int                   // Stored Property, 用 var 定义，它是变量
    let length: Int                       // Stored Property, 用 let 定义，它是常量
    init(firstValue: Int, length: Int) {
        self.firstValue = firstValue
        self.length = length
    }
}

var rangeOfThreeItems = FixedLengthRange(firstValue: 0, length: 3)
rangeOfThreeItems.firstValue = 6    // 可以修改 rangeOfThreeItems 的属性 firstValue，但不能修改属性 length


let rangeOfFourItems = FixedLengthRange(firstValue: 0, length: 4)
rangeOfFourItems.firstValue = 6     // 这里不会报错，“如果把实例的引用赋值给常量，则仍然可以通过这个常量修改实例中的可变属性”

struct Point {
    var x = 0.0, y = 0.0
}
struct Size {
    var width = 0.0, height = 0.0
}
struct Rect {
    var origin = Point()
    var size = Size()
    var center: Point {            // center 是一个 Computed Property
        get {
            let centerX = origin.x + (size.width / 2)
            let centerY = origin.y + (size.height / 2)
            return Point(x: centerX, y: centerY)
        }
        set(newCenter) {
            origin.x = newCenter.x - (size.width / 2)
            origin.y = newCenter.y - (size.height / 2)
        }
    }
}
var square = Rect(origin: Point(x: 0.0, y: 0.0),
                  size: Size(width: 10.0, height: 10.0))

let initialSquareCenter = square.center     // 这会调用 center 的 get 方法
square.center = Point(x: 15.0, y: 15.0)     // 这会调用 center 的 set 方法
print("square.origin is now at (\(square.origin.x), \(square.origin.y))")
// Prints "square.origin is now at (10.0, 10.0)"

class StepCounter {
    var totalSteps: Int = 0 {
        willSet(newTotalSteps) {             // 对属性 totalSteps 进行修改前会调用 willSet 代码
            print("About to set totalSteps to \(newTotalSteps)")
        }
        didSet {                             // 对属性 totalSteps 进行修改后会调用 didSet 代码
            if totalSteps > oldValue  {
                print("Added \(totalSteps - oldValue) steps")
            }
        }
    }
}
let stepCounter = StepCounter()
stepCounter.totalSteps = 200
// About to set totalSteps to 200
// Added 200 steps
stepCounter.totalSteps = 360
// About to set totalSteps to 360
// Added 160 steps
stepCounter.totalSteps = 896
// About to set totalSteps to 896
// Added 536 steps

@propertyWrapper
struct TwelveOrLess {               // TwelveOrLess 是个 Property Wrapper
    private var number = 0
    var wrappedValue: Int {         // 属性 wrappedValue 用于实现 Property Wrapper 具体逻辑
        get { return number }
        set { number = min(newValue, 12) }
    }
}

struct SmallRectangle {             // 它的 height 和 width 都不会超过 12
    @TwelveOrLess var height: Int   // 使用 property wrapper 的好处：不用为 height/width 分别写 getter/setter 了
    @TwelveOrLess var width: Int
}

var rectangle = SmallRectangle()
print(rectangle.height)
// Prints "0"

rectangle.height = 10
print(rectangle.height)
// Prints "10"

rectangle.height = 24               // 尽管是设置为 24，但实际上运行 wrappedValue 中的 set 方法
print(rectangle.height)
// Prints "12"

struct SomeStructure {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 1
    }
}
enum SomeEnumeration {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 6
    }
}
class SomeClass {
    static var storedTypeProperty = "Some value."
    static var computedTypeProperty: Int {
        return 27
    }
    class var overrideableComputedTypeProperty: Int {  // 如果类的 Computed Type Property 用 class 修饰，表示它是 Type Property，但“可以被子类 override”
        return 107
    }
}

class NamedShape {
    var numberOfSides: Int = 0
    var name: String

    init(name: String) {
        self.name = name
    }

    func simpleDescription() -> String {
        return "\(name) with \(numberOfSides) sides."
    }
}

let test = NamedShape(name: "My test shape")     // 创建类实例（对象）

print(test.simpleDescription())

class NamedShape {
    var numberOfSides: Int = 0
    var name: String

    init(name: String) {
        self.name = name
    }

    deinit {
        print("Shamp #\(name) is being deinitialized")
    }

    func simpleDescription() -> String {
        return "\(name) with \(numberOfSides) sides."
    }
}

class Square: NamedShape {
    var sideLength: Double

    init(sideLength: Double, name: String) {
        self.sideLength = sideLength             // self 是当前对象
        super.init(name: name)                   // super 是父对象
        numberOfSides = 4
    }

    func area() -> Double {
        return sideLength * sideLength
    }

    override func simpleDescription() -> String {            // 重写父类的simpleDescription方法
        return "A square with sides of length \(sideLength)."
    }
}

let test = Square(sideLength: 5.2, name: "my test square")

print(test.simpleDescription())

class SomeClass {
    static func someTypeMethod() {
        // type method implementation goes here
    }
}

SomeClass.someTypeMethod()

class Class1 {
    class func someTypeMethod() {
        print("Class1 someTypeMethod")
    }
}

class Class2 : Class1 {
    override class func someTypeMethod() {
        print("Class2 someTypeMethod")
    }
}

Class2.someTypeMethod()

func canThrowErrors() throws -> String   // canThrowErrors 可以抛出错误
func cannotThrowErrors() -> String       // cannotThrowErrors 不能抛出错误

do {
    try expression
    statements
} catch pattern 1 {
    statements
} catch pattern 2 where condition {
    statements
} catch {
    statements
}

enum ValidationError: Error {
    case tooShort
    case tooLong
    case invalidCharacterFound(Character)
}

func validate(username: String) throws {   // 函数 validate 可能抛出错误
    guard username.count > 3 else {
        throw ValidationError.tooShort
    }

    guard username.count < 15 else {
        throw ValidationError.tooLong
    }

    for character in username {
        guard character.isLetter else {
            throw ValidationError.invalidCharacterFound(character)
        }
    }
}

func userDidPickName(_ username: String) {
    do {
        // 调用 validate 前使用了 try，如果出错，会执行到 catch 语句中
        try validate(username: username)

        // 代码走到这里里，说明上面的validate没有抛出错误
        // 可以进行其他操作了

        // Do something

    } catch {
        // The variable ‘error’ is automatically available
        // inside of ‘catch’ blocks.
        print(error)
    }
}

userDidPickName("aa")

func someThrowingFunction() throws -> Int {
    // ...
}

let x = try? someThrowingFunction()    // 如果 someThrowingFunction 报错，则 x 为 nil

let x: Int?
do {
    x = try someThrowingFunction()
} catch {
    x = nil
}

let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")