//
//  main.swift
//  1Switf_基本数据类型
//
//  Created by LZXuan on 16-1-26.
//  Copyright (c) 2015年 LZXuan. All rights reserved.
//


//1.swift 没有main函数
//跟脚本语言很像

//从上自下一次执行 语句

import Foundation

//定义函数 无参无返回值
func test1() {
    //(c c++ java c#  OC等等 的一个产物)
    //
    //打印输出函数
    //带换行的打印
    print("Hello, Switf!")
    
    //swift 语句 不需要加';'
    //下面的打印函数 不带换行
    print("hello,swift", terminator: "")
}
//执行函数中的代码 那么需要调用函数
//test1()

//2.数据类型
//2.1定义常量
func test2() {
    //定义一个常量  常量必须要初始化
    //定义常量格式  ->  let 常量名:类型 = 值
    
    //定义一个整型常量
    let age:Int = 24
    //定义一个浮点数
    let f:Double = 3.14
    //定义字符类型
    let c:Character = "x"
    
    //打印输出
    print(age)
    print(f)
    print(c)
    //可以这样来进行格式化输出一个常量或者变量的值
    print("age = \(age)")//类似于C语言的格式化字符串
    print("f = \(f)")
    print("c = \(c)")
    
    //swift 具有类型推断的功能 可以根据后面的值推断出 常量或者变量的类型
    let a = 100//a 就是Int 类型
    
    let 女汉子 = "女汉子"
    print(女汉子)
}
//test2()

//2.2 变量
func test3() {
    
//    var 变量名:类型
    
    //定义一个整型变量 可以初始化也可以不初始化 一般都要初始化
    
    var a:Int
    
    let b:Int16 = 12
    print(b)
    
    //swift 变量名 实际上 是按照unicode
    //变量名/常量名可以是汉字
    
    
    let 汉 = 123
    
    print("汉:\(汉)")
    
}
//test3()
//3.溢出
func test4() {
    //给a 一个UInt32 的最大值
    var a:UInt32 = UInt32.max;
    
    //swift 变量发生溢出这里会报错
    //var b = UInt32.max+1
    
}
//4.强制类型转换
func test5() {
    let a:Double = 1.23
    let b:Int = 2
    
    //swift不支持隐式转换
    //var d:Double  = a+b
    //var c:Double = b
    //不同的数据类型之间 不能直接运算， 如果要运算必须要强转
    
    //类型() 强制类型转换
    
    //把变量b的值得类型 临时强制转换为Double
    let d:Double = a+Double(b)
    
    print("d= \(d)")
}
//test5()

//5.布尔值
//swift 引入了真正的布尔 true  flase 和c++ 类似
//if 表达式中 必须是布尔值 或者 表达式的值是布尔
func test6() {
    //布尔值 只有true 和flase 两个值
    let b:Bool = true
    
    print(b)
    
    //可以用于if结构
    
    if(true) {//if  后面的表达式只能是布尔值
        print("if结构")
    }
    if(b) {//if  后面的表达式只能是布尔值
        print("if结构")
    }
    let c:Int = 3
    if(c == 3) {//if  后面的表达式只能是布尔值
        print("if结构")
    }
    /* 表达式的值必须是布尔值
    if(c = 5) {//if  后面的表达式只能是布尔值
        println("if结构")
    }*/
    
}
//test6()

//6.元组
//元组 (30,”xiaohong”) 多个相同数据类型或者不同的数据类型 组合在一起  这就是一个元组
func test7() {
    //元组类型 就是(类型1,类型2,....)
    //元组不需要定义直接使用
    //第一种形式 (类型推断) 元组常量 stu1   ->(String,Int,Double)
    let stu1 = ("xiaohong",24,99.1)
    print(stu1)
   
    //获取元组中的元素
    let name = stu1.0
    let age = stu1.1
    let score = stu1.2
    //索引 是从0开始 访问
    print("name:\(name) age:\(age) score:\(score)")
    
    //定义第二种形式的元组常量
    //定义 元素的类型  要按照 String Double Int 顺序进行赋值
    let stu2:(String,Double,Int) = ("xiaohuang",3.14,24)
    
    //第三种形式定义元素  赋值的时候加标签
    let stu3 = (name:"xiaohuang",score:3.14,age:24)

    //通过标签访问元素
    print("\(stu3.name)-\(stu3.score)-\(stu3.age)")
}
//test7()

//8.可选值类型
/*
可选值  swift 特有
optionals  有一个值 或者没有值  像布尔值

//两种状态  有值  没有值/nil
*/
func test8() {
    //定义一个可选值
    //?必须要紧跟类型  和 类型之间不能 有空格 
    //var op1:Int ? = 100 //错误
    
    //有值
    let op1:Int? = 100
    
    //没有值
    let op2:Int? = nil
    //或者
//    var op2:Int?
    
    
    print("op1:\(op1)")
    print("op2:\(op2)")
    
    
    //要想得到可选值变量中的值 那么需要进行解包(强制解析)
    //可选值变量+!
    
    let num:Int = op1!//解包 获取可选值 op1中的值
    //解包时必须要有值 否则会崩溃
    print("num = \(num)")
    
    
    
}
//test8()