Swift 常用类别整理

生成颜色，传入16进制数字生成对应颜色

个人不喜欢传字符串的写法，比如 "0x0080FF" 或者 "0080FF"，原因如下：

• 传了字符串最后还是要解析成数字参与颜色运算的，需要额外做字符串转数字的操作，不如直接使用16进制数字更合适
• 输入内容不可控，需要更多的校验，入参为字符串，使用方可以传 "abc" 等无效字符，
  • 检查内容输入合法性多余且不必要，而且作为全局使用的工具方法，浪费性能
  • 不检查作为工具方法感觉缺失功能，缺乏安全意识，没有防御性编程。

let color = UIColor(rgb: 0x0080FF) 

extension UIColor {
    convenience init(red: Int, green: Int, blue: Int, alpha: CGFloat) {
        assert(red >= 0 && red <= 255, "Invalid red component")
        assert(green >= 0 && green <= 255, "Invalid green component")
        assert(blue >= 0 && blue <= 255, "Invalid blue component")
        
        self.init(red: CGFloat(red) / 255.0, green: CGFloat(green) / 255.0, blue: CGFloat(blue) / 255.0, alpha: alpha)
    }
    convenience init(rgb: Int, alpha: CGFloat = 1) {
        self.init(
            red: (rgb >> 16) & 0xFF,
            green: (rgb >> 8) & 0xFF,
            blue: rgb & 0xFF,
            alpha: alpha
        )
    }

    //返回随机颜色
    public class func randomColor() -> UIColor {
        let red = CGFloat(arc4random()%256)/255.0
        let green = CGFloat(arc4random()%256)/255.0
        let blue = CGFloat(arc4random()%256)/255.0
        return UIColor(red: red, green: green, blue: blue, alpha: 1.0)
    }

}

---

整型和浮点型类型转换

在Swift中，做常用的加减乘除都需要先转换类型才能进行计算，在给视图计算Frame时，经常需要这样的宽高计算，

比如视图宽度 = 数量 * 单个元素宽度 + 元素之间间距，

• 元素数量一般为Int，
• 而元素宽度一般根据内容计算，大多数为CGFloat，
• 元素之间间距一般为UI给的标注，Int和CGFloat都有，
• 生成最终宽度一般为CGFloat，

这样一个简单地计算过程中涉及到多次类型强制转换。

在使用OC开发中，一般不用这样写，因为C语言会自动进行类型转换，最终生成浮点型结果。

而在Swift中这样写，就会报错

那么我们想按照正常的c语言开发习惯，可以在Swift中通过重载常见的运算符，支持Int和CGFloat之间的互相运算，比如下面的写法。

// 左侧为CGFloat, 右侧为Int
public func * (left: CGFloat, right: Int) -> CGFloat {
    return left * CGFloat(right)
}


public func + (left: CGFloat, right: Int) -> CGFloat {
    return left + CGFloat(right)
}


public func - (left: CGFloat, right: Int) -> CGFloat {
    return left - CGFloat(right)
}


public func / (left: CGFloat, right: Int) -> CGFloat {
    if right == 0 {
        return CGFloat.nan
    } else {
        return left * CGFloat(right)
    }
}

// 左侧为Int, 右侧为CGFloat
public func * (left: Int, right: CGFloat) -> CGFloat {
    return CGFloat(left) * right
}


public func + (left: Int, right: CGFloat) -> CGFloat {
    return CGFloat(left) + right
}


public func - (left: Int, right: CGFloat) -> CGFloat {
    return CGFloat(left) - right
}


public func / (left: Int, right: CGFloat) -> CGFloat {
    if right == 0 {
        return CGFloat.nan
    } else {
        return CGFloat(left) / right
    }
}

经过运算符重载后，返回值都为CGFloat，和正常开发过程中的期望是一致的。

Swift有完整的访问控制权限，如果三方库没有显式的import 这些函数所在的target的话，这些运算符的重载完全不会影响到三方库，三方库内部还是会编译报错；只有明确的使用了import，这些函数才会生效，影响范围已知且可控。

如果还是担心重载的影响范围太大，可以将重载运算符的声明范围为 internal 或者 不写，这样就只有本模块可以使用，外部模块一定无影响，并且外部模块使用时还是会保持编译报错的状态。

---