Swift基础

Swift已经更新到3.0啦，也算该成熟了，所有对于之前认为版本没确定，学了等于再学的同志可以开始啦！不然就要落后啦！

对于Swift的学习主要是官方文档，官方文档讲的也非常的详细，这里我就不再赘述。

详见，Swift官方文档

这里直接上最现实的最通俗的代码。个人学习和总结，希望大家指正。

//  main.swift
//  Swift-BasicGrammer
//
//  Created by CE on 16/7/8.
//  Copyright © 2016年 vicchou. All rightsreserved.
//

import Foundation

//普通打印
print("Hello, World!")
print("任何一门语言的学习开始于 \("Hello, World!")")

//注释：添加单行语句的注释用//,添加多行语句或者段语句的注释使用
//分号：可写可不写，一般情况下不加分号，但是，当同一行有多条语句的时候必须添加分号
//标记：在OC中，标记使用#pragma mark - xxxx,在Swift中，标记使用的是//MARK: -xxxxxx

//在Swift中，工程没有主函数，类似于脚本语言，但实质上，是一种动态编译型语言，代码的执行顺序是从上往下依次执行

//1.声明变量,使用var关键字
var a = 10
a = 20
print(a)

//2.声明常量,使用let关键字
let b = 20
//b = 30
print(b)

//3.类型标注
//为了在声明常量或者变量的时候，通过添加类型标注的方式来说明当前常量或者变量所代表的类型
var c: Int = 10
var d: Double = 2.2
//在Swift中，字符和字符串都用双引号
var e: Character = "e"
var f: String = "hello"

//4.常量和变量的命名

//var 1a = 10
//var - = 10
//var let = 10

//5.数据类型转换
var a1 = Int("10")
var b1 = String(10)
print("\(a1!)~~~\(b1)")

//6.声明布尔类型
var bool = true //只有true和false
var bool2: Bool = false


//7.元组变量
//元组是Swift提供的一种新的数据结构，将多个元素组合在一起叫做元组，在元祖中，元素的数据类型可以互不相同
var c1 = (4,"hello") //方式一
print(c1.1) //通过索引的方式访问元组元素

var(key1,key2) = (10,"abc") //方式二
print(key1)
print(key2) //通过映射的方式访问元组元素

let c2 = (name:"小芳",age:18,score:100) //方式三
print("有个姑娘叫 \(c2.name),今年 \(c2.age) 岁，考试成绩 \(c2.score)")//通过key值的方式访问元组元素

//8.可选类型
//可选类型也是Swift提供的一种新的类型，分为有值和无值，在Swift中，系统不会自动的帮我们初始化常量或者变量
//？和！，用？设置一个常量或者变量为可选类型，如果可选类型已经被初始化，变量或者常量的值则为这个初始化的值，如果可选类型没有被初始化的话，变量则为nil，这个过程叫做封包

//！，在变量或者常量后面添加！表示将可选类型转化为一般类型，这个过程叫做解包或者拆包
//可选类型就是为了处理值缺失的情况
var d1: Int? = 10
print(d1!)
var d2: String? = "hello"
print(d2!)


//9.if语句
if d1 == nil {
   print("没有值")
} else {
   print("有值")
}

//10.可选绑定
//使用可选绑定来判断可选类型是否包含值，如果有值则将值赋给另外一个变量或者常量
if let x = d1 {
   print(x)
}

//11.使用断言
//使用代码的方式实现断点可以达到的效果
//使用assert来添加断言，如果函数里面表达式为真，则没影响，如果表达式为假，则程序会崩溃到这个地方,作用就是进行辅助调试程序
let e1 = 10
assert(e1 < 100)


//错误处理
//抛出异常（throws）--->捕捉异常（添加关键字try try？ try！）

//12.运算符

//赋值运算符
let a3 = 10
let b3 = 20

//算数运算符
print(a3 + b3)
print(a3 - b3)
print(a3 * b3)
print(a3 / b3)

//求余运算符
//在Swift中，可以使用浮点型进行求余运算
print(3.1 % 2.2)

//自增自减运算符
var i = 10
print(i++)
print(++i)

//复合赋值运算符
var c3 = 3
c3 += 1 //c3 = c3 + 1
print(c3)

//比较运算符
//返回值是布尔值
print(a3 >= b3)
print(a3 == b3)
print(a3 <= b3)


//三目运算符
var apple = 2
var banana = false
var total = banana ? 5 : 2
print(total)

//空合运算符
//形式:a ??b,表示对可选类型a进行空判断，如果a有值则对a进行解封并返回a的值，如果a无值则返回默认值b，空合运算符是三目运算符的升级版，以更优雅的方式诠释了封包和解封这两种行为
var choiceColor: String? = "red"
var defaultColor = "blue"
var useColor = choiceColor ?? defaultColor
print(useColor)
//使用空合运算符的必要条件：1.a必须是可选类型 2.a和b的数据类型必须一致

//逻辑运算符
//与
let answer1 = true
let answer2 = false
print(answer1 && answer2) //一假为假，全真为真
//或
print(answer1 || answer2) //一真则真，全假为假
//非
print(!answer2)

//区间运算符
//1...5表示1，2，3，4，5
for i in 1...5 {
    print("第\(i) 次 say hello")
}
//半开区间
for i  in 1..<5 {
    print("第\(i) 次 say world")
}


//13.字符串
//字符串的初始化
var str1: String = "" //方式一
var str2: String = String() //方式二

//判断字符串是否为空
print(str1.isEmpty)
print(str2.isEmpty)

//判断字符串是否相等
if str1 == str2 {
   print("相等")
}

//进行字符串的拼接
var str3 = "hello"
var str4 = "everybody"
var str5 = str3 + str4
print(str5)


//进行字符串的遍历
for c in str5.characters {
   print(c)
}

//在字符串中插入字符
str3.insert("a", atIndex: str3.startIndex) //在最前面插入字符
str3.insert("b", atIndex: str3.endIndex) //在最后面插入一个字符
str3.insert("c", atIndex:str3.endIndex.advancedBy(-2))//在字符串末尾向前数第几位插入字符
str3.insert("d", atIndex: str3.startIndex.successor())//在正向第二位插入字符
str3.insert("f", atIndex: str3.endIndex.predecessor())//在倒数第二位插入字符
print(str3)

//获取字符串中字符的个数
print(str3.characters.count)

//通过字符串中的索引获取对应的字符
for i in str3.characters.indices {
   //通过索引获取字符
   print(str3[i])
}

//删除字符串中指定位置的字符
str3.removeAtIndex(str3.startIndex)
str3.removeAtIndex(str3.endIndex.predecessor())
//删除字符串中指定范围的字符串
var range = str3.startIndex..
str3.removeRange(range)
print(str3)

//字符串的比较
var str6 = "abc"
var str7 = "bcd"
if str6 <= str7 {
   print("相同")
} else {
   print("不相同")
}

//判断前缀和后缀
var str8 = "hello world"
//判断前缀
print(str8.hasPrefix("h"))
//判断后缀
print(str8.hasSuffix("f"))

//14.数组
//创建空数组
var arr1 = [Int]() //方式一
var arr2 = Array() //方式二

//判断数组是否为空
print(arr1.isEmpty)

//创建带有默认值的数组
//count：数组元素个数，repeatedValue:默认的元素值
var arr3 = [Int](count: 10, repeatedValue: 5)
var arr4 = Array(count: 20, repeatedValue: 10)

//两个数组合并，两个数组里面的数据类型必须一致，相加后两个数组合并为一个数组
var arr5 = arr3 + arr4
print(arr5)

//方式三：用字面量的方式创建数组
var arr6 = [1,2,3,4]

//访问数组
print(arr6[3])

//修改数组元素
arr6[0] = 10
print(arr6)

//15.集合
//创建集合
var set1 = Set() //空集合 //方式一
//向集合中存放数据,集合和数组的区别：数组元素是有序的，集合的元素是无序的
set1.insert(10)
set1.insert(20)
set1.insert(30)
set1.insert(40)
set1.insert(50)
print(set1)

//删除集合中的某个元素
set1.remove(20)
print(set1)

//遍历集合
for i in set1.sort() {
   print(i)
}

//方式二：用字面量的方式创建集合
var set2: Set = [10,11,12,13]
var set3: Set = ["a","b","c","d"]

//集合的运算
var set4: Set = [1,2,3,4,5]
var set5: Set = [3,5,6,7,8]
//获取两个集合的交集
var set45 = set4.intersect(set5)
print(set45)
//合并两个集合，并且相同的元素只保留一份,即只保留一份交集
var set54 = set4.union(set5)
print(set54)

//获取除了交集之外set4剩下的部分
var set6 = set4.subtract(set5)
print(set6)

//获取除过交集之外剩下的所有元素
var set7 = set4.exclusiveOr(set5)
print(set7)

//判断两个集合是否相等
if set6 == set7 {
   print("相同")
} else {
   print("不相同")
}

//判断集合之间的关系
//判断一个集合是否是另外一个集合的子集
var set8: Set = [1,2,3,4]
print(set8.isSubsetOf(set4))

//判断一个集合是否包含另一个集合
print(set4.isSupersetOf(set8))

//判断一个集合是否是另外一个集合的子集并且两个集合不相等
print(set4.isStrictSubsetOf(set8))

//判断一个集合是否包含另外一个集合并且两个集合不相等
print(set4.isStrictSupersetOf(set8))


//16.字典
//创建空字典
var dic1 = [Int: String]() //方式一
//通过字面量的方式创建字典
var dic2 = [1:"a",2:"b",3:"c"] //方式二

//访问字典中的元素
print(dic2[2]!)
//修改字典中的元素
dic2[3] = "f"
print(dic2)

//字典的遍历
//方式一
for(key,value) in dic2 {
   print("\(key) 对应着 \(value)")
}
//方式二：字典的有序遍历
for key in dic2.keys.sort() {
   //获取到key对应的value
    var value =dic2[key]
   print("\(key) 对应着 \(value!)")
   
}

//17.循环控制语句
//for in
//_在Swift中表示被忽略
for _ in 1...10 {
    print("helloworld")
}

//while
var w = 0
while w < 10 {
   print("hahahhaahh")
   
    w++
}

//repeat while 相当于c中的do while
var r = 0
repeat {
   print("胖狗子")
    r++
} while r < 10

//swich语句
//Swift中的switch语句和c中的不同，当匹配的case分支中的代码执行完毕之后，不会接着向下执行下面的case语句
var somePoint = (2,2)
switch somePoint {
case (1,1):
   print("（1，1）")
case (2,_):
   print("（2，2）")
case (3,3):
   print("（3，3）")
default:
   print("default")
}

//元组值的绑定
switch somePoint {
case (let x,3):
   print(x)
default:
   print("没有匹配的值")
}

//where条件语句的使用，用于增加额外的条件
switch somePoint {
case let(x,y) where x == y:
   print("\(x)  \(y)")
default:
   print("default")
}

//fallthrough(贯穿),添加贯穿之后，会接着执行下面的代码
var somePoint2 = (2,2)
switch somePoint2 {
case (2,1):
   print("2,1")
case (2,2):
   print("2,2")
    //添加贯穿
   fallthrough
case (2,3):
   print("2,3")
default:
   print("default")
}