swift——基础数据类型

常量和变量的声明:

let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0

声明一个叫maximumNumberOfLoginAttempts的值为10的常量。

声明一个变量currentLoginAttempt初始值为0。

在这个例子中，最大的登录尝试次数10是不变的，因此声明为常量。而已经登录的尝试次数是可变的，因此定义为变量。

也可以在一行中声明多个变量或常量，用,号分隔：

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

在声明常量和变量时，可以使用注解来注明该变量或常量的类型。

使用" : + 空格 + 类型名" 在变量或常量名之后就可以完成类型注解。

下面的例子就是声明了一个变量叫welcomeMessage，注解类型为字符串String：

var welcomeMessage: String

冒号:在这的作用就像是在说：…是…类型的，因此上述代码可以理解为：

注：实际编程中很少需要使用类型注解，定义常量或者变量的时候Swift已经根据初始化的值确定了类型信息。

Swift几乎都可以隐式的确定变量或常量的类型，详见： Type Safety and Type Inference。

而上面的welcomeMessage的例子中：

初始化值没有被给出，所以更好的办法是指定welcomeMessage变量的类型而不是让Swift隐式推导类型。

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

但是名称中不能含有：

1. 数学符号，
2. 箭头，
3. 无效的Unicode，
4. 横线-和制表符，
5. 且不能以数字开头，尽管数字可以包含在名称里。

变量和常量也不能互换。

var friendlyWelcome = “hello!”
friendlyWelcome = “Bonjour!”
// friendlyWelcome is now “Bonjour!”

与变量不同的是，常量的值一旦确定就不能修改。如果想尝试改变一个常量的值，编译代码时就会报错

let languageName = “Swift”
languageName = “Swift++”
// this is a compile-time error – languageName cannot be changed

输出常量和变量

println(friendlyWelcome)
// prints “Bonjour!”

println函数一般输出一个字符串

println("This is a string")
// prints "This is a string"

println函数还可以格式化输出一些日志信息，就像是Cocoa中NSLog函数的行为一样，可以包括一些常量和变量本身。

Swift在字符串中插入变量名作为占位符，使用反斜杠和小括号()来提示Swift替换变量/常量名为其实际的值，如：

println(“The current value of friendlyWelcome is (friendlyWelcome)”) 
// prints “The current value of friendlyWelcome is Bonjour!”

2、注释

不参与编译的语句称为注释，注释可以提示你代码的意图。Swift中的注释和C语言中的一样

单行注释

//this is a comment

/* this is also a comment,but written over multiple lines */

/* this is the start of the first multiline comment
/* this is the second,nested multiline comment */
this is the end of the first multiline comment */

let cat = ""; println(cat)
// prints ""

整数就是像42和-23这样不带分数的数字，包括有符号（正数，负数，0）和无符号（正数，0）。

Swift提供了8、16、32和64位的数字形式，和C语言类似，可以使用8位的无符号整数UInt8，或者32位的整数Int32。像其他Swift类型一样，这些类型名的首字母大写。

let minValue = UInt8.min // minValue is equal to 0,and is of type UInt8
let maxValue = UInt8.max // maxValue is equal to 255,and is of type UInt8

Swift是一种类型安全的语言。

类型安全就是说在编程的时候需要弄清楚变量的类型。如果您的代码部分需要一个字符串，你不能错误地传递一个整数类型。

let meaningOfLife= 42
// meaningOfLife is inferred to be of typeInt

let pi = 3.14159
// pi is inferred to be of type Double

let anotherPi= 3 + 0.14159
// anotherPi is also inferred to be of typeDouble

let decimalInteger= 17
let binaryInteger = 0b10001 // 17 in binary notation
let octalInteger = 0o21 // 17 in octal notation
let hexadecimalInteger = 0x11 // 17 inhexadecimal notation

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

使用Int类型的代码中的所有通用的整型常量和变量，即使它们是非负的。

在日常生活中使用默认的整数类型是指整型常量和变量是在代码中直接互操作，并将匹配的类型推断为整数值。

可以存储在一个整数常量或变量的范围根据每个数值类型是不同的。

一个Int8常量或变量可以存储数-128到127之间的数，而一个UInt8常量或变量可以存储0到255之间的数字。错误的赋值会让编译器报错：

let cannotBeNegative: UInt8 = -1
// UInt8 cannot store negative numbers,and so this will report an error
let tooBig: Int8 = Int8.max + 1
// Int8 cannot store a number larger thanits maximum value,// and so this will also report an error

因为每个数字类型可以存储不同范围的值，你必须选择加入在逐案基础上数值类型的转换。

这种选择适用的做法可以防止隐藏的转换错误，并帮助作出明确在你的代码的类型转换意图。

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 equals 3.14159,and is inferred to beof typde Double

反过来也是如此浮点到整数的转换，在一个整数类型可以用double或float值进行初始化：

let integerPi= Int(pi)
// integerPi equals 3,and is inferred tobe of type Int

以这种方式初始化一个新的整数值，原始的浮点值总是被截断。

这意味着，4.75变为4，和-3.9变为-3。

if turnipsAreDelicious {
println("Mmm,tasty turnips!")
} else {
println("Eww,turnips are horrible.")
}
// prints "Eww,turnips are horrible."

let i = 1
if i {
// this example will not compile,and will report an error

let i = 1
if i == 1 {
// this example will compile successfully
}

let http404Error = (404,“Not Found”) // http404Error is of type (Int,String),and equals (404,“Not Found”)

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

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

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

let http200Status = (statusCode: 200,description: "OK")
println("The status code is (http200Status.statusCode)")
// prints "The status code is 200"
println("The status message is (http200Status.description)")
// prints "The status message is OK"

元组类型在作为函数返回值的时候特别适用，可以为函数返回更多的用户需要的信息。

let possibleNumber = "123"
let convertedNumber = possibleNumber.toInt()
// convertedNumber is inferred to be of type "Int?",or "optional Int"

由于toInt方法可能会失败，因此它会返回一个可选的Int类型，而不同于Int类型。一个可选的Int类型被记为Int?

而不是Int。问号表明它的值是可选的，可能返回的是一个Int，或者返回的值不存在。

convertedNumber {
println("(possibleNumber) has an integer value of (convertedNumber!)")
} else {
println("(possibleNumber) could not be converted to an integer")
}
// prints "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")
}
// prints "123 has an integer value of 123"

var serverResponseCode: Int? = 404
// serverResponseCode contains an actual Int value of 404
serverResponseCode = nil
// serverResponseCode now contains no value

var surveyAnswer: String? // surveyAnswer is automatically set to nil

注: Swift 的nil不同于Object-C中的nil. Object-C中，nil是一个指针指向不存在的对象。

Swift中，nil不是指针而是一个特定类型的空值。任何类型的可选变量都可以被设为nil，不光是指针。

隐式强制使用可选类型

但是在一些情况下，可选类型是一直有效的，那么可以通过定义来隐式地去掉类型检查，强制使用可选类型。

这些可选类型被成为隐式解包的可选类型。你可以直接在类型后面加! 而不是？来指定。

隐式解包的可选类型主要用在一个变量/常量在定义瞬间完成之后值一定会存在的情况。

这主要用在类的初始化过程中，详见Unowned References and Implicitly Unwrapped Optional Properties.

隐式解包的可选类型本质是可选类型，但是可以被当成一般类型来使用，不需要每次验证值是否存在。

如下的例子展示了可选类型和解包可选类型之间的区别。

let possibleString: String? = "An optional string."
println(possibleString!) // requires an exclamation mark to access its value
// prints "An optional string."
 
let assumedString: String! = "An implicitly unwrapped optional string."
println(assumedString) // no exclamation mark is needed to access its value
// prints "An implicitly unwrapped optional string."

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

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

let age = -3
assert(age >= 0,"A person's age cannot be less than zero")
// this causes the assertion to trigger,because age is not >= 0

assert(age >= 0)

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!