一、常量与变量
let声明常量(在整个生命周期只允许赋值一次)
var声明变量
//不允许再次赋值，会报错
let a = 1
a = 10
//可以先声明类型再赋值
let b : Int
b = 10
//let声明的常量不要求在编译期间确定 c在整个编译期间可以一直改变导致d无法确定，只要保证用之前赋值一次就行
var c = 1
let d = c
使用let 和 var 要么赋值要么明确声明对象的类型，在使用前必须要赋值
二、基本数据类型
Bool、Int、Float、Double
String、数组[T]、字典[T1 : T2]、元组
1.字符串操作
//闭区间...
//开区间..<
let strEN = "hello world"
let strCN = "你好世界"
//拼接
let str10 = strEN + strCN
print(str10)
//截取
let str20 = strEN.prefix(2)
let str21 = strEN.suffix(2)
let startIndex = strEN.index(strEN.startIndex, offsetBy: 2)
let endIndex = strEN.index(strEN.startIndex, offsetBy: -2)
let str22 = strEN[startIndex...endIndex]
print(str20, str21, str22)
2.数组操作
let arr = [1, 1, 2]
var arrM = [7, 8, 9, 10, 11, 12, 13]
var arrM1 = ["4", "5", "6"]
//增
arrM.append(2)
print("增\(arrM)")
arrM.insert(100, at: 2)
print("插入\(arrM)")
//删
arrM.remove(at: 0)
print("删除\(arrM)")
//改
arrM[2] = 1000
print("改\(arrM)")
//查
let num = arr[2]
print("查\(num)")
//遍历
//1、forin遍历 带下标
for index in 0..<arr.count {
print(arr[index]) // 1 1 2
}
//2、forin遍历
for item in arr {
print(item) // 1 1 2
}
// 3、enum block遍历：同时拿下标和元素（元组接收）
for (index, item) in arr.enumerated() {
print(index, item)
}
// 4、反向遍历数组，for-in直接拿数据内元素
for item in arr.reversed() {
print(item) // 2 1 1
}
// 5、反向遍历数组，enum block遍历：同时拿下标和元素（元组接收）：必须先enumerated，后reversed
for (index, item) in arr.enumerated().reversed() {
print(index, item)
}
3.字典操作
//注意字典无序
let dic = ["age": 18, "name":9]
var dicM:[String:Any] = ["age": 18, "name":"zfc"]
//增
dicM["height"] = 1.88
print("增\(dicM)")
//删 字典无序 通过removeAtIndex删除会导致问题
dicM.remove(at: dicM.index(dicM.startIndex, offsetBy: 1))
print("删index:\(dicM)")
dicM.removeValue(forKey: "age")
print("删key:\(dicM)")
//改
dicM["height"] = 1.70
print("改:\(dicM)")
//查
let hegit = dicM["height"]
print("查:\(dicM)")
// 同时拿key和value（元组接收） 字典无序enumerated()无意义
for (key, value) in dicM {
print(key, value)
}
4.元组类型
let tuple = ("张三", 18, 1.88)
print(type(of: tuple)) // (String, Int, Double)
print(tuple.0) // 张三
print(tuple.1) // 18
print(tuple.2) // 1.88
// 像字典一样使用元组，只不过元组的语法糖是个小括号()
var tuple1 = (name: "张三", age: 18, height: 1.88)
print(tuple1.name) // 张三
print(tuple1.age) // 18
print(tuple1.height) // 1.88
//应用场景
//1.给多个变量赋值
let (name, _, height) = ("张三", 18, 1.88)
//2.作为函数的返回值，来实现多返回值的效果
func fn() -> (name: String, age: Int, height: Double) {
return (name: "张三", age: 18, height: 1.88)
}
5.函数
//函数定义格式
func 函数名(函数的参数) -> 函数的返回值 {
函数的执行体
}
//函数可选参数与必选参数
// num1必选参数，num2可选参数
func sum(num1 : Int, num2 : Int = 2) -> Int {
return num1 + num2;
}
print(sum(num1: 11)) // num1必须得传，num2可以不传，结果为13
print(sum(num1: 11, num2: 22)) // num1必须得传，num2也可以传，结果为33
func sum(_ num1 : Int, _ num2 : Int = 2) -> Int {
return num1 + num2;
}
print(sum(11)) // 11
print(sum(11, 22)) // 33
6.可选？
var age:Int? //所有可选项类型的变量的默认值都是nil
//？可选类型：表示变量 age 允许为nil
//! 可选变量age后面跟表示强制解包，前提是可选变量age不为nil,不然会造成崩溃
//可选项解包(三种方式)
//1.判断可选变量age是否为nil，不为nil再进行强制解包
if age != nil { // 判断一下可选项变量age是不是nil
print(age!)
} else {
print("age为nil")
}
//2.可选项绑定解包（if let/var、guard let/var）
if let age = age {
// 临时常量age的作用域仅限于这个大括号，并且已经是解包之后的数据了
print(age)
} else {
// 临时常量age的作用域不包含这个大括号
print("age为nil")
}
//guard作用域不再自己的大括号中，而在外层大括号中
guard var age = age else {
return
}
var age1:Int?
//3.小三目运算符解包??
//如果??前面的可选项有值，那么就会自动解包后使用该值；如果??前面的可选项为nil，就使用??后面的值。
let str2: Int = age1 ?? 0
7.闭包
//普通闭包
var closure = {(a:Int, b:Int) -> Int in
return a + b
}
//尾随闭包，是一个被书写在函数调用括号外面的闭包表达式,使用尾随闭包增强函数的可读性
func exe(a:Int, b:Int, closure:(Int, Int)->Int) {
print(closure(a, b))
// exe(a:100, b:1, closure:{a, b -> Int in return a + b}) //原始
// exe(a:100, b:1, closure:{a, b -> Int in a + b}) //简化,去掉return
// exe(a:100, b:1, closure:{$0 + $1}) //简化,去掉a,b
// exe(a:100, b:1, closure:+) //简化,直接用+
}
func exe1(closure:()-> Void) {
print("测试");
}
