一、变量、常量
1、Swift中分别使用let、var来定义常量与变量的。
2、Swift在定义常量或变量时，必须指定其数据类型。
格式：let a:Int = 10 （变量名 : 数据类型） 其含义是：定义了一个Int类型的常量，值为10，且不能做修改
注：Swift编译时，是通过空格或回车符来断句的，所以使用Swift语言书写的代码只要回车就行，不用以分号结束。
如果定义常量的格式为 let a = 10 其也可以执行，并不会报错，因为Swift语言会根据初始值自动推断出自己是什么类型的数据或常量（具备隐式推断的功能）
3、使用var来定义我们的变量，变量可进行重新赋值操作
如：var a = “lianxi"
var b = “duoqiao"
以上分别定义了两个字符串类型的变量，那么我们如何来拼接它们呢？
var c = a + b
Swift语言拼接字符串可以直接相加，它会隐式判断出你所要进行的操作，但是如果遇到两个不同数据类型的加减乘除的话，它会报错，其不支持隐式类型转换，必须提前进行显示转换成相同数据类型
var d = 3
var e = a + String(d) //提前将Int类型的d显示转换成String类型
4、在定义变量的时候，在数据类型后面加？表示该变量可以为nil 例如： var a : Int? = nil
5、在Swift中Bool类型是一个结构体，不是枚举，只有两种结果：ture 和 false ，所以不能通过以前的非0为真去判断Bool的真假
var bool = ture
注：Swift中的变量输出为：print( \( 变量名 ) )
二、数组
1、Swift 中分别使用let和var去定义一个不可变的数组和可变的数组（使用[ ]来表示定义了一个数组）
数组的定义与定义常量和变量一样，有两种定义方式：1）定义初值，系统自动推断；2）变量后面加 :类型名
特别地：如果定义成：var array = [ 1, 2, “a”] 根据系统特性：数组中的元素必须是同一数据类型的；那么系统推断的数组元素类型为NSObject
var array : Array<Int> = [ 1, 2, 4] //数组中的元素只能是Int类型的
var array : [ Int ] = [ 1, 3 ,5 ] 等同于以上格式
2、数组跟C中的一致，也是通过下标来访问数组元素的
3、数组可通过相加来拼接数组，也可通过点语法来添加和移除数组元素（最后添加、指定位置添加、指定位置移除、移除全部元素）
4、数组里面添加数组元素
三、字典 (也是[ ]来表示）
1、定义字典格式： let/var 字典名 = [key : value, key : value ]
如果字典是通过定义初值的方法去定义，里面的key和value数据类型可以不相同
而字典通过指定类型来定义，里面的key和value数据类型不可改变
var dictionary : [ Sting : Int ] = [ “a” : 1, “b” : 2]
2、字典也可以创建一个可以为nil的字典，也是用？修饰
而通过？修饰的变量在使用的时候，必须在变量名后面添加！来进行拆包读取
dictionary![“a”] = 100 (通过key值读取并做修改）
四、元组 （Swift中新增类型）
元组定义时是用（）来表示的
元组的元素可以通过下标定义和读取，也可以通过key/value定义和读取
元组定义时给定元素类型使用（）
注:若果使用指定类型定义，元组里面的元素相同，也必须每个元素对应一个类型
它的读取与字典和数组不同，不用使用【】，而是直接使用点语法 ：元组名 .下标 或 元组名 . key
五、分支语句
if 判断与OC中的区别不大，有两点改变：1）条件可不用加括号；2）条件必须写全，如：bool == ture
区间条件：…和..<
…代表从0开始到最后一位，包含最后一位的值
不包含最后一位的值
switch分支
与OC中switch相比：1、每一个分支不用加break，系统会默认添加
2、每一个分支都必须写东西，不能为空
3、可以使用fallthrough来贯穿执行两个分支代码
4、可以对一个区间条件进行匹配使用
5、可以搭配一个元组一起使用（使用_来忽略某一个条件）
6、可以使用where来作为判断条件
六、循环语句
for； for…in ； while； repeat…while（代替了do...while）
基本语法与OC与类似，是有一点改变，条件的括号可以省略不写
七、函数
Swift中的函数有以下几个不同于OC函数的特点：
1、使用元组可实现有多个返回值的函数
Swift中，一个参数有两个名字，内部参数名和外部参数名
内部参数名：在函数内部使用的参数名称。
外部参数名：在函数调用时候，显示的参数名称
3、在函数内部是不能修改参数值的，因为它是默认使用let来定义的，如果需要修改，需要手动使用var来定义
4、默认情况下，多参数函数的第一个参数名，不在外部显示，其他参数的外部参数名与内部变量名一致，如果不想让它们在外部显示，可以在定义参数名前加_来忽略外部参数名
5、Swift中定义的函数里面还能定义函数（函数能够嵌套定义）
另外：inout参数:
1.参数默认是用let修饰,即常量
2.在参数前面添加var,就可以在函数内部修改参数的值,但不能改变实参变量的值.
3.如果参数使用inout来修饰,就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.
函数只是一个格式的转变：各种代码格式如下：
//Swift里面的函数是一个变量
//无参数无返回值 ( -> Void 可省略不写）
//定义函数的格式：
//func （关键字） test（函数名）（参数）->返回值类型
//{
// 函数体
//}
//如果没有返回值， -> Void 可以省略
func test() -> Void {
print("我是一个无参数无返回值的函数")
}
//调用函数
test()
//无参数有返回值
func test1() -> String {
return "a"
}
print(test1())
//返回一个OC的数组类型
func test2() -> NSArray {
return [2,3, 4]
}
print(test2())
//返回一个Swift的数组类型
func test3() -> Array<NSObject> {
return [1,2, "33"]
}
print(test3())
//Swift中可以返回多个返回值，其实就是返回一个元组
func test4() -> (String,Int,Int,Array<NSObject>) {
return ("a",10,10, [1,2])
}
print(test4())
//有参数无返回值
func test5(name : String, age :Int) {
print(name, age)
}
test5("你猜", age: 12)
//定义一个参数是数组类型的函数
func test6(people : Array<NSObject>) {
print(people)
}
test6([1,2, 3, "33"])
//Swift中含有内部参数名和外部参数名
//下面的函数中 你好 是外部参数名
// nicai 是内部参数名
func test7(你好 不好:String) {
print(不好)
print("你好不好")
}
test7(你好:"你也好")
//如果不想让外界知道你的外部参数名，可以使用_忽略掉外部参数名，每个参数都会自带一个外部参数名的，如果不写则和内部参数名一致
func test8(name: String, age :Int){
print("name =\(name), age =\(age)")
}
//test8(<#T##name: String##String#>, age: <#T##Int#>)
//在函数内部是不能修改参数值的，因为每一个参数是默认使用let定义的
//如果需要修改的话，可以手动的使用var定义参数
func test9(var name : String) {
name = "a"
}
//inout修饰的函参数，是var定义的，在使用的时候可以改变传进来的参数的值
func test10(inout name : String) {
name = "韩一路"
}
var name = "过冬"
test10(&name)
print(name)
func test11(inout people : (String,String)) {
let temp = people.0
people.0 = people.1
people.1 = temp
}
var since = ("100","500")
test11(&since)
print(since)
func test12(name : String, age :String) ->String
{
let string = "我叫\(name),今年\(age)岁"
return string
}
let string = test12("刘永杰", age: "25")
print(string)
func test13(people : (String,Int)) ->Array<String>
{
return ["我叫\(people.0),今年\(people.1)岁"]
}
let array = test13(("刘永杰",25))
print(array[0])
//函数里面可以嵌套定义一个新的函数,可以无限地循环下去
func test14() {
func test1() {
func test2(){
}
}
func test2() {
func test1() {
}
}
}
test14()
