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:
                    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