Swift 3.0之后的Array用法记录以及循环遍历知识点

Swift更新还是蛮快的，以前写的一下小东西基本上编译起来都是一片红，还是稍微记录下，后期可以帮助自己翻阅

数组

// 方法1
let arrar1 = ["hehe","haha"];

// 方法2
let arrar2 = [String]()

- 数组使用[]即可

- 数组中类型一致，那么就是该类型的数组 let arr: [String]

- 数组中类型不一致，那么就是any类型的 let arr1: [Any]

基本操作

// 数组
let arr = ["zhangsan","sli"]
// 这里打印出来是swift样式的
print(arr)

for a in arr {
print(a)
}
// 像OC一样打印
print(arr as NSArray)

// 不同类型的数据就全是对象类型
let arr1 = ["ssa","aaa",1] as [Any]
print(arr1 as NSArray)

let a = 1
var array:[String]
array = ["zhangsan"]
print(array)
// 增加字符串
array.append("hehe")
// 数组基本操作
print(array)
// 拼接基本类型
array.append("\(a)")
// 容量
print(array.capacity)
print(array)
// 删除下标
array.remove(at: 1)
print(array)
// 删除全部
array.removeAll(keepingCapacity: true)
print(array.capacity)
// 动态添加成员
for i in 0..<10 {
array.append("\(i)")
//    print("\(array)--\(array.capacity)")
}
print(array)

// 数组拼接
// 初始化
var array2 = [String]()
array2.append("1")
array2.append("2")

array2 += array
print(array2)

- 如果定义数组时制定了保存对象的类型，择不能像数组里面添加其他类型

- 可以使用String初始化

- let类型的数组时不可变的

- var类型的数组是可变的

1.Range类型遍历

//for var i=0;i<10;i++{
//    print(i)
//}

// Swift循环
// 0..<10 代表一个区间返回 0-10 包含头部，不包含尾部
for i in 0..<10 {
print(i)
}

// _ 代表忽略，如果不关心某个参数，就可以使用_ 使用较多
for _ in 0..<10 {
print("f")
}

// 0...10 <=10
for i in 0...10 {
print(i)
}

2.数组的enumerated遍历

1.普通获取
let lists = [1,2,3,4,5,6,7]
var result = ""
for num in lists.enumerated() {
result += "\(num.offset)---\(num.element)||"
}
print(result)
0---1||1---2||2---3||3---4||4---5||5---6||6---7||
分别打印的是inedx和value

// 元祖类型遍历
// 可以吧上面的num换成元祖
let lists = [1,2,3,4,5,6,7]
var result = ""
for (index,item) in lists.enumerated() {
result += "\(index)--\(item)||"
}
print(result)

可以看下enumerated为什么可以用元祖

public func enumerated() -> EnumeratedSequence<Array<Element>>

这东西再点进去就是

EnumeratedSequence

类型

这个东西十个结构体，反正按照文档上的注释来操作，该数组的每个值都是(index,item的形式，分别代表下标和值)

/// To create an instance of `EnumeratedSequence`, call `enumerated()` on a
/// sequence or collection. The following example enumerates the elements of
/// an array.
///
///     var s = ["foo", "bar"].enumerated()
///     for (n, x) in s {
///         print("\(n): \(x)")
///     }
///     // Prints "0: foo"
///     // Prints "1: bar"
public struct EnumeratedSequence<Base : Sequence> : Sequence

扩展下，这个类型结构体里面还有反向输出以及过滤输出等功能

// 反向输出
let lists = [1,2,3,4,5,6,7]
var result = ""
for (index,item) in lists.enumerated().reversed(){
result += "\(index)--\(item)||"
}
print(result)
6--7||5--6||4--5||3--4||2--3||1--2||0--1||

// 筛选输出为index是2的倍数的值，这里可以进行无线扩展了，如果需要筛选尽管给需要的条件就好了
let lists = [1,2,3,4,5,6,7]
var result = ""
for (index,item) in lists.enumerated().filter({ (index,item) -> Bool in
return index%2 == 0;
}) {
result += "\(index)--\(item)||"
}
print(result)
0--1||2--3||4--5||6--7||