注意：在创建Swift工程时，工程名不能与swift重名，因为当创建swift工程时，Xcode会自动导入swift类库，一旦重名，Xcode将会找不到swift类库，导致工程出错。

import Foundation//当需要导入类库时，使用 import + 类库名，不再添加< >或者" "
//在swift中，语句末尾可以不加";"
print("hi")
//但是，当以在同一行书写多条语句时，必须用";"隔开
print("Hello");print("World")

1.Swift中的变量和常量

用 let 修饰常量：常量的值不可以改变
用 var 修饰变量：变量的值可以改变
注意：可以使用汉字，表情对常量变量进行命名

1.1 定义常量

let 常量 = "hello"
//常量 = "hi"//常量的值不可以改变
print(常量)

let a = 1.8234
print(a)

let 😙 = "😘"
print(😙)

1.2 定义变量

var 变量 = "OC"
变量 = "swift"//变量的值可以修改
print(变量)

var b = 2.22222
print(b)

var 😭 = 555555
print(😭)

1.3 在swift中，如果开始没有给数据类型，swift会根据初始值自动判断数据类型

#常量，变量的数据类型
let c:Int = 8//整型
let d:Float = 1.5//单精度浮点型
let e:Double = 3.3333333//双精度浮点型
let f:String = "String"//字符串类型，是有序集合，可以看成character类型的集合
let g:Character = "a"//单个字符(使用双引号)
let flag:Bool = true//布尔类型，值只有true，false
//数据类型的转换：值永远不会被隐式转换为其他类型，如需转换，请写明。
let h = String(d)

//可选类型："?"表示可选类型
//赋初值：如果使用let修饰let修饰可选类型，赋初值
let second:String? = "String"
//不赋初值：如果使用var修饰可选类型，可不赋初值
var first:String? = "String"

2.Swift中的字符串

//1.定义字符串变量
var str1 = "hello 摩托"

//2.创建空变量字符串，以下两者均为空字符串，且等价
var empty_str1 = ""
var empty_str2 = String()

//3.通过字符串对象的 isEmpty 方法判断是否为空
if empty_str1.isEmpty{
    print("empty_str1 is empty")
}

//4.字符串拼接
//创建字符串变量
var str2 = "http://"
str2 += "www.baidu.com"
print(str2)

//5.获取字符串长度
let count_str = "hello"
//获取长度：“.characters.count”单个字符的个数
let length = count_str.characters.count
print(length)

//6.字符串比较
let name1 = "lizhen"
let name2 = "jiali"
if name1 == name2{
    print("\(name1) = \(name2)")
}else{
    print("不等于")
}

//7.字符串的插值
let num = 3.0
let NewNum = "\(num) * 2.5 = \(num * 2.5)"
print(NewNum)

3.Swift中的数组

1.swift数组中，存储的数据类型，都必须是同一数据类型。如果想存储不同的数据类型，可以使用OC中的数组。
2.在swift中，使用let 和 var声明一个数组
3.数组需要指定类型，如果没有指定，那么会根据数组的初值去推断数据类型

//1.定义数组
//未给定数据类型
let nameArray:Array = ["尼古拉斯凯奇","金凯瑞","奥黛丽赫本"]//根据初值自动判断数据类型
let genderArray = ["男","男","女"]

//2.数组元素的访问
print(nameArray[0])
print("元素2 = ",nameArray[1])
print("元素3 = \(nameArray[2])")

//3.给定数据类型
var ageArray:Array<Int> = [1,2,3]
print(ageArray)

//4.给定类型的空数组
let array = Array<String>()//定义一个字符串类型的空数组
let _array = [String]()//定义一个字符串类型的空数组

//5.向数组中添加元素
//方法一：
ageArray.append(4)
print(ageArray)
//方法二;
ageArray += [5,6]
print(ageArray)

//6.向数组中某个位置插入元素
ageArray.insert(7, atIndex: 2)
print(ageArray)

//7.移除数组中第一个元素
ageArray.removeFirst()
print(ageArray)

//8.移除数组中最后一个元素
ageArray.removeLast()
print(ageArray)

//9.移除数组中某个位置的元素
ageArray.removeAtIndex(3)
print(ageArray)

4.Swift中的字典

字典中所有的key和value的值必须是同一数据类型

//1.定义字典
let let_Dic:Dictionary = ["a":10]//不可变
print(let_Dic)
var var_Dic:Dictionary<String,Int> = ["b":12]//可变
print(var_Dic)

//2.定义空字典
let let_empty_Dic:Dictionary<String,Int> = [:]
var var_empty_Dic:Dictionary<String,Int>

//3.向子典中添加一对键值
var_Dic["c"] = 20
print(var_Dic)

var var_Empty:Dictionary<String,Int> = [:]
var_Empty["d"] = 15
print(var_Empty)

//4.修改字典中的一对键值
var_Empty["d"] = 2
print(var_Empty)

//5.通过key删除键值
var_Empty.removeValueForKey("d")
print(var_Empty)

5.swift中的元组

元组：是一个数据类型
是一个可以返回多个值的数据格式
在swift中，声明元组的时候，用“( )”
元组可以通过下标访问元组元素，也可以通过key的值去访问
类似于C语言的结构体，可以放多种数据类型

//1.定义一个元组
//方法一：直接初始化一个元组
let status = ("土建",["施工员","质检员","安全员"])
//方法二：
let NewStatus:(String,Array) = ("土建",["施工员","质检员","安全员"])

//2.取出元组中的值得方法
//方法一：直接赋值给常量，并通过使用标记名来获取对应的值
let statu:(classRoom:String,couse:Array) = status
var classInfo = statu.classRoom + statu.couse[0] + statu.couse[1]
print(classInfo)

//方法二：通过下标获取元组元素的值
var classInfo1 = statu.0
print(classInfo1)

var classInfo2 = statu.0 + statu.1[0]
print(classInfo2)

var classInfo3 = statu.0 + statu.1[0] + statu.1[1]
print(classInfo3)

6.Swift中空格

swift中，不像C、C++、JAVA里面完全忽视空格。swift对空格有一定要求

//1.在swift中，运算符不能直接跟在变量或常量的后面
//let let_a= 1 + 2//报错

//2.
//let let_b = 1+ 2//报错，因为swift认为到1+，这个语句就结束了，2开始就是下一个语句了

//3.
let let_c = 1 + 2//编码规范推荐使用这种方法
let let_d = 3+4

7.Swift中的循环

swift 中的循环结构包括：for、for-in、while、repeat-while

//for循环
for var i = 0; i < 10; i++ {
    print("I LOVE YOU")
}

//for-in循环
for number in 1..<10 {//"..<"开区间，表示1-9，不包括10
    print(number)
}

for number in 1...10 {//"..."闭区间，表示1-10
    print(number)
}

//while循环
var j = 5
while j > 0{
    j--
    print(j)
}

//repeat-while循环：先执行一次循环体，在判断条件（循环体至少被执行一次）
repeat{
    print("repeat...while")
}while 1 < 0

//循环遍历数组
var animalsArray = ["dog","cat","pig","tiger"]
for a in animalsArray{
    print(a)
}

//循环遍历字典
var animalsDic = ["cat":"🐱","monkey":"🐒"]
for (key,value) in animalsDic{
    print("key = \(key),value = \(value)")
}

8.Swift中的分支结构

swift中分支结构:if、if-else、switch...case

//if、if-else
let flag1 = true
if flag1 == true{
    print("flag = \(flag1)")
}else{
    print("为假")
}

//switch...case (默认自带break)
let temp = 20
//特点1：switch中想要实现贯穿，使用关键字fallthrough
switch temp{
case 0:
    print("0")
    fallthrough
case 10:
    print("10")
    fallthrough
default:
    print("Other")
}

//特点2：case后面可以是定义一个变量，where后面是被定义变量需要满足的条件
switch temp{
case var i where temp >= 0 && temp < 10:
    i = 20
    print(i)
default:
    print("Other")
}

//特点3：case后面可以是一个范围
switch temp{
case 0..<10:
    print("范围在0-9，不包括10")
case 10...100:
    print("范围在10-100，包括100")
default:
    print("Other")
}

//特点4：switch...case可以匹配一个元组
let point = (10,10)
switch point{
case (0,10):
    print("case1")
case (10,0):
    print("case2")
case (10,10):
    print("case3")
default:
    print("Other")
}

9.Swift中的枚举

C语言中，枚举类型的枚举值和一个整型数值相对应
而swift中的枚举更加灵活，不必给每一个枚举成员提供一个确定的枚举值
如果给枚举成员提供一个值(称为“原始值”)，则该值得类型可以是字符串，字符，或是一个整形值或浮点数

//定义一个枚举类型，原始类型为String
enum animalsEnum:String {
    case cat = "猫"
    case dog = "狗"
    case duck = "鸭子"
}
print(animalsEnum.cat.rawValue)//rawValue打印原始值
print(animalsEnum.dog.hashValue)//hashValue打印哈希值

//使用原始值创建一个变量
var dir = animalsEnum(rawValue: "狗")//表示取得的是原始值为“狗”的那个枚举成员名，而枚举成员的类型为：animalsEnum
print(dir)

10.Swift中的函数

swift中里面用“func”表示声明一个函数
swift的文件格式里面，没有类似于OC的.h文件，所以，需要定义一个私有函数，可以砸爱func前面加private修饰

函数格式：

func 函数名(参数名：参数类型,参数名:参数类型....)->返回值类型{
                  实现内容
                  return 返回值
     }

//1.定义无参无返回值函数
func sayHi()->Void{
    print("Hi")
}
sayHi()

//2.有参无返回值函数
func sayHello(hello:String)->Void{
    print(hello)
}
sayHello("hello")

//3.无参有返回值函数
func money()->String{
    return "No money"
}
let str = money()
print(str)

//4.有参有返回值函数
func number(a:Int,b:Int)->Int{
    return a + b
}
var add = number(6, b: 6)
print(add)

//5.有参数，多返回值函数
func all(number:Int,number2:Int)->(Int,Int,Int,Int){
    return (number + number2,number - number2,number * number2,number / number2)
}
let result = all(5, number2: 2)
print(result)

//6.内参和外参
/*
  swift中，一个参数有两个名字，内部参数名 和 外部参数名
  内部参数名：在函数内部使用的参数名称
  外部参数名：在函数调用时候，显示的参数名称
*/
func hero(first one:String,second two:Int){
    print(one,two)//使用内参
}
hero(first: "盖伦", second: 60)//显示外参

/** 注意：
    在默认情况下，函数的第一个参数，不显示外部参数名，其余参数，显示外部参数名，并且和内部参数名名字一致
    如果不嫌显示外部参数名，可以使用“_"省略，但是，函数的第一个参数不能使用"_"省略外部参数名
*/
func text(one:Int,_ two:Int){
    print(one,two)
}
text(5, 0)

/** inout参数
    函数参数，如果不给数据类型，默认为let，如果在参数面前加var，就可以修改参数
    但是，如果参数前面加“inout”来修饰，那么就成了输入输出函数，如果在函数内部修改参数，可以影响到外部变量的值
*/
var name = "豆豆"
func NewName(inout name1:String){
    name1 = "小花"//修改name值
    print("name修改为：",name1)
}
NewName(&name)//传的是地址
print("修改后的值:",name)

//函数的嵌套
func outer(){
    print("外部函数")
    func inside(){
        print("内部函数")
    }
    inside()//在外部函数中调用内部函数
}
outer()//在外部函数的外面，调用外部函数