Swift

Posted 2021-03-15 mrkeen

基本语法

类型别名

在swift中，可以给类型起别名：

如：

typealias dog = Int //类型别名 Int类型变成了dog类型

var a:dog = 10

var b:Int = 20

print(a+b)
typealias S = String

在上述代码段中，可以知道，a和b的类型是相同的，我们定义的dog本质上就是Int类型

note：在swift中，类型可以不声明

字符串拼接

let c:S = "hello"

var d:String = "world"

print(c+d)

var a = 10

print("值等于="+String(a))

print("值等于="+String(1.5))

print("值等于="+String(true))

在上述代码中，可以得知，String类型和String类型可以直接拼接，但是如果一个String类型想和其他基本类型进行拼接则需要进行类型转换，可以使用String(xxx)进行强制类型转换，也可以使用swift中特有的拼接语法进行拼接，如：

print("值等于 = (xxx)")

注意：()这样的转换语法只能在字符串即双引号""包裹内才能生效，即使将(xxx)写在外部拼接也需要加双引号包裹

Swfit ?? 语法 （合并空值运算符）

var a = "10asd"
var c = Double(a) ?? 0 //问号语法，ss如果能转换则转换m，不能则使用后面的值

上述语法定义了一个字符串a，在第二行中使用Double进行强制转换，显然这是行不通的，如果无法转换则会将0赋值给c，但是如果可以转换，则会将转换后的值赋值给c

可选类型和叹号语法

var a:Int? = 10;

var b:Int? = nil;

var c:String? = "Hello"

print(a!)//叹号语法

print(c!)

在上述代码中，定义了abc，在类型后面紧跟一个?表示这个类型的值可以是nil，或是并未赋值，若确定这个变量是有值的，则应该使用（变量名!）的方式取出这个值，否则将无法输出准确的值

if else语法

var value:String? = "hello world"

var a:Int? = 10

if a==nil{
    print("a = nil")
}else{
    print("a = (a!)")
}

这里不做过多赘述，swfit中的if else语法和其他语言并无二致，只是if后的小括号()可以省略直接写表达式

元组类型

元组类型可以封装不同的数据，在一个类型中

var a = (1,15.6,"hello",true) //直接定义元组类型



var b:(Int,String) = (10,"wsift")   //在定义变量的时候就规定元组类型

print(a)

print(b)

var c = () //定义一个空元组c

print(c)

注意：可以直接定义一个空元组，但是如果定义了元组的类型就不能赋一个空元组

var a = (1,15.6,"hello",true) //直接定义元组类型

print(a.0)
print(a.1)
print(a.2)
print(a.3)

若要取出元组中的值，可以使用元素名加下标的方式

元组元素的修改

var a = ("hello",true) 

a.0 = "world"
print(a)

如果元组是用var定义的变量则可以改变元组内的元素，如果是let则不行

元组的值传递

var a = ("hello",true) 

var b = a

b.0 = "world"

print(a)
print(b)


a:("hello", true)
b:("world", true)

如上所述，将a元组赋值给b元组传递的是值而不是引用，更改元组b并不会影响到元组a

通过名称取出元组的值

var a = (name1:"hello",name2:true)

print(a.name1)

//简洁语法
var (name3,name4) = ("swift",100)
print(name3,name4)

你甚至可以在声明元组类型的时候就定义元组的名称

var a:(name1:Int,name2:String) = (100,"Hello")

print(a.name1)
print(a.name2)

可选项绑定

var a:Int? = 10 //可选参数a，现在有一个值为10

if let value = a //如果参数a有值则将值赋给常量value，并执行if语句
{
        print(value)
}
else//如果a没有值，则执行else语句
{
    print("没有值")
}

在可选绑定中，if let value = a 这个语句不需要使用a!解析，swift会自动解析值

Switch case 和 fallthrough穿透效果

var a = 10

switch a {
case 10:
    print("情况1")
    //fallthrough //打开这行代码实现switch穿透
case 20:
    print("情况2")
default:
    print("没有匹配")
}

**在swift中，switch默认是没有穿透效果的，即在case匹配成功后不会执行下一个case，若想要穿透效果可以在case下跟fallthrough关键字。

区间运算符

var a = 1...4
print("范围 = (a)")

var b = 1..<4
print("范围 = (b)")


var c = -1...4
print("范围 = (c)")

var e = 0...
print(e) //0到无限大的半开区间

for循环

for index in (0...5)
{
    print(index)
}

//包括开头不包括结尾
for index in stride(from: 0, to: 10, by: 2)
{
    print(index)
}

//包括结尾
for index in stride(from: 0, through: 10, by: 2){
    print(index)
}

//反向遍历
for index in stride(from: 0, through: 10, by: 2).reversed(){
    print(index)
}

//跳过步数为2的循环
for index in (0...5){
    if(index==2)
    {
        continue
    }
    print(index)
}

//循环到2结束
for index in (0...5){
    if(index==2)
    {
        break
    }
    print(index)
}

注意：stride规定开始结尾和步长，to的遍历不包含结尾，through的遍历包含结尾，reversed函数可以使for循环从结尾向开始结尾

String基础操作

添加、包含、插入

var str = "ABCDEF"
//取出str长度
print(str.count)
//判断str是否包含123
print(str.contains("123"))
//判断前缀是否包含
print(str.hasPrefix("A"))
//判断后缀是否包含
print(str.hasSuffix("DEF"))
//插入字符串
str.append("abcde")
//从str中的第三个下标开始插入hello
str.insert(contentsOf: "hello", at: str.index(str.startIndex, offsetBy: 3))

添加

var str = "ABCDEF"
//将str的下标1赋值给index1
let index1 = str.index(str.startIndex,offsetBy: 1)
//将str的下标3赋值给index2
let index2 = str.index(str.startIndex,offsetBy: 3)
//range区间
let range = index1...index2
//将区间内的字符替换成123123
str.replaceSubrange(range, with: "123123")
print(str)

var str = "ABCDEF"
//将str中的BC替换成888
str.replacingOccurrences(of: "BC", with: "888")
print(str)

删除

//删除下标为2的字符
var str = "ABCDEF"
str.remove(at: str.index(str.startIndex, offsetBy: 2))
print(str)

遍历

for item in str{
    print(item)
}

多行文本

var value = """
                hello
            swift
                world
            """
print(value)

注意：三个引号中包裹的格式也会被输出

Array数组的基本操作

数组的遍历

var a = [1,2,3,4]

print(a)

var b:[String] = ["hello","world"]
print(b)

var c:Array<Double> = [3.2,3.14,23.2]
print(c)

print(c[0])

数组的替换

var array = ["hello","world","swift"]
//将数组的第0号元素替换
array.replaceSubrange(0..<1, with: ["macOS","ios"])

print(array)

数组的添加

var array = ["hello","world","swift"]
//直接使用加号的方式向数组末尾添加元素
array = array+["ios","macOS"]
print(array)

//========================================


var array = ["hello","world","swift"]
//使用append的方式向数组末尾添加元素
array.append("macOS")

print(array)

数组的插入

var array = ["hello","world","swift"]
//在1下标插入aaa
array.insert("aaa", at: 1)

print(array)

数组的删除

var array = ["hello","world","swift"]
//将元素的0号元素删除
array.remove(at: 0)

print(array)

数组的元素修改

var array = ["hello","world","swift"]
//将索引为1的元素修改为ios
array[1] = "ios"

print(array)

元素的查找

var array = ["hello","world","swift"]

array.contains("hello")

Set集合数组的基本操作

Set数组的定义

var a:Set = [1,2,3,4]

print(a)

var b:Set<String> = ["hello","world"]

print(b)

var c:Set<Int> = []

print(c)

基本操作

var a:Set = ["hello","world","swift"]

//打印数组长度
print(a.count)
//数组末尾插入abc
a.insert("abc")

print(a)
//判断数组是否包含hello
print(a.contains("hello"))
//删除数组中的hello元素
a.remove("hello")

合并数组（去除重复）

var a:Set = ["hello","world","swift"]

let b:Set = ["iphone","android","ios","swift"]
//将a集合和b集合合并成c集合并去除重复的元素
var c = a.union(b)
print(c)

返回两个集合中相同的元素

var a:Set = ["hello","world","swift"]

let b:Set = ["iphone","android","ios","swift"]

//返回两个集合中相同的元素
var c = a.intersection(b)

print(c)

返回两个集合中不同的元素

var a:Set = ["hello","world","swift"]

let b:Set = ["iphone","android","ios","swift"]

//返回两个集合中不同的元素
var c = a.symmetricDifference(b)

print(c)

比较第一个Set和第二个Set中不同的数据

let b:Set = ["iphone","android","ios","swift"]

//比较两个Set，返回前面Set中与后面Set中不同的数据
var c = a.subtracting(b)

print(c)

判断两个集合是否相等

var a:Set = [1,2,3,3]

var b:Set = [3,2,1]

if a==b {
    print("两个集合相等")
}else{
    print("两个集合不等")
}

注意：这两个Set集合是相等的，因为Set集合是无序无重复的。

Set集合的遍历

var a:Set = ["A","B","C","D"]

//因为Set集合是无序的，所以不能使用数组下标的方式取值
for item in a {
    print(item)//遍历出来的顺序是不确定的（底层可能按照一定的算法排序，如：红黑二叉树）
}

数组的过滤

var a:Set = ["A","B","C","D"]

var b = a.filter({(item)->Bool in
    if(item == "B" || item == "D"){
        return false
    }else{
        return true
    }
})

print(b)