1. 简单值
使用let声明常量 ： 一个常量的值在编译时并不需要获取，但是只能为它赋值一次。（你只需要决定一次，但是需要使用很多次）。
使用var声明变量
使用时，常量或者变量的类型必须和你赋给它们的值一样。
var myNumber = 250
myNumber = 13
let myNumber = 250 //这里myNumber是整数（integer）
当 初始值 没有提供足够的信息 （或者没有初始值），需要在变量后面声明类型，用冒号分割。
let implicitInteger = 50
let implicitDouble = 50.0
let explicitDouble:Double = 70 (显式)
值永远不会被隐式转换为其他类型。若需要把一个值转换成其他类型，请显式转化。
let label = "The width is" //判断是字符串
let width = 94 //判断是数字
let widthLabel = label + String(width); //显式 数字转化为字符串
println(label);
使用\() 转化
let apples = "apples"
let oranges = "oranges"
let myApples = "5 \(apples)"
println(myApples);
使用 : 加 空格 加类型名在变量货常量名之后可以完成类型注解
var welcomeMessage: String
声明一个叫welcomeMessage的变量，类型是String
常量和变量的命名
swift可以使用几乎任何字符来作为常量和变量包括Unicode
let π = 3.14149
let 你好 = "你好世界"
但是名称中不能含有数字符号，箭头，无效的unicode，横线和制表符且不能以数字开头。数字可以包含在名称里。一旦完成声明，就不能再次声明相同名称的变量或常量，或者改变它的类型。变量和常量也不能互换。
swift在字符串中插入变量名作为占位符，使用反斜杠\和小括号来提示swift替换变量/常量名为其实际的值
var friendlyWelcome = "hello"
friendlyWelcome = "Bonjour"
println("the current value of friendlyWelcome is \(friendlyWelcome)")
整数边界
使用min或者max值来获取改类型的最大值最小值
let minValue = UInt8.min
let maxValue = UInt8.max
println("min is \(minValue) max is \(maxValue)")
//min is 0 max is 255
浮点数
double比float精度更高
数值量表达
十进制不带前缀
二进制带前缀0b
八进制带前缀0o
十六进制带前缀0x
let decimalInteger = 17
let binaryInteger = 0b10001 // 17 in binary notation
let octalInteger = 0o21 // 17 in octal notation
let hexadecimalInteger = 0x11 // 17 inhexadecimal notation
println(binaryInteger)
浮点文本可以是十进制（不带前缀）或十六进制（以0x前缀）。它们必须始终具有在小数点的两侧（或十六进制数）。他们也可以有一个可选的指数，由一个大写或小写e表示十进制浮点数表示，或大写或小写p表示十六进制浮点数
let a = 25e2 //表示25乘以10的2次方
let b = 0xFp2 //表示15乘以2的2次方
let c = 0xFp-2 // 表示15乘以2的负2次方
println(a,b,c) //(2500.0, 60.0, 3.75)
数字文本可以包含额外的格式，使它们更容易阅读。这两个整数和浮点数可以被额外的零填充，并且可以包含下划线，以帮助可读性。无论类型的格式不影响变量的值：
let aa = 1_000_000.000_000
println(aa) //1000000.0
let twoThousand: UInt = 16
let one: UInt = 16
let three = twoThousand + one
println(three) //32
let twoThousand: UInt8 = 16
let one: UInt = 16
let three = UInt(twoThousand) + one
//println(three) //32
let q = 3
let p = 0.14159
let qi = q + Int(p)
let pi = Double(q) + p
println(qi) //3
println(pi) //3.14159
类型别名
类型别名为现有类型定义的代替名称，可以使用typealias关键字定义类型别名。当使用的类型名称更符合上下文时，可以定义如：
typealias AudioSample = UInt16
一旦定义了一个类型别名，你可以在任何会使用原来的名称地方使用别名：
var maxAmplitudeFound = AudioSample.min
AudioSample被定义为一个UInt16的别名。因为它是一个别名，调用AudioSample.min实际上是调用了UInt16.min，给maxAmplitudeFound变量赋初始值0
BOOL类型
Swift中的BOOL值分别是true和false
let something = false
if something{
println("abcdefg")
}else{
println("hijklmn")
}
Swift的类型安全策略会纺织其他非BOOL类型转换为BOOL类型使用，比如
let something = 1
if something{
println("abcdefg")
}else{
println("hijklmn")
}
报错： Type 'Int' does not conform to protocol 'LogicValue'
修改后即可运行：
let something = 1
if something == 1{
println("abcdefg")
}else{
println("hijklmn")
}
元组类型
元组类型可以将一些不同的数据类型组装成一个元素，这个元素可以用来作为函数的返回值返回包含很多种数据类型的值。
let http404Error = (404,"Not Found")
println(http404Error) 可以通过如下方式分别访问一个元组的值
let http404Error = (404,"Not Found")
let (statusCode, statusMessage) = http404Error
println("the status code is \(statusCode)")
//the status code is 404
如果仅需要元组中的个别值，可以使用（_）来忽略不需要的值
let myExample = (1, 2, "baby","boy")
let (example1, _ ,_ ,_) = myExample
let (_,example2,_,_) = myExample
let (_,_,example3,_) = myExample
let (_,_,_,example4) = myExample
println("the example is \(example1)") //the example is 1
println("the example is \(example2)") //the example is 2
println("the example is \(example3)") //the example is baby
println("the example is \(example4)") //the example is boy也可以使用元素序号来选择元组中的值，注意序号是从0开始的
println("the example5 is \(myExample.1)") //the example is 2
println("the example6 is \(myExample.3)") //the example is boy
在创建一个元组的时候，也可以直接指定每个元素的名称，然后直接使用元组名.元素名访问。如：
let myExample = (num1:1,num2:2,str1:"baby",str2:"boy")
println(myExample.num2) //2
可选类型
在一个值可能不存在的时候，可以使用可选类型。这种类型的定义是，要么存在这个值，且等于x，要么不存在这个值。
这个类型在C和OC中是不存在的，但是OC里有个相似的类型，叫nil，但仅仅对对象有用。
举栗：
在Swift中String类型有一个叫toInt的方法，能够将一个字符串转化为一个int类型。但是需要注意的是，不是所有字符都可以转化成为整数。"123"可以转化成123，"hello"不能被转化。
let possibleNumber = "123"
let convertedNumber = possibleNumber.toInt()
println(convertedNumber) //123
let possibleNumber = "hello"
let convertedNumber = possibleNumber.toInt()
println(convertedNumber) //nil由于toInt方法可能会失败，因此它会返回一个可选的Int类型，而不同于Int类型，一个可选的Int类型被记为Int？
问号表名它的值是可选的，可能返回的是一个Int，或者返回的值不存在
可以使用if语句来检测一个可选类型包含一个特定的值，如果一个可选类型确实包含了一个值，在if语句中它将返回true，否则返回false。如果你已经检测确认该值存在，那么可以使用或者输出它，在输出的时候只需要在名称后面加上感叹号(!)即可，意思是告诉编译器：我已经检测好这个值了，可以使用它了。
let possibleNumber = "123"
let convertedNumber = possibleNumber.toInt()
if convertedNumber {
println("\(possibleNumber) has a integer value of \(convertedNumber!)")
}else{
println("\(possibleNumber) could not be converted to a integer")
}
//123 has a integer value of 123
let possibleNumber = "hello"
let convertedNumber = possibleNumber.toInt()
if convertedNumber {
println("\(possibleNumber) has a integer value of \(convertedNumber!)")
}else{
println("\(possibleNumber) could not be converted to a integer")
}
//hello could not be converted to a integer
选择性绑定
使用一个变量或者常量来绑定一个可选类型，在if和while语句中，来检查该值是否存在，然后在继续使用它。绑定方法如下：
let possibleNumber = "hello"
if let actualNumber = possibleNumber.toInt(){
println("\(possibleNumber) has a integer value of \(actualNumber)")
}else{
println("\(possibleNumber) could not be converted to a integer")
}
//hello could not be converted to a integer
let possibleNumber = "123"
if let actualNumber = possibleNumber.toInt(){
println("\(possibleNumber) has a integer value of \(actualNumber)")
}else{
println("\(possibleNumber) could not be converted to a integer")
}
//123 has a integer value of 123
当判断optional 为nil是返回false，当不为nil时返回true
可以给可选类型指定一个特殊的值nil：
var serverRespomseCode: Int? = 404
println(serverRespomseCode) //404
serverRespomseCode = nil
println(serverRespomseCode) //nil如果定义了一个可选类型并且没有给初始值时，会默认设置为nil
var surveyAnswer:String?
println(surveyAnswer) //nil
注: Swift 的nil不同于Object-C中的nil. Object-C中，nil是一个指针指向不存在的对象。Swift中，nil不是指针而是一个特定类型的空值。任何类型的可选变量都可以被设为nil，不光是指针。
隐式强制使用可选类型
上面的例子中，可选类型表示一个常量/变量可以没有值。可选类型可以被if语句检测是否有值，并且可以被可选绑定解包。
但是在一些情况下，可选类型是一直有效的，那么可以通过定义来隐式地去掉类型检查，强制使用可选类型。这些可选类型被成为隐式解包的可选类型。可以直接在类型后面加! 而不是？来指定。
隐式解包的可选类型本质是可选类型，但是可以被当成一般类型来使用，不需要每次验证值是否存在。
let possibleString: String? = "An optional string"
println(possibleString!)
let assumedString: String! = "An implicitily unwrapped optional string"
println(assumedString)
直接在变量后面加上!，String!，这样可以确保该值一定存在。
使用断言
只有在满足特定条件的时候，代码才会继续执行。
使用断言调试：
断言是一种实时检测条件是否为true的方法。
如果这个条件是false，那么代码将会终端执行。
在Xcode中，在调试的时候如果终端，可以通过查看调试语句来找出问题所在。
使用全局函数assert来使用断言调试，如：
let age = 3
assert(age <= 0,"abc")
//assertion failed: abc: /.../main.swift, line 141为了方便测试学习，先学习如何创建一个视图控制器
----------------------------------------------------------------------------------ViewController
appDelegate.swift//创建一个<span style="font-size:18px;">视图</span>控制器
let test_vc = TestController();//设置self.windows根<span style="font-size:18px;">视图</span>控制器
self.window!.rootViewController = test_vc;
Test.swiftimport Foundation
import UIKit
class TestController:UIViewController
{
override func viewDidLoad()
{
super.viewDidLoad();
}
}
----------------------------------------------------------------------------------ViewController
