Swift 3.0 基础部分

一、变量和常量
1、变量 : 使用var来声明一个变量,你可以更改现有的变量值为其他同类型的值
2、常量： 使用let来声明一个常量,与变量不同，常量的值一旦被确定就不能更改了
3、命名规则: 你可以用任何你喜欢的字符作为常量和变量名，包括 Unicode 字符,但是常量与变量名不能包含数学符号，箭头，保留的（或者非法的）Unicode 码位，连线与制表符,也不能以数字开头。

定义一个如下变量并输出变量值:

var variable = "Hello Swift";
print(variable);

输出如下:

Hello Swift

你会发现，为什么定义变量却没有声明变量的类型而且编译通过了？继续往下看就明白了。

二、类型推断
解释 : 在定义一个变量或常量的时候，如果你没有显式指定类型，Swift 会使用类型推断来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。
例如: 我给上面的variable变量再次赋值 variable = 15；这行代码编译是不通过的
注意: variable被赋值成”Hello Swift”后,编译器将variable通过监听赋值类型，将variable定义成String类型。再次修改variable 的值必须也是String类型，否则编译报错。
如果你没有给浮点字面量标明类型，Swift 会推断你想要的是 Double。

例如:

let meaningOfLife = 42
// meaningOfLife 会被推测为 Int 类型

当推断浮点数的类型时，Swift 总是会选择 Double 而不是Float。

let pi = 3.14159
// pi 会被推测为 Double 类型

如果表达式中同时出现整数和浮点数，会被推测为Double类型

let sum = 3 + 0.14159;
// sum 会被推测为 Double 类型

因为有类型推断，和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。当你声明常量或者变量并赋初值的时候类型推断非常有用。当你在声明常量或者变量的时候赋给它们一个字面量（literal value 或 literal）即可触发类型推断。

三、输出函数print()

print(items: Any..., separator: String, terminator: String)

其中 ：
items : 0项或者多项的打印输出
separator ： item 之间的分割符，默认是单个空格分割,即 ” ”
terminator ： print结束的标识符，默认是”\n”

四、类型标注
当你声明常量或者变量的时候可以加上类型标注（type annotation），说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。
注意: 如果初始值没有提供足够的信息（或者没有初始值），那你需要在变量后面声明类型，用冒号:分割。
例如:

var message: String;
message = "weclome to Swift !";
print(message);

五、字符串插值
Swift 用字符串插值（string interpolation）的方式把常量名或者变量名当做占位符加入到长字符串中，Swift 会用当前常量或变量的值替换这些占位符。将常量或变量名放入圆括号中，并在开括号前使用反斜杠将其转义。
例如:

let multiplier = 3
print("\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)")

输出结果:

3 times 2.5 is 7.5

注意 : 值永远不会被隐式转换为其他类型。如果你需要把一个值转换成其他类型，请显式转换。上面把 multiplier 显示转化成 Double 类型。

六、注释
1、当行注释 : // 这是一个单行注释
2、多行注释: /*这是一个多行注释*/
3、嵌套注释 : Swift 的多行注释可以嵌套在其它的多行注释之中

/*  这是第一个多行注释开头

 /*这是第二个被嵌套的多行注释*/

 这是第一个多行注释的结尾*/

七、分号
与其他大部分编程语言不同，Swift 并不强制要求你在每条语句的结尾处使用分号（;），当然，你也可以按照你自己的习惯添加分号。但是，有一种情况下必须要用分号，即你打算在同一行内写多条独立的语句。

八、基本数据类型部分
< 一 > 整型 (Int)
1、整型 : 是指没有小数部分的数字
2、分类 ： 有符号整型（正、零、负）Int 和 无符号整型（零、正）UInt
3、Swift 提供了8、16、32、64的有符号和无符号整型，你可以访问不同整数类型的 min 和 max 属性来获取对应类型的最小值和最大值，一般来说使用 Int 就够了。

let minValue = Int.min;
let maxValue = Int.max;
print(minValue,maxValue,separator:"->");

输出结果:

-9223372036854775808->9223372036854775807

< 二 > 浮点数 (Double)
1、浮点数 ： 浮点数是有小数部分的数字
2、分类 ： Double 表示64位浮点数 和 Float 表示32位浮点数
注意 ： Double精确度很高，至少有15位数字，而Float只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围，在两种类型都匹配的情况下，将优先选择 Double。

< 三 > 整数和浮点数之间的转化

整数和浮点数的转换必须显式指定类型

整数转化成浮点数

let three = 3;
let pointFloat = 0.14149;
let PI = Double(three)+pointFloat;

浮点数转化成整数

//同样的，浮点型也可转化成整形(注意: NSInteger 在Swift并不是关键字)
let NSInteger = Int(PI);
//integerPi 等于 3，所以被推测为 Int 类型,但是当用这种方式来初始化一个新的整数值时，浮点值会被截断。

< 四 > 类型别名 (typealias)
类型别名（type aliases）就是给现有类型定义另一个名字。你可以使用typealias关键字来定义类型别名。当你想要给现有类型起一个更有意义的名字时，类型别名非常有用。

typealias int = Int;  // 注意 ： int在Swift不是关键字
let intValue = int.max;
print(intValue);

< 五 > 布尔类型 (Bool)
布尔值指逻辑上的值，因为它们只能是真或者假。Swift 有两个布尔常量，true 和 false

let isTrue  = true;
let isFlase = false;

< 六 > 元组 (Tuples)
1、定义 ： 把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。
2、注意：
1） 作为函数返回值时，元组非常有用。
2) 元组在临时组织值的时候很有用，但是并不适合创建复杂的数据结构

/定义一个类型是 (Int, String)，值是 (404, "Not Found")元组
let httpsError = (404,"Not Found");
let (statusCode, statusMessage) = httpsError;
print("The status code is \(statusCode)");
// 输出 "The status code is 404"
print("The status message is \(statusMessage)");
// 输出 "The status message is Not Found"

//如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线"_"标记
let (justTheStatusCode,_) = httpsError;
print("The status code is \(justTheStatusCode)")
// 输出 "The status code is 404"


// 还可以通过下标访问元组中的单个元素
print("The status code is \(httpsError.0)")
// 输出 "The status code is 404"
print("The status message is \(httpsError.1)")
// 输出 "The status message is Not Found"


//你还可以在定义元组的时候，给单个元素命名
let http200Status = (statusCode: 200, description: "OK");
print("The status code is \(http200Status.statusCode)")
// 输出 "The status code is 200"
print("The status message is \(http200Status.description)")
// 输出 "The status message is OK"

< 七 > 可选类型(optionals)
1、简单表示为 ： 有值，等于 x或则没有值（值缺失）
我们可以简单看个例子

let possibleNumber = "123";
//converNumber 被推测为类型 "Int?"， 或者类型 "optional Int"
let converNumber = Int(possibleNumber);
print("可选类型:\(converNumber)");

输出结果 :

可选类型:Optional(123)

解释 ： Swift 的 Int 类型有一种构造器，作用是将一个 String 值转换成一个 Int 值。然而，并不是所有的字符串都可以转换成一个整数。字符串 “123” 可以被转换成数字 123 ，但是字符串 “hello, world” 不行。

2、那么。如果获取可选类型的值呢?
可选值的强制解析:当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。
注意: 使用 ! 来获取一个不存在的可选值会导致运行时错误。所以，使用 ! 来强制解析值之前，一定要确定可选包含一个非 nil 的值。

print("可选类型:\(converNumber!)")

输出结果 ：

可选类型:123

再看一个例子：

let randomString = "hello, world";
let converString = Int(randomString);
print("可选类型:\(converString)");

输出结果：

可选类型:nil

3、 关于nil
你可以给可选变量赋值为nil来表示它没有值

var serverResponseCode: Int? = 404
// serverResponseCode 包含一个可选的 Int 值 404
serverResponseCode = nil
// serverResponseCode 现在不包含值

如果你声明一个可选常量或者变量但是没有赋值，它们会自动被设置为 nil

var surveyAnswer: String?
// surveyAnswer 被自动设置为 nil

注意 ：
nil不能用于非可选的常量和变量。如果你的代码中有常量或者变量需要处理值缺失的情况，请把它们声明成对应的可选类型。任何类型的可选状态都可以被设置为 nil，不只是对象类型。

4、可选绑定
使用可选绑定（optional binding）来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在 if 和 while 语句中，这条语句不仅可以用来判断可选类型中是否有值，同时可以将可选类型中的值赋给一个常量或者变量。

if let number = Int("50"){

    // 不需要通过强制解析来获取可选类型的值
    // 在 if 条件语句中使用常量和变量来创建一个可选绑定，仅在 if 语句的句中(body)中才能获取到值。
    print("可选值:\(number)");

}

if let firstNumber = Int("4"){

    if let secondNumber = Int("15"){

        if firstNumber < secondNumber{

            print("\(firstNumber) < \(secondNumber)");
        }
    }
}

输出结果:

可选值:50
4 < 15

5、隐式可选类型
如上所述，可选类型暗示了常量或者变量可以“没有值”。可选可以通过 if 语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。
有时候在程序架构中，第一次被赋值之后，可以确定一个可选类型总会有值。在这种情况下，每次都要判断和解析可选值是非常低效的，因为可以确定它总会有值。
这种类型的可选状态被定义为隐式解析可选类型（implicitly unwrapped optionals）。把想要用作可选的类型的后面的问号（String?）改成感叹号（String!）来声明一个隐式解析可选类型。
当可选类型被第一次赋值之后就可以确定之后一直有值的时候，隐式解析可选类型非常有用。隐式解析可选类型主要被用在 Swift 中类的构造过程中，请参考无主引用以及隐式解析可选属性。
一个隐式解析可选类型其实就是一个普通的可选类型，但是可以被当做非可选类型来使用，并不需要每次都使用解析来获取可选值。下面的例子展示了可选类型 String 和隐式解析可选类型 String 之间的区别：

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // 需要感叹号来获取值

let assumedString: String! = "An implicitly unwrapped optional string."
let implicitString: String = assumedString  // 不需要感叹号



// 你仍然可以把隐式解析可选类型当做普通可选类型来判断它是否包含值
if assumedString != nil{

    print("assumedString is  \(assumedString!)");

}

// 你也可以在可选绑定中使用隐式解析可选类型来检查并解析它的值
if let explainNumber = assumedString{

      print("assumedString is  \(explainNumber)");
}

输出结果：

assumedString is  An implicitly unwrapped optional string.
assumedString is  An implicitly unwrapped optional string.