Swift 中 Literal 可以这么用，你造吗？

简评：看看这段 Swift 代码：
let link:LinkedList = [1,2,3,4,5,6,7,8]
link 并不是一个数组哦，看完这篇文章你就懂了。

自2012年以来，可以使用 “literal” 表达式初始化NSDictionary，NSArray，NSNumber或NSString。

NSNumber *numb = @1;
NSArray *things = @[@3,@45,@65];
NSDictionary *map = @{@"Florida" : @1 , @"Nevada" : @6 };
NSString *greet = @"Hello there!";

这种 “literal” 表达式让代码变得更加简洁。

你有没有想过使用 “literal” 表达式来初始化自己的数据结构。

Swift 中提供了 “ExpressibleBy _____” 这类协议：

Expressible By Array Literal
Expressible By Boolean Literal
Expressible By Dictionary Literal
Expressible By Float Literal
Expressible By Integer Literal
Expressible By String Literal
Expressible By Unicode Scalar Literal
Expressible By Extended Grapheme Cluster Literal

可以使用 “literal” 表达式来初始化自己的数据结构，可以看看下面的例子，如何使用 “literal” 表达式来构建自己的数据结构。

Array-ish 数据结构

来看看 Swift 中的例子， [1,2,3,4,5,6,7,8] 这很可能用于初始化一个 Array。但是！他也可以用于初始化成其他的数据结构。

链表

下面这段代码就是介绍如何使用 Array literal 来初始化一个链表:

class LinkedList<T> : ExpressibleByArrayLiteral, CustomDebugStringConvertible {
    var debugDescription: String {
        get {
            var accum = ""
            guard let startNode = self.head else { return "(empty list)" }
            accum += startNode.debugDescription
            var currentNode:Node = startNode
            while(true) {
                guard let node = currentNode.next else { break }
                accum += node.debugDescription
                currentNode = node
            }
            return accum
        }
    }
    var head:Node?
    var tail:Node?
    typealias Element = T
    required public init(arrayLiteral elements:Element...) {
        for i in elements {
            if self.head == nil {
                self.head = Node(data:i)
                self.tail = self.head
                continue
            }
            let newNode = Node(data:i)
            self.tail?.next = newNode
            self.tail = newNode
        }
    }
    class Node : CustomDebugStringConvertible {
        var debugDescription: String {
            get {
                var accum = "(\(data))->"
                if next == nil {
                    accum += "*"
                }
                return accum
            }
        }
        var next:Node?
        var data:T
        init(data:T) {
            self.data = data
        }
    }
}
let link:LinkedList<Int> = [1,2,3,4,5,6,7,8]
print(link)   // Prints (1)->(2)->(3)->(4)->(5)->(6)->(7)->(8)->*

LinkedList 类遵从 ExpressibleByArrayLiteral 协议，实现 init(arrayLiteral: Self.Element...) 这个初始化方法，那么我们就可以直接使用 Array literal 赋值进行初始化。

let link:LinkedList<Int> = [1,2,3,4,5,6,7,8]

注意：必须使用 Array literal 来赋值，而不能用一个数组赋值，因为这是两个不同的东西，例如：

let someArray = [1,2,3,4]
let list:LinkedList<Int> = someArray  // 这段代码会报错。

堆栈

struct ConvertibleStack<T> : ExpressibleByArrayLiteral, CustomDebugStringConvertible {

    var debugDescription: String {
        get {
            return "Stack: \(storage)"
        }
    }
    typealias Element = T
    private var storage: [T] = []

    public init(arrayLiteral elements:Element...) {
        self.storage = elements
    }

    mutating func push(item:T) {
        storage.insert(item, at: 0)
    }

    mutating func pop() -> T? {
        guard storage.count > 0 else { return nil }
        return storage.remove(at: 0)
    }
}

队列

struct ConvertibleStack<T> : ExpressibleByArrayLiteral, CustomDebugStringConvertible {

    var debugDescription: String {
        get {
            return "Stack: \(storage)"
        }
    }
    typealias Element = T
    private var storage: [T] = []

    public init(arrayLiteral elements:Element...) {
        self.storage = elements
    }

    mutating func push(item:T) {
        storage.insert(item, at: 0)
    }

    mutating func pop() -> T? {
        guard storage.count > 0 else { return nil }
        return storage.remove(at: 0)
    }
}

最后，如果正确的使用 litera 初始化可以提高可读性。这种方法适用于树或有向图吗？我把这个探索留给了读者 : ) Happy Hacking!

原文：Express Yourself Swift Style

Swift 中 Literal 可以这么用，你造吗？

Array-ish 数据结构

推荐阅读更多精彩内容