swift (一)

直接上代码：

  // 输出函数
        println( "Hello world" )

        // let 定义常量  var 定义变量
        let loginCount = 5
        var currentLoginCount = 0
//        loginCount = 10  // 爆红
//        currentLoginCount = 20
        println((loginCount, currentLoginCount)) // 去掉括号报错

        // 在同一行中定义多个常量 或者 变量
        let a = 1, b = 2 , c = 3
        var x = 4, y = 5 , z = 6
        var str1 = "str1", str2 = "str2", str3 = "str3"

        // 类型标注
        // 声明了一个 String 类型的变量名字叫 nameString
        var nameString: String
        nameString = "cacaca"
        println((nameString))

//        let count: Int  // 适用于Xcode 6.3及以上
//        count = 12
//        println((count))

        // 变量，常量的命名
        let 王 = "高富帅"
        var �� = "☺"
        // 变量或者常量命名的时候不能以数字开头，但是数字可以放在中间或者结尾
        let a2b2 = 123;
        println((��))
        println(王)

        // 输出常量和变量
        // 使用字符串差值的方式，把当前变量名当做占位符加入到字符串当中，然后加上括号和反斜杠将其转移输出。
        var juiceName = "apple Juice"
        println((juiceName))
        println(("I Love \(juiceName)"))

        var iosDevice = "iPhone6"
        println("I want to \(iosDevice) ぁゅゐ ��")

        // 注释
        // 单行注释
        /*
            多行注释
        */

        /* 
            这是第一个多行注释的开头

        /*  这是第二个多行注释的开头
        */  这是第二个多行注释的结尾

            这是第一个多行注释的结尾
        */

        // 必须在语句后边添加分号的情况
        // 在一行中需要添加多个独立语句的时候需要添加分号
        var �� = "Rubbit"; println(��)
        let adb = 10; println((adb));

        // 8位有符号整数类型可以表示的最小值最大值
        let minInt8 = Int8.min
        let maxInt8 = Int8.max
        println((minInt8, maxInt8))

        // 8位无符号整数类型可以表示的最大值最小值
        let minUint8 = UInt8.min
        let maxUint8 = UInt8.max
        println((minUint8, maxUint8))

        // 16位有符号整数类型可以表示的最大值最小值
        let minInt16 = Int16.min
        let maxInt16 = Int16.max
        println((minInt16, maxInt16))

        // 16位无符号整数类型可以表示的最大值最小值
        let minUint16 = UInt16.min
        let maxUint16 = UInt16.max
        println((minUint16, maxUint16))

        // 32位有符号整数类型可以表示的最大值最小值
        let minInt32 = Int32.min
        let maxInt32 = Int32.max
        println((minInt32, maxInt32))

        // 32位无符号整数类型可以表示的最大值最小值
        let minUint32 = UInt32.min
        let maxUint32 = UInt32.max
        println((minUint32, maxUint32))

        // 64位有符号整数类型可以表示的最大值最小值
        let minInt64 = Int64.min
        let maxInt64 = Int64.max
        println((minInt64, maxInt64))

        // 64位无符号整数类型可以表示的最大值最小值
        let minUint64 = UInt64.min
        let maxUint64 = UInt64.max
        println((minUint64, maxUint64))

        // Float 精确到小数点后5位
        var π:Float
        π = 3.1415926
        println((π))

        // Double 精确到小数点后14位
        var π1:Double
        π1 = 3.1415926535897932384
        println((π1))

        // 类型安全
        var str = "iPhone"
        // 系统会自动推断 str 为 String 类型
        // 类型安全 ，上边系统推断为 String ,下边在赋值其他类型，编译器会直接报错。
        // str = 10; // 编译器会爆红提示 str 为 String 类型，
        var value = 10
        // 系统会自动推断为 Int
//        value = "AGLKHELKHG"  在赋值的时候系统会先进行类型推断，系统推断为 Int 类型，下边赋值的时候是 String ，编译器会直接报错，提示类型不匹配。

        let pdsu = 5 + 1.442
        // 系统会自动推断为 Double 类型

        // 数值类型转换
        let value1:UInt16 = 3200
        let value2:UInt8 = 7
        // 两种不同数值类型不能直接进行相加的操作，因为类型不匹配
//        let value3 = value1 + value2
        // 需要进行数值类型转换成同一种类型，才能进行其他操作
        let value3 = value1 + UInt16(value2)
        println((value3))

        var one = 25 // 类型推断为 Int 类型
        var two = 3.13  // 类型推断为 Double 类型
        var three = Double(one) + two
        println((three))

        // 类型别名
        // 给现有类型起一个更有意义的名字
        typealias audioSample = Int
        let maxValue = audioSample.max
        println(maxValue)

        // Bool 类型 ，类型会触发类型推断，推断为 Bool 类型
        let areYouOk = true
        let areYouLikeShit = false
        if areYouOk {
            println((areYouOk))
        }
        if !areYouLikeShit {
            println((areYouLikeShit))
        }

        // 元组
        let http404Error = (404, "Not Found !")
        // 元组数据的访问方式
        let (messageCode, message) = http404Error
        println("this is status code \(messageCode)")
        println("this is status message \(message)")

        // 通过下标访问
        println("this is status code \(http404Error.0)")
        println("this is status message \(http404Error.1)")

        // 如果你只需要一部分元组的值，分解的时候可以把要忽略的部分用 _ 标记
        let (justNeedStatusCode, _) = http404Error
        println("this is status code \(justNeedStatusCode)")
        let (_, justNeedStatusMessage) = http404Error
        println("this is status message \(justNeedStatusMessage)")

        // 可以在定义元组的时候给单个元素命名
        let http200Status = (statusCode: 200, message: "OK")
        println("this is status code \(http200Status.statusCode)")
        println("this is status message \(http200Status.message)")

        // 可选类型
        let possableNumber = "123"
        let converNumber = possableNumber.toInt()
        // converNumebr 被推断为 “Int?”或者是 Optional Int
        if let number = possableNumber.toInt() {
            println("\(possableNumber) has an integer value of \(number)")
        }
        else {
            println("\(possableNumber) could not convered integer")
        }

        // 断言
        let age = -3
        assert(age >= 0, "A Person's Age Cound not be less than zero")