Dollar 9.0.0

Dollar 9.0.0

×

测试已测试✓
语言语言 SwiftSwift
许可协议 MIT
发布最后发布2019 年 7 月
SPM支持 SPM✓

由 Ankur Patel 维护。

Dollar 9.0.0

  • 作者：
  • Ankur Patel

Dollar 构建状态 CocoaPods 由 Hound 审查

Gitter

Dollar 是一个 Swift 库，它提供了有用的功能性编程辅助方法，而不扩展任何内置对象。它在 JavaScript 中类似于 Lo-Dash 或 Underscore.js。

Cent 是一个库，它使用扩展功能扩展了某些 Swift 对象类型，并对 Swift 语言提出了建议。现在它已移动到一个单独的仓库以支持 Swift Package Manager

注意：从 Swift 4 开始 $ 不是一个有效的标识符。因此您会收到以下错误 error: '$' 不是一个标识符；使用反引号进行转义。请使用 Dollar。

内容

设置

使用 cocoapods 版本 0.36.x 或更高

将 pod 'Dollar' 添加到您的 Podfile 并运行 pod install。在 Podfile 末尾添加 use_frameworks!。还可以查看这个 示例应用程序。

使用 Swift 包管理器

将以下依赖项 .Package(url: "https://github.com/ankurp/Dollar", majorVersion: 7, minor: 1) 添加到您的 Package.swift 文件中，然后运行 swift build。需要版本 2.2 或更高版本的 Swift，您可以从 https://swiftlang.cn 安装

使用 git submodule

  1. 如果您正在使用 git，请使用 git submodule add https://github.com/ankurp/Dollar.git 将 Dollar 添加为子模块。如果不使用 git，请在您项目管理文件夹中使用 git clone https://github.com/ankurp/Dollar.git 下载项目。
  2. 打开 Dollar 文件夹。将 Dollar.xcodeproj（位于 Dollar 文件夹内）拖到 Xcode 项目的文件导航器中。
  3. 在 Xcode 中，通过单击蓝色项目图标，然后在侧边栏“目标”标题下选择“应用程序目标”，来进入目标配置窗口。
  4. 在该窗口的选项卡栏顶部，打开“构建阶段”面板。
  5. 展开“链接二进制库”组，并添加 Dollar.framework。
  6. 在您的项目文件中 import Dollar 并可以调用所有辅助函数。

如果您仍然遇到问题，请查看有关 如何导入 的屏幕录像。

Xcode和Swift支持

  • 使用Xcode 11（Swift 5.0）时，使用版本9.0.0
  • 使用Xcode 10（Swift 4.2）时，使用版本8.0.0
  • 使用Xcode 9（Swift 4）时，使用版本7.1.0
  • 使用Xcode 8（Swift 3）时，使用版本6.0.0
  • 使用Xcode 7（Swift 2）时，使用版本4.1.0或5.2.0
  • 使用Xcode 6.3（Swift 1.2）时，使用版本3.0.3
  • 使用Xcode 6.1和6.2（Swift 1.1）时，使用版本2.2.0

示例应用程序

通讯

  • 如果您需要帮助，请使用gitter.im或在带有标签dollar.swift的Stack Overflow上提出问题。
  • 如果您想提出一般性问题，请使用Stack Overflow。
  • 如果您发现了bug，请开通一个问题。
  • 如果您有功能请求，请开通一个问题。
  • 如果您想贡献力量，请提交一个拉取请求。

Dollar使用

数组

at - Dollar.at

从集合的指定索引或键创建元素数组。索引可以指定为单个参数或索引数组的组合。

Dollar.at(["ant", "bat", "cat", "dog", "egg"], indexes: 0, 2, 4) 
=> ["ant", "cat", "egg"]

chunk - Dollar.chunk

将元素数组分割成大小为 size 的组。如果无法均匀分割数组，则最后一个块将是剩余元素。

Dollar.chunk([1, 2, 3, 4], size: 2)
=> [[1, 2], [3, 4]]

Dollar.chunk([1, 2, 3, 4], size: 3)
=> [[1, 2, 3], [4]]

compact - Dollar.compact

创建一个移除所有 nil 值的数组。

Dollar.compact([3, nil, 4, 5]) 
=> [3, 4, 5]

Dollar.compact([nil, nil]) as NSObject[] 
=> []

contains - Dollar.contains

检查给定的值是否存在于数组中。

Dollar.contains([1, 2, 3, 1, 2, 3], value: 2) 
=> true

Dollar.contains([1, 2, 3, 1, 2, 3], value: 10) 
=> false

cycle - Dollar.cycle

循环遍历数组并通过回调函数传递每个元素，可以指定循环次数。如果省略，则无限循环。

Dollar.cycle([1, 2, 3], 2) {
  print($0)
}
// Prints the following
123123

difference - Dollar.difference

创建一个数组，排除提供的数组的所有值。

Dollar.difference([1, 2, 3, 4, 5], [5, 2, 10]) 
=> [1, 3, 4]

each - Dollar.each

将数组中的每个元素传递给回调函数

Dollar.each(["A", "B"]) { 
  print("Value \($0)")
}
=> ["A", "B"]

Dollar.each(["A", "B"]) { (index, elem) in
  print("\(index) - \(elem)")
}
=> ["0 - A", "1 - B"]

every - Dollar.every

检查给定的回调函数是否为数组中所有项目返回真值。

Dollar.every([1, 2, 3, 4], callback: { $0 < 20 }) 
=> true

Dollar.every([1, 2, 3, 4]) { $0 == 1 } 
=> false

阶乘 Dollar.factorial

返回整数的阶乘

Dollar.factorial(3)
=> 6

Dollar.factorial(0)
=> 1

fetch - Dollar.fetch

从给定索引的数组中获取元素，检索到数组的末尾可以是负数。如果索引越界，则可以返回默认值。

let arr = [1, 2, 3, 4, 5, 6, 7, 8]
Dollar.fetch(arr, 100)
=> nil

Dollar.fetch(arr, 100, orElse: 42)
=> 42

Dollar.fetch(arr, -1)
=> 8

fill - Dollar.fill

从开始填充数组元素到结束（不包括结束）。此方法将修改数组。

var arr = Array<Int>(count: 5, repeatedValue: 1)
Dollar.fill(&arr, withElem: 42)
=> [42, 42, 42, 42, 42]

var arr = Array<Int>(count: 5, repeatedValue: 1)
Dollar.fill(&arr, withElem: 42, startIndex: 1, endIndex: 3)
=> [1, 42, 42, 42, 1]

find - Dollar.find

遍历数组元素，返回回调函数返回为真的第一个元素。

Dollar.find([1, 2, 3, 4], callback: { $0 == 2 }) 
=> 2

Dollar.find([1, 2, 3, 4]) { $0 == 10 } 
=> nil

findIndex - Dollar.findIndex

此方法与 find 相似，但返回通过回调函数检查的第一个元素的索引。

let arr = [["age": 36], ["age": 40], ["age": 1]]
let result = Dollar.findIndex(arr) { $0["age"] < 20 }
result 
=> 2

findLastIndex - Dollar.findLastIndex

此方法类似于 findIndex，但它是从数组的右侧开始迭代元素。

let arr = [["age": 36], ["age": 40], ["age": 1]]
let result = Dollar.findLastIndex(arr) { $0["age"] > 30 }
result
=> 1

first - Dollar.first(array: AnyObject[])

获取数组中的第一个元素。

Dollar.first([1, 2, 3, 4])
=> 1

Dollar.first([]) 
=> nil

groupBy Dollar.groupBy

此方法返回一个字典，其值按照回调函数返回的值进行分组。

Dollar.groupBy([1, 2, 3, 4, 5], callback: {$0 % 2})
=> [0: [2, 4], 1: [1, 3]]

Dollar.groupBy(["strings", "with", "different", lengths"], callback: {$0.characters.count})
=> [7: ["strings", "lengths"], 9: ["different"], 4: ["With"]]

second - Dollar.second(array: AnyObject[])

获取数组中的第二个元素。

Dollar.second([1, 2, 3, 4])
=> 2

Dollar.second([1]) 
=> nil

Dollar.second([])
=> nil

flatMap - Dollar.flatMap

使用转换元素为一个列表的函数，并将它们连接起来。

let values = [2, 3, 4, 5, 6, 7]
Dollar.flatMap(values) { [$0, $0] }
=> [2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7]

flatMap - Dollar.flatMap

将函数映射到一个Optional中，该函数将类型转换为Optional，然后返回一个单级别的Optional。

let url = NSURL(string: "https://apple.com/swift")
Dollar.flatMap(url) { $0.lastPathComponent }
=> Optional("swift")

注意：这与Optional链有相同的行为。上面的代码可以翻译为

NSURL(string: "https://apple.com/swift/")?.lastPathComponent
=> Optional("swift")

flatten - Dollar.flatten

将任何深度的嵌套数组扁平化。

Dollar.flatten([[3], 4, 5]) as Int[] 
=> [3, 4, 5]

Dollar.flatten([[3], "Hello", 5]) as NSObject[] 
=> [3, "Hello", 5]

Dollar.flatten([[[3], 4], 5]) as Int[] 
=> [3, 4, 5]

frequencies - Dollar.frequencies

此方法返回一个字典，将数组中的值映射到数组中出现的总次数。如果传递一个函数，则返回函数对数组元素的结果的频率表。

Dollar.frequencies(["a", "a", "b", "c", "a", "b"]) 
=> ["a": 3, "b": 2, "c": 1]

Dollar.frequencies([1, 2, 3, 4, 5]) { $0 % 2 == 0 }
=> [false: 3, true: 2]

gcd Dollar.gcd

GCD函数返回与传递的数字的最大的公约数。

Dollar.gcd(3, 10)
=> 1

Dollar.gcd(3, 9)
=> 3

indexOf - Dollar.indexOf

获取到第一次出现值的位置。

Dollar.indexOf([1, 2, 3, 1, 2, 3], value: 2) 
=> 1

Dollar.indexOf(["A", "B", "C"], value: "B") 
=> 1

Dollar.indexOf([3, 4, 5], value: 5) 
=> 2

Dollar.indexOf([3, 4, 5], value: 3) 
=> 0

Dollar.indexOf([3, 4, 5], value: 2) 
=> nil

initial - Dollar.initial

获取数组的所有元素，除了最后一个或最后n个元素。

Dollar.initial([3, 4, 5]) 
=> [3, 4]

Dollar.initial([3, 4, 5], numElements: 2) 
=> [3]

intersection - Dollar.intersection

创建一个包含所有提供的数组中存在的唯一值的数组。

Dollar.intersection([1, 2, 3], [5, 2, 1, 4], [2, 1]) 
=> [1, 2]

it-isIn Dollar.it<T: Comparable>(i: T, isIn range: Range<T>)

如果 i 在区间或范围内，则返回 true。

Dollar.it("c", isIn: "a"..."z")
=> true

Dollar.it("z", isIn: "a"..<"z")
=> false

Dollar.it(1, isIn: -1.0...10.0)
=> true

last - Dollar.last

从数组中获取最后一个元素。

Dollar.last([3, 4, 5]) 
=> 5

lastIndexOf - Dollar.lastIndexOf

获取值的最后出现位置的索引。

Dollar.lastIndexOf([1, 2, 3, 1, 2, 3], value: 2) 
=> 4

lcm Dollar.lcm

LCM 方法返回与传递的数字的最小公倍数。

Dollar.lcm(3, 10)
=> 30

Dollar.lcm(3, 9)
=> 9

rest - Dollar.rest

该方法与初始方法相反，用于获取除第一个元素或前 n 个元素之外的所有数组元素。

Dollar.rest([3, 4, 5]) 
=> [4, 5]

Dollar.rest([3, 4, 5], numElements: 2) 
=> [5]

map - Dollar.map

基于传入的映射函数将每个元素映射到新的值

Dollar.map([1, 2, 3, 4]) { 
  $0 * 2
}
=> [2, 4, 6, 8]

min - Dollar.min

从数组中检索最小值。

Dollar.min([2, 1, 2, 3, 4]) 
=> 1

max - Dollar.max

从数组中检索最大值。

Dollar.max([1, 2, 3, 4, 2, 1]) 
=> 4

pluck - Dollar.pluck

从数组中检索指定属性的值。

let arr = [["age": 20], ["age": 30], ["age": 40]]
Dollar.pluck(arr, value: "age") 
=> [20, 30, 40]

pull - Dollar.pull

从给定的数组中删除所有提供的值。

Dollar.pull([3, 4, 5, 3, 5], values: 3, 5) 
=> [4]

Dollar.pull([3, 4, 5, 3, 5], values: 4) 
=> [3, 5, 3, 5]

Dollar.pull([3, 4, 5, 3, 5], values: 3, 4, 5) 
=> []

pullAt - Dollar.pullAt

从给定索引处的数组中删除所有提供的值

let arr = [10, 20, 30, 40, 50]
Dollar.pullAt(arr, indices: 1, 2, 3)

range - Dollar.range

创建一个从开始 upward 但不包括结束的数字（正数和/或负数）数组。

Dollar.range(4) 
=> [0, 1, 2, 3]

Dollar.range(from: 1, to: 5) 
=> [1, 2, 3, 4]

Dollar.range(from: 0, to: 20, incrementBy: 5) 
=> [0, 5, 10, 15]

Dollar.range(from: 1, through: 5)
=> [1, 2, 3, 4, 5]

Dollar.range(from: 0, through: 20, incrementBy: 5)
=> [0, 5, 10, 15, 20]

reduce - Dollar.reduce

将所有元素执行 combine 函数后的一个值返回的 reduce 函数

Dollar.reduce([1, 2, 3], initial: 0) { (total, element) in
    total + element
}
=> 6

sample - Dollar.sample

从数组中返回一个样本元素

let arr : Int[] = [2, 1, 2, 3, 4]
Dollar.contains(arr, value: Dollar.sample(arr))
=> true

sequence - Dollar.sequence

创建一个任意序列的数组。与内置范围配合使用特别有用。

Dollar.sequence(0..4) 
=> [0, 1, 2, 3]

Dollar.sequence(-2.0..2.0) 
=> [-2.0, -1.0, 0.0, 1.0]

Dollar.sequence((0..20).by(5)) 
=> [0, 5, 10, 15]

Dollar.sequence("abc") 
=> ["a", "b", "c"]

remove - Dollar.remove

从数组中移除一个元素。

Dollar.remove(["A", "B", "C", "D"], value: "B")
=> ["A", "C", "D"]

remove - Dollar.remove

从数组中移除所有返回 true 的 callback 返回的元素。

let result = Dollar.remove([1, 2, 3, 4, 5, 6]) { 
  $0 == 2 || $0 == 3 
}
result
=> [1, 4, 5, 6]

shuffle - Dollar.shuffle

返回一个新打乱的数组。

let result = Dollar.shuffle([1, 2, 3, 4, 5, 6])
result
=> [4, 1, 3, 5, 6, 2]

大小 - 美元.size

返回数组的大小

Dollar.size(["a", "b", "c")
=> 3

有序索引 - 美元.sortedIndex

给出一个值应插入到给定数组中的最小索引，该数组是已排序的。

Dollar.sortedIndex([3, 4, 6, 10], value: 5)
=> 2

Dollar.sortedIndex([10, 20, 30, 50], value: 40)
=> 3

转置 - 美元.transpose

创建一个转置矩阵。

Dollar.transpose([[1, 2, 3], [4, 5, 6]])
=> [[1, 4], [2, 5], [3, 6]]

并集 - 美元.union

创建一个包含提供的数组中所有唯一值的顺序数组。

Dollar.union([1, 2, 3], [5, 2, 1, 4], [2, 1]) 
=> [1, 2, 3, 5, 4]

合并 - 美元.merge

创建一个包含提供的所有数组的所有值（包括重复项）的数组。

let arr  = [1, 5]
let arr2 = [2, 4]
let arr3 = [5, 6]
let result = Dollar.merge(arr, arr2, arr3)
result
=> [1, 5, 2, 4, 5, 6]

唯一 - 美元.uniq

创建一个不包含重复值的数组版本。

Dollar.uniq([1, 2, 1, 3, 1])
=> [1, 2, 3]

Dollar.uniq([1, 2.5, 3, 1.5, 2, 3.5]) {
  floor($0)
}
=> [1, 2.5, 3]

删除 - 美元.without

创建一个排除所有提供值的数组。

Dollar.without([3, 4, 5, 3, 5], values: 3, 5)
=> [4]

Dollar.without([3, 4, 5, 3, 5], values: 4)
=> [3, 5, 3, 5]

Dollar.without([3, 4, 5, 3, 5], values: 3, 4, 5)
=> []

xor - Dollar.xor

创建一个数组，该数组是提供的数组的对称差集。

Dollar.xor([1, 2, 3], [5, 2, 1, 4])
=> [3, 4, 5]

zip - Dollar.zip

创建一个数组，其中包含分组元素，第一个元素包含给定数组的第一个元素。

Dollar.zip(["fred", "barney"], [30, 40], [true, false]) as [NSObject] 
=> [["fred", 30, true], ["barney", 40, false]]

zipObject - Dollar.zipObject

从键和值数组中创建一个对象。

Dollar.zipObject(["fred", "barney"], values: [30, 40])
=> ["fred": 30, "barney": 40]

partition - Dollar.partition

生成一个数组数组，每个数组包含n个元素，每个元素相对于step偏移。停止后，当一个分区的长度小于n时。

let arr = [1, 2, 3, 4, 5]
Dollar.partition(arr, n: 2)
=> [[1, 2], [3, 4]]

Dollar.partition(arr, n: 4, step: 1)
=> [[1, 2, 3, 4], [2, 3, 4, 5]]

Dollar.partition(arr, n: 4, step: 1, pad: nil)
=> [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5]]

Dollar.partition(arr, n: 4, step: 1, pad: [6, 7, 8])
=> [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6]]

partitionAll - Dollar.partitionAll

生成一个数组数组，每个数组包含n个元素，每个元素相对于step偏移。当分区长度小于n时继续。

Dollar.partitionAll([1, 2, 3, 4, 5], n:4, step: 1)
=> [[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5], [4, 5], [5]]

partitionBy - Dollar.partitionBy

对数组中的每个元素应用一个函数，每次函数返回新值时分割数组。

Dollar.partitionBy([1, 2, 3, 4, 5]) { $0 % 2 == 0 }
=> [[1], [2, 4], [3, 5], [6]]

Dollar.partitionBy([1, 7, 3, 6, 10, 12]) { $0 % 3 }
=> [[1, 7], [3, 6], [10], [12]]

词典

键 - Dollar.keys

根据字典创建一个键数组。

Dollar.keys(["Dog": 1, "Cat": 2])
=> ["Dog", "Cat"]

值 - Dollar.values

根据字典创建一个值数组。

Dollar.values(["Dog": 1, "Cat": 2])
=> [1, 2]

合并 - Dollar.merge

合并所有字典，后一个字典将覆盖指定键的值。

let dict: Dictionary<String, Int> = ["Dog": 1, "Cat": 2]
let dict2: Dictionary<String, Int> = ["Cow": 3]
let dict3: Dictionary<String, Int> = ["Sheep": 4]
Dollar.merge(dict, dict2, dict3)
=> ["Dog": 1, "Cat": 2, "Cow": 3, "Sheep": 4]

选择 - Dollar.pick

创建一个指定键的字典的浅拷贝。

Dollar.pick(["Dog": 1, "Cat": 2, "Cow": 3], keys: "Dog", "Cow")
=> ["Dog": 1, "Cow": 3]

省略 - Dollar.omit

创建一个除指定键外的浅拷贝字典。

Dollar.omit(["Dog": 1, "Cat": 2, "Cow": 3, "Sheep": 4], keys: "Cat", "Dog")
=> ["Cow": 3, "Sheep": 4]

对象

tap - Dollar.tap

使用该对象调用拦截器，然后返回该对象。

var beatle = Car(name: "Fusca")
Dollar.tap(beatle, {$0.name = "Beatle"}).color = "Blue"

函数

after - Dollar.after

创建一个函数，仅在调用n次后才执行传递的函数。

var saves = ["profile", "settings"];
let asyncSave = { (function: () -> ()?) in
   function() 
   // Saving right away for testing 
   // but in real world would be async
}
var isDone = false
var completeCallback = Dollar.after(saves.count) {
   isDone = true
}
for elem in saves {
   asyncSave(completeCallback)
}
isDone 
=> true

bind - Dollar.bind

创建一个函数，当调用时，使用提供的参数绑定调用func。

var helloWorldFunc = Dollar.bind({(T...) in
  T[0] + " " + T[1] + " from " + T[2] 
}, "Hello", "World", "Swift")
helloWorldFunc() 
=> "Hello World from Swift"

helloWorldFunc = Dollar.bind({ $0 + " World" }, "Hello")
helloWorldFunc()
=> "Hello World"

helloWorldFunc = Dollar.bind({ $0 + $1 + " World" }, "Hello ", "Great")
helloWorldFunc()
=> "Hello Great World"

compose - Dollar.compose

组合两个或更多函数，其中第一个函数的返回值传递给下一个函数。当需要链式调用函数并返回可以接受可变参数值或值数组的函数时非常有用。

let double = { (params: Int...) -> [Int] in
  return Dollar.map(params) { $0 * 2 }
}
let subtractTen = { (params: Int...) -> [Int] in
  return Dollar.map(params) { $0 - 10 }
}
let doubleSubtractTen = Dollar.compose(double, subtractTen)
doubleSubtractTen(5, 6, 7)
=> [0, 2, 4]

let f = Dollar.compose({ (arr: [Int]) -> [Int] in
  Dollar.map(arr) { $0 + 1 }
}, { (arr: [Int]) -> [Int] in
  Dollar.map(arr) { $0 * 2 }
})
f([1, 2])
=> [4, 6]

curry - Dollar.curry

返回一个函数，当调用时，如果已提供了所有函数参数，则执行该函数并返回其结果；如果没有提供所有参数，则返回另一个函数，该函数接受剩余参数中的一个，直到所有参数都提供为止。这在实现像以下示例中看到的部分函数时非常有用。

func adder(x: Int, y: Int, z: Int) -> Int {
return x + y + z
}

let curriedAdder = Dollar.curry(adder)
let addTenAnd = curriedAdder(10)
let addThirtyAnd = addTenAnd(20)
addThirtyAnd(1)
=> 31

addThirtyAnd(50)
=> 80

addTenAnd(10)(10)
=> 30

id - Dollar.id

一个简单的识别函数，它只是返回它给出的参数。

Dollar.id("Hello World from Swift")
=> "Hello World from Swift"

memoize - Dollar.memoize

返回一个缓存函数值以提高性能的缓存的函数。

var times = 0 // to test memoization

let fibMemo = Dollar.memoize { (fib: (Int -> Int), val: Int) -> Int in
  times += 1
  return val == 1 || val == 0 ? 1 : fib(val - 1) + fib(val - 2)
}

let x = fibMemo(5)
times
=> 6

times = 0
let y = fibMemo(5)
times
=> 0

times = 0
let z = fibMemo(6)
times
=> 1

noop - Dollar.noop

一个不做任何操作的函数。

Dollar.noop() 
=> nil

now - Dollar.now

获取自Unix纪元（1970年1月1日00:00:00 UTC）以来已过的秒数。

Dollar.now() 
=> 1431911564.292577

once - Dollar.once

获取一个包装函数，该函数仅执行一次传入的函数。这在获取共享配置或创建单例对象时非常有用。

func createConfig() -> [String: String] {
  var i = 1
  return [
    "App ID": "\(i++)",
    "URL": "https://someurl"
  ]
}

let getConfig = Dollar.once(createConfig)
getConfig()
=> ["App ID": "1", "URL": "https://someurl"]

getConfig()
=> ["App ID": "1", "URL": "https://someurl"]

partial - Dollar.partial

创建一个函数，当调用该函数时，会将额外部分参数附加到传递给新函数的参数之前。

let partialFunc = Dollar.partial({(T...) in 
  T[0] + " " + T[1] + " from " + T[2] 
}, "Hello")
partialFunc("World", "Swift") 
=> "Hello World from Swift"

times - Dollar.times

调用函数 n 次，并传递索引。如果函数中有返回值，则 times 方法将返回这些值组成的数组。

let fun = Dollar.bind({ (names: String...) -> String in
   let people = Dollar.join(names, separator: " from ")
   return "Hello \(people)"
   }, "Ankur", "Swift")
Dollar.times(2, function: fun) as String[] 
=> ["Hello Ankur from Swift", "Hello Ankur from Swift"]

绑定

Dollar.chain(...)

any

如果回调函数至少对一个数组元素返回 true，则返回 true。

var chain = Dollar.chain([1, 2, 3])
chain.any({ ($0 as Int) < 2 })
=> true

all

如果回调函数对数组中的所有元素返回 true，则返回 true。

var chain = Dollar.chain([1, 2, 3])
chain.all({ ($0 as Int) < 10 })
=> true

each

将每个元素值传递给回调函数。

var chain = Dollar.chain(["Hello", "World"])
var strBuilder = ""
chain.each({ strBuilder += ($0 as String) }).value
strBuilder
=> "HelloWorld"

filter

筛选出回调函数返回为真的数组元素

var chain = Dollar.chain([1, 2, 3, 4])
chain.filter({ ($0 as Int) < 3 }).value
=> [1, 2]

first

返回数组中的第一个元素并结束链式调用

var chain = Dollar.chain([1, 2, 3, 4])
chain.first()
=> 1

second

返回数组中的第二个元素并结束链式调用

var chain = Dollar.chain([1, 2, 3, 4])
chain.second()
=> 2

third

返回数组中的第三个元素并结束链式调用

var chain = Dollar.chain([1, 2, 3, 4])
chain.third()
=> 3

flatten

将任何深度的嵌套数组扁平化。

var chain = Dollar.chain([[1, [2]], [3], 4])
chain.flatten().value
=> [1, 2, 3, 4]

initial

获取数组的所有元素，除了最后一个或最后n个元素。

var chain = Dollar.chain([1, 2, 3, 4])
chain.initial(2).value
=> [1, 2]

map

将每个元素映射为回调函数返回的新值

var chain = Dollar.chain([1, 2, 3, 4])
chain.map({ ($0 as Int) * 2 }).value
=> [2, 4, 6, 8]

大小

返回数组大小并终止链式调用

var chain = Dollar.chain([1, 2, 3, 4])
chain.map({ ($0 as Int) * 2 }).size()
=> 4

切片

根据起始和结束位置对数组进行切片。如果未指定结束位置，将切片到数组末尾。

var chain = Dollar.chain([1, 2, 3, 4, 5, 6, 7])
chain.slice(2, end: 4).value
=> [3, 4]

值

评估所有回调后返回值

var chain = Dollar.chain([1, 2, 3, 4, 5, 6, 7])
chain.value
=> [1, 2, 3, 4, 5, 6, 7]

链式调用多个方法

Dollar.chain([[1, 2], 3, [[4], 5]])
  .initial()
  .flatten()
  .first()
=> 1

Dollar.chain([1, 2, 3, 4, 5])
  .filter { $0 % 1 == 0 }
  .map { $0 * 2 }
  .all {$0 < 10}
=> false

Dollar.chain([1, 2, 3, 4, 5])
  .map({ $0 * 2 })
  .flatten()
  .initial(2).value
=> [2, 4, 6]

使用方法

数组扩展

<< elem: Element -> [Element]

重载运算符，可以将元素添加到数组中，或从另一个数组中将元素添加到第一个数组中。返回添加元素后的数组。

var array = [1, 2, 3]
array << 4
=> [1, 2, 3, 4]
array << [5, 6]
=> [1, 2, 3, 4, 5, 6]

at(indexes: Int...) -> [Element]

根据指定的索引或键，从集合中创建一个元素的数组。

let array = ["foo", "spam", "bar", "eggs"]
let some = array.at(1, 3)
=> ["spam", "eggs"]

each(callback: (Element) -> ()) -> [Element]

针对数组中的每个元素调用回调，传递元素本身。

let array = ["foo", "spam", "bar", "eggs"]
array.each {
  print($0)
}
=> ["foo", "spam", "bar", "eggs"]

eachWithIndex(callback: (Int, Element) -> ()) -> [Element]

针对数组中的每个元素调用回调，同时传入元素及其索引。

let array = ["foo", "spam", "bar", "eggs"]
array.each { (index, elem)
  print("\(index) - \(elem)")
}
=> ["foo", "spam", "bar", "eggs"]

cycle<U>(times: Int, callback: (Element) -> U)

循环遍历数组并通过回调函数传递每个元素，可以指定循环次数。如果省略，则无限循环。

[1, 2, 3].cycle(2) {
  print($0)
}
// Prints the following
123123

[1, 2, 3].cycle {
  print($0)
}
// Cycles in an infinite loop

every(callback: (Element) -> Bool) -> Bool

检查给定的回调函数是否为数组中所有项目返回真值。

["angry", "hungry"].every { (a: String) -> (Bool) in 
  a.hasSuffix("gry") 
}
=> true

indexOf<T: Equatable>(value: T) -> Int

获取到第一次出现值的位置。

let array = ["foo", "spam", "bar", "eggs"]
array.indexOf("spam")
=> 1
array.indexOf("None")
=> nil

fetch(index: Int, orElse: T? = .None) -> T!

从给定索引的数组中获取元素，检索到数组的末尾可以是负数。如果索引越界，则可以返回默认值。

let arr = [1, 2, 3, 4, 5, 6, 7, 8]
arr.fetch(100)
=> nil

arr.fetch(100, orElse: 42)
=> 42

arr.fetch(-1)
=> 8

findIndex(callback: (Element) -> Bool) -> Int?

此方法与 find 相似，但返回通过回调函数检查的第一个元素的索引。

let ind: int? = ["foo", "bar", "spam", "eggs"].findIndex {
  $0.length == 4
}
ind! == 2 
=> true

findLastIndex(callback: (Element) -> Bool) -> Int?

此方法类似于 findIndex，但它是从数组的右侧开始迭代元素。

let ind: int? = ["foo", "bar", "spam", "eggs"].findLastIndex {
  $0.length == 4 
}
ind! == 3 
=> true

first() -> Element?

获取数组中的第一个元素。

let first = ["foo", "bar"].first()
=> "foo"

flatten() -> [Element]

将任何深度的嵌套数组扁平化。

let unFlattened = ["foo", ["bar"], [["spam"]], [[["eggs"]]] ]
let flattened = unFlattened.flatten() 
=> ["foo", "bar", "spam", "eggs"]

get(index: Int) -> Element?

获取索引处的元素

let element = ["foo", "bar"].get(0)
element!
=> "foo"

let nothing = ["foo", "bar"].get(1000)
=> nil

initial(numElements: Int? = 1) -> [Element]

获取数组的所有元素，除了最后一个或最后n个元素。

let initial = ["foo", "bar", "spam"].initial(2) 
=> ["foo"]

last() -> Element?

从数组中获取最后一个元素。

let last = ["foo", "bar"].last() 
=> "bar"

rest(numElements: Int? = 1) -> [Element]

该方法与初始方法相反，用于获取除第一个元素或前 n 个元素之外的所有数组元素。

let rest = ["foo", "bar", "spam"].rest(2)
=> ["spam"]

min<T: Comparable>() -> T?

从数组中检索最小值。

let min = [ 0, 1, 2 ].min()
=> 0

max<T: Comparable>() -> T?

从数组中检索最大值。

let max = [ 0, 1, 2].max()
=> 2

remove<T: Equatable>(value: T) -> T?

从数组中移除元素

var arr = ["A", "B", "C", "D", "E"]
arr.remove("B")
=> ["A", "C", "D", "E"]

contains<T:Equatable>(value: T) -> Bool

检查给定的值是否存在于数组中。

var arr = ["A", "B", "C", "D", "E"]
arr.contains("C")
=> true
arr.contains("Z")
=> false

字符扩展

"A".description -> String

获取字符的字符串描述

let ch: Character = "A"
let str = ch.description
=> "A"

"A".ord -> Int

获取字符的整型表示

Character("A").ord
=> 65

日期扩展

Date.from(#year: Int, month: Int, day: Int) -> NSDate

给定年份、月份和日期创建一个新的日期对象

let date = Date.from(2014, 1, 1) 
=> "Jan 1, 2014, 12:00 AM"

Date.from(#unix: Double) -> NSDate

给定Unix时间戳（timeIntervalSince1970）创建一个新的日期对象

let date = Date.from(unix: 1_388_552_400.0)
=> "Jan 1, 2014, 12:00 AM"

Date.parse(dateStr: String, format: String = "yyyy-MM-dd") -> NSDate

根据格式解析日期，并返回一个新的日期对象

let parsedDate = Date.parse("2014-01-01", format: "yyyy-MM-dd")
=> "Jan 1, 2014, 12:00 AM"

Date.unix(date: NSDate = NSDate()) -> Double

返回传入日期的 UNIX 时间戳或当前 UNIX 时间戳

let currentUnix = Date.unix()
=> 1,388,552,400.0

var otherNSDate = Date()
let otherUnix = Date.unix(otherDate)
=> 1,388,552,400.0

Int.hour.fromNow 等。

使用以下语法根据用户当前日历计算日期和时间。

1.day.ago
=> "Apr 10, 2015, 11:51 AM"
4.hours.fromNow
=> "Apr 11, 2015, 3:51 PM"

字典扩展

merge<K, V>(dictionaries: Dictionary<K, V>...)

合并传入的字典。后者将覆盖已设置的键的值

var dic = ["foo": "bar"] 
let anotherDic = ["foo": "baz", "spam": "eggs"]
dic.merge(anotherDic)
=> ["foo": "baz", "spam": "eggs"]

Int 扩展

times(callback: (Int) -> ())

调用带索引的回调 n 次

5.times { print("Na") } 
=> "NaNaNaNaNa"

times (function: () -> ())

调用回调 n 次

5.times { (a: Int) -> () in print("\(a) ") } 
=> 0 1 2 3 4

char -> 字符

从整数获取ASCII字符

65.char
=> "A"

isEven

检查整数是否为偶数

2.isEven
=> true

1.isEven
=> false

isOdd

检查整数是否为奇数

3.isOdd
=> true

2.isOdd
=> false

digits () -> [Int]

将整数字符串分隔为数组

4208.digits()
=> [4, 2, 0, 8]

lcm () -> Int

LCM 方法返回与传递的数字的最小公倍数。

3.lcm(10)
=> 30

3.lcm(9)
=> 9

gcd () -> Int

最大公约数方法与传入的数字的最大公约数

3.gcd(10)
=> 1

3.gcd(9)
=> 3

random () -> Int

返回从0到但不包括整数值的随机数

3.random()
=> 2

3.random()
=> 1

factorial() -> Int

返回整数的阶乘

3.factorial()
=> 6

0.factorial()
=> 1

isIn(interval) -> Bool

如果 i 在区间或范围内，则返回 true。

5.isIn(1...10)
=> true

10.isIn(1..<10)
=> false

next() -> Int

获取下一个整数值

10.next()
=> 11

prev() -> Int

获取前一个整数值

10.prev()
=> 9

upTo(limit: Int, callback: () -> ())

从整数值limit开始调用回调函数，包括limit

3.upTo(5) {
  print("Hi")
}
Prints "HiHiHi"

downTo(limit: Int, callback: () -> ())

从整数值limit开始调用回调函数，包括limit

3.downTo(0) {
  print("Hi")
}
Prints "HiHiHiHi"

字符串扩展

.length

获取字符串的长度

"Hello".length
=> 5

.camelCase

获取字符串的驼峰表示形式

"__Dollar and cent-- dollarANDCent".camelCase
=> "dollarAndCentDollarAndCent"

.kebabCase

获取字符串的短横线表示形式

"__Dollar and cent-- dollarANDCent".kebabCase
=> "dollar-and-cent-dollar-and-cent"

.snakeCase

获取字符串的蛇形表示形式

"__Dollar and cent-- dollarANDCent".snakeCase
=> "dollar_and_cent_dollar_and_cent"

.startCase

获取字符串的开头表示形式

"__Dollar and cent-- dollarANDCent".startCase
=> "Dollar And Cent Dollar And Cent"

=~ str: String -> Bool

是否正则匹配，右侧的正则表达式字符串是否匹配左侧的字符串

"Dollar" =~ "oll"
=> true

* n: Int -> String

获取字符串被重复连接n次的结果

"Hi Swift! " * 3
=> "Hi Swift! Hi Swift! Hi Swift! "

[i: Int] -> Character?

获取指定下标的字符

"Hello World"[6] == "W"
=> true

"Hi"[5]
=> nil

[str: String] -> String?

根据下标中的第一个正则表达式匹配返回子串

let proj = "Dollar and Cent"
proj["^.+[^and Cent]"]
=> {Some: "Dollar"}

[r: Range<Int>] -> String

使用下标表示法并通过传递范围获取子串

"Hello World"[0..<5] == "Hello" 
=> true

indexOf(char: Character) -> Int?

获取字符的起始索引

"hello world".indexOf(Character("o"))!
=> 4

indexOf(str: String) -> Int?

获取字符串的起始索引

"hello world".indexOf("llo")!
=> 2

"hello world".indexOf("illo")
=> nil

indexOf(pattern: String) -> Int?

获取字符串中正则表达式的起始索引

"hello world".indexOf(".llo")!
=> 1

split(delimiter: Character) -> [String]

使用分隔符字符从字符串中获取数组

"Hello World".split(" ") 
=> ["Hello", "World"]

lstrip() -> String

获取不带前导空格的字符串

let leadingSpace = "  Hello"
leadingSpace.lstrip()
=> "Hello"

rstrip() -> String

获取不带尾随空格的字符串

let trailingSpace = "Hello   "
trailingSpace.rstrip()
=> "Hello"

strip() -> String

获取不带前导或尾随空格的字符串

let spaces = "   Hello   "
spaces.strip()
=> "Hello"

Regex

init

使用字符串形式的正则表达式模式初始化

Regex.init("^Hello.World$") // Regex that matches "Hello World"

matches(testStr: String) -> [AnyObject]

返回基于传入的字符串的匹配项。

let re = Regex.init("^Hello.World$")
re.matches("Hello World")

test(testStr: String) -> Bool

let re = Regex.init("^Hello.World$")
re.test("Hello World")
=> true

re.test("Str")
=> false

escapeStr(str: String) -> String

使用正则表达式字符编码字符串

Regex.escape("Hello.World")
=> "Hello\.World"

范围扩展

equals - ==

检查两个范围的相等性

(1...5) == (1...5) 
=> true

(1..<5) == (1...5) 
=> false

eachWithIndex(callback: (T) -> ())

对范围中的每个索引，通过传递范围中的元素来调用回调函数

(1...5).eachWithIndex { (a: Int) -> () in print("\(a)") } 
=> 12345

each(callback: () -> ())

对范围中的每个索引调用回调函数

(1...5).each { print("Na") } 
=> "NaNaNaNaNa"

贡献

如果您有兴趣进行贡献，请查看 CONTRIBUTING.md