[Swift]运算符、条件语句、循环语句

import UIKit

class HomeViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        /*
         [运算符]
         运算符是一个符号，用于告诉编译器执行一个数学或逻辑运算。
         运算符与参数间，不能一边留空格一边不留空格。
             算术运算符
             比较运算符
             逻辑运算符
             位运算符
             赋值运算符
             区间运算符
             其他运算符
         */
        /*
         [算数运算符]
             运算符      描述
             +          加号
             −          减号
             *          乘号
             /          除号
             %          求余
         */
        var x = 2;
        var y = 8;
        print(x+y);     // 输出：10
        print(x-y,y-x); // 输出：-6 6
        print(x*y);     // 输出：16
        print(x/y,y/x); // 输出：0 4
        print(x%y,y%x); // 输出：2 0
        // swift3 中已经取消了++、--
        x += 1;         // 相当于x++
        y -= 1;         // 相当于y--
        print(x,y);     // 输出：3 7
        
        /*
         [比较运算符]
             运算符      描述
             ==         等于
             !=         不等于
             >          大于
             <          小于
             >=         大于等于
             <=         小于等于
         */
        let i = 1;
        let j = 2;
        print("\(i == j)"); // 输出：false
        print("\(i != j)"); // 输出：true
        print("\(i > j)");  // 输出：false
        print("\(i < j)")   // 输出：true
        print("\(i >= j)"); // 输出：false
        print("\(i <= j)"); // 输出：true
        
        /*
         [逻辑运算符]
             运算符      描述
             &&         与
             ||         或
             !          非
         */
        let a = true;
        let b = false;
        print(a && b);  // 输出：false
        print(a || b);  // 输出：true
        print(!a,!b);   // 输出：false true
        
        /*
         [位运算符]
         位运算符用来对二进制位进行操作。
             运算符      描述
             ~          取反，得到的结果为-(a+1)
             &          按位与
             |          按位或
             ^          按位异或（相同为0，相异为1）
             <<         按位左移,<<1左移一位
             >>         按位右移,>>2右移两位
 
         注意：“取反”与“反码”是两个概念
         [负数的补码]
         补码 = 原码的反码 + 1
         获得原码的反码，不需要对符号位反码。
         
         [正数的补码]
         正数原码、原码的反码和原码的补码是一样的。
         
         [正数取反]
         A = 20用八位二进制来表示：00010100
         每一位取反，得到最终结果的补码：11101011
         根据补码得到最终结果的原码：10010100+1 -> 10010101 -> -21
         
         [负数取反]
         B = -10用八位二进制来表示：10001010
         得到二进制数的补码：11110101+1 -> 11110110
         每一位取反，得到最终结果的补码：00001001
         根据补码得到最终结果的原码：00001001 -> 9
         
         ~A       10010101
         ~B       00001001
         A&B      00000000
         A|B      10011110
         A^B      10011110
         A<<1     00101000
         A<<2     01010000
         A>>1     00001010
         */
        
        /*
         [赋值运算符]
         运算符      描述
         =          简单的赋值运算，指定右边操作数赋值给左边的操作数。
         +=         相加后再赋值
         -=         相减后再赋值
         *=         相乘后再赋值
         /=         相除后再赋值
         %=         求余后再赋值
         <<=        按位左移后再赋值
         >>=        按位右移后再赋值
         &=         按位与运算后赋值
         ^=         按位异或运算符后再赋值
         |=         按位或运算后再赋值
         */
        
        /*
         [区间运算符]
         [闭区间运算符]
            闭区间运算符（a...b）定义一个包含从a到b(包括a和b)的所有值的区间，b必须大于等于a。 ‌
         [半开区间运算符]
            半开区间（a..
         */
        for tInt in 11...22 {
            // 包含22
            print(tInt);
        }
        for sInt in 10..<15 {
            // 不包含15
            print(sInt);
        }
        
        /*
         [其它运算符]
         [一元运算符]
            一元运算符分前置运算符和后置运算符。
            如：-1（一元减）、+1（一元加）、!a、c！（用在Optional类型取值，在Java／C没有类似c！的语法）
         [二元运算符]
            如：1+2、a-b...
         [三元运算符]
            condition ? X : Y
         */
        let m = 3;
        let n = 2;
        print(m<n ?"m<n":"m>n");
        
        /*
         [条件语句]
             if
             if...else
             if...else if...else
             switch
         */
        let tString = "1";
        if (tString == "1") {
            print("tString = \"1\"");
        }
        
        let uInt = 5;
        if (uInt < 5 ) {
            print(" < ");
        } else if (uInt == 5) {
            print(" = ");
        } else {
            print(" > ");
        }
        
        // 在大多数语言中switch语句块中case要紧跟break，否则case之后的语句会顺序运行，而在Swift语言中执行case后默认会结束switch。如果想在Swift中让case之后的语句按顺序继续运行，则需要使用fallthrough语句。
        let mark = 2;
        switch mark {
        case 1:
            print("1");
        case 2:
            print("2");
            fallthrough; // 有fallthrough语句时，只会顺序执行下一个case或default。
        case 3:
            print("3");
        default:
            print("default");
        }
        
        /*
         [循环语句]
             循环类型              描述
             for-in              遍历一个集合里面的所有元素，例如由数字表示的区间、数组中的元素、字符串中的字符。
             for循环              该循环方式在Swift3中已经弃用。
             while循环            运行一系列语句，如果条件为true，会重复运行，直到条件变为false。
             repeat...while循环   类似while语句区别在于判断循环条件之前，先执行一次循环的代码块。
         */
        let intArr:[Int] = [3,6,9];
        for tempX in 1...3 {
            for tempY in intArr {
                let tempVale = tempX * tempY;
                print(tempVale, terminator: ",");    // 输出：3,6,9,6,12,18,9,18,27,
            }
        }
       
        var tempConditional = 1;
        while tempConditional < 10 {
            print(tempConditional, terminator: ","); // 输出：1,2,3,4,5,6,7,8,9,
            tempConditional += 1;
        }
        
        // 相当于C中的do...while
        var tempCon = 1;
        repeat {
            print(tempCon, terminator: ","); // 输出：1,2,3,4,5,6,7,8,9,
            tempCon += 1;
        } while (tempCon < 10);
    }
}