每天进步一点点，加油

1、数组的介绍

数组（Array）是一串有序的由相同类型元素构成的集合，数组中的集合元素是有序的，可以重复出现。
Swift中的数组
swift数组类型是Array，是一个泛型集合。在初始化的时候需要指定集合中元素的类型。

1.1数组的基本使用

数组分成:可变数组和不可变数组
使用let修饰的数组是不可变数组
使用var修饰的数组是可变数组

声明的数组需要进行初始化才能使用，数组类型往往是在声明的同时进行初始化的

// 1、当数组中的元素类型一直的时候可以不使用泛型
let arrayA = ["name","age","height","weight","sex"]

// 2、使用泛型限制数组中的元素类型
let arrayB : [String] = ["name","age", "sex"]

// 3、设置数组中的元素为任意类型 一般不建议在数组中存放多种类型的数据
let arrayC = ["name","age","sex",1.88] as [Any]

// 4、数组必须初始化之后才可以使用
let arrayD : [String] = [String]()

// 5、可变数组的初始化 声明的数组需要进行初始化才能使用，数组类型往往是在声明的同时进行初始化的
var arrayE : [String] = ["刘德华","吴彦祖","彭于晏","张家辉","梁朝伟"]

// 6、声明一个数组
var arrayF :Array<String>
arrayF = ["刘诗诗","杨澜","刘亦菲","李冰冰","赵丽颖","杨幂"]

var arrayG : [String]
arrayG = ["swift","Objective-C","iOS","C++","Java"]

// 7、数组的遍历
for name in arrayF {

  print(name)

}

for i in 0..<arrayF.count {
 print(arrayF[i])
   
}

// 8、数组的元素操作

arrayF.append("赵雅芝") // 添加元素
arrayF.remove(at: 0) // 删除元素

// 9、数组的合并

var arrayH = arrayF + arrayG // 只有数据类型一直的数组才可以合并

arrayH.append(contentsOf: arrayF) // 使用API进行数组的合并操作

2、字典的介绍

字典允许按照某个键来访问元素，字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合。键集合是不能有重复元素的，而值集合是可以重复的，键和值是成对出现的。
Swift中的字典
Swift字典类型是Dictionary，也是一个泛型集合。

2.1 字典的基本使用

Swift中的可变和不可变字典
使用let修饰的数组是不可变字典
使用var修饰的数组是可变字典
声明的字典需要进行初始化才能使用，字典类型往往是在声明的同时进行初始化的

// 1、不可变字典的定义
let dictA : [String : NSObject] = [String : NSObject]()

// 2、可变字典的定义
var  dictB : [String : String] = [String : String]()

// 3、不可变字典的初始化
let dictC : [String : String] = ["name" : "刘德华" , "age" : "18" ]

// 4、可变字典的初始化
var dictD :[String : String ] =  ["name" : "刘德华" , "age" : "18" ]

// 5、字典的遍历

for (key ,value) in dictD { // 遍历所有的键值对
   print(key)
   print(value)
  print("\(key):\(value)")
}

for value in dictD.values {  // 遍历所有的value

    print(value)
}

for key in dictD.keys {   // 遍历所有的key
    print(key)
}

// 6、字典的操作
dictD["name"] = "吴彦祖" // 修改name

dictD["age"] = "30"

dictD.removeValue(forKey: "age") // 删除字典的字段

print(dictD)

dictD["name"]  // 查询操作

// 7、字典的合并
var dictE = ["name" : "吴彦祖" , "age": 18] as [String : Any]
var dictF = ["height" : 1.88 , "phoneNumber": 18809884598] as [String : Any]

for (key,value) in dictE {
    dictF[key] = value
}
print(dictF)

/*
 note: overloads for '+' exist with these result types: UInt8, Int8, UInt16, Int16, UInt32, Int32, UInt64, Int64, UInt, Int, Float, Double, Float80, String, Date, Decimal, IndexPath, DispatchTime, DispatchWallTime, CGFloat, T, C, RRC1, UnsafeMutablePointer<Pointee>, UnsafePointer<Pointee>, Self, Measurement<UnitType>
 字典合并不可以使用相加的方式来实现
 dictF = dictF + dictE
 */

3、元组

3.1 元组的介绍

元组是Swift中特有的,OC中并没有相关类型。它是一种数据结构，在数学中应用广泛
类似于数组或者字典，可以用于定义一组数据，组成元组类型的数据可以称为“元素”。
元组是使用小括号来定义的，通常使用元组作为函数的返回值。

元组的使用

4、可选类型

在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)，但是在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强类型语言)。开发中赋值nil,在所难免.因此推出了可选类型。使用可选类型的最主要的目的是让代码更加严谨，更加安全。

可选类型的取值:
空值
有值

// 1、这是一种错误的写法
//let stringA : String = nil

// 2、可选类型的写法1
let stringB : Optional<String> = nil

// 3、可选类型的写法2 语法糖  这是一个比较常见的写法
var stringC : String?  = nil

// 4、给可选类型赋值
stringC = "woshiyigezifuchuan"

// 5、取出可选类型中的值
/*
 可选类型 + ！ ---->表示强制解包
 注意：强制解包是一个非常危险的操作，如果可选类型为nil，强制解包会导致系统崩溃
 建议：在强制解包之前先对可选类型判断，判断是否为nil
 */

print(stringC!)

print(stringC) // 如果不强制解包 会显示 Optional("woshiyigezifuchuan") 这不是我们想要的结果

// 6、可选类型
/*
 判断 stringC是否有值 如果没有值 直接不执行{}里面的内容
 如果 stringC有值，系统会自动将stringC进行解包，并且将解包的结果赋值给 stringC
 因为 let 后面的stringC 是我们定义的一个临时变量 根据就近原则 打印的stringC 就是let后面的stringC
 */
if let stringC = stringC {
   print(stringC)
}

5、函数

在swift中函数的定义格式：

func 函数名(参数列表) -> 返回值类型 {
    代码块
    return 返回值
}
func是关键字,多个参数列表之间可以用逗号（,）分隔，也可以没有参数
使用箭头“->”指向返回值类型
如果函数没有返回值，返回值为Void.并且“-> 返回值类型”部分可以省略

// 1、没有参数没有返回值的函数
func swiftFuncA() ->Void {

  print("这是一个没有参数没有返回值的函数")

}
swiftFuncA() // 函数的调用

// 2、有参数没有返回值的函数
func swiftFuncB(x : Int ) {
   print("这是一个有参数没有返回值的函数")
}

swiftFuncB(x: 1)

// 3、没有参数有返回值的函数 有返回值的函数就必须写 return

func  swiftFuncC() -> Int {

  print("这是一个没有参数有返回值的函数")
    
    return 1
}

swiftFuncC()

// 4、有参数有返回值的函数
func swiftFuncD(y : Int ) -> Double {
    print("这是一个有参数有返回值的函数")
    return 1.0
}
swiftFuncD(y: 1)

// 5、可变参数
func calculateNumbers(num : Int ...) -> Int{

    var result = 0
    for n in num {
        result += n
    }
    return result
}
// 传入多个参数
calculateNumbers(num: 10,20,30,40)

6、闭包

@escaping
传递给函数的闭包如果不是在函数内调用，而是在函数内用外部变量保存当前的闭包，在合适的时间再进行调用，这是就需要在闭包参数前加入 @escaping 关键字，不然编译器会报错。