本文来自Swift中文开发组，感谢翻译者的分享。

本文将分几部分对Swift对ios的语法做讲解。本文为第一节，主要讲解基础语法。

常量和变量

声明常量和变量

常量和变量必须在使用前声明，用let来声明常量，用var来声明变量。下面的例子展示了如何用常量和变量来记录用户尝试登录的次数：

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

你可以在一行中声明多个常量或者多个变量，用逗号隔开：

var x = 0.0,y = 0.0,z = 0.0 

注意：如果你的代码中有不需要改变的值，请使用let关键字将它声明为常量。只将需要改变的值声明为变量。

类型标注

var welcomeMessage: String 

welcomeMessage = "Hello" 

注意：一般来说你很少需要写类型标注。如果你在声明常量或者变量的时候赋了一个初始值，Swift可以推断出这个常量或者变量的类型，请参考类型安全和类型推断。在上面的例子中，没有给welcomeMessage赋初始值，所以变量welcomeMessage的类型是通过一个类型标注指定的，而不是通过初始值推断的。

常量和变量的命名

你可以用任何你喜欢的字符作为常量和变量名，包括 Unicode 字符：

let π = 3.14159
let 你好 = "你好世界"

注意：如果你需要使用与Swift保留关键字相同的名称作为常量或者变量名，你可以使用反引号（`）将关键字包围的方式将其作为名字使用。无论如何，你应当避免使用关键字作为常量或变量名，除非你别无选择。

你可以更改现有的变量值为其他同类型的值，在下面的例子中，friendlyWelcome的值从"Hello!"改为了"Bonjour!":

var friendlyWelcome = "Hello!"
friendlyWelcome = "Bonjour!"
// friendlyWelcome 现在是 "Bonjour!" 

与变量不同，常量的值一旦被确定就不能更改了。尝试这样做会导致编译时报错：

let languageName = "Swift"
languageName = "Swift++"
// 这会报编译时错误 - languageName 不可改变 

输出常量和变量

你可以用println函数来输出当前常量或变量的值:

println(friendlyWelcome) // 输出 "Bonjour!" 

println("This is a string") // 输出 "This is a string" 

println("The current value of friendlyWelcome is \(friendlyWelcome)")
// 输出 "The current value of friendlyWelcome is Bonjour! 

注意：字符串插值所有可用的选项，请参考字符串插值。

注释

// 这是一个注释

你也可以进行多行注释，其起始标记为单个正斜杠后跟随一个星号(/*)，终止标记为一个星号后跟随单个正斜杠(*/)

/* 这是一个,多行注释 */

与C 语言多行注释不同，Swift 的多行注释可以嵌套在其它的多行注释之中。你可以先生成一个多行注释块，然后在这个注释块之中再嵌套成第二个多行注释。终止注释时先插入第二个注释块的终止标记，然后再插入第一个注释块的终止标记：

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

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

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

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

let cat = "

整数

你可以访问不同整数类型的min和max属性来获取对应类型的最大值和最小值：

let minValue = UInt8.min // minValue 为 0，是 UInt8 类型的最小值
let maxValue = UInt8.max // maxValue 为 255，是 UInt8 类型的最大值 

Int

• 在32位平台上，Int和Int32长度相同。
• 在64位平台上，Int和Int64长度相同。

注意：尽量不要使用UInt，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用Int，即使你要存储的值已知是非负的。统一使用Int可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推测，请参考类型安全和类型推测。

浮点数

注意：Double精确度很高，至少有15位数字，而Float最少只有6位数字。选择哪个类型取决于你的代码需要处理的值的范围。

类型安全和类型推测

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

同理，如果你没有给浮点字面量标明类型，Swift 会推测你想要的是Double：

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

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

let decimalInteger = 17
let binaryInteger = 0b10001 // 二进制的17
let octalInteger = 0o21 // 八进制的17
let hexadecimalInteger = 0x11 // 十六进制的17 

let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0 

数值类字面量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字面量：

let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1 

数值型类型转换

不同整数类型的变量和常量可以存储不同范围的数字。Int8类型的常量或者变量可以存储的数字范围是-128~127，而UInt8类型的常量或者变量能存储的数字范围是0~255。如果数字超出了常量或者变量可存储的范围，编译的时候会报错：

let cannotBeNegative: UInt8 = -1 // UInt8 类型不能存储负数，所以会报错
let tooBig: Int8 = Int8.max + 1 // Int8 类型不能存储超过最大值的数，所以会报错 

let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one) 

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

let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
// pi 等于 3.14159，所以被推测为 Double 类型 

let integerPi = Int(pi) // integerPi 等于 3，所以被推测为 Int 类型 

类型别名

typealias AudioSample = UInt16 

定义了一个类型别名之后，你可以在任何使用原始名的地方使用别名：

var maxAmplitudeFound = AudioSample.min // maxAmplitudeFound 现在是 0 

Swift 有一个基本的布尔(Boolean)类型，叫做Bool。布尔值指逻辑上的(logical)，因为它们只能是真或者假。Swift 有两个布尔常量，true和false：

let orangesAreOrange = true
let turnipsAreDelicIoUs = false 

if turnipsAreDelicIoUs {
    println("Mmm,tasty turnips!")
} else {
    println("Eww,turnips are horrible.")
}
// 输出 "Eww,turnips are horrible." 

let i = 1 if i { // 这个例子不会通过编译，会报错 } 

然而，下面的例子是合法的：

let i = 1 if i == 1 { // 这个例子会编译成功 } 

let http404Error = (404,"Not Found") // http404Error 的类型是 (Int,String)，值是 (404,"Not Found") 

let (statusCode,statusMessage) = http404Error
println("The status code is \(statusCode)")
// 输出 "The status code is 404"
println("The status message is \(statusMessage)")
// 输出 "The status message is Not Found" 

如果你只需要一部分元组值，分解的时候可以把要忽略的部分用下划线（_）标记：

let (justTheStatusCode,_) = http404Error
println("The status code is \(justTheStatusCode)")
// 输出 "The status code is 404" 

此外，你还可以通过下标来访问元组中的单个元素，下标从零开始：

println("The status code is \(http404Error.0)") // 输出 "The status code is 404"
println("The status message is \(http404Error.1)") // 输出 "The status message is Not Found"

你可以在定义元组的时候给单个元素命名：

let http200Status = (statusCode: 200,description: "OK") 

给元组中的元素命名后，你可以通过名字来获取这些元素的值：

println("The status code is \(http200Status.statusCode)") // 输出 "The status code is 200"
println("The status message is \(http200Status.description)") // 输出 "The status message is OK" 

可选

注意：C 和 Objective-C 中并没有可选这个概念。最接近的是 Objective-C 中的一个特性，一个方法要不返回一个对象要不返回nil，nil表示“缺少一个合法的对象”。然而，这只对对象起作用——对于结构体，基本的 C 类型或者枚举类型不起作用。对于这些类型，Objective-C 方法一般会返回一个特殊值（比如NSNotFound）来暗示值缺失。这种方法假设方法的调用者知道并记得对特殊值进行判断。然而，Swift 的可选可以让你暗示任意类型的值缺失，并不需要一个特殊值。

let possibleNumber = "123"
let convertedNumber = possibleNumber.toInt()
// convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int" 

if convertedNumber {
    println("\(possibleNumber) has an integer value of \(convertedNumber!)")
} else {
    println("\(possibleNumber) could not be converted to an integer")
}
// 输出 "123 has an integer value of 123" 

if let constantName = someOptional { statements } 

if let actualNumber = possibleNumber.toInt() {
    println("\(possibleNumber) has an integer value of \(actualNumber)")
} else {
    println("\(possibleNumber) could not be converted to an integer")
}
// 输出 "123 has an integer value of 123" 

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

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

let possibleString: String? = "An optional string."
println(possibleString!) // 需要惊叹号来获取值
// 输出 "An optional string."
let assumedString: String! = "An implicitly unwrapped optional string."
println(assumedString) // 不需要感叹号
// 输出 "An implicitly unwrapped optional string." 

你仍然可以把隐式解析可选当做普通可选来判断它是否包含值：

if assumedString {
    println(assumedString) 
}
// 输出 "An implicitly unwrapped optional string." 

你也可以在可选绑定中使用隐式解析可选来检查并解析它的值：

if let definiteString = assumedString { 
    println(definiteString) 
} 
// 输出 "An implicitly unwrapped optional string." 

注意：如果一个变量之后可能变成nil的话请不要使用隐式解析可选。如果你需要在变量的生命周期中判断是否是nil的话，请使用普通可选类型。