Swift學習（4）- 進階運算子（程式碼完善版）

let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits  // 等於0b11110000
print("對值\(initialBits)按位元反後的結果是：\(invertedBits)")
---
output: 對值15按位元反後的結果是：240

let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8 = 0b00111111
let middleFourBits = firstSixBits & lastSixBits  // 等於0b00111100
print("值\(firstSixBits)和值\(lastSixBits)按位元與後的結果為：\(middleFourBits)")
---
output: 值252和值63按位元與後的結果為：60

let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedBits = someBits | moreBits
print("值\(someBits)和值\(moreBits)按位元或後的結果為：\(combinedBits)")
---
output: 值178和值94按位元或後的結果為：254

let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits
print("值\(firstBits)和值\(otherBits)按位元異或後的結果為：\(outputBits)")
---
output: 值20和值5按位元異或後的結果為：17

let shiftBits: UInt8 = 0b00000100
print("\(shiftBits)向左移1位：\(shiftBits << 1)")  // 0b00001000
print("\(shiftBits)向左移2位：\(shiftBits << 2)")  // 0b00010000
print("\(shiftBits)向左移5位：\(shiftBits << 5)")  // 0b10000000
print("\(shiftBits)向左移6位：\(shiftBits << 6)")  // 0b00000000
print("\(shiftBits)向右移2位：\(shiftBits >> 2)")  // 0b00000001
---
output: 4向左移1位：8
4向左移2位：16
4向左移5位：128
4向左移6位：0
4向右移2位：1

let pink: UInt32 = 0xCC6699; print(pink)
let redComponent  = (pink & 0xFF0000) >> 16  // redComponent為0xCC，即204
let greenComponent = (pink & 0x00FF00) >> 8  // greenComponent為0x66，即102
let blueComponent = (pink & 0x0000FF) // blueComponent為0x99，即153
print("pink中紅色成分為：\(redComponent)")
print("pink中綠色成分為：\(greenComponent)")
print("pink中藍色成分為：\(blueComponent)")
---
output: 13395609
pink中紅色成分為：204
pink中綠色成分為：102
pink中藍色成分為：153

var potentialOverFlow = Int16.max
//potentialOverFlow += 1  // 若取消這行註解，執行後會報錯：Swift runtime failure: arithmetic overflow

var unsignedOverFlow = UInt8.max  // unsignedOverFlow等於UInt8可容納的最大整數255
unsignedOverFlow = unsignedOverFlow &+ 1  // 此時unsignedOverFlow等於0
print("UInt8上溢後的值：\(unsignedOverFlow)")
---
output: UInt8上溢後的值：0

unsignedOverFlow = UInt8.min  // unsignedOverFlow等於UInt8可容納的最小整數0
unsignedOverFlow = unsignedOverFlow &- 1  // 此時unsignedOverFlow等於255
print("UInt8下溢後的值：\(unsignedOverFlow)")
---
output: UInt8下溢後的值：255

var signedOverFlow = Int8.min  // signedOverFlow等於Int8可容納的最小整數-128
signedOverFlow = signedOverFlow &- 1  // 此時signedOverFlow等於127
print("Int8下溢後的值：\(signedOverFlow)")
---
output: Int8下溢後的值：127

var result = 2 + 3 % 4 * 5  // result的值是17
print("2 + 3 % 4 * 5的值是：\(result)")
---
output: 2 + 3 % 4 * 5的值是：17

struct Vector2D {
        var x = 0.0, y = 0.0
}
extension Vector2D {
        static func + (left: Vector2D, right: Vector2D) -> Vector2D {
                return Vector2D(x: left.x + right.x, y: left.y + right.y)
        }
}

let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector  // combinedVector為新的Vector2D實例，值為(5.0, 5.0)
print("兩個Vector2D型別向量相加後的值為：\(combinedVector)")
---
output: 兩個Vector2D型別向量相加後的值為：Vector2D(x: 5.0, y: 5.0)

extension Vector2D {
        static prefix func - (vector: Vector2D) -> Vector2D {
                return Vector2D(x: -vector.x, y: -vector.y)
        }
}

let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive  // negative為(-3.0, -4.0)的Vector2D實例
let alsoPositive = -negative  // alsoPositive為(3.0, 4.0)的Vector2D實例
print("-positive的值為：\(negative)")
print("-negative的值為：\(alsoPositive)")
---
output: -positive的值為：Vector2D(x: -3.0, y: -4.0)
-negative的值為：Vector2D(x: 3.0, y: 4.0)

extension Vector2D {
        static func += (left: inout Vector2D, right: Vector2D) {
                left = left + right  // 因為Vector2D的加法運算已定義，可直接利用現有加法運算子函式
        }
}

var original = Vector2D(x: 1.0, y: 2.0)
let vectorToAdd = Vector2D(x: 3.0, y: 4.0)
original += vectorToAdd  // original的值現在是(4.0, 6.0)
print("Vector2D型別加法賦值運算後的值為：\(original)")
---
output: Vector2D型別加法賦值運算後的值為：Vector2D(x: 4.0, y: 6.0)

extension Vector2D: Equatable {  // 遵循Equatable協定即可包含對「相等」運算子（==）與「不等」運算子（!=）的實作
        static func == (left: Vector2D, right: Vector2D) -> Bool {
                return (left.x == right.x) && (left.y == right.y)
        }
}

let twoThree = Vector2D(x: 2.0, y: 3.0)
let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
if twoThree == anotherTwoThree {
        print("這兩個向量相等！")
}
let threeTwo = Vector2D(x: 3.0, y: 2.0)
if twoThree != threeTwo {  // 已實作「相等」運算子，故不需再實作「不等」運算子
        print("這兩個向量不相等！")
}
---
output: 這兩個向量相等！
這兩個向量不相等！

prefix operator +++  // 定義一個新的名為`+++`的前置運算子

extension Vector2D {
        static prefix func +++ (vector: inout Vector2D) -> Vector2D {
                vector += vector
                return vector
        }
}

var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled  // toBeDoubled與afterDoubling現在的值皆為(2.0, 8.0)
print("toBeDoubled的值為：\(toBeDoubled)")
print("afterDoubling的值為：\(afterDoubling)")
---
output: toBeDoubled的值為：Vector2D(x: 2.0, y: 8.0)
afterDoubling的值為：Vector2D(x: 2.0, y: 8.0)

infix operator +-: AdditionPrecedence
extension Vector2D {
        static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
                return Vector2D(x: left.x + right.x, y: left.y - right.y)
        }
}
let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector  // plusMinusVector為Vector2D實例，值為(4.0, -2.0)
print("plusMinusVector的值為：\(plusMinusVector)")
---
output: plusMinusVector的值為：Vector2D(x: 4.0, y: -2.0)

protocol Drawable {
        func draw() -> String
}
struct Line: Drawable {
        var elements: [Drawable]
        func draw() -> String {
                return elements.map { $0.draw() }.joined(separator: "")  // 繪製Line時，會呼叫每個元素的draw()，再將所有結果字串串接成單一字串
        }
}
struct Text: Drawable {
        var content: String
        init(_ content: String) { self.content = content }
        func draw() -> String {
                return content
        }
}
struct Space: Drawable {
        func draw() -> String {
                return " "
        }
}
struct Stars: Drawable {
        var length: Int
        func draw() -> String {
                return String(repeating: "*", count: length)
        }
}
struct AllCaps: Drawable {
        var content: Drawable
        func draw() -> String {
                return content.draw().uppercased()
        }
}

let name: String? = "Jensen Jon"
let manualDrawing = Line(elements: [Stars(length: 3), Text("Hello"), Space(), AllCaps(content: Text((name ?? "World") + "!")), Stars(length: 2)])
print(manualDrawing.draw())  // 輸出“***Hello JENSEN JON!**”
---
output: ***Hello JENSEN JON!**

@resultBuilder
struct DrawingBuilder {
        static func buildBlock(_ components: Drawable...) -> Drawable {
                return Line(elements: components)
        }
        static func buildEither(first component: Drawable) -> Drawable {
                return component
        }
        static func buildEither(second component: Drawable) -> Drawable {
                return component
        }
}

func draw(@DrawingBuilder content: () -> Drawable) -> Drawable {
        return content()
}
func caps(@DrawingBuilder content: () -> Drawable) -> Drawable {
        return AllCaps(content: content())
}

func makeGreeting(for name: String? = nil) -> Drawable {
        let greeting = draw {
                Stars(length: 3)
                Text("Hello")
                Space()
                caps {
                        if let name = name {
                                Text(name + "!")
                        } else {
                                Text("World!")
                        }
                }
                Stars(length: 2)
        }
        return greeting
}

let genericGreeting = makeGreeting()
print(genericGreeting.draw())  // 輸出“***Hello WORLD!**”

let personalGreeting = makeGreeting(for: "Jensen Jon")
print(personalGreeting.draw())  // 輸出“***Hello JENSEN JON!**”
---
output: ***Hello WORLD!**
***Hello JENSEN JON!**

let capsDrawing = caps {
        let partialDrawing: Drawable
        if let name = name {
                let text = Text(name + "!")
                partialDrawing = DrawingBuilder.buildEither(first: text)
        } else {
                let text = Text("World!")
                partialDrawing = DrawingBuilder.buildEither(second: text)
        }
        return partialDrawing
}

extension DrawingBuilder {
        static func buildArray(_ components: [Drawable]) -> Drawable {
                return Line(elements: components)
        }
}
func makeStars() -> Drawable {
        let manyStars = draw {
                Text("Stars:")
                for length in 1...3 {
                        Space()
                        Stars(length: length)  // for迴圈中會自動呼叫buildArray(_:)方法
                }
        }
        return manyStars
}
let generateStars = makeStars()
print(generateStars.draw())
---
output: Stars: * ** ***