swift之数值类型杂谈（数值）
最后更新于：2022-04-01 11:39:31
~~~
import Foundation
//整数，没有小数部分，有正数有负数
/*
Swift 提供了8，16，32和64位的有符号和⽆符号整数类型。这些整数类型和 C 语⾔的命
名⽅式很像，⽐如8位⽆符号整数类型是 UInt8 ，32位有符号整数类型是 Int32 。就像
Swift 的其他类型⼀样，整数类型采⽤⼤写命名法。
*/
var x8 : Int8 = 10
var x16 : Int16 = 10
var x32 : Int32 = 0
var x64 : Int64 = -10
var ux8 : UInt16 = 20
//不再多说
//整数范围
var minInt32 = Int32.min
var maxInt32 = Int32.max
print("int32.min = \(minInt32), int32.max = \(maxInt32)")
//int32.min = -2147483648, int32.max = 2147483647
/*
⼀般来说，不需要专⻔指定整数的⻓度。Swift 提供了⼀个特殊的整数类型 Int ，⻓度与
当前平台的原⽣字⻓相同：
在32位平台上 Int 和 Int32长度相同
在64位平台上 Int 和 Int64长度相同
UInt 也是一样
在32位平台上 UInt 和 UInt32长度相同
在64位平台上 UInt 和 UInt64长度相同
尽量不要使⽤ UInt ，除⾮你真的需要存储⼀个和当前平台原⽣字⻓相同的⽆符号整
数。除了这种情况，最好使⽤ Int ，即使你要存储的值已知是⾮负的。统⼀使
⽤ Int 可以提⾼代码的可复⽤性，避免不同类型数字之间的转换
*/
//浮点数
/*
Double 表⽰64位浮点数。当你需要存储很⼤或者很⾼精度的浮点数时请使⽤此类型。
Float 表⽰32位浮点数。精度要求不⾼的话可以使⽤此类型。
Double 精确度很⾼，⾄少有15位数字，⽽ Float 最少只有6位数字。选择哪个类型取
决于你的代码需要处理的值的范围。
*/
//类型推断
/*
Swift 是⼀个类型安全（type safe）的语⾔。类型安全的语⾔可以让你清楚地知道代码要
处理的值的类型。如果你的代码需要⼀个 String ，你绝对不可能不⼩⼼传进去⼀个 Int 。
由于 Swift 是类型安全的，所以它会在编译你的代码时进⾏类型检查（type checks），并
把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。
当你要处理不同类型的值时，类型检查可以帮你避免错误。然⽽，这并不是说你每次声明
常量和变量的时候都需要显式指定类型。如果你没有显式指定类型，Swift 会使⽤_类型推
断（type inference）来选择合适的类型。有了类型推断，编译器可以在编译代码的时候
⾃动推断出表达式的类型。原理很简单，只要检查你赋的值即可
*/
let value1 = 15
//value1会被推断为Int
let value2 = 12.88
//value2会被推断为Double
// 当推断浮点数的类型时，Swift 总是会选择 Double ⽽不是 Float
let value3 = 2 + 11.00
//valuew3 会被推断为Double
//因为：如果表达式中同时出现了整数和浮点数，会被推断为 Double 类型
//数值类型：
/*
⼀个⼗进制数，没有前缀
⼀个⼆进制数，前缀是 0b
⼀个⼋进制数，前缀是 0o
⼀个⼗六进制数，前缀是 0x
*/
let decimalInteger = 17
let binaryInteger = 0b10001 // ⼆进制的17
let octalInteger = 0o21 // ⼋进制的17
let hexadecimalInteger = 0x11 // ⼗六进制的17
print("十进制：\(decimalInteger), 二进制：\(binaryInteger), 八进制：\(octalInteger), 十六进制：\(hexadecimalInteger)")
//十进制：17, 二进制：17, 八进制：17, 十六进制：17
//如果⼀个⼗进制数的指数为 exp ，那这个数相当于基数和10^exp的乘积：
var testEXP = 3.33e5 // = 333000
var testEXPfu = 3.33e-2
print("\(testEXP) - \(testEXPfu)")
//输出：333000.0 - 0.0333
var testexp2 = 0xAp3 // = 10 * (2 * 2 * 2) = 80
var testexp2fu = 0xap-3
print("\(testexp2) - \(testexp2fu)")
//输出：80.0 - 1.25
//数值类字⾯量可以包括额外的格式来增强可读性。整数和浮点数都可以添加额外的零并且包含下划线，并不会影响字⾯量：
let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1
//下划线和0不会影响原有值
//数值类型转换
/*
不同整数类型的变量和常量可以存储不同范围的数字。 Int8 类型的常量或者变量可以存储
的数字范围是 -128 ~ 127 ，⽽ UInt8 类型的常量或者变量能存储的数字范围是 0 ~ 255 。如
果数字超出了常量或者变量可存储的范围，编译的时候会报错：
let cannotBeNegative: UInt8 = -1
// UInt8 类型不能存储负数，所以会报错
let tooBig: Int8 = Int8.max + 1
// Int8 类型不能存储超过最⼤值的数，所以会报错
由于每种整数类型都可以存储不同范围的值，所以你必须根据不同情况选择性使⽤数值型
类型转换。这种选择性使⽤的⽅式，可以预防隐式转换的错误并让你的代码中的类型转换
意图变得清晰。
要将⼀种数字类型转换成另⼀种，你要⽤当前值来初始化⼀个期望类型的新数字，这个数
字的类型就是你的⺫标类型。在下⾯的例⼦中，常量 twoThousand 是 UInt16 类型，然⽽常
量 one 是 UInt8 类型。它们不能直接相加，因为它们类型不同。所以要调⽤ UInt16(one) 来
创建⼀个新的 UInt16 数字并⽤ one 的值来初始化，然后使⽤这个新数字来计算：
*/
var twoThousand: UInt16 = 2_000
var one: UInt8 = 1
var twoThousandAndOne = twoThousand + UInt16(one)
//整数和浮点类型的转换
var valueInt = 12
var valueDouble = 10.11
var valueTotal = Double(valueInt) + valueDouble
print(valueTotal)
//输出：22.11
var valueTotalToInt = Int(valueTotal)
print(valueTotalToInt)
//输出：22
//此时会发生截断
//类型别名
typealias DZL = Int32
var t1 : DZL = 111
//布尔值
//Swift 有两个布尔常量， true 和 false
var boolType : Bool = true
~~~