Swift 基本语法1

一、Swift简介

2010年的夏天，苹果公司的开发人员Chris Lattne接到了一个特别的任务，为OS X 和iOS平台开发下一代的编程语言，也就是Swift。

苹果公司于2014年WWDC（苹果开发者大会）发布的新开发语言Swift，可与Objective-C共同运行于Mac OS和iOS平台，用于搭建基于苹果平台的应用程序。
2015年的WWDC开发者大会上，苹果公司推出了Swift2.0版本，并且Swfit完全开源。

自从Swift发布以来，在http://www.tiobe.com中的排行一直处于上升的状态。

二、声明变量和常量

在Swift中使用“let”修饰一个常量，使用“var”修饰一个变量;

let修饰常量的值是不可以更改的；

var修饰的变量的值是可以更改的；

在声明常量和变量的时候可以使用表情符号、中文等命名常量名和变量名。

Swift里不会自动给常量变量赋初始值，也就是说常量变量不会有默认值，所以定义常量的时候一定要给定初始值

Swift定义变量或者常量的时候，需要标识出变量或者常量的类型，如果不标识，会根据初始值自动推断。

因为swift是强类型语言，所以不同类型的变量不能相加，如果想要相加，可以强制类型转换

1、声明常量变量

// MARK: - 定义常量变量：变量类型的隐式转换

// 在Swift中如果不给定变量常量的类型，该常量变量的类型就是其初始值的类型
var name = "Jack"    // 隐式转换为String类型

var name1 : String = "Rose"  // 给定name1的类型为String，不能赋值其他类型

var age : Int = 18  // 整型变量

var age1 : Int?   // ?表示age1的类型为可选类型，其值可以为空
print(age1)

var gender : Character = "f"  // 字符变量，字符用""括起来，""中只能写一个字符

var flag : Bool = true   // Bool类型，其值只有true 和 false

2、定义字符串，以及常用到的函数

1. String是有序的字符集合，例如“Hello World”
2. Swift中的字符串通过String类型表示，当然也可以看成Character字符类型的集合

// MARK: - 字符串
// 1、创建一个空的字符串
var str_empty = ""
var str2_empty = String()

// 2、判断字符串是否为空
if str_empty.isEmpty {
print("空")
} else {
print("非空")
}

// 3、字符串的拼接
var url : String = "http://"
var str : String = "www.baidu.com"
// 方式1：
//url.appendContentsOf(str)
// 方式2：
var newUrl = url + str
// 方式3：字符串插值  --  \(变量名)
var newURL = "百度网址:\(newUrl)"

print(newURL)

// 4、获取字符串长度
var str1 : String = "abcdef"
print(str1.characters.count)

// 5、字符串的比较
var str2 : String = "MBBoy"
var str3 : String = "GBLW"
if str2 == str3 {
print("\(str2)和\(str3)相等")
} else if str2 > str3 {
print("\(str2)大于\(str3)")
} else {
print("\(str3)大于\(str2)")
}

3、Float 和 Double

// MARK: - float与double
var num1 = 3.14   // 不指定类型，默认是double类型
// 如果想定义float类型的变量，必须要指定类型
var num2 : Float = 2.14
// 因为swift是强类型语言，所以不同类型的变量不能相加，如果想要相加，可以强制类型转换
//var sum = num1 + num2  // 报错
var sum = num1 + Double(num2)  // 不会报错
print("和是\(sum)")

4、小结

常量或者变量的类型必须和你赋给它们的值的类型一样;

声明时类型是可选的，声明的同时赋值的话，编译器会自动推断类型;

如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号分割;

使用let来声明常量，使用var来声明变量;

常量只能赋值一次，使用的时候可以直接获取到这个值;

数据只能进行显示类型转换;

三、声明一个数组、字典

在Swift中使用“let”或者“var”声明一个数组或者字典;
数组必须指定数据类型，如果没有指定类型则会根据数组的初值去推断数据类型;
字典所有的key值必须是同一数据类型;
字典所有的value必须是同一数据类型。

1、数组

// MARK: - 数组
// Swift中数组的元素类型必须相同，如果想存放不同类型的元素，用OC

// 定义一个数组
var nameArray = ["yuanyuan", "GBLW", "WYW"]
print(nameArray)

// 指定数组元素类型
var ageArray : Array<Int> = [1, 4, 5]
print(ageArray)

// 定义一个空数组
// 方式1：
var carArray = Array<String>()
// 方式2：
var carArray1 = [Int]()
print(carArray)

// 访问数组元素
print(nameArray[1])

// 给数组添加元素
carArray.append("bb")
print(carArray)

// 使用运算符添加数组元素，可以添加多个
carArray += ["cc", "dd"]
print(carArray)

// 插入元素到具体位置
carArray.insert("aa", atIndex: 0)
print(carArray)

// 移除某个元素
carArray.removeAtIndex(2)
print(carArray)

// 移除所有元素
carArray.removeAll()
print(carArray)

// 数组排序
print(nameArray)
nameArray.sortInPlace()
print(nameArray)

2、字典

// MARK: - 字典
// 定义一个字典类型的变量
var dic : Dictionary<String,Int> = ["a" : 18, "b" : 33, "c" : 38]
print(dic)

// 定义空字典
// 方式1
var dic_empty = Dictionary<String, Int>()
// 方式2
var dic_empty2 : Dictionary<String, Int> = [:]

// 向字典中添加键值对
dic["d"] = 66
print(dic)

// 修改字典中的值
dic["d"] = 9
print(dic["d"])

// 删除一个键值对
dic.removeValueForKey("a")
print(dic)

四、元组

元组是Swift里面独有的一种数据格式。
是一个可以返回多个值的数据格式。
在Swift里面声明的时候使用“（）”声明。
元组可以通过下标去访问元素，也可以通过key值去访问元素;
整体的数据结构有点类似于C语言里面的结构体。

// MARK: - 元组

// 定义一个元组
// 方法1：直接初始化一个元组，使用Swift隐式转换
var tuples = ("水果",["香蕉", "苹果", "西瓜"])
// 方法2：初始化元组的时候给元组指定类型
var tuples1 : (String, Array) = ("动物", ["🐶", "🐱", "🐯"])
print(tuples1)

// 取值
// 方式1: 直接把元组赋给另外一个常量，根据相关标记进行取值，
let newTuples : (animals : String, pet : Array) = tuples1
print("\(newTuples.animals)里有\(newTuples.pet[0])、\(newTuples.pet[1])、\(newTuples.pet[2])")

// 也可以在定义元组的时候给单个元素命名
var tuples2 = (city : "北京", area : ["海淀区", "朝阳区"])
// 取值时可以直接用名字来获取元素的值
print("\(tuples2.city)包括\(tuples2.area[0]),\(tuples2.area[1])")

// 常量名可以省略, 要忽略的元组元素可直接用_表示
let (_, fruit) = tuples
print(fruit)

// 方式2：直接根据下标取值
print("\(tuples.0)里有\(tuples.1[0]),\(tuples.1[1]),\(tuples.1[2])")

五、循环结构和分支结构

Swift里面的循环结构包含：for、for-in、while、repeat-while
Swift里面的分支结构包含：if、if－else

1、循环结构

var nameArray = ["yuanyuan", "GBLW", "WYW"]
var dic : Dictionary<String,Int> = ["a" : 18, "b" : 33, "c" : 38]
// MARK: - 循环结构
// 1、for 循环
// 第一种:
// i++后面不能直接接{ 会报错，要打一个空格或者换行
for var i = 1; i < 10; i++ {
print(i)
}

// 第二种: ..< 半闭集范围操作符
for number in 1..<10 {
print(number)  // 不包括10
}

// 第三种:  ... 闭集范围操作符
for number in 1...10 {
print(number)  // 包括10
}

// 2、while 循环
var i = 8
while i > 0 {
print(i)
i--
}

// repeat...while 相当于do...while，限制性一此循环体，再去判断条件语句，循环体至少走一次
repeat {
print("我爱你们")
}while 1 < 0

// 使用循环遍历数组
for newName in nameArray {
print(newName)
}

// 使用循环遍历字典
// 第一种：
for newAge in dic {
print(newAge)
}
// 第二种
for (key, value) in dic {
print("key = \(key), value = \(value)")
}

2、分支结构

switch分支结构：在Swift里面，switch的每个case后面会自动的添加一个break，所以不需要手动的去添加了。Swift里面的枚举是可以范围枚举的，系统会根据给定的数据自动的匹配相近的范围

// MARK: - 分支结构
// if
let flag1 = true
if flag1 == true {
print("是真哒！")
} else {
print("嘿嘿，假哒，骗你哒")
}

// switch
// 要求每个分支必须有代码
// switch形式使用fallthrough关键字，实现OC中没有break关键字的情况，每个case都执行
// 不写fallthrough，实现OC中有break关键字的情况
let value = 0
switch value {
case 0 :
print("0")
fallthrough
case 1 :
print("1")
//    fallthrough
default :
print("other")
}

// case 后面可以使用一个范围
switch value {
case 0..<10 :
print("0 - 9")
case 10...20 :
print("10 - 20")
default :
print("额，不在范围内")
}

// case 后面可以使用常量或者变量
switch value {
case var i where value >= 0 && value <= 6 : i = 99
print(i)
default :
print("other")
}

// case 后面还可以使用元组
let point = (1, 10)
switch point {
case (10, 0) :
print("x = 10, y = 0")
case (2, 10) :
print("x = 2, y = 10")
case (_, 10) :
print("x = ?, y = 10")
default :
print("没")
}

六、枚举

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

注意：只有枚举值是Int类型时才会有递增

// MARK: - 枚举(enum)

// 原始类型为int
enum Direction : Int {
case east = 0
case south = 1
case west = 2
case north = 3
}
// rawValue -- 枚举的原始值
print(Direction.east.rawValue)

// 原始类型为string
enum Seasen : String {
case spring = "春天"
case summer = "夏天"
case autumn = "秋天"
case winter = "冬天"
}
print(Seasen.spring.rawValue)

// 根据原始值获取相对应的枚举
print(Direction(rawValue: 2))

七、函数

Swift里面用 func 表示声明一个函数。
Swift的文件格式里面没有类似于OC的.h文件。所以，如果需要定义一个私有的函数，可以在func前面添加private 修饰。

函数类型：函数定义格式

无参无返回值

无参有返回值

有参无返回值

有参有返回值

有参多个返回值（返回一个元组）

func 函数名（参数名：参数类型，参数名：参数类型....）->返回值类型 {
　　函数实现
　　return 返回值
}

外部参数和内部参数

　　Swift中，一个参数有两个名字，内部参数名和外部参数名
　　内部参数名：在函数内部使用的参数名称。
　　外部参数名：在函数调用时候，显示的参数名称

忽略外部参数

　　默认情况下，函数的第一个参数，不显示外部参数名，其余参数，显示外部参数名，并且和内部参数名一致
　　如果不想要显示外部参数名，可以使用“_”忽略掉
　　注意：函数的第一个参数不能使用“_ ”忽略掉外部参数名。

函数嵌套

　　函数嵌套：Swift里面可以函数嵌套定义
　　注意：作用域问题，嵌套在函数1里的函数2不能在函数1外部调用，函数2是函数1私有的

inout参数

　　inout参数:
　　1.参数默认是用let修饰,即常量
　　2.在参数前面添加var,就可以在函数内部修改参数的值,但不能改变实参变量的值.
　　3.如果参数使用inout来修饰,就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.此时实参必须是变量，且调用函数的时候传的参数是实参的地址

// MARK: - 函数
// 表示函数的关键字 func
// 函数的类型有五种：
// 1、无返回值无参数  ->Void 可省略
func function1() -> Void {

}

// 2、无返回值有参数  ->Void 可省略
func function2(str: String) -> Void {
print(str)
}

function2("baekhyun")

// 3、有返回值无参数
func function3() -> String {
return "boom sky"
}

print(function3())

// 4、有返回值有参数
func function4(num1 : Int, num2 : Int) -> Int {
return num1 + num2
}

print(function4(1, num2: 2))

// 5、有参，返回值为元组类型
func function5(a : Int, b : Int) -> (Int, Int, Int, Int) {
return (a - b, a + b, a * b, a / b)
}

print(function5(5, b: 6))

// 外部参数和内部参数
// 内部参数名：在函数内部使用的参数名
// 外部参数名：在函数调用的时候，显示的参数名
func function6(first one : Int, second two : Int) {
print(one, two)
}

function6(first: 2, second: 5)

// 忽略外部参数
// 默认情况下，函数调用时，函数的第一个参数不显示外部参数名，其余参数显示外部参数名，并且和内部参数名一致，如果不想要显示外部参数名，可以使用 _ 忽略掉
// 注意：函数的第一个参数不能使用 _ 忽略掉外部参数名
func function7(one : Int, _ two : Int) {
print(one, two)
}
function7(3, 6)

// 函数嵌套 : Swift里函数可以嵌套定义
// 注意：作用域问题，嵌套在函数1里的函数2不能在函数1外部调用，函数2是函数1私有的
func function8() {
print("第一层")
func function9() {
print("第二层")
}
// 调用function9, 不调用的话function9不会执行
function9()
}

function8()

// inout参数
// 如果形参使用inout来修饰，就变成了输入输出参数，在函数内部改变形参的值，实参的值也会变
func function10 (inout name : String) {
name = "Baek"
print(name)
}
// 实参要定义为变量，不能定义成常量，否则不能传参给输入输出参数
var myName = "Hyun"
function10(&myName)  // 传入的是个地址
print("myName : " + myName)

补充：

Swift中导入类库使用import，不再使用<>。不需要导入自定义类。
语句结尾的分号可有可无