Swift基础知识入门（基于Swift2.0）

//: Playground - noun: a place where people can play

 

import UIKit

 

// Swift中不需要设置main函数入口，编译器会在全局函数中自动设置程序的入口，在书写Swift代码时，可以不使用";"作为语句的结束标志

var str = "Hello, playground"

var str1 = "Hello, LiLe"

print("Hello World!") // Swift2.0使用的输出语句（在Swift1.2版本中也可以使用）

// println("Hello World!") // Swift1.2及以前的版本使用的输出语句

 

 

 

// 在Swift中，我们不需要给定常量和变量的数据类型，编译器会根据后面的赋值自动推测其数据类型，在某些情况下我们需要给定常量或变量的数据类型，这个时候我们只需要在常量/变量名称后边添加":"

// -----------常量-----------

// 使用let关键字进行定义

 

// 定义形式1：let 常量名 = 常量值

let a = 10

 

// 定义形式2：let 常量名 : 数据类型 = 常量值

let b : Int8 = 11

 

 

 

// ------------变量-------------

// 使用var关键字进行定义

 

// 定义形式：var 变量名 = 变量值

var c = 12

 

// 定义形式：var 变量名 : 数据类型 = 变量值

var d : Float = 13

 

// Swift常量/变量命名规范更开放，几乎支持所有Unicode编码，我们甚至可以使用中文进行命名

var 哈哈 = "呵呵"

print(哈哈)

 

// 运算 在Swift中不支持隐式转换数据类型，必须显示转换

var sum = Float(c) + d

print("呵呵 is " + "\(c)")

print("呵呵 is \(c)")

 

 

 

// ------------元组-------------

var person = (name : "张三", age : 99, sex : "男")

person.0

person.1

person.2

 

person.name = "李四"

person.age

person.sex

 

 

// ------------数组-------------

// Swift中的数组要求每个元素的数据类型必须是统一的，如果数据类型不统一，将会自动转换成OC中的数组

 

// let定义的是不可变数组，var定义的是可变数组

 

// 定义形式 ： let/var 数组名称 : [数组元素类型] = 数组的值 ps : "[数组元素类型]"可省略不写

 

// 定义一个空数组

var emptyArray : [String] = [String]()

var 黑名单 = ["张三", "白昊"]

黑名单.append("李四")

黑名单.insert("葛德福", atIndex: 2)

黑名单.insert("金鑫亮", atIndex: 2)

黑名单.removeAtIndex(2)

 

// 取某个范围

// 0...2 代表0到2的闭区间

黑名单[0...2]

 

// 0..<2 代表0到2的左闭右开区间

黑名单[0..<2]

 

// ------------字典-------------

 

// 在Swift中要求字典中的key必须是统一类型，value必须是统一类型，key和value可以是不同一类型，如果存放不同类型，会自动转化成OC中的字典

 

// 创建一个空字典

 

// 形式1：(推荐)

var emptyDic1 = [String : Int]()

 

// 形式2：

var emptyDic2 = Dictionary<String, Int>()

 

var personDic = ["age" : 11, "num" : 99]

// 取值：可以通过key直接获取，写法和OC中字面量的写法类似

personDic["age"]

// 更改：直接取出对应的value进行更改值的操作

personDic["age"] = 22;

// 添加：如果key不存在，会直接向字典中追加该键值对

personDic["number"] = 10

// 删除：通过key值删除对应的键值对

personDic.removeValueForKey("age")

personDic

 

 

// ------------if语句-------------

 

// if的判断条件要求必须是布尔表达式，也就是说以前我们熟悉的if(变量)的写法，在Swift中不再隐式转化为布尔值，另外，if的判断条件可以不写括号

if 0 == a {

    print(a)

} else if 1 == a {

    print(a)

} else {

    print(a)

}

 

 

// ------------循环-------------

var count = 10

while count > 5 {

    count--

}

 

// repeat-while (ps : 相当于do-while)

repeat {

    count--;

} while count > 0

 

/*

// Swift 1.2写法

do {

    count--;

} while count > 0

*/

 

// for循环

for var i = 0; i < 10; i++ {

    print(i)

}

 

var = ["", "", "", "", "", "", "", "", "", "", "", "老白"]

// for-in

for something in {

    print(something)

}

 

for i in 0...10 {

    print(i)

}

 

 

// ------------可选变量(optional变量)-------------

// 可选变量的意图在于某一个变量的值在使用过程中，可能为空，我们需要做一个声明

var string = "123"

var number : Int? = Int(string)

if nil != number {

    print(number!) // !为可选变量的拆包，告诉编译器，此时我确定其一定有值

} else {

    print("number 为nil")

}

 

// 第二种判断可选变量是否为空的方式，如果number为空，常量n将会初始化失败，代码执行else中的内容，如果number不为空，常量n初始化成功，在该条件对应的执行代码中，可以使用n

if let n = number {

    print(n)

} else {

    print("number为空")

}

 

// 在使用可选变量时，我们可能不想使用空值，所以我们可以给可选变量赋一个默认值，当可选变量为空时，取默认值

var string1 = "abc"

var number1 : Int? = Int(string1)

var finalNumber = number1 ?? 0

print(finalNumber)

 

 

// switch

// Swithc中对switch的写法做了优化，我们可以不写选择条件的括号，可以不写break(ps:默认我们执行break操作)，如果我们想强行执行下一个case，需要使用fallthrough关键字，要求必须有default

var caseNumber = 0

switch caseNumber {

case 0:

    print("选择了0")

    fallthrough

case 1:

    print("选择了1")

default:

    print("选择了其它")

}

 

// case的条件可以为字符串

var caseString = "老白"

switch caseString {

case "张涛":

    print("选择了张涛")

    fallthrough

case "老白":

    print("选择了老白")

default:

    print("选择了其它")

}

 

// case条件可以是一个范围，且这个范围是可以交叉的，如果同时满足多个选择条件，会执行第一个，我们可以使用"where"关键字附加选择所匹配的条件

var caseNumber1 = 10

switch caseNumber1 {

case 0...5:

    print("0到5之间的数")

case let x where 10 == x:

    print(x)

case 4..<11:

    print("大于等于4小于11的数")

default:

    print("other")

}

 

 

// case的条件还可以是一个元组

var point = (10, 20)

switch point {

case (0, 0):

    print("在原点")

case (_, 0):

    print("在x上")

case (0, _):

    print("在y上")

default:

    print("不在坐标轴上")

}

 

 

 

// ------------函数-------------

// 定义形式：func 函数名 （参数列表）->返回值

// 内部可以访问的参数叫做内部参数，外部调用时可以看见的标签叫做外部参数，在Swift2.0中，默认第一个参数是没有外部标签的，之后的参数会自动生成和内部参数名相同的外部参数

// 定义一个无参无返回值的函数

func sayHello() {

    print("Hello")

}

 

sayHello()

 

// 有参数无返回值

func sayHello(name:String) {

    print("呵呵\(name)")

}

 

sayHello("老白")

 

// 有参数有返回值

func sayHello1(name1:String, name2:String)->String {

    return "呵呵," + name1 + name2

}

 

var result = sayHello1("老白,", name2: "SB")

 

 

// 我们可以给参数添加对应的外部标签，不添加则使用默认设置

func sayHello2(PersonName1 name1:String, PersonName2 name2:String, name3:String)->String {

    return "呵呵" + name1 + name2 + name3

}

var result2 = sayHello2(PersonName1: "老白", PersonName2: "", name3: "SB")

 

// 在Swift1.2中的写法

//

//func sayHello2(PersonName1 name1:String, PersonName2 name2:String, #name3:String)->String {

//    return "呵呵" + name1 + name2 + name3

//}

//var result2 = sayHello2(PersonName1: "老白", PersonName2: "", name3: )

 

 

// 多参数的函数（ps:不确定参数个数的）

func sum(numbers: Int...)->Int {

    var sumResult = 0

    for i in numbers {

        sumResult += i

    }

    return sumResult

}

 

sum(1, 2, 3)

 

 

var value = 10

func changeValue(inout num: Int) {

    num = 20

}

changeValue(&value)

 

 

var compareNumber = 20

var numberArray = [3, 46, 5, 17, 25, 36, 48, 59]

 

 

func sortNumbers(compare: Int, numbers: [Int])->[Int] {

    var resultArray : [Int] = [Int]()

    for num in numbers {

        if num > compareNumber {

            resultArray.append(num)

        }

    }

    return resultArray

}

 

 

sortNumbers(compareNumber, numbers: numberArray)

 

// ------------闭包函数-------------

// 相当于OC中的block

// 闭包的声明：（参数列表）——> 返回值

// 闭包的定义：{(参数列表) ——> 返回值 in 函数体}

 

func sortNumbersFinish(compare: Int, numbers: [Int], cb:(num1: Int, num2: Int)->Bool)-> [Int] {

    var resultArray = [Int]() // 创建一个空数组，用于接收满足条件的结果

    for num in numbers { // 遍历传进来的数组，获取数组中的每一个数字，用来做比较

        if cb(num1: num, num2: compare) { // 带两个参数和一个返回值的函数参数

            resultArray.append(num)

        }

    }

    return resultArray

}

 

// 完整地闭包函数，cb : 带两个参数和一个返回值的函数参数

sortNumbersFinish(compareNumber, numbers: numberArray, cb: {(num1: Int, num2: Int)->

    Bool

    in

    return num1 > num2

})

 

 

// 可以不写闭包函数的参数类型，编译器会根据传进来的参数自动推测出参数的类型

sortNumbersFinish(compareNumber, numbers: numberArray, cb: {(num1, num2)->Bool in

    return num1 > num2

})

 

// 可以不写返回值类型，编译器会根据最后一行的表达式的返回值作为闭包函数的返回值

sortNumbersFinish(compareNumber, numbers: numberArray, cb: {(num1, num2) in

    num1 > num2

})

 

// 可以不写闭包参数的声明，"$0"代表闭包函数的第0个参数，"$1"代表闭包函数的第1个参数

sortNumbersFinish(compareNumber, numbers: numberArray, cb: {$0 > $1})

 

 

// 此需求还可以进一步简写，">"代表两个数做比较

sortNumbersFinish(compareNumber, numbers: numberArray, cb: > )

 

// 尾随闭包(推荐)：当闭包函数作为函数的最后一个参数的时候，可以把这个闭包函数放到函数列表的外边

// 当函数参数列表中只有一个闭包函数参数时，参数列表的小括号也可以不写:函数名{闭包函数}

sortNumbersFinish(compareNumber, numbers: numberArray) { (num1, num2) -> Bool in

    return num1 > num2

}

 

 

// *******************结构体*********************

// Swift中的结构体跟类很相似，都有自己的属性和方法，甚至可以有构造器（ps:init），这点和OC中的结构体有很大不同

// Swift中的结构体和类的不同点：

// 1.结构体是值类型，类是引用类型（ps:引用类型，操作内存本身，是对内存的引用。值类型，拷贝出一个新的相等的值去使用）

// 2.类可以被继承，结构体不可以被继承

// 3.类有析构器，结构体没有（ps:析构器我们可以理解为ARC下得dealloc方法，可以在里面做释放资源的操作）

 

struct Car {

    var brand = "奥迪双钻"

    func run() {

        print("I am \(brand), I am running!")

    }

    

    // 构造器(ps:相当于OC中的初始化方法),如果我们不自定义构造器方法，结构体会为我们自动生成构造器方法

    init(brand: String){

        self.brand = brand

    }

}

 

var myCar = Car(brand: "奥拓")

myCar.run()

 

struct Point {

    var x = 0.0

    var y = 0.0

}

 

struct Size {

    var width = 0.0

    var height = 0.0

}

 

struct Rect {

    var origin = Point()

    var size = Size()

    // 计算属性

    var center:Point {

        get {

            let centerX = origin.x + size.width * 0.5

            let centerY = origin.y + size.height * 0.5

            return Point(x: centerX, y: centerY)

        }

        set {

            origin.x = newValue.x - size.width * 0.5

            origin.y = newValue.y - size.height * 0.5

        }

    }

    

    init(x: Double, y: Double, width: Double, height: Double) {

        self.origin = Point(x: x, y: y)

        self.size = Size(width: width, height: height)

    }

}

 

var frame = Rect(x: 0, y: 0, width: 100, height: 100)

frame.center.x

frame.center.y

 

frame.center = Point(x: 200, y: 100)

frame.origin.x

frame.origin.y

 

 

// ********************类*********************

// Swift中不要求有根类，所以可以没有继承关系

class People {

    //var name = ""

    var name: String

    var age: Int?

    

    init(name: String, age: Int) {

        self.name = name

        //self.age = age

    }

    

    func sayHello() {

        print("My name is \(self.name), I am \(self.age) years old!")

    }

    

    // 类方法

    class func sayByeBye() {

        print("bye bye")

    }

}

 

var people = People(name: "哈哈", age: 20)

people.name

people.age

people.sayHello()

People.sayByeBye()

 

class Student: People {

    var number = 0

    init(name: String, age: Int, number: Int) {

        self.number = number

        super.init(name: name, age: age)

    }

    override func sayHello() {

        print("My name is \(self.name), I am \(self.age) years old!, my number is \(self.number).")

    }

}

 

// *********************协议**********************

protocol A {

    func sayHeHe()

}

 

class LanOuStudent: Student, A {

    func sayHeHe() {

        print("He He 老白")

    }

}