Swift基础知识总结(一)

Swift1 基本语法

1.常量和变量
let 声明常量  var声明变量
类型标注
声明变量时标注类型
常量和变量的命名
规则：不可以使用某些特殊字符  不可以使用关键字  不可以使用数字开头
输出常量和变量
print(“hello:\(a)”)

常量&变量的使用原则：尽量先用 let，只有需要变的时候，再用 var，能够更加安全

2.注释
// 行注释
/*块注释*/

3.分号
何时使用分号？  - -  一行有多句代码时 代码之间用分号隔开

4.数据类型转换
转化成整型Int()  转化成字符串String()

5.布尔值
没有C语言中的非0即真的判断的  只有true 和 false
例如：
let a = 10
if a {
    // 输出
}
以上的写法是错误的
应该如此
if a > 0 {
    // 输出
}

6.元组【新知识点】 - 可以将不同的元素组合在一起
let  g = (2, 3, “abc”)
// 取值以脚标来取

7.可选类型（？）
可以有值，也可以没值，当没有值时为nil
【注意】1.swift中的nil与OC中不一样，在OC中只有指针类型可以为nil，而在swift中基本数据类型也可以为nil   

在OC中定义一个基本数据类型的变量可以不初始化，但是在swift中不可以，这样会报错，那么该如何解决这个问题呢？？？
解答：这种情况下就可以使用可选类型，不赋初始值时默认为nil

当使用可选类型时，打印结果会被optional()包含，如果想获得具体的值该如何操作？ ——>  这里涉及到一个新的知识：拆包。【拆包时必须保证有值】

拆包分为显式拆包和隐式拆包。


8.可选绑定
定义：判断可选类型是否包含值，如果包含值就赋值给一个临时常量或者变量。这时候通常用if或者while语句来对可选类型的值进行判断，并将其赋值给一个临时常量或者变量
var opt: Int?
// 如果为nil 不会走判断  若有值 会为常量赋值
if let x = opt {
    print(x)
}

9.使用断言进行调试
辅助进行代码调试
assert(<#T##condition: Bool##Bool#>)
参数是一个Bool值，可以写一个表达式，若表达式为真，这句代码会通过，如果表达式为假 则会出现崩溃

10.区间运算符 - 一般与for循环配合使用
1…5  代表 1-5     [1,5]
半开区间运算符
1..<5      [1,5)


字符串
1.字符串初始化
1.1 构造函数
1.2 字面量初始化

可以用isEmpty判断字符串是否为空

2.字符串的拼接
3.字符串中字符遍历（str.characters）
4.字符数据类型 
var e: Character = “a”

字符串后面添加字符
let c: Character = "a";
catStr.append(c);

5.字符串插值
// 字符串插入字符
var str6 = "sdaf"
// startIndex 首位  endIndex 末尾
str6.insert("k", atIndex: str6.startIndex)
str6.insert("p", atIndex: str6.endIndex)
// 字符串之间 末位向前挪几位
str6.insert("8", atIndex: str6.endIndex.advancedBy(-3))
// 向次首位插入字符
str6.insert("7", atIndex: str6.startIndex.successor())
// 向次末尾插入字符
str6.insert("4", atIndex: str6.endIndex.predecessor())

6.计算字符数量(str.characters.count)
7.字符串索引
indeces使用
// 索引
var tst = "hellloChina"
for i in tst.characters.indices {
    print(i)
    print(tst[i])
}

8.字符串删除
// 删除字符
var ata = "helloqianfeng"
// 删除首字母
ata.removeAtIndex(ata.startIndex)
// 删除指定范围
var range = ata.startIndex...ata.endIndex.advancedBy(-5)
ata.removeRange(range)
print(ata)
// 删除末尾的字符  不写-1  认为越界 会崩溃
ata.removeAtIndex(ata.endIndex.advancedBy(-1))
print(ata)


9.字符串比较 (==)
10.前缀后缀
var fixString = "abcdetxt"
// 前缀
print(fixString.hasPrefix("ab"))
// 后缀
print(fixString.hasSuffix("txt"))

11.替换字符串
var range1 = ata.startIndex...ata.endIndex.advancedBy(-1)
fixString.replaceRange(range, with: "C++")
print(fixString)


数组
1.创建一个空数组
// 空的整型数组
var z = [Int]()
// 或者 利用泛型创建
var z2 = Array<Int>()

2.创建一个带有默认值的数组
// 带有参数值  开辟10个值 每个值都是0
var x = [Int](count:10, repeatedValue:0)
var x2 = Array<Int>(count: 5,repeatedValue:20)

3.整合两个数组 （+）
4.用字面量构造数组
var ix = [1,2,3,4,5,"abc"]
5.访问和修改数组   利用脚标的形式访问
6.遍历数组

集合
集合和数组的区别与联系：数组有序 集合无序 在数组中是链表实现  集合是哈希表

1.创建一个空集合
var set = Set<Int>()
2.用字面量创建集合
// 通过字面量创建集合
var set2: Set<Int> = [1,2,3,4,5]
3.添加删除集合元素
// 删除首元素
set2.removeFirst()
print(set2)
// 删除集合中的指定元素
set2.remove(1)

集合的操作
1.union合并集合
2.intersect交集
3.subtract不在集合中的数组
4.exclusiveOr不在两个集合中
5. sort()排序

集合之间的关系
使用“是否相等”运算符(==)来判断两个集合是否包含全部相同的值。
使用isSubsetOf(_:)方法来判断一个集合中的值是否也被包含在另外一个集合中。
使用isSupersetOf(_:)方法来判断一个集合中包含另一个集合中所有的值。
使用isStrictSubsetOf(_:)或者isStrictSupersetOf(_:)方法来判断一个集合是否是另外一个集合的子集合或者父集合并且两个集合并不相等。
使用isDisjointWith(_:)方法来判断两个集合是否不含有相同的值(是否没有交集)。


    字典
1.创建一个空字典
        var dict = [Int: String]()

2.用字面量创建字典
        var  dict  =  [1: “a”, 2: “b”]
3.访问和修改字典  ——>  以脚标的形式访问和修改
4.字典遍历
        // 遍历
        for (mKeys,mValues) in dict2 {
            print("键\(mKeys) 值\(mValues)")
        }

        for mValues in dict2 {
            print("键 值\(mValues)")
        }

5.字典的有序输出
for mkey in dict2.keys.sort(){
    print(dict2[mkey]!)
}



结构控制语句

1.For…In 结构
// 循环打印helloChina
// i变量没有用到  这里呢可以将i变为_
//for i in 1...10 {
//    print("helloChina")
//}
for _ in 1...10 {
    print("helloChina")
}
2.while    结构

// 循环的使用
var cnt = 0
while cnt < 10 {
    print("kitty")
    // swift3中将 ++ = +=
    cnt += 1
}


3.带标签的while循环

// 带有标签
lb:while lct < 10 {
    for i in 1...10 {
        print("hello World")
        if i == 1 {
            // 通过标签可以决定跳出哪层循环
            break lb
        }
    }
    print("当前数值为：\(lct)")
    lct += 1
}

4.repeat…while 结构   ——>   do  while

var ct = 0
repeat{
    print("kitty")
    ct += 1
} while ct < 10

5.Switch…case 中的元组_使用

// switch case  元组中的使用
let js = (2,3)
switch js {
    // 第二个值为3 第一个值任意
    case (_,3):
        print("_,3")
    case (2,3):
        print("2,3")
    case (2,5):
        print("2,5")

    default:
        print("default")
}

6.Switch…case 中的元组值绑定
// 元祖值的绑定
let gt = (10,20)
switch gt{
case (1,1):
    print("1,1")
    // 第二个值为20  绑定x为第一个值
case (let x , 20):
    print("\(x),20")
default:
    print("default")
}

7.Switch…case 中的where条件语句
// switch case where条件语句的使用
let ge = (20, 10)
switch ge {
case let(x,y) where x == y :
    print("\(x) \(y)")
default:
    print("default")
}


函数
1.函数的定义与调用

// 函数的定义  func 函数名(参数) {}
func login() {
    print("login function")
}
// 调用
login()

2.函数参数与返回值

// 参数与返回值  -> Bool返回值  name: String, age: Int 参数
func register(name: String, age: Int) -> Bool {
    print(name + String(age))

    return true
}

3.元组作为返回值

// 元祖作为函数的返回值
func add(a: Int, b: Int) -> (Int,Int) {
    print("\(a + 10) \(b + 10)")
    return (a + 10, b + 10)
}

let ga = add(50, b: 10)
print(ga)

4.可选元组作为返回值

// 可选元祖作为返回值
func sub(a: Int, b: Int) -> (Int ,Int)? {
    return (a - 10, b - 10);
}

let gb = sub(50, b: 20)
print(gb!.0)

5.制定函数外部参数
// 制定函数的外部参数 作用为给调用者提示该参数的作用
func point(name param1: Int,age param2: Int){

}
point(name: 20, age: 20)

6.忽略函数外部参数
// 如何完全忽略外部参数(默认第一个忽略)  在第二个参数前添加 _
func line(a: Int, _ b: Int) -> Int{
    return a + b
}
print(line(20, 20))

7.函数默认参数值
// 函数的默认参数
func kiss(a: Int = 2, b: Int) -> Int {
    return a + b
}
print(kiss(b: 10))
print(kiss(20, b: 20))

8.函数可变参数(…)

// 函数可变参数
func multiParam(a: Int...) -> Int {
    // 求所有参数的和
    var sum = 0
    for i in a {
        sum += i
    }

    return sum
}
print(multiParam(1,2,3,4,5,6))

9.函数常量参数和变量参数

// 函数的常量参数和变量参数
// 默认情况下函数参数为常量类型 a,b都为常量
// 在默认参数前添加var 参数则为变量
// 在swift3中舍弃了这种样式
func paramFunc(var a: Int, b: Int) -> Int {
// 若不做操作 直接修改a的值
    //    a = 2 报错
    a += b
    return a
}
print(paramFunc(10, b: 20))

10.函数输入输出参数

// 函数的输入输出  inout 传地址运算
var t1 = 10
var t2 = 20
func changeTwoWord(inout a: Int, inout b: Int) {
    let tmp = a
    a = b
    b = tmp
}
changeTwoWord(&t1, b: &t2)
print("\(t1) \(t2)")

11.函数类型的使用

// 函数类型的使用
func myAdd(a: Int, b: Int) -> Int {
    return a + b ?? 0
}
func mySub(a: Int, b: Int) -> Int {
    return a - b
}

// 以上两个函数传值和返回值类型一致 （Int,Int）-> Int
// 可以说以上两个函数具有相同类型

//
var ty: (Int, Int) -> Int = mySub
print(ty(1, 100))

12.函数类型作为参数

// 函数类型作为参数类型使用
func fu(a: (Int, Int) -> Int, b: Int, c: Int) -> Int {
    return a(b,c)
}

print(fu(myAdd, b: 10, c: 8))

13.函数类型做为返回值

// 函数类型作为返回值
func link(a: Int, b: Int) -> (Int, Int) -> Int {
    if a + b > 10 {
         return myAdd
    } else {
        return mySub
    }
}
// link(5, b: 5) 相当于函数
print(link(5, b: 5)(100,100))


//编写函数判断该整数是否带7
// 编写函数，传入自数n，打印1——n的所有数，除了7的倍数和带7的数。