iOS中 Swift初级入门学习(二)

//  Copyright (c) 2015年 韩俊强. All rights reserved.
//

import Foundation
/*
// 控制语句
// for - in
// 遍历字符串
for character in "hello,word" {
    println(character)
}

// 变量数组
let array = ["小韩哥","小妹妹","二妹子","小美女","二美女","习大大"]

for element  in array {
    println(element)
}

// 同时取出数组中的下标和元素
for (index,element) in enumerate(array) {
    println("index = \(index), element = \(element)")
}

// 遍历字典中的key,value
let dict = ["name":"小韩哥","age":18,"gender":"男"]
for (key,value) in dict {
    println((key,value))
}

// 遍历字典中的所有keys
for key in dict.keys {
    println(key)
}

// 遍历字典中的所有的values
for value in dict.values {
    println(value)
}

// 遍历区间
for number in 1...10 {
    println(number)
}

// 计算2的8次幂
// _ 在这里是忽略该值的意思
var result = 1
for _ in 1...8 {
    result *= 2
}
println(result)

// for 循环
result = 0
for var i = 0; i <= 100; i++ {
    result += i
}
println(result)

// while 循环
result = 0;
var i = 0
while i <= 100 {
    result += i
    i++
}
println(result)

// do...while 循环
// do...while 和 while 的区别就是 do...while循环不管条件真假, 都会执行一次循环体
while false {
    println("hello, word")
}

do {
   println("hello,word")
}while false

// if 分支语句
// Swift当中,赋值语句没有返回值, 我们不能把赋值语句作为判断条件
let genderOfSuoNing = "女"
if genderOfSuoNing == "女" {
    println("hello, word!!!!")
}else{
    println("去泰国吧")
}

// 级联式
let numberOfFriends = 5
if numberOfFriends == 1 {
    println("打台球")
}else if numberOfFriends == 2 {
    println("斗地主")
}else if numberOfFriends == 3 {
    println("打麻将")
}else if numberOfFriends == 4 {
    println("旅游")
} else {
    println("KTV")
}

// if 语句值绑定
// 我们通过if语句可以给一个常量或者变量赋一个可选类型的值, 不用通过强制解析
var optionalNumber : Int? = 10
if let number = optionalNumber {
    println("number = \(number)")
} else {
    println("没有赋值成功")
}

// switch 语句
// Swift当中, 两个case语句之间默认是不贯穿的, 我们不用加break关键词
let phoneNumber = 5
switch phoneNumber {
case 1:
    println("一楼分级")
case 2:
    println("二楼分级")
case 5:
    println("三楼分级")
 // 如果想执行下面的case语句, 我们可以加一个关键字 fallthrough
    fallthrough
default:
    println("对不起,您拨打的电话正在通话中")
}

// continue, break 关键字
for var i = 0; i < 5; i++ {
    if i == 3{
        // 结束本层循环
        break
    }
    println("i = \(i)")
}

for var i = 0; i < 5; i++ {
    if i == 3{
        // 结束本次循环
        continue
    }
    println("i = \(i)")
}

// 标签语句
小韩哥 : while true {
    for var i = 0; i < 10; i++ {
        if i == 5 {
            break 小韩哥
        }
        println("i = \(i)")
    }
}

// 区间匹配
let moneyOfHjq = 200
switch moneyOfHjq {
case 1..<10:
    println("只有几块钱")
case 10..<100:
    println("只有几百块钱")
default:
    println("有好多钱呢")
}

// 元组匹配
// case 语句中的元组, 只要有一个条件满足, 元组就不会匹配值, 如果执行了一个case语句, 那么除非加上fallthrough 关键字,否则下面的case语句就不会执行
let aTuple = (5,6)
switch aTuple {
case (let x,7):
    println("x = \(x)")
case (5,let y):
    println("y = \(y)")
default:
    println("没有匹配成功")
}

// where 关键字 , 加一个判断条件, 相当于且的意思
switch aTuple {
case (let x, let y) where x > y:
    println("x = \(x),y = \(y) x > y")
case (let x,let y) where x < y:
    println("x = \(x),y = \(y) x < y")
default:
    println("x = y")
}

// _ 任意值. 忽略该值
let somePoint = (0,2)
switch somePoint {
case (0,0):
    println("该点在原点")
case (0,_):
    println("该点在y轴上")
case (_,0):
    println("该点在x轴上")
default:
    println("该点在坐标系上")
}


*/

// 函数
// 语法 func 函数名(参数) -> 返回值 { 执行语句 }
// 无参,无返回值
// 无返回值的花, -> Void 可以省略
func printHello() -> Void {
    println("Hello, word")
}

func printHi(){
    println("Hi,你好啊")
}
// 函数的调用
printHello()
printHi()

// 无参,有返回值
func returnAString() -> NSString {
    return "太棒了,下雪了"
}
let aString = returnAString()
println("aString = \(aString)")

// 有参,有返回值
func returnUpprtCaseOfStr(Str: String) -> NSString {
    return Str.uppercaseString
}
let result = returnUpprtCaseOfStr("abc")
println("result = \(result)")

// 有参,无返回值
func printStringWithAStr(str : String) {
    println("str = \(str)")
}
printStringWithAStr("hello,word")

// 返回一个元组
func returnMangElement(str:String) -> (String,String) {
    return (str.uppercaseString,str.lowercaseString)
}

let 元组 = returnMangElement("aBc")
println(元组.0,元组.1)

var array = ["hello","hi"]
array.removeAll(keepCapacity: false)

// personName 是外部参数, 让使用者很方便的知道我们需要传入什么样的参数, 但是这个外部参数对内部参数没有任何影响
func printStr(personName str: String){
    println("name = \(str)")
}
printStr(personName: "啦啦啦")

// #号的作用, 让我们这个参数在内部可以使用, 在外部可以让使用者看到
func printAStr(#personName : String){
    println("name = \(personName)")
}
printStr(personName: "你好")

// 求两个数的和的函数
// 函数的类型 (Int,Int) ->Int
func addTwoNumber(num1 : Int, num2 : Int) ->Int {
    return num1 + num2
}

// 求两个数的积的函数
func mulTwoNumber(num1:Int,num2: Int) ->Int {
    return num1 * num2
}
// 根据类型推断, aFunction就是一个函数, 类型为(Int,Int) ->Int
var aFunction : (Int,Int) ->Int = addTwoNumber

let result2 = aFunction(5,6)
println("result = \(result2)")

aFunction = mulTwoNumber
let result3 = aFunction(5,6)
println("result3 = \(result3)")

// 函数作为返回值
func returnAFunction(judge: Bool) ->(Int,Int) ->Int {
    return judge ? addTwoNumber : mulTwoNumber
}
var resultFunction = returnAFunction(true)
let result4 = resultFunction(5,6)
println(result4)

// 函数作为参数
func hanshu(funcName : (Int,Int) ->Int,num1:Int,num2:Int){
    let result = funcName(num1,num2)
    println("result = \(result)")
}

hanshu(addTwoNumber , 9, 8)

// 函数内部函数
func functionEmbedFunction(judge: Bool,number:Int){
    
    // 函数内部的函数只能在该函数内部调用
    // 函数的参数默认是不可变的, 如果想要改变函数参数的值, 我们需要把该参数用 var 修饰
    func addNumber(var num:Int){
        println(++num)
    }
    func reduceNumber(var num:Int){
        println(--num)
    }
    judge ? addNumber(number) : reduceNumber(number)
}

functionEmbedFunction(true, 19)
functionEmbedFunction(false, 30)

// 闭包
// 闭包含函数代码块
// 语法
     /*
{
   (参数) ->返回值 in
    执行语句
}
    */

let blockValue = {
    (str:  String) ->String in
    return "hello" + str
}

// 闭包的调用
let resultOfBlock = blockValue("word")
println(resultOfBlock)

// 枚举
// 值类型
// 如果枚举是整形值的话, 和我们C语言中枚举的用法基本相同, 如果不给参数赋初始值, 参数默认从0开始,递增
enum Season : Int{
    case Spring
    case Summer
    case Autumn
    case Winter
}
var currentSeason = Season.Winter
println(currentSeason)

// 通过 .rawValue可以取出枚举值
println(currentSeason.rawValue)

// 如果枚举类型不是整形, 我们需要给枚举的成员变量赋值
enum FromWhere : String {
    case North = "北方"
    case South = "南方"
    case West = "西方"
    case East = "东方"
}
var currentLocation = FromWhere.North
println(currentLocation.rawValue)

// 如果我们已经知道变量是什么枚举类型, 那么我们给他赋值的时候, 就可以省略,枚举名, 通过 .成员变量的方式直接给他赋值
currentLocation = .West
println(currentLocation.rawValue)

//  验证枚举类型是值类型还是引用类型
var anotherLocation = currentLocation
anotherLocation = .East
switch currentLocation {
case .West:
    println("以前的值没有发生变化, 枚举是值类型")
default:
    println("值发生了变化, 枚举是引用类型")
}

// 类
// 引用类型, 声明一个类我们用关键字 class 来修饰
class Student {
    // 属性
    var name : String!
    var age : Int!
    var gender : String!
    func printInfoOfStudent(){
        println("name = \(name),age = \(age),gender = \(gender)")
    }
}
// 通过构造方法创建一个学生实例
// 用let修饰类的实例, 如果属性是可变的, 那么我们就能修改该属性, 如果属性是不可变的, 我们就不能修改该属性
let student = Student()
student.name = "小韩"
student.age = 18
student.gender = "男"

student.printInfoOfStudent()
let student2 = student
student2.name = "小妹"
student2.gender = "女"
student2.age = 20

student2.printInfoOfStudent()

// 因为student是用let修饰的,我们不能改变student
//student = student2

// 结构体
// 值类型, 声明结构体我们用struct关键词
// 和类的区别: 类可以被继承, 结构体不可以
struct People{
    // 属性
    var name : String
    var age : Int
    var gender : String
    // 方法
    func printInfoIfPeople(){
        println("name : \(name),age : \(age),gender : \(gender)")
    }
}
// 结构体属性不用赋初始值, 因为结构体默认有一个逐一构造器, 通过这个方法, 我们可以给每一个属性
let people = People(name: "小白", age: 21, gender: "男")
people.printInfoIfPeople()
// 结构体实例如果用let修饰, 即使结构体的属性是可变的, 该实例的属性也不能发生改变, 要想修改该实例的属性, 我们需要用var来修饰该实例
//people.name = "小花"

// 验证结构体是引用类型还是值类型_值类型
var people1 = People(name: "静静", age: 18, gender: "男")
var people2 = people1
people2.name = "哈哈"
people1.printInfoIfPeople()