Swift Learning (4) - Advanced Operators (Fully Ver.)

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("These two vectors are equivalent!")
}
let threeTwo = Vector2D(x: 3.0, y: 2.0)
if twoThree != threeTwo {  // 已经实现了“相等”运算符，故不需要再去实现“不等”运算符
    print("These two vectors are not equivalent!")
}
---
output: These two vectors are equivalent!
These two vectors are not equivalent!

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: * ** ***