扩展 #

extension Double {
    var km: Double { return self * 1000 }
    var m: Double { return self }
    var cm: Double { return self / 100 }
    var mm: Double { return self / 1000 }
}

let distance = 1.5.km
print("\(distance)米")

let height = 180.cm
print("\(height)米")

extension String {
    var length: Int {
        return count
    }
    
    var reversed: String {
        return String(self.reversed())
    }
    
    var isNotEmpty: Bool {
        return !isEmpty
    }
}

let text = "Hello"
print(text.length)
print(text.reversed)
print(text.isNotEmpty)

extension Int {
    func times(_ action: () -> Void) {
        for _ in 0..<self {
            action()
        }
    }
    
    func squared() -> Int {
        return self * self
    }
}

5.times {
    print("Hello")
}

print(5.squared())

extension Int {
    mutating func square() {
        self = self * self
    }
}

var number = 5
number.square()
print(number)

extension String {
    static func random(length: Int) -> String {
        let letters = "abcdefghijklmnopqrstuvwxyz"
        return String((0..<length).map { _ in letters.randomElement()! })
    }
}

print(String.random(length: 10))

struct Size {
    var width: Double
    var height: Double
}

extension Size {
    init(square side: Double) {
        self.init(width: side, height: side)
    }
}

let square = Size(square: 10)
print("宽: \(square.width), 高: \(square.height)")

extension Double {
    init?(fromString string: String) {
        guard let value = Double(string) else {
            return nil
        }
        self = value
    }
}

if let value = Double(fromString: "3.14") {
    print(value)
}

extension String {
    subscript(i: Int) -> String {
        guard i >= 0 && i < count else { return "" }
        let index = self.index(startIndex, offsetBy: i)
        return String(self[index])
    }
    
    subscript(range: Range<Int>) -> String {
        let start = index(startIndex, offsetBy: range.lowerBound)
        let end = index(startIndex, offsetBy: range.upperBound)
        return String(self[start..<end])
    }
}

let text = "Hello"
print(text[0])
print(text[1..<4])

extension Array {
    subscript(safe index: Int) -> Element? {
        return indices.contains(index) ? self[index] : nil
    }
}

let numbers = [1, 2, 3, 4, 5]
print(numbers[safe: 2] ?? 0)
print(numbers[safe: 10] ?? 0)

extension Int {
    enum Kind {
        case negative, zero, positive
    }
    
    var kind: Kind {
        switch self {
        case 0: return .zero
        case let x where x > 0: return .positive
        default: return .negative
        }
    }
}

print(5.kind)
print((-3).kind)
print(0.kind)

struct Person {
    var name: String
    var age: Int
}

extension Person: CustomStringConvertible {
    var description: String {
        return "\(name), \(age)岁"
    }
}

let person = Person(name: "张三", age: 25)
print(person)

extension Array: CustomStringConvertible where Element: CustomStringConvertible {
    var description: String {
        return "[" + map { $0.description }.joined(separator: ", ") + "]"
    }
}

extension Person: Equatable, Comparable {
    static func == (lhs: Person, rhs: Person) -> Bool {
        return lhs.name == rhs.name && lhs.age == rhs.age
    }
    
    static func < (lhs: Person, rhs: Person) -> Bool {
        return lhs.age < rhs.age
    }
}

extension UIColor {
    convenience init(hex: String, alpha: CGFloat = 1.0) {
        var hexFormatted = hex.trimmingCharacters(in: CharacterSet.whitespacesAndNewlines)
        hexFormatted = hexFormatted.replacingOccurrences(of: "#", with: "")
        
        var rgbValue: UInt64 = 0
        Scanner(string: hexFormatted).scanHexInt64(&rgbValue)
        
        self.init(
            red: CGFloat((rgbValue & 0xFF0000) >> 16) / 255.0,
            green: CGFloat((rgbValue & 0x00FF00) >> 8) / 255.0,
            blue: CGFloat(rgbValue & 0x0000FF) / 255.0,
            alpha: alpha
        )
    }
}

let color = UIColor(hex: "#FF8000")

extension Date {
    var isToday: Bool {
        return Calendar.current.isDateInToday(self)
    }
    
    var isYesterday: Bool {
        return Calendar.current.isDateInYesterday(self)
    }
    
    var isTomorrow: Bool {
        return Calendar.current.isDateInTomorrow(self)
    }
    
    func format(_ format: String) -> String {
        let formatter = DateFormatter()
        formatter.dateFormat = format
        return formatter.string(from: self)
    }
}

let now = Date()
print(now.isToday)
print(now.format("yyyy年MM月dd日"))

extension Array {
    func chunked(into size: Int) -> [[Element]] {
        guard size > 0 else { return [] }
        return stride(from: 0, to: count, by: size).map {
            Array(self[$0..<Swift.min($0 + size, count)])
        }
    }
    
    func unique<T: Hashable>(by keyPath: KeyPath<Element, T>) -> [Element] {
        var seen = Set<T>()
        return filter { seen.insert($0[keyPath: keyPath]).inserted }
    }
}

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(numbers.chunked(into: 3))