前言
很庆幸有golang 这样的语言面世。语义清晰的同时概念又特别简洁,去掉了很多无谓传统编程语言繁杂又无效率的写法,作者们通过了实现表达了我们这些广大程序员敢想不敢言的心声。
我也算是在IOS领域上摸爬滚打接近十年的老人了。要说Object-C 语法思维属于反人类的绝对错不了,但只要掌握了它的消息机制就会觉得不花巧又实用。 没想到作为后继者的Swift,反人类的写法一点都不逊色于前辈,同时要说起语法卖弄,它敢称第二绝对不会有其他语言敢占这排名。
以下是我从Object-C 转型到Swift 后的初期最需要注意的功能点:
-对变量常量的定义:let 和var,可选项? 、!
- 控制流
- 函数和闭包
- 结构体和类
- 下标脚本
- 可选链
- 扩展
- 泛型
Swift对变量常量的定义:let 和var,可选项? !
let代表不可变对象,即对象首地址不能发生变更,也就是说内存地址不能改变,但也可以修饰可变对象。相当于其它语言的const 或者#define 表达。与传统语言比较,Swift 不允许直接对变量、常量定义为nil,也不允许执行过程中赋值nil。
let someInt: Int = 100
someInt = 50 // 报错误 ,因为let修饰的变量不能改变指针指向
//let 可以允许定义时不赋值,第一次使用再赋值
let otherInt: Int
otherInt = 80 // 不会报错。
let nilStr: String = nil //不允许设置为nil,报错:cannot initialize specified type 'String'
var代表可变对象,即内存地址可以发生改变,可以修饰指针重新指向的变量。
var someStr: String = "Hello "
someStr = "Hello world" // 不会报错,因为var修饰的变量指针可以重新指向
someStr = nil //不允许设置为nil,报错:cannot initialize specified type 'String'
为了允许变量支持空值赋值,在定义变量时增加可选项: ? !
var some2Str: String? = nil;
var other2Str: String! = nil;
在Swift5 后,不论是添加! 还是添加?变量的定义都等价于
//类型已经从String 转变为Optional
var some2String: Optional
var other2String: Optional
而变量访问的方式也相应产生变化:
print(some2String ?? "this is default value")
/*
添加?? 等价于以下写法:
if some2String == nil{
print("this is default value")
}
else{
print(some2String)
}
*/
print(some2String!)
/*
添加! 对变量进行访问的写法等价于:
if some2String == nil{
throw ('Fatal error: Unexpectedly found nil while unwrapping an Optional value')
}
else{
print(some2String)
}
*/
同时访问的方式也可以变成另一种写法:
if let defString = some2String {
print(defString)
}
//把some2String 进行展开,把真实的类型赋值到defString
Swift的控制流
与传统语言对比,Swift 中的 if 和 switch 作为条件控制变化不大。而 作为循环体的 for-in 、 while 、 repeat-while 是需要注意的。其中for-in 循环的写法为:
let scores = [34, 21, 3, 99, 101]
//写法一
for score in scores {
//语句执行
}
//写法二
for (key,item) in scores.enumerated(){
//key 为当前数组枚举的索引值
//item 为值
}
//写法三 :通过 ".." 来表示索引范围或明确声明一个初始值、条件、增量
for index in 0...scores.count{
//语句执行
}
//写法四:通过..< 来表示索引范围到scores.count-1 后结束。
for index in 0..
while 循环可以有两种写法:
/*
while condition
{
statement(s)
}
*/
while index <100{
print(index)
}
/*
repeat
{
statement(s);
}while( condition );
*/
var index = 0
repeat{
print( "index 的值为 \(index)")
index = index + 1
}while index < 20
Swift的函数和闭包
Swift 函数语法定义:
/*
func funcname(外部形参名 内部形参名 类型, ...) -> returntype {
Statement1
Statement2
……
Statement N
return parameters
}
*/
//其中内部形参名非必填
//示例一:只有外部形参
func runoob(name: String, site: String) -> String {
return name + site
}
funoob(name:"Hello",site:"world")
//示例二:外部形参 +内部形参
func runoob(name _name: String, site _site: String) -> String {
return _name + _site
}
funoob(name:"Hello",site:"world")
//示例三:匿名外部形参
func runoob(_ _name: String, _ _site: String) -> String {
return _name + _site
}
funoob("Hello","world")
//示例四:可变形参
func vari(members: N...){
for i in members {
print(i)
}
}
vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Hello", " ", "World")
//示例五:可通过函数内变更参数值 的地址引用 可选项:inout
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
a = a ^ b
b = b ^ a
a = a ^ b
}
var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 现在的值 \(x), y 现在的值 \(y)")
//示例六:返回类型可以是一个元组
func minMax(array: [Int]) -> (min: Int, max: Int)? {
if array.isEmpty { return nil }
var currentMin = array[0]
var currentMax = array[0]
for value in array[1.. currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
print("最小值为 \(bounds.min),最大值为 \(bounds.max)")
}
闭包
就是把函数该简化的省略,该匿名则匿名,去其糟粕留其精华。自己写好了就是美如画,写烂了接手方如同恶梦。
以下定义了一个接收参数并返回指定类型的闭包语法:
/*
{(parameters) -> return type in
statements
return parameters
}
*/
//简单的示例:
let closure = {(val1: Int, val2: Int) -> Int in
return val1 / val2
}
let result = closure(100, 50)
print (result)
闭包常用在函数回调传参的写法上,以标准库sorted方法为示例来做一个闭包逐步简化的演示:
//在不使用闭包的写法上,可以使用定义传统函数的方式:
let names = ["AT", "AE", "D", "S", "BE"]
// 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
func backwards(s1: String, s2: String) -> Bool {
return s1 > s2
}
var reversed = names.sorted(by: backwards)
print(reversed)
//利用闭包简写后,从关键字in 后是具体的执行命令
var reversed = names.sorted(by:{(s1:String, s2: String) ->Bool in
return s1 > s2
})
print(reversed)
//上述写法还是复杂,再简约一点,参数名、返回结构都不要了
//$0、$1 .....$n 去表示参数的顺序
var reversed = names.sorted(by:{
return $0 > $1
})
print(reversed);
//甚至在主函数只有一个函数形参时,可以去掉形参以及return,把代码书写到外面。
var reversed = names.sorted(){
$0 > $1
}
print(reversed);
//这样够了吗? 不,还可以写得更“简约”:
var reversed = names.sorted(by:>)
Swift的结构体和类
结构体的关键词是struct ,可以拥有自己的构造函数,没有释构函数。格式如下:
/*
struct nameStruct {
Definition 1
Definition 2
……
Definition N
init(parameters){
}
}
*/
var aStruct = MarksStruct(mark: 100)
var bStruct = aStruct // aStruct 和 bStruct 是使用相同值的结构体!
bStruct.mark = 20
print(aStruct.mark) // 100
print(bStruct.mark) // 20
类(Class),相比起结构体,有以下不同点:
- 继承允许一个类继承另一个类的特征
- 类型转换允许在运行时检查和解释一个类实例的类型
- 解构器允许一个类实例释放任何其所被分配的资源
- 引用计数允许对一个类的多次引用
语法:
/*
class classname {
Definition 1
Definition 2
……
Definition N
}
*/
class MarksStruct {
var mark: Int
//构造函数
init(mark: Int) {
self.mark = mark
}
//释构函数
deinit{
print("MarksStruct is deinit");
}
}
class studentMarks {
var mark = 300
}
var p_mask: MarksStruct? = MarksStruct(mark: 500)
if let let_p_mask = p_mask {
print("成绩为 \(let_p_mask.mark)")
}
p_mask = nil;
let a_marks = studentMarks()
print("成绩为 \(a_marks.mark)")
下标脚本
给结构体定义subscript 方法,显式声明入参(一个或多个)和返回类型后,则结构体可以达成类似someDictionary[key]方式的读写:
/*
subscript(index: Int) -> Int {
get {
// 用于下标脚本值的声明
}
set(newValue) {
// 执行赋值操作
}
}
*/
class daysofaweek {
private var days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Tsday", "Friday", "saturday"]
subscript(index: Int) -> String {
get {
return days[index] // 声明下标脚本的值
}
set(newValue) {
self.days[index] = newValue // 执行赋值操作
}
}
}
var p = daysofaweek()
print(p[0])
print(p[1])
print(p[2])
print(p[3])
p[4] = "Thursday"
print(p[4])
以上程序执行输出结果为:
Sunday
Monday
Tuesday
Wednesday
Thursday
下标脚本允许任意数量的入参索引,并且每个入参类型也没有限制。返回值也可以是任何类型。同时也可以使用变量参数和可变参数。
struct Matrix {
let rows: Int, columns: Int
var print: [Double]
init(rows: Int, columns: Int) {
self.rows = rows
self.columns = columns
print = Array(repeating: 0.0, count: rows * columns)
}
subscript(row: Int, column: Int) -> Double {
get {
return print[(row * columns) + column]
}
set {
print[(row * columns) + column] = newValue
}
}
}
// 创建了一个新的 2 行 2 列的Matrix实例
var mat = Matrix(rows: 2, columns: 2)
// 通过下标脚本设置值
mat[0,0] = 3.0
mat[0,1] = 6.0
mat[1,0] = 9.0
mat[1,1] = 12.0
// 通过下标脚本获取值
print("\(mat[0,0])")
print("\(mat[0,1])")
print("\(mat[1,0])")
print("\(mat[1,1])")
可选链
回顾最初变量常量所定义的 可选项(! ?),同样适用在类和结构体上。通过在属性、方法、或下标脚本的可选值后面放一个问号(?),即可定义一个可选链。
class SubTree {
var numberOfTress = 1
}
class Root {
var subTree: SubTree? //定义属性为可选项
}
使用感叹号(!)访问可选链实例,强制检测属性是否存在,不存在则抛出异常。
let root = Root()
//将导致运行时错误
let numberOfTress = root.subTree!.numberOfTress;
//输出结果:fatal error: unexpectedly found nil while unwrapping an Optional value
/* 以上语句,等价于传统写法:
try {
let numberOfTress = root.subTree.numberOfTress
}catch{
throw ('Fatal error: Unexpectedly found nil while unwrapping an Optional value')
}
*/
使用问号(?)可选链实例,检测属性是否存在,不存在则正常返回nil值,不报异常,这处理方式非常接近Object-C 的非空检测。
// 链接可选residence?属性,如果residence存在则取回numberOfRooms的值
if let numberOfTress = root.subTree?.numberOfTress {
print("树的 节点总量有 \(numberOfTress)。")
} else {
print("不存在节点")
}
扩展
扩展就是向一个已有的类、结构体或枚举类型添加新功能。扩展可以对一个类型添加新的功能,但是不能重写已有的功能。
语法:
extension SomeType {
// 加到SomeType的新功能写到这里
}
示例:
extension Int {
var add: Int {return self + 100 }
var sub: Int { return self - 10 }
var mul: Int { return self * 10 }
var div: Int { return self / 5 }
}
let addition = 3.add
print("加法运算后的值:\(addition)")
let subtraction = 120.sub
print("减法运算后的值:\(subtraction)")
let multiplication = 39.mul
print("乘法运算后的值:\(multiplication)")
let division = 55.div
print("除法运算后的值: \(division)")
let mix = 30.add + 34.sub
print("混合运算结果:\(mix)")
泛型
Swift 提供了泛型的标准模板,来让开发者写出可重用的函数和类型。
一个简单的示例:
// 定义一个交换两个变量的函数
func swapTwoValues(_ a: inout T, _ b: inout T) {
let temporaryA = a
a = b
b = temporaryA
}
var numb1 = 100
var numb2 = 200
print("交换前数据: \(numb1) 和 \(numb2)")
swapTwoValues(&numb1, &numb2)
print("交换后数据: \(numb1) 和 \(numb2)")
var str1 = "A"
var str2 = "B"
print("交换前数据: \(str1) 和 \(str2)")
swapTwoValues(&str1, &str2)
print("交换后数据: \(str1) 和 \(str2)")
以结构体来实现一个栈示例:
struct Stack {
var items = [Element]()
mutating func push(_ item: Element) {
items.append(item)
}
mutating func pop() -> Element {
return items.removeLast()
}
}
var stackOfStrings = Stack()
print("字符串元素入栈: ")
stackOfStrings.push("google")
stackOfStrings.push("runoob")
print(stackOfStrings.items);
let deletetos = stackOfStrings.pop()
print("出栈元素: " + deletetos)
var stackOfInts = Stack()
print("整数元素入栈: ")
stackOfInts.push(1)
stackOfInts.push(2)
print(stackOfInts.items);
入门学习的资料参考:
Swift教程| 菜鸟教程
Swift 5 从零到精通IOS开发训练营