标签：影响 ase 字符串拼接 语言 tin 就是 replace efault pre
在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)写在外部拼接也需要加双引号包裹
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，或是并未赋值，若确定这个变量是有值的，则应该使用（变量名!）的方式取出这个值，否则将无法输出准确的值
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会自动解析值
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 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循环从结尾向开始结尾
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)注意：三个引号中包裹的格式也会被输出
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")
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)
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集合是无序无重复的。
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)标签：影响 ase 字符串拼接 语言 tin 就是 replace efault pre
原文地址：https://www.cnblogs.com/MrKeen/p/12198061.html
