直接上代码：

// 运算符
// 一元运算符
// 1、负号运算符
var number1 = 10.0
var number2 = -number1
println((number2))
// 2、正号运算符
// 正号运算不做任何操作
var number3 = +number2
println((number3))

// eg:b = a++ 相当于 a 先赋值再完成自增，而 b = ++a 相当于 a 先完成自增，再去赋值
var number4 = number1++
number4++
println((number4))
number4--
println((number4))

// 二元运算符
// 1、赋值运算符
// 1.1 在 swift 当中，赋值语句没有任何返回值，不可以跟 if - else 相结合
let a:Double = 1.0

// 2、算术运算符
// 2.1、取余运算符
// 在 swift 当中，与 C 语言中的取余运算符有些不同，swift 中的取余运算符的左右两侧可以为小数，这也是 swift 有所改进的地方
var quyuNumber = 10.0 % 3.0
println((quyuNumber))

// 3、组合赋值运算符
var zuheNumber = 10
zuheNumber += 10
println((zuheNumber))

// 4、比较运算符


// 5、逻辑运算符
// 6、区间运算符 <<<<<< swift 新增的运算符
let aa = 1
let bb = 5
// 6.1、全闭区间
for qujianNumber in aa...bb {
    println((qujianNumber))
}
// 6.2、半开半闭 15..<25
for qujianNumber2 in 15 ..< 25 {
    println((qujianNumber2))
}

// 7、空合运算符 <<<<<< swift 新增的运算符
// 7.1 空合运算符 ?? 前面必须是可选类型的
// 7.2 空合运算符 ?? 前后的类型必须一致

// ! 表示这个变量是可选类型的，但是这个变量是一定有值的
// ? 表示这个变量是可选类型的，但是这个变量不一定有值的
var optionalNumber:Int! = 10
println(optionalNumber!)
// ?? 如果 optionalNumber 不为 空 则返回 optionalNumber的值；如果 optionalNumber 为 空，则返回 ？？后面的值。
let kongheNumber = optionalNumber ?? 20
println((kongheNumber))


// 三元运算符
// 形式结构：a > b ? a : b

// 字符串
// 1、字符串的字面量 eg:"cacavca"字面量
var string1 = "cacavca"
var string2 = "wang" + "zhen" + "gang"
println((string1))
println((string2))
// 转义字符，类比 C 语言eg,\t \n \` \``
var string3 = "\"wang\""        /// 加 双引号
println(string3)
var string4 = "\'zhengang\'"    /// 加 单引号
println(string4)


// 2、swift 中的字符串和 OC 中的字符串的区别
// 2.1、 没有可变类型和不可变类型之分，在 swift 中，字符串到底可变不可变，取决于声明变量的类型，如果定义的是 let 就是不可变，假如定义的是 var 就是可变
// 2.2、 swift 中的字符串是值类型，而 OC 当中，不加特殊声明的话是引用类型。不用担心内存问题，swift 已经做了优化。
var appendingStr1 = "wangzhigang"
var appendingStr2 = appendingStr1
appendingStr2 += "shuai"
println((appendingStr1))
println((appendingStr2))
// 2.3、 swift 中 String 类型 和 OC 中 NSString 做了完美的对接，换句话说，就是 swiftString 可以使用 NSString 的方法。

// 字符串的初始化
var initString:String = String(appendingStr1 + "age")
println((initString))
// 字符串拼接,+ 可以进行字符串拼接，注意要拼接的变量必须是可变的。
initString += "hgkehg"
//initString.append("c")
println((initString))

// 字符串进行大小写转换
var changeString1 = "good boys"
// 改成大写
var changeString2 = changeString1.uppercaseString
println((changeString2))
// 改成小写
println((changeString2.lowercaseString))
// 首字母大写
println((changeString2.capitalizedString))

// 字符串插值
// 在 swift 输出语句中没有格式化占位符，想要实现这样的效果，我们要用到字符串插值格式 ："\()"
var insertNumber = 18
println("insertNumber = \(insertNumber)")

// swift 中的集合
// 1、数组
// 2、字典
// 3、set (了解)

// 区别：
// 1、在 swift 中的集合类也都是值类型，而 OC 当中的是引用类型；
// 2、在 swift 中，也是使用引用计数的概念来管理内存的，但是引用计数只适用于对象类型，值类型不需要管理；
// 3、swift 中，引用计数管理内存的方法与 OC 当中引用计数管理内存的方法，还是不同的，（见后面内容）；
// 4、在 swift 中数组是可以存放任意类型，但是 OC 中，只能存放对象类型。

// 1、 Array
// 1.1、 swift 中，Array 也没有可变和不可变之分。而是取决于用什么关键字类修饰， var 就是可变的 ， let 就是不可变的
// 1.2、 使用字面量来为一个数组赋值
// 当我们实现声明数组中元素的类型，内部的元素类型必须一致
var array = ["wang","zhen", 9]
println((array))

// 数组增加元素
// 1、调用 append 方法,当我们调用 append 方法进行元素添加时，是添加到数组最后面。
array.append("wang")
println((array))
// 2、调用 += 添加元素
array += ["wzg1","wzg2"]
println((array))
// 3、调用 insert 方法,把元素插入到指定位置
array.insert("wzg3",atIndex: 0)
println((array))
// 4、数组删除元素
// 调用 removeAtIndex 方法进行删除
array.removeAtIndex(0)
println(array)

// 5、改变数组中的元素
// 1、通过下标来更改元素
array[0] = "youmo"
println(array)
// 2、利用下面的方法，不及可以修改，而且可以删除元素。
array[0...3] = ["1","2","3"]
println(array)

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

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

// 数组的初始化，声明存储固定类型的数组
// 1、
var initArray1:[String] = [String]() // 完成写法
var initArray2:[String] = [String](count: 3,repeatedValue: "wang")
println(initArray2)

// 2、
var initArray3:Array<String> = Array(count: 4,repeatedValue: "zhen")
println((initArray3))

// 3、使用构造方法创建的是由一个特定数据类型构成的数组

// 字典
// 1、使用字面量来给字典进行赋值
var dictionary = ["boy":"wang","age":"12","gender":"man"]
println(dictionary)
println(dictionary["age"])

// 增
// 使用下标增加键值对
dictionary["girl"] = "shiyingying"
println((dictionary))

// 删
// 调用 removeValueForKey 方法进行删除
dictionary.removeValueForKey("age")
println("delete : \(dictionary)")

// 改
// 1、使用键，修改键对应的值
dictionary["girl"] = "liujingran"
println((dictionary))
// 2、使用 updateValue 方法进行修改
// updateValue 方法可以进行修改，也可以进行添加键值对，当填入的键存在时，就会进行数据更新，把键对应的老值返回出来，当键不存在时，就会进行添加，返回是 nil 。
let returnValue = dictionary.updateValue("18",forKey: "age")
println("returnValue = \(returnValue),dictionary = \(dictionary)")

let returnValue2 = dictionary.updateValue("19",forKey: "class")
println("returnValue2 = \(returnValue2),dictionary = \(dictionary)")

// 查(遍历字典)
for (key,value) in dictionary {
    println("key = \(key) value = \(value)")
}

// 字典初始化的方式也有两种
// 使用字典初始化方式进行创建的是固定键值类型的字典
// 1、
var initDiction1 : [String : String] = [String : String]()
// 2、
var initDiction2 : Dictionary<String,String> = Dictionary()

// 控制流
// 1、for-in 循环
for value in 1...10 {
    println(value)
}

// 当我们不需要使用区间的值的时候，我们可以使用‘_’告诉系统，相当于 while()
for _ in 1...10 {
    println("wangzhengang")
}

// 2、for 循环
for var index = 0 ; index < 10 ; index++ {
    println("index = \(index)")
}

// while 循环
var whileNumber = 0
while whileNumber < 10 {
    println("whileNumber = \(whileNumber)")
    whileNumber++;
}

// do-while 循环
do {
    println("111112")
}while(false)

// if-else 语句
var houValue = 20
if houValue <= 21 {
    println("小于等于21")
}
else {
    println("大于21")
}

// switch-case
// 1、 在 swift 当中是没有贯穿的，只会执行满足条件的语句，不用加 break 也不会贯穿
// 2、 在 swift 当中每一个 case 分支中都必须有一个语句，假如真不想写，可以加 break ，通过编译
// 3、 在 swift 当中 case 可以加多个条件
// 4、 可以使用 fallthrough 实现贯穿
// 5、 在 swift 当中， switch-case 可以进行值得绑定
// 6、 在 swift 中，switch-case 可以进行区间匹配
var switchNumber = 12
switch switchNumber {
case 2, 3, 6, 10:
    break
case 11:
    println("11")
case 12, 123:
    println("I am 12")
    fallthrough
case 13:
    println("I am 13")
default :
    println("qita")
}
// 5、 在 swift 当中， switch-case 可以进行值得绑定
var (x,y) = (10, 0)
switch (x,y) {
case (let xValue, 0):
    println(xValue)
case (0,let yValue):
    println(yValue)
default:
    println("others")
}
// 6、 在 swift 中，switch-case 可以进行区间匹配
var domianNumber = 50
switch domianNumber {
case 0...10:
    println("几块钱，穷逼")
case 11...100:
    println("几十块，也挺穷")
default :
    println("土豪！")
}

// 控制流中，我们会遇到的关键字 : break,continue,fallthrough
// break 在循环当中，跟 C 语言的语法规则一样，用来结束整个循环；
// continue 在循环当中， 跟 C 语言的语法规则一样，用来结束本次循环；

// 标签语句
// 当我们遇到的多个循环嵌套的时候，我们根据需求，想要关掉某个循环，此时我们就要使用标签语句，用来区别不同的循环，标签语句的定义语法：name : 写到想要标识的循环前面
wang: while true {
    for var labelNumber = 0; labelNumber < 100 ; labelNumber++ {
        if labelNumber == 5 {
            break wang
        }
        println("labelNumber = \(labelNumber)")
    }
}