swift 类型推倒 运算符 逻辑运算 解析

2016年7月9日
本章主要内容为 类型推倒 运算符 逻辑运算 解析

print("swift学习第二天内容")

print("typeInference")
/*****************************
 一,数据类型辅助语法
 1, 编译器的类型推导机制
 2, 数据类型的可空机制
 3, 字面常量
 4, 类型转换
 5, 类型别名
 *****************************/
 
 
//typeInference(类型推导)

/*
 编译器的类型推导机制:
 1, 在定义变量时不加类型标注，由初始化的值来推导变量的类型,  右推左
 2, 字面常量赋值给变量时，根据变量标注的类型来推导  左推右
 
 3, 整型字面常量给无类型标注的变量赋值时，会执行默认推导(即为Int)
 4, 浮点字面常量给无类型标注的变量赋值时，会执行默认推导(即Double)
 
 5, 推导的动作发生在编译时,而不是运行时
 解释: 即原来我们需要写类标注再编译
 有了推导，程序员可以省略类型标注，由编译器在编译时加上类型标注
 */

var i:Int = 8
var j = i //j被推导为Int类型

var k = 8//8是一个整型字面常量，默认被推导为Int类型的常量，继而k也被推导为Int类型
var m:Int8 = 8 //8被推导为Int8类型的字面常量
var f = 1.5 //f被推导为Double

/*
 字面常量（literal constant）
 
 整型字面常量:    8    12
 浮点字面常量:    1.5
 字符字面常量:     "A"
 字符串字面常量:    "abc"
 */

/*
 给现有类型取别名的语法:
 typealias   新类型名=现有类型名
 */
typealias x = Int
var y:x = 888 //x是一个新的类型名（newType），本质还代表Int
//var g:x = 88.88//报错原因
//因为x相当于Int，但88.88是浮点字面常量

/*
 类型强转:
 Int8 ->Int16->Int32->Int64->Int
 Int->Float->Double
 */
var i8:Int8 = 8
var i16:Int16 = Int16(i8)//理解为类型强转
//C中强转：   short i16 = short(i8)
//C++中强转： short i16 = short(i8)

/*
 数据类型的可空(可选)机制:
 
 如果某个变量可能为空,即没有实体映射,这个变量必须定义为可空类型
 var wife: Girl = 美女实体
 这个wife不能简定单义为Girl类型,必须为可空的Girl类型: Optional<Girl>,简写为:Girl?
                                    Optional（可选择的，随意的）
 */

var ni:Optional<Int> = 5
var ni1:Int? = 5
//可空的Int类型: Optional<Girl>,简写为:Girl?
print("ni1=\(ni1)")
//输出为：ni1=Optional(5)
print("ni1=\(ni1!)")
//输出为：ni1=5
/*******
nil与null
 *******/
//nil 相当于没有字符，null相当于数值为空
ni1=nil //空，nil表示空，即没有实体
print("赋空后，ni1=\(ni1)")

//var r:Int? = ni1 + 3
//报错：ni1是Int？类型，3是Int类型，两个类型不匹配，不能做加法
//did you mean to use ？你的意思是实用“！”or“？”？
/***************************************************************
 *可空类型的理解:
 *      原来的类型为Int,但是Int必需有值，即不能为空
 *      而 Int? 可以理解为一个包装盒，盒子里可能有Int,可能没Int(为空)
 ***************************************************************/

// 对可选类型做解析才能得到实体，且有可能失败，因为可选类型可能为nil
//此处会导致程序崩溃，因为解析可选失败
//print("ni1=\(ni1!)")   // ! 表示解析可选
//上边ni1的的值为nil(无，零)

//可选类型的原始写法

var nni:Optional<Int> = 5
var fi:Optional<Float> = 1.5
//现在的写法
var nnii:Int? = 5
var fiii:Float? = 1.5

/************************************************
 二, 运算符分类和表达式求值
 1,  算术运算
 2, 关系运算
 3, 逻辑运算
 4, 条件运算符
***************************************************/
/*
    控制流：控制程序执行的流程的语法
    1，顺序执行
    2，条件执行
    3，分支选择
    4，循环执行
 ＊／
／＊
    条件执行：
        1，如果条件满足，就执行某段代码
            if  条件为真    ｛执行代码｝
        2，如果条件满足，就执行代码A，如果不满足就执行代码B
            if 条件为真 {执行代码A｝
            else ｛执行代码B｝
        3，如果条件a满足，就执行代码A
            否则 如果条件b满足，就执行代码B
            否则 如果条件c满足，就执行代码C
            否则 如果 ...
            ...
            否则  ...
            if a { A }
            else if b { B }
            else if c { C }
            else {默认代码｝
*/
/*
    运算符：
        1，算术运算 ＋ － ＊ ／ ％
        2，关系运算 > < >= <= == !=
        3，逻辑运算 与&& 或||  非!
        4，条件运算  ? :
 */

var i1 = 5;
var i2 = 6;
var i3 = i1+i2;  //加法运算,加法运算的结果给到i3   = 表示赋值,  将右边的值赋给左边
print("i3=\(i3)")

var i4 = i1*i2;  //乘法
print("i4=\(i4)")

var i5 = i1/i2;  //除法: 整数除法,结果只保留整数部分
print("i5=\(i5)")

var f1 = 5.0
var f2 = 6.0
var f3 = f1/f2 //浮点除法(数学中的除法)
print("f3=\(f3)")

//求余
var i6 = i1%i2  //5对6求余 ，余5
print("i6=\(i6)")

var f4 = f1%f2 //浮点求余 5.0
print("f4=\(f4)")
//关系运算：运算结果只有真和假

var b1 = i1>i2 //b1的类型为Bool
print("b1=\(b1)")

var b2 = i1<i2
print("b2=\(b2)")

print("b1==b2 is \(b1==b2)")
print("b1!=b2 is \(b1 != b2)")

//逻辑运算
//与 ：
//      A真，B真，则  A&&B为真
//      A和B只要有一个为假，则A&&B为假
var ba = true
var bb = false
print("ba&&bb = \(ba&&bb)")
bb=true
print("bb赋真后,ba&&bb = \(ba&&bb)")

//非真既假，非假既真
print("!ba=\(!ba)")
// 或：
// A和B只要有一个为真，A||B则为真
//条件运算符 （条件 ？ 表达式x :   表达式Y）
//上边的圆括号是一个条件表达式
//如果 条件为真，表达式的值取表达式X的值
//如果 条件为假，表达式的值取表达式Y的值
var ix=5
var iy=4
var bxy:Bool = ix < iy
print("bxy=\(bxy)")
var min = bxy ? ix : iy
print("min=\(min)")

var minn = ix > iy ? ix : iy
print("minn = \(minn)")

//表达式：ix , ix-1 , ix>iy , !ix
          ix = 8
        ix = ix+8 //是一个赋值表达式
print("ix=\(ix)")
        ix += 8
print("ix=\(ix)")

        ix -= 8
print("ix=\(ix)")

        ix *= 8
print("ix=\(ix)")

        ix /= 8
print("ix=\(ix)")
var t=ix=5
//赋值表达式没有值
print("t=\(t)")

var r = arc4random()%3  //arc4random()是生成随机数的函数
                    //%3是限制范围在3以内
print("r=\(r)")
var rx = r%3    //rx 的范围：0，1，2
print("rx=\(rx)")

//if rx==0

var r1 = arc4random()%10
var r2 = arc4random()%10

// if ...else if ...else
if r1>r2{
    print("r1(\(r1))>r2(\(r2))")
}else if r1<r2{
    print("r1(\(r1))<r2(\(r2))")
}else{
    print("r1(\(r1))==r2(\(r2))")
}

/*练习
        随机产生一个随机数：在100以内
        根据分数的范围输出：A B C D E各等级
        ［90-100］ A
        ［80－90］  B
        ［80-70］ C
        ［70-60］ D
        ［60-0］  E
*/
let score = arc4random()%101
print("score=\(score)")
//score一定在100以内
if score>=90{
    print("A")
}else if score>=80{
    print("B")
}else if score>=70{
    print("C")
}else if score>=60{
    print("D")
}else {
    print("E")
}

//对可选类型做条件解析：
var na:Int? = 7
//如果不为空，才解析
//if na != nil{
//    print("na != \(na!)")
//}else{
//    print("na为空，不能解析")
//}

// 解析完，它才可以作为类型计算
// var g =(na!)
var h:Int = 8
var g = h + (na!)
print(g)
//可空类型的绑定解析方式:
if let x = na{
    print("解析成功，x = \(x)")
}