Swift开发基础 二

    override func viewDidLoad() {

        super.viewDidLoad()

        // Do any additional setup after loading the view, typically from a nib.

        // 数据可读性

        let readAbility1 = 10_000_000_000;

        let readAbility2 = 1_000_000.000_000_1;

        var readAbility3 : Int = 1_00_00_000_000;

        

        // typealias  类型别名 = 原始类型

        typealias NewInt = Int32;

        var new_value : NewInt = 123;

        

        // Int类型转换成其他类型

        var j : Int = 3;

        Double(j);  // 3.0

        Float(j);   // 3.0

        "\(j)"      // 3

        

        // String 类型转换成其他类型

        var s : String = "2.156asd2";

        Int(s)      // nil

        var s1 = s as NSString;

        s1.integerValue;    // 2

        s1.doubleValue;     // 2.156

        s1.floatValue;      // 2.156

        print(s1.integerValue);

        print(s1.doubleValue);

        print(s1.floatValue);

        

        // 各类型转String

        var d : Double = 1.68;

        "\(d)";     // “1.68”

//        d.format(".1");     // 根据extension Double 扩展的方法（四舍五入）-> "1.7"

        

        var f : Float = 1.68;

        "\(f)";     // "1.68"

        

        var i : Int = 1;

        "\(i)"      // "1"

        

        // 赋值运算符

        let b = 20;

        var a = 10;

        a = b;  // a现在等于 20

        

        // 赋值语句，无法进行判断，编译器报错

//        if (a = b) {

//            

//        }

        

        // 字符串拼接

        var newString = "hello, " + "world";    // 等于 "hello, world"

        let endChar : Character = "!";

        newString.append(endChar);    // 字符串追加一个字符

        

        // 求余运算

        9 % 4       // 等于 1

        

        // 自增运算

        var aInt = 0;

        ++aInt      // aInt现在等于1

        

        let bInt = ++aInt; // 先把aInt加1，再返回aInt的值，所以aInt和bInt都是1

        let cInt = aInt++; // 先使用了aInt的值，然后aInt才加1，所以cInt得到了aInt的旧值1，而aInt加1后变成2

        

        // 一元负号

        let three = 3;

        let minusThree = -three;    // minusThree 等于 －3

        let plusThree = -minusThree;    // plusThree 等于 3，或 "--3"

        

        // 一元正号 不做任何改变的返回操作数

        let minusSix = -6;

        let alsoMinusSix = +minusSix; // alsoMinusSix 等于 －6

        

         // 复合赋值

        var aF = 1;

        aF += 2;    // aF现在是3

        

        // 三元条件运算

        let contentHeight = 40;

        let hasHeader = true;

        let rowHeight = contentHeight + (hasHeader ? 50 : 20);  // rowHeight现在是90

        

        // 区间运算符(a...b)定义一个包含从a到b(包括a和b)的所有值的区间，闭区间运算符在迭代一个区间的所有值时是非常有用的，如在for－in循环中

        for index in 1...5 {

            print("\(index) * 5 = \(index * 5)");

        }

        // 半闭区间(a..<b)定义一个从a到b但不包括b的区间，之所以成为半闭区间，是因为该区间包含第一个值而不包括最后的值

        for index in 1..<5 {

            print("\(index) * 5 = \(index * 5)");

        }

        

        // 逻辑运算 与或非

        var book : Bool = true;  // 是否购买了本书

        var px : Bool = true; // 是否去培训

        var oc : Bool = true;   // 是否有OC基础

        

        if (oc && book && px) {

            print("恭喜你，你将快成为Swift专家");

        } else if ((!oc && book && px) || (oc && !book && px)) {

            print("在培训下，你将很容易掌握Swift语言");

        } else {

            print("你需要经过自己辛苦的努力才会掌握Swift语言");

        }

        class SomeSuperType {}

        class SomeType : SomeSuperType {}

        class SomeChildType : SomeType {}

        

        let st = SomeType();

        

        let x = st as SomeSuperType; // 成功，返回值， SomeSuperType

        

//        let y = st as Int // 失败，编译期错误

        

//        let z = st as SomeChildType; // 可能在运行期失败，返回值类型为SomeChlidType

        

        // 对编译器来说，使用“as”来确定类型和类型声明也是可以的

        let y1 = x as! SomeType;  // 使用as表明类型

        let y2 : SomeSuperType = x;   // 使用类型声明

        

        // is 操作符将在运行时检查表达式是否为特定类型。如果是就返回真（true），否则返回假（false）。在编译期检查的结果必须不确定，

        "hello" is String;

        "hello" is Int ;

        

        // 两种for循环

        for index in 1...5 {

            print("\(index) * 5 = \(index * 5)");

        }

        

        for (var i = 0; i < 6; i++) {

            print("i = \(i)");

        }

        

        // while 循环

        /*

        while语句，只有当 ip<5 为 false 才跳出 while语句

         */

        var ip = 0;

        while (ip < 5) {

            print("ip = \(ip)");

            ip++;

        }

        // repeat－while循环。经典的do－while语句改名了，改为repeat－while

        /*

         repeat-while 循环，不管 pa是多少，先执行一次，再判断，为false则跳出 repeat－while 语句

         */

        var pa = 5;

        repeat {

            print("pa = \(pa)");

            pa++;

        } while (pa < 5);

        

        // if语句

        // 可以与else配合执行条件

        var book1 : Bool = true;  //  是否购买了书籍

        var px1 = true as Bool; // 是否培训

        

        if (book1) {

            print("你购买了书籍，将快速成为Swift专家");

        } else {

            print("你没有购买书籍，学习Swift将非常艰难");

        }

        

        // 对于稍微比较复杂一点的条件，我们可以使用if...else if...else这样的语句

        if (book1) {

            print("你购买了书籍");

        } else if (px1) {

            print("你参加了培训");

        } else {

            print("你什么都没有啦");

        }

        

        // switch 用在一些条件比较复杂／执行分支语句比较多的情况下。每一条switch分支语句不需要跟一个break，每条switch分支必须跟上一条语句。在Swift中，每条分支执行完毕之后，就会跳出switch语句，而不悔执行下一条语句。在一个switch分支之中，可以包含多个条件语句。

        var day1 = "Mon";

        switch (day1) {

            case "Mon":

                print("星期一");

            case "Tue":

                print("星期二");

            case "Wes":

                print("星期三");

        default:

            print("不知道今天星期几");

        }

        

        // switch 分支使用范围

        let count = 3_000;

        var naturalThings : String;

        switch count {

        case 0:

            naturalThings = "数字0";

        case 1...3:

            naturalThings = "数字1-3";

        case 4...9:

            naturalThings = "数字4-9";

        case 10...99:

            naturalThings = "数字10-99";

        case 100...999:

            naturalThings = "数字100-999";

        case 1000...9999:

            naturalThings = "数字1000－9999";

        default:

            naturalThings = "数字9999以上";

        }

        print(naturalThings);

        

        //  控制转移语句，改变代码的执行顺序，通过它可以实现代码的跳转。Swift有4种控制转移语句：continue，break，fallthrough，return

        // 循环中的转移语句break

        var m = 0;

        while (m < 5) {

            if (m == 3) {

                break; // 当m＝3时，break跳出整个循环

            }

            print("m = \(m)");

            m++;

        }

        

        // 在中间退出本次循环，我们使用continue语句

        var k = 0;

        var l = 0;

        while (k < 3) {

            while (l < 3) {

                if (l == 2) {

                    l = 10;

                    continue;

                }

                print("l = \(l)");

                l++;

            }

            print("k = \(k)");

            k++;

        }

        

        // switch语句不会从上一个case分支落入到下一个case分支中。只要匹配到一个分支完成了它需要执行的语句，整个switch代码块就完成了它的执行。如果想在配置case之后还继续往下执行，就可以使用fallthrough语句。fallthrough语句使得switch模块执行了case2，3，5，7之后继续执行case5.

        // fallthrough语句的使用

        let number = 5;

        switch number {

        case 2, 3, 5, 7:

            print("这是一个质数");

            fallthrough;

        case 5:

            print("5");

        default:

            print("这是一个整数");

        }

        print(description);

        

        // return语句用于在函数或方法的实现中将控制权传递给调用者，接着程序将会从调用者的位置继续向下执行

        // 使用return语句时，可以只写return这个关键词，也可以在return后面跟上表达式。

        

        // 枚举定义了一个通用类型的一组相关值，使你可以在代码中以一个安全的方式来使用这些值，即使用enum关键词并且把它们的整个定义放在一对大括号内。枚举可以包含方法。

        //枚举定义

        enum SomeEnumeration {

            // 在这里定义枚举

        }

        

        

        // 以下是地图四个方向的一个例子

        enum MapDirection {

            case North;

            case South;

            case East;

            case West;

            

            func simpleDescription() -> String {

                switch self {

                case .North:

                    return "North";

                case .South:

                    return "South";

                case .East:

                    return "East";

                case .West:

                    return "West";

                default:

                   
b6d7
return String("unknow");

                }

            }

        }

        

        // 多个成员可以出现在同一行上，用逗号隔开

        enum MpaDirection1 {

            case North, South, East, West

        }

        

        // 枚举的使用：枚举名称通过点语法获取枚举的某一个值

        var directionToHead = MapDirection.West;

        

        // 一旦 directionToHead被声明为一个 MapDirection 类型，我们就可以使用更短的点(.)语法将其设置为另一个 MapDirection 的值

        directionToHead = .South;

        

        // 结构体的定义和使用

        struct Summation {

            var addend : Int;

            var augend : Int;

            func sum() -> Int {

                return addend + augend;

            }

        }

        

        //  创建一个结构体

        let newStruct = Summation(addend: 6, augend: 8);

        

        // 使用结构体内方法

        let newNum = newStruct.sum()

        print(newNum);
    }

//

//  Contans.swift

// 

//

//  Created by  on 16/7/7.

//  Copyright © 2016年 . All rights reserved.

//

import UIKit

// Swift中并没有加入宏系统，C语言使用#define定义的基本常量在导入Swift时被Swift编译器自动转换为Swift语言的全局变量。但复杂的宏定义不能被Swift转换。Swift中类似宏定义，可以单独创建一个类，如Contans.swift，在此类中声明一些常量

// 判断iPhone4

let iPHONE4_DEV : Bool! = (UIScreen.mainScreen().bounds.size.height == 480) ? true : false;

// 判断iPhone5

let iPHONE5_DEV : Bool! = (UIScreen.mainScreen().bounds.size.height == 568) ? true : false;

// 判断iPhone6

let iPHONE6_DEV : Bool! = (UIScreen.mainScreen().bounds.size.height == 667) ? true : false;

// 判断 iPad

let iPAD_DEV : Bool! = (UIDevice.currentDevice().userInterfaceIdiom == .Pad) ? true : false;

// Swift代码也支持条件编译，

#if iPHONE4_DEV

    // iPhone4设备编译此处

#elseif iPHONE5_DEV

    // iPhone5 设备编译此处

#elseif iPad_DEVICE

    //iPad设备编译此处

#else

    // 其他设备编译此处

#endif