Swift运算符

运算符分类

运算符分类

一元运算符

1.负号运算符

1 var number1 = 10
2 var number2 = -number1

 

2.正号运算符

1 //正号运算符不作任何操做
2 var number3 = +number2
3 println(number3)
4 //b = a++ 至关于a先赋值,在完成自增,而b = ++a,至关于a先完成自增,再去赋值
5 var number4 = ++number1
6 println(number4)

 

二元运算符

1.赋值运算符

1.1在Swift当中,赋值语句没有返回值,不能够跟if-else相结合

1 let a:Double = 1

 

2.算术运算符

取余

在Swift中,与C语言的取余运算符不一样,Swift中的取余运算符的左右两侧能够为小数,这也是Swift中有所改进的地方

 

var modNumber = 10.0 % 3.0

println(modNumber)

 

3.组合赋值运算符

var groupNumber = 10
groupNumber += 10
println(groupNumber)

 

4.比较运算符

// eg:< > <= >= ==

 

5.逻辑运算符

1 // 短路现象
2 let logicalNumber1 = 10
3 let logicalNumber2 = 15
4 logicalNumber1 < logicalNumber2 || 3 > 2

 

//<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<Swift新增

6.区间运算符

6.1全闭区间

1 logicalNumber1...logicalNumber2
2     for aaa in logicalNumber1...logicalNumber2 {
3         println(aaa)
4     }

 

6.2半开半闭

1 for aaa in logicalNumber1..<logicalNumber2 {
2         println(aaa)
3     }
4     for qujian in 100..<150 {
5         println(qujian)
6     }

 

7.空合运算符, 与可选类型配合使用

1 var optionalNumber:Int? = 10
2 //    println(optionalNumber!)
3     // 可选类型能够修饰任何类型的变量.在构造函数中使用不少
4     let kongheNumber = optionalNumber ?? 20
5     println("空合运算\(kongheNumber)") // 若是可选类型有值,返回可选类型的值,不然返回 ?? 后的值
6     // 注意
7     // 1.空合运算符??前面必须是可选类型
8     // 2.空合运算符??先后的类型必须一致

 

三元运算符

// 形式结构 a > b ? a : b

字符串

1.字符串的字面量

var string = "💊💊💊💊💊💊" // 字面量
var string2 = "\"\n\'"
println(string)
println(string2)

2.swift中的字符串和oc中字符串的区别

2.1没有可变类型与不可变类型之分,在Swift中,字符串是否可变,取决于声明的变量类型,若为let,不可变,若为var,可变

2.2在Swift中的字符串是值类型;OC中,不加特殊声明是引用类型,不用担忧内存问题,Swift已经作了优化

var appendString1 = "houzichao"
var appendString2 = appendString1
appendString2 += "shuai"
println("\(appendString2)")

2.3在Swift中,String类型和OC中的NSString作了完美对接,换句话说,就是Swift中String可使用NSString的方法

3字符串的初始化

var initString = String()

字符串拼接

initString += "abc"
println(initString)

// 大小写转换
var changeString = "good girls"
// 大写
var upString = changeString.uppercaseString
println(upString)
var lowString = upString.lowercaseString
println(lowString)
// 首字母大写
var lowString1 = upString.capitalizedString
println(lowString1)
// 插值
// 在Swift语句中,没有格式化占位符,想要实现这样的效果,咱们要用到字符串插值格式  \()
var insertNumber = 18
println("insertNumber = \(insertNumber)")

---

Swift中的集合

//与OC区别
// 1.在Swift中的集合类都是值类型,而OC中为引用类型
// 2.在Swift中,也是使用引用计数管理内存,可是引用计数是适用于对象类型,值类型不须要管理
// 3.在Swift中,引用计数管理内存的方法,与OC中的方法不太同样
// 4.在Swift中,数组能够存听任意类型,OC中只能存放对象类型

数组

1.Array

// 1.1 Swift中,Array没有可变与不可变之分,取决于用什么关键字修饰(let, var)
//1.2使用字面量给一个数组赋值
// var array = ["a", "b", "c"] // String类型
var array = ["a", "b", 1] // NSObject类型
// println(array)

数组增长元素

// 1.调用append方法, 当咱们调用append方法进行元素添加时,添加到数组最后面
    array.append("wangxiaofang")
// 2.调用 +=
    array += ["houzhichao", "zhangdi"]
    println(array)
// 3.调用insert方法
    array.insert("哈哈", atIndex: 0)
    println(array)

数组元素删除

// 调用removeAtIndex方法进行删除
array.removeAtIndex(0)

改变数组元素

// 1.经过小标改变元素
array[0] = "youmo"
println(array)
// 2.利用下面的方法,不只能够修改,并且能够删除元素
array[0...3] = ["1", "2", "3"]
println(array)

数组查询

// 利用for-in 进行数组遍历
for value in array {
    println("value = \(value)")
}

// 使用全局enumerate函数返回一个由每个数据项索引值和数据值组成的元组
for (index, value) in enumerate(array) {
    println("\(index):\(value)")
}

数组初始化, 声明存储固定类型的数组

// 1.
var initArray:[String] = [String](count: 3, repeatedValue: "houhou")
println(initArray)
// 2.
var initArray2:Array<String> = Array(count: 4, repeatedValue: "jianjian")
println(initArray2)
// 使用构造方法,建立的是由一个特定数据类型构成的数组

字典

1.使用字面量赋值

var dictionary = ["boy":"lishuanglong", "girl":"shiyingying"]
println(dictionary)

增

// 使用key增长键值对
dictionary["age"] = "34"

删

// 调用removeValueForKey
//    dictionary.removeValueForKey("age")
//    println("----------------\(dictionary)")

改

// 1.使用key修改value
dictionary["girl"] = "liujingrang"
println(dictionary)
// 2.使用updateValue方法修改
// 能够进行修改,也能够进行添加,当填入的键值存在时,就会进行数据更新,把旧值返回出来,当键不存在时,就会进行添加,放回是nil(返回可选类型)
let returnValue = dictionary.updateValue("18", forKey: "age")
println("returnValue=\(returnValue), dictionary = \(dictionary)")
let returnValue2 = dictionary.updateValue("19", forKey: "class")
println("returnValue=\(returnValue2), dictionary = \(dictionary)")

查 (遍历)

for (key, value) in dictionary {
    println("key = \(key), value =\(value)")
}

字典初始化

// 使用字典初始化方式建立的事固定键值类型的字典
// 1.
var initDictionary:[String:String] = [String:String]()
// 2.
var initDictionary2:Dictionary<String, String> = Dictionary()

---

控制流

for循环

1.for-in循环

for value in 0...10 { println(value) }

 

// 当咱们不须要使用区间的值得实惠,咱们可使用"_"告诉系统 

for _ in 1...10 {
     println("jiang") 
}

 

2.for循环

for var index = 0; index < 10; index++ {
    println("index = \(index)")
}

 

 

while循环

1 var whileNumber = 0
2 while whileNumber < 10 {
3     println("whileNumber = \(whileNumber)")
4     whileNumber++
5 }

 

do-while循环

1 do {
2     println("哈哈哈")
3 } while (false)

 

If-else语句

1 var houValue = 20
2 if houValue <= 21 {
3     println("小于或等于21")
4 } else {
5     println("大于21")
6 }

 

switch-case

1.在Swift中,是没有贯穿的,只会执行知足条件的语句,不用加break不会贯穿

2.每个case分支必须有个一个语句,假如真不想写,能够加break,经过编译

3.case能够加多个条件

4.真想贯穿,请加fallthough

 1 var switchNumber = 1
 2 switch switchNumber {
 3     case 1, 2, 3:
 4         println("1")
 5         fallthrough  // 真想贯穿,请加fallthough
 6     case 2:
 7         println("2")
 8   default:
 9     println("others")
10 }

 

5.Swift中,switch-case能够进行值的绑定

1 var (x, y) = (10, 0)
2 switch (x, y) {
3 case (let xValue, 0):
4     println(xValue)
5 case (0, let yValue):
6     println(yValue)
7 default:
8     println("others")
9 }

 

6.swift中,switch-case能够进行区间匹配

1 var domainNumber = 40
2 switch domainNumber {
3 case 1...10:
4     println("几块钱")
5 case 11...100:
6     println("土豪")
7 default :
8     println("others")
9 }

 

// 控制流中,咱们还会遇到的关键字: break, continue, fallthrough

// break在循环当中,跟C语言语法规则同样,用来结束整个循环

// continue在循环中,跟C语言的规则同样,结束本次循环

// fallthough

标签语句

当咱们遇到多个循环嵌套的时候, 咱们根据需求, 想要关掉某个循环, 就要使用标签语句, 用来区别不一样的循环, 标签语句的定义语法: name: 想要标识的循环以前

1 jiang: while true {
2     for var labelNumber = 0; labelNumber < 100; labelNumber++ {
3         println("\(labelNumber)")
4         if labelNumber == 5 {
5             break jiang // 结束所有循环
6         }
7     }
8 }