学习Swift第一天的笔记

import Foundation

println("Hello, World!")

/*
    let 定义常量，var 定义变量
*/
var hello = "Hello, World!"　　　　　　　　   //定义一个变量
var helloWorld: String = "Hello, World!"　　//一般情况下Swift会自动推断其所属类型，如果想要显示的指定其类型，就在变量名后面跟“: 类型名”
helloWorld += "!"　　　　　　　　　　　　　　　 //借鉴了C++里面的运算符重载，追加字符串
println(helloWorld)　　　　　　　　　　　　　　 //后台打印变量"hello"的值
println("hell0 = \(hello)")　　　　　　　　   //在打印的字符串中引入变量

var 你好 = "你好" 　　　　　　　　　　　　　　　 //Swift中支持几乎所有的Unicode字符，除了数学上的符号、剪头、横杠以及系统关键字以外
let 动物园 = "zoo"
println("\(你好)，\(动物园)")　　　　　　　　　 //后台打印中文字符的变量，并进行变量拼接

let 动物 = "animal"; let 猴子 = "monkey"    //单行创建多个变量或常量其间需要使用";"隔开

let a: Int8 = 8                            //整形会自动推断为Int类型（在32位机器上是Int32，在64位机器上是Int64），如果想声明为其他类型，则需要显示指定其类型。

let b = 12.0　　　　　　　　　　　　　　　　   //浮点型数据会自动推断为Double类型。
let c: Float = 16.0　　　　　　　　　　　　   //指定浮点型变量为Float类型需要显示指定。
//let d = a + b　　　　　　　　　　　　　　　　//两个不同数据类型的常量/变量不能直接进行运算，因为Swift中没有隐式转换，必须开发者显示转换。
let d = Double(a) + b　　　　　　　　　　　　 //添加显示转换的两个不同类型的变量间运算，显示转换方式：类型名（常量/变量）

/*
    元组分解
*/
let http404ErrorA = (404, "httpRequestError")
println("errorCode = \(http404ErrorA.0)")                                       //通过下标分解元组
println("errorCode = \(http404ErrorA.0), errorMessage = \(http404ErrorA.1)")    //通过下标分解元组并拼接字符串

let http404ErrorB = (errorCode:404,errorMessage:"httpRequestError")
println("errorCode = \(http404ErrorB.errorCode),errorMessage = \(http404ErrorB.errorMessage)")


/*
    数组，一个数组里只能存储一种类型的数据
*/

var nameArrayA:String[] = ["zhangsan","lisi","wangwu"]  //显示表示字符串数组
var nameArrayB = ["zhangsan","lisi","wangwu",32]        //显示表示字符串数组
var nameArrayC = [12,22,32,43]

println("nameArrayA = \(nameArrayA)")//
println("nameArrayB = \(nameArrayB)")//
println("nameArrayC = \(nameArrayC)")//

println("nameArrayA = \(nameArrayA),nameArrayB = \(nameArrayB)")

nameArrayA.append("32")                 //Swift中的数组内只能拼接同一种类型的数据
nameArrayA.removeAtIndex(0)             //Swift中移除数组中的一条数据，remove后只是删除了相应字段的内容值，但不会删除字段
nameArrayA[0] = "xingxing"              //Swift中修改数组中的一条数据
println("nameArrayA = \(nameArrayA)")

//循环遍历数组（两种方法）
for name in nameArrayA{
    println("name = \(name)")
}
for (index, name) in enumerate(nameArrayA){
    println("index = \(index),name = \(name)")
}

var person:Dictionary<String, String> = ["name":"zhangsan","sex":"m"]　　//Swift中定义字典
println("\(person)")

//添加数组成份
person["habit"] = "football"
person["name"] = "gavin"
person["sex"] = "m";
println("person1 = \(person)")

//添加具有相同字段名的成份
person["name"] = "xiaoli"
person["sex"] = "w"
person["habit"] = "read"
println("person2 = \(person)")

//更新数组中相应字段名的数据
let oldName = person.updateValue("baobei",forKey:("name"))
println("person = \(person), oldName = \(oldName)")

//循环遍历字典
for (key, value) in person{
    println("key = \(key), value = \(value)")
}
/*
    数组可以进行更新，字典不可以更新
*/

var condition = true
var number = 1

/*
    if条件语句
*/
//错误if条件语句
//if number {                     //if条件语句不需要添加小括号，判断条件必须为bool类型数据
//    println("do something")
//}
//正确if条件语句
if condition {                   //if条件语句不需要添加小括号，判断条件必须为bool类型数据
    println("do something")
}
/*
    for循环
*/
for var i = 0; i < 100; i++ {
    print("\(i)   ")         //不换行打印
    println("i ＝ \(i)")     //换行打印
}

/*
    switch语句
*/
var s = 5
switch s{
case 1:
    println("s = 1")
//    fallthrough         //强制执行下一句
case 2..6:                //范围运算符“1..10”:只包括1，不包括10，“1...10”:1和10都包括
    println("s = 2")
//    fallthrough
case 3..11 where s==10:   //双重判定
    println("s = 3")
//    fallthrough
default:
    println("s = other number")
}

var point1 = (3, 4)

switch point1 {
case (0, 0):
    println("origion")
case (0,_):             //“_”忽略这个位置的值
    println("y axis")
case (_,0):
    println("x axis")
default:
    println("in range")
}
var point2 = (0, 4)

switch point2 {
case (0, 0):
    println("origion")
case (0,let y):
    println("y axis, y = \(y)") //输出y轴上的值
case (_,0):
    println("x axis")
default:
    println("in range")
}

/*
——————————optionals可选变量————————————
1.nil：所有类型为空均可使用
2.optionals声明
3.optionals拆包（Forced Unwrapping）
*/

var value: Int?//“？”用在数据类型之后代表为可选类型，值可能为nil

//将字符串转换为Int类型
let numberStr = "12345"
value = numberStr.toInt()           //value返回一个bool类型

//解包
if value{
    println("value = \(value!)")    //"!"表示解包,表示将value中的值取出
    var acceptValue: Int = value!   //使用“!”可将value中的值取出并赋给其他变量
}else{
    
}
/*
    函数：func 函数名 (参数列表) 返回值 {
        实现体
    ｝
*/
func sayHello(name: String) -> String{
    return "Hello" + name
}

println(sayHello("zhangsan"))

//函数的类型：参数类型+返回值类型

var funcType1:(String) -> String = sayHello //定义一个名称为"funcType"的函数

func sayGoodBye(name: String) -> String{
    return "GoodBye" + name
}

println(funcType1("lisi"))

funcType1 = sayGoodBye

var funcType2:(String) -> String = sayGoodBye

println(funcType1("lisi"))
println(funcType2("lisi"))

func count(name: String) -> (vowels: Int, consonant: Int)
{
    var vowels = 0, consonants = 0
    for character in name{
        var string: String = String(character).lowercaseString
        switch string{
            case "a","e","i","o","u":
            vowels++
            case "b","c","d","f","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","y","z":
            consonants++
        default:
            println("非字母")
        }
    }
    return(vowels, consonants)
}
println(count("woshixingxing"))

var array = count("我是xingxing")
println("vowels = \(array.0) consonants = \(array.1)")

/*
    局部变量和外部变量
*/

func join1(string1: String, string2: String) -> String{
    return string1 + string2
}

println(join1("Hello"," Xiaoxingxing"))

func join2(externalName1 string1: String, string2: String) -> String{
    return string1 + string2
}

println(join2(externalName1:"Hello"," Xiaoxingxing"))   　　　　　　　　 //"externalName1"为外部变量名，"string1"为局部变量名

func join3(#string1: String, #string2: String, #joiner:String) -> String{
    return string1 + joiner + string2
}
println(join3(string1:"Hello",string2:"xingxing",joiner:"-"))

func join4(#string1: String, #string2: String, joiner: String = "-") -> String{
    return string1 + joiner + string2
}
println(join4(string1:"Hello",string2:"xingxing"))
println(join4(string1:"Hello",string2:"xingxing",joiner:"*"))
//println(join3(string1:"Hello",string2:" Xiaoxingxing"))　　　　　　　//在"string1"和"string2"前加”#“，"string1"和"string2"既为局部变量名也是外部变量名

func join5(#string1: String, #string2: String,_ joiner: String = "-") -> String{     //”_“取消其外部名称
    return string1 + joiner + string2
}
println(join5(string1:"Hello",string2:"xingxing"))
//println(join5(string1:"Hello",string2:"xingxing",joiner:"#"))
println(join5(string1:"Hello",string2:"xingxing","#"))

func caculateMeal(numbers: Double ...) -> Double
{
    var sum = 0.0
    for number in numbers{ 　　　　　　　　　　　　　　　　　　　　　　　　//获取每一个参数的值
        sum += number
    }
    return sum/Double(numbers.count)
}

println("meal = \(caculateMeal(1.0,2.0,3.0))")

func incream(var a: Int,var b: Int)
{
    a++
}

var increamNumber = 5
incream(increamNumber, 3)               279 println("increamNumber = \(increamNumber)")

func swapTwoInt(inout a: Int,inout b: Int)  　　　　　　　　　　　　   //”inout“为可修改关键字，即：传进的参数可以进行修改
{
    var temp = a
    a = b
    b = temp
}

var swapValueA = 3,swapValueB = 5
swapTwoInt(&swapValueA, &swapValueB)        　　　　　　　　　　　　　//传变量地址进行修改
println("swapValueA = \(swapValueA), swapValueB = \(swapValueB)")


/*
    函数嵌套
*/
//外部函数
func stepBackward(number: Int) -> Int
{
    return number - 1
}

func stepForward(number: Int) -> Int
{
    return number + 1
}

//内部嵌套函数
func changeValue(isStepBackward: Bool) -> (Int) -> Int
{
    //被嵌套的函数
    func stepBackward(number: Int) -> Int
    {
        return number - 1
    }
    
    func stepForward(number: Int) -> Int
    {
        return number + 1
    }
    return isStepBackward ? stepBackward : stepForward
}

var changeValueFunc: (Int) -> Int = changeValue(true)
var changedValue = 3
println("after changed: changedValue = \(changeValueFunc(changedValue))")
//——————————闭包——————————
var names = ["zhangsan","lisi","wangwu","zhaoliu"]

//var sortedNames = sort(names,{
//    (stringA: String ,stringB: String)  -> Bool in return stringA > stringB
//})

//自动类型推断
var sortedNames = sort(names,{
    (stringA ,stringB)  -> Bool in return stringA > stringB
})
println("sortedNames = \(sortedNames)")

//var sortedNmaes  = sort(names,{stringA,stringB->Bool in stringA > stringB})

//var sortedNmaes  = sort(names,{$0>$1})

var sortedNmaes  = sort(names,>)

//如果函数中有闭包的话就把闭包放到外面 并且闭包参数是最后一个 例如：
var sortedNmaes1 = sort(names){
    $0>$1
}