前言
你自定义了一个数据类型后，是否希望像var num: Int = 10这样通过一个字面量初始化一个类型的实例呢？是的话，请看下文详细介绍。
一、字面量类型（Literal Type）
在介绍字面量类型前，我们先认识下字面量的概念。
所谓字面量，是指一段能表示特定类型的值（如数值、布尔值、字符串）的源码表达式（it is the source code representation of a fixed value）。比如下面例子：
let num: Int = 10
let flag: Bool = true
let str: String = "hello"
例子中的10、true、hello都是字面量。
那什么是字面量类型呢？
字面量类型就是支持通过字面量进行实例初始化的数据类型，如例子中的Int、Bool、String类型。
在Swift中，其的字面量类型有：
- 所有的数值类型: Int、Double、Float以及其的相关类型（如UInt、Int16、Int32等）
- 布尔值类型：Bool
- 字符串类型：String
- 组合类型：Array、Dictionary、Set
- 空类型：Nil
二、字面量协议（Literal Protocol）
Swift是如何让上述的数据类型具有字面量初始化的能力呢？
答案是：实现指定的字面量协议。
所以，如果我们希望自定义的数据类型也能通过字面量进行初始化，只要实现对应的字面量协议即可。
Swift中的字面量协议主要有以下几个：
-
ExpressibleByNilLiteral// nil字面量协议 -
ExpressibleByIntegerLiteral// 整数字面量协议 -
ExpressibleByFloatLiteral// 浮点数字面量协议 -
ExpressibleByBooleanLiteral// 布尔值字面量协议 -
ExpressibleByStringLiteral// 字符串字面量协议 -
ExpressibleByArrayLiteral// 数组字面量协议 -
ExpressibleByDictionaryLiteral// 字典字面量协议
其中， ExpressibleByStringLiteral 字符串字面量协议相对复杂一点，该协议还依赖于以下2个协议（也就是说，实现ExpressibleByStringLiteral时，还需要实现下面2个协议）:
ExpressibleByUnicodeScalarLiteralExpressibleByExtendedGraphemeClusterLiteral
在 Swift3.0 之前，上述的字面量协议的名称对应如下：
NilLiteralConvertibleIntegerLiteralConvertibleFloatLiteralConvertibleBooleanLiteralConvertibleStringLiteralConvertibleArrayLiteralConvertibleDictionaryLiteralConvertible
三、字面量协议例子（Literal Protocol Example）
下面将会通过具体例子为大家演示如何通过实现上述的字面量协议。
下面的例子均已经上传GitHub，查看下载请点击LiteralProtocolExample
1、定义Moeny类型，实现通过整数字面量、浮点数字面量、字符串字面量、布尔值字面量初始化Money实例：
//: Playground - noun: a place where people can play
import UIKit
import Foundation
struct Money {
var value: Double
init(value: Double) {
self.value = value
}
}
// 实现CustomStringConvertible协议，提供description方法
extension Money: CustomStringConvertible {
public var description: String {
return "\(value)"
}
}
// 实现ExpressibleByIntegerLiteral字面量协议
extension Money: ExpressibleByIntegerLiteral {
typealias IntegerLiteralType = Int
public init(integerLiteral value: IntegerLiteralType) {
self.init(value: Double(value))
}
}
// 实现ExpressibleByFloatLiteral字面量协议
extension Money: ExpressibleByFloatLiteral {
public init(floatLiteral value: FloatLiteralType) {
self.init(value: value)
}
}
// 实现ExpressibleByStringLiteral字面量协议
extension Money: ExpressibleByStringLiteral {
public init(stringLiteral value: StringLiteralType) {
if let doubleValue = Double(value) {
self.init(value: doubleValue)
} else {
self.init(value: 0)
}
}
// 实现ExpressibleByExtendedGraphemeClusterLiteral字面量协议
public init(extendedGraphemeClusterLiteral value: StringLiteralType) {
if let doubleValue = Double(value) {
self.init(value: doubleValue)
} else {
self.init(value: 0)
}
}
// 实现ExpressibleByUnicodeScalarLiteral字面量协议
public init(unicodeScalarLiteral value: StringLiteralType) {
if let doubleValue = Double(value) {
self.init(value: doubleValue)
} else {
self.init(value: 0)
}
}
}
// 实现ExpressibleByBooleanLiteral字面量协议
extension Money: ExpressibleByBooleanLiteral {
public init(booleanLiteral value: BooleanLiteralType) {
let doubleValue: Double = value ? 1.0 : 0.0
self.init(value: doubleValue)
}
}
// 通过整数字面量初始化
let intMoney: Money = 10
// 通过浮点数字面量初始化
let floatMoney: Money = 10.1
// 通过字符串字面量初始化
let strMoney: Money = "10.2"
// 通过布尔值初始化
let boolMoney: Money = true
2、定义Book类型，实现通过字典字面量、数组字面量、nil字面量初始化Book实例:
//: Playground - noun: a place where people can play
import Foundation
struct Book {
public var id: Int
public var name: String
init(id: Int, name: String = "unnamed") {
self.id = id
self.name = name
}
}
// 实现CustomStringConvertible协议，提供description方法
extension Book: CustomStringConvertible {
public var description: String {
return "id:\(id)\nname:《\(name)》"
}
}
// 实现ExpressibleByDictionaryLiteral字面量协议
extension Book: ExpressibleByDictionaryLiteral {
typealias Key = String
typealias Value = Any
public init(dictionaryLiteral elements: (Key, Value)...) {
var dictionary = [Key: Value](minimumCapacity: elements.count)
for (k, v) in elements {
dictionary[k] = v
}
let id = (dictionary["id"] as? Int) ?? 0
let name = (dictionary["name"] as? String) ?? "unnamed"
self.init(id: id, name: name)
}
}
// 实现ExpressibleByArrayLiteral字面量协议
extension Book: ExpressibleByArrayLiteral {
typealias ArrayLiteralElement = Any
public init(arrayLiteral elements: ArrayLiteralElement...) {
var id: Int = 0
if let eId = elements.first as? Int {
id = eId
}
var name = "unnamed"
if let eName = elements[1] as? String {
name = eName
}
self.init(id: id, name: name)
}
}
// 实现ExpressibleByNilLiteral字面量协议
extension Book: ExpressibleByNilLiteral {
public init(nilLiteral: ()) {
self.init()
}
}
// 通过字典字面量初始化
let dictBook: Book = ["id": 100, "name": "Love is Magic"]
print("\(dictBook)\n")
// 通过数组字面量初始化
let arrayBook: Book = [101, "World is word"]
print("\(arrayBook)\n")
// 通过nil字面量初始化
let nilBook: Book = nil
print("\(nilBook)\n")
四、关于 'not expressible by any literal
enum' Error
当你使用自定义数据类型定义枚举时，可能会遇到以下类似错误：
raw type 'XX_TYPE' is not expressible by any literal
enum XX_ENUM: XX_TYPE
这是说你的自定义数据类型没有实现字面量协议。然而需要注意的是，enum目前支持的字面量协议是有限制的，其目前只支持以下几个字面量协议：
- ExpressibleByIntegerLiteral
- ExpressibleByFloatLiteral
- ExpressibleByStringLiteral
也就是说，若你的自定义数据类型实现的字面量协议没有包含上面中的一个，就会得到此种错误。具体示例如下：
//: Playground - noun: a place where people can play
import Foundation
struct StockType {
var number: Int
}
// 实现CustomStringConvertible协议，提供description方法
extension StockType: CustomStringConvertible {
public var description: String {
return "Stock Number:\(number)"
}
}
// 实现Equatable协议，提供==方法
extension StockType: Equatable {
public static func ==(lhs: StockType, rhs: StockType) -> Bool {
return lhs.number == rhs.number
}
}
// 实现ExpressibleByDictionaryLiteral字面量协议
extension StockType: ExpressibleByDictionaryLiteral {
typealias Key = String
typealias Value = Any
public init(dictionaryLiteral elements: (Key, Value)...) {
var dictionary = [Key: Value](minimumCapacity: elements.count)
for (k, v) in elements {
dictionary[k] = v
}
let number = (dictionary["number"] as? Int) ?? 0
self.init(number: number)
}
}
// 实现ExpressibleByIntegerLiteral字面量协议
extension StockType: ExpressibleByIntegerLiteral {
public init(integerLiteral value: IntegerLiteralType) {
self.init(number: value)
}
}
/*
若StockType没有实现 ExpressibleByIntegerLiteral、ExpressibleByFloatLiteral、ExpressibleByStringLiteral中的一个，会报错误：error: raw type 'StockType' is not expressible by any literal
*/
// 你可以尝试去掉ExpressibleByIntegerLiteral的实现，看看编译器报的错误
enum Stock: StockType {
case apple = 1001
case google = 1002
}
let appleStock = Stock.apple.rawValue
print("\(appleStock)")
上述例子中，定义了StockType数据类型和Stock枚举类型。若StockType去掉ExpressibleByIntegerLiteral字面量的协议的实现，将会获得上述的编译错误。
