[Swift]Swift的常用内置函数

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/ ）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/9837176.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

内置函数：在Swift中不需要导入任何模块（如UIKit等）或者引用任何类就可以使用的函数。Swift预先定义的函数
//快捷键Control+⌘+Space来开启Emoji字符输入

1、断言assert和先决条件precondition
断言和先决条件是在运行时发生的检查。在执行任何进一步的代码之前，您可以使用它们来确保满足基本条件。如果断言或先决条件中的布尔条件求值为true，则代码执行将照常继续。如果条件评估为false，则程序的当前状态无效; 代码执行结束，您的应用程序终止。
断言和先决条件之间的区别在于它们的检查时间：仅在调试版本中检查断言，但在调试和生成版本中都会检查先决条件。在生产版本中，不会评估断言中的条件。这意味着您可以在开发过程中使用任意数量的断言，而不会影响生产中的性能。

使用断言进行调试

您可以通过assert(_:_:file:line:)从Swift标准库中调用函数来编写断言。您将此函数传递给一个表达式，该表达式求值为true或者false，如果条件的结果为，则显示一条消息false。例如：

let age = -3
assert(age >= 0, "A person's age can't be less than zero.")
// This assertion fails because -3 is not >= 0.

在此示例中，如果求值，则代码执行继续，即，值是否为非负值。如果值为负，如上面的代码所示，则求值为，并且断言失败，终止应用程序。
你可以省略断言消息 - 例如，它只是重复条件作为断言。

assert(age >= 0)

如果代码已经检查了条件，则使用该assertionFailure(_:file:line:)函数指示断言失败。例如：

if age > 10 {
    print("You can ride the roller-coaster or the ferris wheel.")
} else if age >= 0 {
    print("You can ride the ferris wheel.")
} else {
    assertionFailure("A person's age can't be less than zero.")
}

执行先决条件

只要条件可能为false，就使用先决条件，但对于代码继续执行必须确实为真。例如，使用先决条件检查下标是否超出范围，或检查函数是否已传递有效值。

你通过调用precondition(_:_:file:line:)函数来编写前提条件。您将此函数传递给一个表达式，该表达式求值为true或者false，如果条件的结果为，则显示一条消息false。例如：

// In the implementation of a subscript...
precondition(index > 0, "Index must be greater than zero.")

您也可以调用该preconditionFailure(_:file:line:)函数来指示发生了故障 - 例如，如果采用了交换机的默认情况，但是所有有效的输入数据应该由交换机的其他情况之一处理。

注意

如果以unchecked mode（-Ounchecked）编译，则不检查先决条件。编译器假定先决条件始终为true，并相应地优化代码。但是，fatalError(_:file:line:)无论优化设置如何，该功能始终会暂停执行。

您可以fatalError(_:file:line:)在原型设计和早期开发期间使用该功能，通过编写fatalError("Unimplemented")存根实现来创建尚未实现的功能的存根。因为致命错误永远不会被优化，与断言或先决条件不同，您可以确保执行总是在遇到存根实现时停止。

2、count函数：获取序列的元素个数 

let str:String = "strengthen"
print(str.count)
//Pring: 10
print(str.characters.count)
//Pring: 10
let arr:[Int] = [1,2,3,4,5]
print(arr.count)
//Pring: 5

3、enumerated() 将原有序列转换成以元组作为元素的序列输出

let arr = ["s","t","r","e","n","g","t","h","e","n"]
//打印新序列
for (i,j) in arr.enumerated()
{
    print("\(i):\(j)")
}
//0:s
//1:t
//2:r
//3:e
//4:n
//5:g
//6:t
//7:h
//8:e
//9:n

4、max() 返回多个元素的最大值
      min()  返回多个元素的最小值

/*min()*/
//方式1
let num1 = min(9,1)
print(num1)
//Print 1
let num2 = min(9,7,5,3,1)
print(num2)
//Print 1

let arr = [3,1,5,9]
//方式2 数组
let num4 = arr.min { (a, b) -> Bool in
     a < b
 }
print(num4)
//Print Optional(1)

/*max()*/
//方式1
let num1 = max(9,1)
print(num1)
//Print 9
let num2 = max(9,7,5,3,1)
print(num2)
//Print 9

let arr = [3,1,5,9]
//方式2 数组
let num4 = arr.max { (a, b) -> Bool in
     a < b
 }
print(num4)
//Print Optional(9)

5、map函数：对数组/序列中的元素进行特定操作,返回一个新的数组/序列。

map函数能够被数组调用，它接受一个闭包作为参数，作用于数组中的每个元素，闭包返回一个变换后的元素，接着将所有这些变换后的元素组成一个新的数组。

let arr = [1,2,3,4,5,6,7,8,9]

//数组各元素放大2倍
let doubleArr = arr.map {$0 * 2}
print(doubleArr)
//Print [2, 4, 6, 8, 10, 12, 14, 16, 18]

//Int数组各元素放大3倍，再转换为String
let moneyArr = arr.map { "$\($0 * 3)"}
print(moneyArr)
//Print ["$3", "$6", "$9", "$12", "$15", "$18", "$21", "$24", "$27"]

//数组转元组
let groupArr = arr[0...5].map{($0, "\($0)")}
print(groupArr)
//Print [(1, "1"), (2, "2"), (3, "3"), (4, "4"), (5, "5"), (6, "6")]

6、flapMap降低数组维度，过滤数组中的nil值。

let arr1 = [[1,2],[3,4],[5,6],[7,8,9]]

//flapMap函数降低维度
let flapMapAry1 = arr1.flatMap{$0}
print(flapMapAry1)
//Print [1, 2, 3, 4, 5, 6, 7, 8, 9]

//flapMap函数降低维度
let arr2 = [[[1,1,1],2],[3,4],[5,6],[7,8,[9,9,9]]]
//flapMap函数降低维度
let flapMapAry2 = arr2.flatMap{$0}
print(flapMapAry2)
//Print [[1, 1, 1], 2, 3, 4, 5, 6, 7, 8, [9, 9, 9]]

//flapMap函数会过滤数组中的nil值
let arr3:[Int?] = [1, 2, 3, nil, nil]
let flapMapAry3 = arr3.flatMap{$0}
print(flapMapAry3)
//Print [1, 2, 3]

7、filter筛选函数：序列/数组的元素进行筛选,筛选的结果放入一个新的数组

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

//方式1
//筛选偶数值
let even = numbers.filter{(num) -> Bool in
      num % 2 == 0
}
print("\(even) ", terminator: "")
//Print [2, 4, 6, 8]

//筛选奇数值
let odd = numbers.filter{(num) -> Bool in
      num % 2 == 1
}
print("\(odd) ", terminator: "")
//Pring [1, 3, 5, 7, 9] 

//方式2
//筛选偶数值
let evens = numbers.filter{$0 % 2 == 0}
print("\(evens) ", terminator: "")
//Print [2, 4, 6, 8]

//筛选奇数值
let odds = numbers.filter{$0 % 2 == 1}
print("\(odds) ", terminator: "")
//Pring [1, 3, 5, 7, 9] 

8、reduce()：给定一个序列sequence，以及一个初始值initial，然后将initial和序列里的第1个元素作为参数传入combineClosure中进行运算，得到的结果保存到initial；然后再将initial和第2个元素传入combineClosure中计算，结果保存到initial；重复计算直到所有sequence中的元素都计算完毕，并返回最终的initial值。

let arr = [1,2,3,4,5]
//方式1
let res = arr.reduce(0){(res, item) -> Int in
    res + item
}
print("\(res) ", terminator: "")
//Print 15

//方式2
//数组各元素求和reduce(0)
let sum = arr.reduce(0) {$0 + $1}
print("\(sum) ", terminator: "")
//Print 15
//数组各元素求积reduce(1)
let product = arr.reduce(1) {$0 * $1}
print("\(product) ", terminator: "")
//Print 120

//方式3
let arr2 = ["1","2","3","4","5"]
//方式2：数组转字符串
let str = arr2.reduce("", {$0 + $1})
print("\(str) ", terminator: "")
//Print 12345

9、绝对值函数
　   abs()函数：取绝对值。适用于整数和浮点数
 fabs(double)：取double类型的取绝对值
fabsf(double)：取float类型的取绝对值

//小数位5个9
print(abs(9.999999))
print(fabs(9.999999))
print(fabsf(9.99999))
//Print 9.999999

//小数位6个9
print(fabsf(9.999999))
//Print 1.0

10、dropFirst(): 返回一个去掉第一个元素的新序列/数组

//初始化一个数组
var arr = ["s","t","r","e","n","g","t","h","e","n"]
//删除第一位元素，变成ArraySlice<String>类型
var arr2:ArraySlice<String> = arr.dropFirst()
//ArraySlice<String>类型转换为[String]类型
var arr3 = [String](arr.dropFirst())
print(arr2)
//Print ["t", "r", "e", "n", "g", "t", "h", "e", "n"]
print(arr3)
//Print ["t", "r", "e", "n", "g", "t", "h", "e", "n"]

11、dropLast(): 返回一个的新序列/数组，该序列去掉作为参数传递给函数的最后一个元素。

//初始化一个数组
var arr = ["s","t","r","e","n","g","t","h","e","n"]
//删除第一位元素，变成ArraySlice<String>类型
var arr2:ArraySlice<String> = arr.dropLast()
//ArraySlice<String>类型转换为[String]类型
var arr3 = [String](arr.dropLast())
print(arr2)
//Print ["s", "t", "r", "e", "n", "g", "t", "h", "e"]
print(arr3)
//Print ["s", "t", "r", "e", "n", "g", "t", "h", "e"]

12、dump(object): 一个对象的内容转储到标准输出。

//初始化一个数组
var arr = ["s","t","r","e","n","g","t","h","e","n"]
dump(arr)
//Print
▿ 10 elements
  - "s"
  - "t"
  - "r"
  - "e"
  - "n"
  - "g"
  - "t"
  - "h"
  - "e"
  - "n"

13、elementsEqual(other: Sequence): 判断两个序列/数组中的元素是否完全相等,元素的顺序也必须相同。

//初始化一个数组
var arr1 = ["s","t","r","e","n","g","t","h","e","n"]
var arr2 = ["s","t","r","e","n","g","t","h","e","n"]
//判断两个序列/数组中的元素是否完全相等,元素的顺序也必须相同
let flag = arr1.elementsEqual(arr2)
print(flag)
//Print true

14、contains() 序列/数组是否包含某个元素：如果某个序列sequence（比如说一个数组）包含指定的元素element，则返回true，否则返回false

//初始化一个数组
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]

//方式1：闭包拓展性强
let flag = arr.contains { (num) -> Bool in
    //判断是否包含偶数
     num % 2 == 0
}
print(flag)
//Print true

//方式2：直接
print(arr.contains(7))
//Print true

15、joined(separator: String)序列\数组拼接字符串,对数组的元素顺序拼接,并插入指定字符串

var arr = ["s","t","r","e","n","g","t","h","e","n"]
let str = arr.joined(separator: "-")
print(str)
//Print s-t-r-e-n-g-t-h-e-n

16、sorted排序,sorted()默认是升序,.sorted(by: (Int, Int) -> Bool)自定义排序

//方式1
//sorted()默认是升序
let arr1 = arr.sorted()
print(arr1)
//Print [1, 2, 3, 4, 5]

//方式2
//降序
let arr2 = arr.sorted { (a, b) -> Bool in
    a > b
}
//简写形式
let arr3 = arr.sorted{$0 > $1}
//最简形式
let arr4 = arr.sorted(by: >)
print(arr2)
print(arr3)
print(arr4)
//Print [5, 4, 3, 2, 1]

//升序
let arr5 = arr.sorted { (a, b) -> Bool in
    a < b
}
//简写形式
let arr6 = arr.sorted{$0 < $1}
//最简形式
let arr7 = arr.sorted(by: <)
print(arr5)
print(arr6)
print(arr7)
//Print [1, 2, 3, 4, 5]

17、indices: 在指定的序列中返回元素的索引(零索引),可用于字符串遍历
        reversed(): 返回所给序列的倒序。

let arrayStr:[String] = ["s","t","r","e","n","g","t","h","e","n","!"]

//根据元素索引倒序遍历
for item in arrayStr.indices.reversed() {
   print("\(item) ", terminator: "")
}
//Print 10 9 8 7 6 5 4 3 2 1 0 

18、其他函数

let num:Double = 3.141592658
// round：四舍五入
let res1 = round(num) 
// ceil： 向上取整,返回大于或者等于指定表达式的最小整数
let res2 = ceil(num)
// floor: 向下取整,返回不大于指定表达式的的最大整数
let res3 = floor(num) 

print(res1)
//Print 3.0
print(res2)
//Print 4.0
print(res3)
//Print 3.0