1> 导入框架 ：import UIKit
2> 定义标识符: let/var let a:Int = 20
3> 语句结束时;可以省略
4> print(a)
常量变量
1> 在开发中,优先使用常量(let). 只有发现标识符需要修改时,再使用变量
// 目的: 防止在其它不希望修改的地方,不小心将值修改掉
2> 常量的本质: 指向的内存地址不可以修改,但是可以通过内存地址找到对应的对象,之后修改对象内部的属性
let view : UIView = UIView()
view.backgroundColor = UIColor.blue
基本运算
将Int类型转成Double: Double(标识符)
逻辑分支 if
1> if后面的()可以省略掉
2> 没有非0(nil)即真
逻辑分支 guard
条件不满足时才执行else里面的语句
guard age >= 18 else {
print("回家去")
return
}
逻辑分支 switch
1.switch的基本使用
1> switch()可以省略
2> case结束可以不加break
2.基本使用补充
1> case后面可以跟上多个条件
2> 如果希望产生case穿透,可以在case结束时fallthrough
3.可以判断多种类型
1> 浮点型
2> 字符串
3> 区间类型
循环使用 for
- Swift中for循环现在只支持区间遍历 0..<10/0...9
2.在swift开发中,如果一个变量/常量暂停不会使用,那么可以使用_来代替
循环使用 while
1> while后面()可以省略
2> 没有非0(nil)即真 Bool(true/false)
字符串
1.字符串的定义
1> 不可变字符串的定义 let str = "Hello Swift"
2> 可变字符串的定义 var strM = "Hello World"
2.获取字符串的长度 let length = str.characters.count
3.字符串的拼接
1> 字符串之间的拼接 let str3 = str1 + str2
2>字符串和其它标识符之间的拼接 "(标识符)"
let name = "why"
let age = 19
let infoStr = "my nams is (name), age is (age)"
3> 字符串拼接过程中格式化: String(format:"%d:%d", 参数)
4.字符串的截取
1>方式一: 将String转成NSString,再进行截取(推荐)
let header1 = (urlString as NSString).substring(to: 3)
let range1 = NSMakeRange(4, 5)
let middle1 = (urlString as NSString).substring(with: range1)
let footer1 = (urlString as NSString).substring(from: 10)
2> 方式二: 直接使用String中方法,进行截取. String.Index （不好用）
数组
1.数组的定义
1> 定义不可变数组 let array1 = ["why", "yz"]
2> 定义可变数组 var arrayM = [String]()
2.对可变数组的基本操作
增删改查 arrayM.append("why") arrayM.remove(at: 0)
arrayM[0] = "yz" let item = arrayM[1]
3.数组的遍历
1> 获取数组的长度 let count = array.count
2> 数组的遍历(i/item/index-item)
获得下标 for i in 0..<count
获得下标 for item in array
既获取下标值,又获取元素 for (index, item) in array.enumerated()
4.数组的合并，两个数组中存放的是相同的元素直接合并 array1 + array2
字典
1.定义的定义
1> 不可变字典: let dict : [String : Any] = ["name" : "why", "age" : 18]
2> 可变字典: var dictM = [String : Any]()
2.对可变字典的基本操作
增删改查 dictM["name"] = "why" dictM.removeValue(forKey: "height")
3.遍历字典
1> 所有的key for key in dict.keys
2> 所有的value for value in dict.values
3> 所有的key/value for (key, value) in dict2
4.字典合并
dict1 可变 dict2 不可变
for (key, value) in dict2 {
dict1[key] = value
}
元组
使用元组保存信息(取出数据时,更加方便)
写法1 let infoTuple0 = ("why", 18, 1.88) let tupleName = infoTuple0.0
写法2 let infoTuple1 = (name : "why",age : 18, height : 1.88) infoTuple1.age
写法3 let (name, age, height) = ("why", 18, 1.88) name
可选类型
在开发中,只有可选类型才能赋值为nil, 其它类型都不能赋值为nil
只要一个类型有可能为nil, 那么这个标识符的类型一定是一个可选类型
1.定义可选类型 var name : String? = nil
2.给可选类型进行赋值 name = "why"
3.从可选类型中取值
if let name = name {
print(name)
}
类型转换
- as使用 (str as NSString).substring(to: 6)
- as?转成可选类型 let name = tempName as? String
- as!转成具体的类型 如果确定转化成功,再用as!, 平时不建议
函数
内部参数: func sum(_ num1 : Int, _ num2 : Int) -> Int
外部参数: func sum(num1 : Int, num2 : Int, num3 : Int) -> Int
可变参数: func sum(_ nums : Int...) -> Int
默认参数 func makeCoffee(coffeeName : String = "雀巢") -> String
指针函数
func swapNum(num1 : inout Int, num2 : inout Int) {
let temp = num1
num1 = num2
num2 = temp
}
swapNum(num1: &m, num2: &n)
枚举
创建枚举1
enum Direction : Int {
case east = 0
case west = 1
case north = 2
case south = 3
}
创建枚举2
enum Direction {
case east, west, north, south
}
1>当原始值的类型为整数时，系统将隐式地对成员值赋值且值依次递增1，若第一个成员值没有设置原始值，则默认为0。
2>当原始值的类型为String类型时，每个枚举成员的隐式原始值是该成员的名称
结构体
1.定义结构体
struct Location {
var x : Double
var y : Double
// 最普通的函数: 该函数是没有用到成员属性
func test() {
print("结构体中的test函数")
}
// 改变成员属性 : 如果在函数中修改了成员属性, 那么该函数前必须加上mutating
mutating func moveH(_ distance : Double) {
self.x += distance
}
// 给结构体扩充构造函数
// 1> 默认情况下, 系统会为每一个结构体提供一个默认的构造函数, 并且该构造函数, 要 求给每一个成员属性进行赋值
// 2> 构造函数都是以init开头, 并且构造函数不需要返回值
// 3> 在构造函数结束时, 必须保证所有的成员属性有被初始化
init(xyStr : String) {
// 20,30 --> ["20", "30"]
let array = xyStr.components(separatedBy: ",")
let item1 = array[0]
let item2 = array[1]
// ?? 判断前面的可选类型是否有值
// 有值, 则解包, 没有值,则使用后面的值
self.x = Double(item1) ?? 0
self.y = Double(item2) ?? 0
}
}
2.创建结构体对应的值 var center = Location(x: 20, y: 30)
3.系统结构体的创建方式 let size = CGSize(width: 20, height: 20)
4.给结构体扩充方法 center.test() center.moveH(20)
5.给结构体扩充构造函数 Location(xyStr : "20,30")
**类似于class 但是class是类型引用，而struct是值引用
struct没有继承的功能，class有继承功能
swift在本质上来说是面向协议的, 所以使用struct+protocol是构成swift面向协议语言的基础
义的对象类型 都可以改成结构体去定义
模型 都可以改成机构体
Swift 常用的 String, Array, Dictionary 都是 struct
结构体封装少量相关简单数据值
数据需要被拷贝而不是被引用，不需要继承的时候
类的使用
1.如何定义类
class Person {
// 如果属性是值类型, 则初始化为空值
// 如果属性是对象类型, 则初始化为nil值
var name : String = ""
var age : Int = 0
var view : UIView?
}
2.创建类的对象
let view = UIView()
类的构造函数（KVC）
使用KVC条件
1> 必须继承自NSObject
2> 必须在构造函数中,先调用super.init()
3> 调用setValuesForKeys
4> 如果字典中某一个key没有对应的属性, 则需要重写setValue forUndefinedKey
class Person : NSObject {
var name : String = ""
var age : Int = 0
var height : Double = 0
init(dict : [String : Any]) {
super.init()
setValuesForKeys(dict)
}
override func setValue(_ value: Any?, forUndefinedKey key: String) {}
}
类的析构函数 -相当dealloc
class Person {
var name : String = ""
var age : Int = 0
// 重写析构函数, 监听对象的销毁
deinit {
print("Person --- deinit")
}
}
var p : Person? = Person()
p = nil
循环引用解决方案
OC中表示弱引用 __weak/__unsafe_unretained(野指针错误)
Swift中表示弱引用 weak/unowned(野指针错误)
// unowned 不能用于修饰可选类型
unowned var owner : Person = Person()
可选链
当类中包含的元素特别多时，可以把里面的元素单独出类来包含，取值时可使用可选链
1> 从可选链中进行取值?.
2> 给可选链进行赋值
3> 可选链调用方法
