数据类型

布尔Bool

布尔值是逻辑值（true/false）

if d > 10 //一个比较表达式可以返回一个布尔值，从而对返回的布尔值做判断
{
    print("bhdvb")
}
//将对布尔类型判断时，必须使用{},这也是和objec-c的不同之处

整型类型

包括符号整型和无符号整型

var a : Int = 2//定义整型变量
var b : Int8 = 2 //定义八位的整型变量
var c : UInt = 2 //定义一个无符号的整型变量
let mi = UInt8.min  //最小值属性0
let max = UInt8.max //最大值属性 255
var f = 5
f.bigEndian // 大端属性，查看低地址可以存放的最高的有效字节数
f.littleEndian // 小端属性，查看低地址可以存放的最低的有效字节数
f.byteSwapped //查看字节顺序交换后的当前整数
f.description //查看整数转换成字符串后的值
f.advanced(by: 3)//获得当前整数在指定数量之后的值
f.distance(to: 8) //获得当前整数和指定数的差值

浮点类型

var a = 1.5
var b : Float = 1.2 //两种浮点类型：Double/Float,Float表示32为浮点数
var c = Float.infinity //获得指定类型的最大值
var d : Double = 3.5 //双精度表示64位浮点数
d + 3.4 //进行浮点数值的计算,这样d的值还是没有改变
d.addProduct(2.0, 6.0)//将变量的值加上给定值的乘积
d.advanced(by: 1.0)//将变量加上给定的值
d.distance(to: 15.0)//获得当前值和给定的值之间的差值
var e = 15.0
e.significand//获得浮点数值的有效位数
e.exponent // 获得浮点数值的指数
e.binade //获得和15.0具有相同符号和指数的浮点数值，且有效位为1
e.bitPattern//获得数值的编码的位模式
e.description //查看当前浮点数值转化成字符串后的值
e.isFinite
e.isInfinite //检查数值是否为有限数值，无限数值
e.isNaN
e.isZero //检查是否为非数字是否为零
e.magnitude //获得数值大小
e.negate()//相反数
   
12.9.rounded(.up)// 将浮点数转换成大于或等于源数值的最接近的允许值
-12.9.rounded(.up)//负数是舍入到幅度大于或等于源数值的允许值，即向远离0的方向舍入
12.9.rounded(.toNearestOrAwayFromZero)//四舍五入
12.5.rounded(.toNearestOrAwayFromZero)
-12.5.rounded(.toNearestOrAwayFromZero)//舍入到最接近的允许值，两个值相等，则选择具有较大幅度的值
13.5.rounded(.toNearestOrEven)//舍入到最接近的允许值，两个值相等，则选择偶数
14.0.truncatingRemainder(dividingBy: 3.0)//获得浮点数值处以指定值的余数
14.0.remainder(dividingBy: 3.0)

• 预览

  

• 在IEEE 754标准中，浮点数由符号位、指数和尾数（significand）组成。对于一个给定的浮点数值，其内部表示并不是直接以十进制形式存储的，而是转换成了二进制，并且是以科学计数法的形式来存储。

  以15.0为例：首先，将15.0转换成二进制：

  • 15.0 (十进制) = 1111.0 (二进制)

  接着，我们将这个二进制数转换成规范化的科学记数法形式：

  • 1111.0 (二进制) = 1.111 * 2^3

  在这个规范化形式中，1.111 就是该数的二进制尾数（significand）。在IEEE 754标准下，由于隐含了最左边的1（即不需要实际存储），所以实际存储的是小数点后的部分 111，这对应于十进制的小数 0.875。因此，在IEEE 754表示中，我们看到的实际上是 1 + 0.875 = 1.875。

  所以15.0的有效位数是1.875

• 数值的编码位模式指的是在计算机内存中表示一个数值时所使用的二进制格式。

  1. 整数（如 int、long）：
     • 整数通常使用补码形式存储。对于正整数，其二进制表示就是它的直接二进制形式；对于负整数，则是其绝对值的二进制形式取反后加1。
     • 例如，在32位系统中，整数 -1 的二进制表示为 11111111 11111111 11111111 11111111。
  2. 无符号整数（如 unsigned int）：
     • 无符号整数只用来表示非负数，因此所有的位都用来表示数值大小。
     • 例如，无符号8位整数的最大值是 11111111 二进制，即十进制的 255。
  3. 浮点数（如 float、double）：
     • 浮点数遵循IEEE 754标准，分为三个部分：符号位、指数位和尾数位。
       • 符号位（Sign bit）: 表示这个数是正还是负。
       • 指数位（Exponent bits）: 用于表示指数的偏移量。
       • 尾数位（Mantissa or Fraction bits）: 代表实际的小数部分。

1. • 例如，32位单精度浮点数（float）有1位符号位、8位指数位和23位尾数位；64位双精度浮点数（double）有1位符号位、11位指数位和52位尾数位。

   • 特殊值如无穷大（Infinity）、负无穷大（-Infinity）和NaN（Not a Number）也有特定的位模式来表示。

在IEEE 754标准下，15.0 这个浮点数的编码位模式会根据它所使用的精度（单精度 float 或双精度 double）有所不同。下面是两种情况下的具体二进制表示：

单精度 float (32-bit)

• 符号位 (S): 因为 15.0 是正数，所以符号位是 0。
• 指数位 (E): 首先，将 15.0 转换成二进制形式是 1111.0。规范化后是 1.111 * 2^3。因此，指数部分是 3。IEEE 754中的指数是有偏移量的，对于单精度浮点数，偏移量是 127，所以实际存储的指数是 3 + 127 = 130，用8位二进制表示为 10000010。
• 尾数位 (M): 尾数去掉前面的隐含的 1. 后，剩下的部分是 111，后面补零到23位，即 11100000000000000000000。

组合起来，单精度 float 的 15.0 的位模式是：

0 10000010 11100000000000000000000

用十六进制表示就是 0x41700000。

双精度 double (64-bit)

• 符号位 (S): 仍然是 0。
• 指数位 (E): 指数同样为 3，但双精度浮点数的偏移量是 1023，所以实际存储的指数是 3 + 1023 = 1026，用11位二进制表示为 10000000010。
• 尾数位 (M): 尾数部分同样是 111，但需要扩展到52位，即 1110000000000000000000000000000000000000000000000000。

组合起来，双精度 double 的 15.0 的位模式是：

0 10000000010 1110000000000000000000000000000000000000000000000000

用十六进制表示就是 0x402e000000000000。

这就是 15.0 在 IEEE 754 标准下单精度和双精度浮点数的编码位模式。

• 使用 truncatingRemainder(dividingBy:)：
  • 14.0.truncatingRemainder(dividingBy: 3.0)
  • 计算步骤：
    • 14.0 / 3.0 = 4.666666...
    • trunc(4.666666...) = 4
    • 14.0 - (3.0 * 4) = 14.0 - 12.0 = 2.0
  • 结果：2.0
• 使用 remainder(dividingBy:)：
  • 14.0.remainder(dividingBy: 3.0)
  • 计算步骤：
    • 14.0 / 3.0 = 4.666666...
    • round(4.666666...) = 5
    • 14.0 - (3.0 * 5) = 14.0 - 15.0 = -1.0
  • 结果：-1.0

字符串类型

import UIKit

let hello = "njiji"
let world = "njub"
var hh = hello + "," + world//使用+将多个字符串连接
hh.count//统计字符串的字符数量
for character in hh
{
    print(character)
    
}//字符串的遍历
hello == world//比较字符串的内容
let intstr = "28"
Int(intstr)//字符串的强制转化
var l : String = "bhbh j bbu jio"
l.hasSuffix("jio")//判断在字符串的尾部是否包含指定的字符串
l.hasPrefix("bhbh")//判断在字符串的首部是否包含指定的字符串
l.uppercased()
l.lowercased()//将字符串转换成大写模式，小写模式
l.capitalized//将字符串的首字母转换成大写
l.isEmpty//判断是否为空
l.components(separatedBy: " ")//按照指定内容进行分隔，并返回数组
l.caseInsensitiveCompare("bhbh j bbu jio").rawValue
l.caseInsensitiveCompare(l.uppercased()).rawValue//将两个字符串进行比较，并且不区分大小写
l.caseInsensitiveCompare("bhbh j").rawValue
l.contains("h")//判断字符串是否包含另一字符串
l.distance(from: l.startIndex, to: l.endIndex)//判断两个字符串的两个索引之间的距离
l.lengthOfBytes(using: .utf8)//获得字符串在指定编码模式下的字节长度l.range(of: "j")?.lowerBound
l.range(of: "j")?.lowerBound
l.range(of: "j")?.upperBound//获得指定字符串在当前字符串中的范围的起点和结束点
"中国".applyingTransform(StringTransform.toLatin, reverse: false)//获得中文字符串的拼音和声调
l.append("aaaa")//在尾部追加其他内容
l.insert("?", at:l.endIndex)
l.insert(contentsOf: "ihbu", at: l.endIndex)//在指定的位置插入特定的字符串
/*
 使用 insert(_:at:) 来插入单个字符。
使用 insert(contentsOf:at:) 来插入一个字符串或多个字符。
 */
let index = l.index(l.startIndex, offsetBy: 3)//获得从字符串头部开始，向后移动3位的位置
l[..<index]//打印输出字符串指定索引区域的内容
let index1 = l.index(l.endIndex, offsetBy: -10)//获得从字符串尾部开始，向前移动10位的位置
let range = index ..< index1 //创建指定区域
l[range]
l.replaceSubrange(range, with: "iuwgh")//将制定区域的字符串进行替换
let a = "buh aer bhi fu fu"
a.replacingOccurrences(of:"fu", with: "oi")
l.removeSubrange(range)//删除特定区域的字符串
l.removeAll()//删除字符串中的所有位置

• 预览

• 字符串的替换
  • replaceSubrange(_:with:)：
    • 直接修改原字符串。
    • 需要提供具体的范围。
    • 只替换指定范围内的内容。
    • 适用于已知具体范围的情况。
  • replacingOccurrences(of:with:)：
    • 不修改原字符串，返回一个新的字符串。
    • 可以替换所有匹配的子字符串。
    • 适用于需要替换多个相同子字符串的情况。
    • 更加灵活，不需要预先知道具体的范围。

Raw String 原始字符串的使用

使用新增的#符号对字符串进行包裹，可以正常输出字符串中的双引号、#、换行等特殊符号

let a = "jni:\"hhbbub"//使用\"对双引号进行转义
print(a)
let b = #"jniivbeu"rhh"#//在字符串的头尾各添加一个#号，即可正常声明包含双引号的字符串（苹果提供）
print(b)
struct p
{
    var s:String
}
let pp = p(s: "ugg")
let hh = #" hwey0gyg" yg8erv"n\#(pp.s)"#//在斜线和左括号的中间添加一个#号，可嵌入外部的值
print(hh)
let jj = ##"buia#viy"##//如果字符串中间包含#则首尾需要两个##
let hhd = """
usvgf80y
huisgf8
bhuivwyefgy
bhiewbfi.
"""//多行段落首尾用“”“
print(hhd)

元组（Tuples）

let ht = (550,"hubbubhu")
let(a,b) = ht//将元组赋值给一个带有元素名称的元组，元素名称的个数要和原元组一一对应
let p = (name:"vfv",age:12)
p.name
p.age //查看元组中两个元素的值
p.0
p.1 //没有名称，也可以查看第n个元素

类型转换

import Foundation
let a = 1
let b = 1.2
let c = Double(a) + b //将整型常量转化成浮点数类型，再进行相加
let d = a + Int(b) //将浮点数类型转化成整数类型，小数部分会被省略
let aa = "25"
let bb = Int(aa)
let cc = "wtegt" + String(describing: bb)
let dd = "wtegt" + bb!.description //整数对象的描述属性，获得整型的字符串内容
let ee = "wtegt\(bb)" // 将整型类型\()嵌入字符串内容

数组

import Foundation
var stringaa = Array<String>() //定义一个字符串类型的数组
var faa = [Float]() //浮点类型的数组
var intaa = [1,5,3,4]
intaa.count
intaa.isEmpty //判断是否为空
intaa .contains(1) //判断是否包含指定的元素
intaa.first //获得第一个元素
intaa.last //获得最后一个元素
intaa.max() //最大值
intaa.min() //最小值
intaa.reverse()//顺序反转
intaa.swapAt(1, 2)//交换数组中的两个指定索引位置的元素
intaa.shuffled()//打乱顺序
intaa += [8,9]//使用加法，将两个数组的元素合并
intaa.append(10)//在数组尾部添加一个相同类型的数据
intaa[2...5] = [1,5,6]//将数组的2到5位的元素替换
intaa.insert(33, at: 3)//在数组的第3个位置，插入33
intaa
intaa.dropFirst()
intaa
intaa.popLast()
intaa
intaa.remove(at: 4)
intaa.sort()//对数组进行升序排序
intaa.sort(by: {$0 > $1})//通过闭包进行排序，指定排序方式为降序
var stringgg = ["hb","heurhurgh","hureh","heuibfuhbihuuhiu","bhfubfu","ebfug"]
stringgg.removeAll{$0.hasPrefix("h")}//通过闭包语句，对数组里的字符串进行检测，删除所有以"h"开头的字符串
stringgg
stringgg.sort(by: {leftone,rightone in
    return leftone.count < rightone.count
})//通过闭包对数组进行排序，自定义参数leftone,rightone，通过return两个参数的长度的比较结果，作为排序的方向
print(stringgg)

数组的遍历

import Foundation
var number1 = [1,2,3,4]
var number2 = [5,6,7]
var number = [number1,number2]//创建一个二维数组，有两个数组元素组成
print(number)
var mm = Array<Array<Int>>()//定义一个整数类型的二维数组
mm.append(number1)
mm.append(number2)//将两个子数组添加到二维数组中
for arrayn in number
{
    for n in arrayn //通过第二个循环，对子数组进行遍历，输出数组中所有元素
    {
        print(n)
    }
}//for-in 循环，对多维数组进行遍历

遍历的方法

import Foundation
var stringgg = ["sehubfi","hsuefiu","nefuwh"]
for i in 0..<stringgg.count
{
    print(stringgg[i])
}//通过获取索引的方式，遍历输出数组中的元素

for ss in stringgg
{
    print(ss)
}//直接遍历数组中的元素并输出

for element in stringgg where element.hasPrefix("s")
{
    print(element)
}//通过where限定条件，条件限制输出

for (index,value) in stringgg.enumerated()
{
    print("\(index)","\(value)")
}//遍历数组中的索引和值

stringgg.forEach{s in
    print(s)
}//通过数组对象的forEach方法，获取数组中的每个元素

var stringss = ["biuewbgi","bsufgyf","huweifgyr8"]
let diffences = stringss.difference(from: stringgg)
print(diffences)//输出两个数组的差异

字符串和数组的相互转化

import Foundation
let stringgg = "heu.bhs0reu.ewb4hfg"
//通过split方法，并在闭包中使用小圆点对字符串进行分割，字符串可以被分割成包含三个元素的属猪
let splitstring = stringgg.split{$0 == "."}

//通过split方法，指定小圆点对字符串进行分割
let splitstringg = stringgg.split(separator: ".")
print(splitstring)

//在闭包中通过对字符串中的数字对字符串进行分割
let splitnumber = stringgg.split{$0.isNumber}
print(splitnumber)

//通过joined方法，将数组拼接成一个字符串
let joinstring = splitstring.joined()
joinstring

//通过指定的separator，将数组拼接成一个字符串
let joinsringgg = splitstring.joined(separator: ".")
joinsringgg

//通过zip函数，将两个序列，通过一一对应的方式，组成一个新的序列
let stringggg = ["hbsuvg","qaqqq","cfcccc"]
let zipstingg = zip(stringggg, splitstring)
print(zipstingg)
for(label,value) in zipstingg
{
    print("\(label):\(value)")
}//对数组遍历，依次输出元组中的两个元素

数组过滤

import Foundation
var stringg = ["gewiyg","ghesuif","sdiuohr"]
//对数组进行过滤，只保留以g开头的元素
let filterstring = stringg.filter{ $0.hasPrefix("g")}

//allSatsfy方法，判断数组内的数字是否都小于60
var scores = [20,30,12,34,13]
let issmall = scores.allSatisfy({$0 < 60})
 
//获得数组中第一个小于30的数字
let firstnumber = scores.first(where: {$0 < 20})

//获得数字34在数组里的索引位置，由前往后开始
let indexnumber = scores.firstIndex(of: 34)

//重新排序集合中的元素，大于30的在前面，小于30的在后面
let partitionscore = scores.partition(by: {$0 > 30})

import Foundation
var source = [1,2,3,4,-1]
let minelment = source.min()

//获得所有元素中，对2取余最小的元素，并返回最早匹配的元素
let minnelement = source.min{$0 % 2 < $1 % 2}

//通过abs函数，获得所有元素中绝对值最大的一个
let maxelement = source.max{abs($0) < abs($1)}

//通过max方法获取字典里的最大值
let dictionary = ["bhsuv":23,"ifhbibh":12,"vidfsu":35]
let maxdictionary = dictionary.max{$0.value < $1.value}

截取数组

import Foundation
var source = [1,2,3,4,5,9,7,6]
//获取数组前面的小于8的元素
let prefixsource = source.prefix{$0 < 8}
print(prefixsource)

//返回从数组开始，到指定位置（但不包含指定位置）的子序列
let prefixuptoscource = source.prefix(upTo: 5)
print(prefixuptoscource)

//返回一个子序列，直到指定的最大长度
let prefixx = source.prefix(4)
print(prefixx)

//返回从数组开始到指定位置的子序列
let prefixtt = source.prefix(through: 4)
print(prefixtt)

//对数组进行遍历，当元素小于4的时候跳过，当元素大于或者等于4时，不再对数组进行遍历，同时返回由该元素和该元素后面所有元素组成的数组
let dropp = source.drop{$0 < 4}
print(dropp)

//丢弃数组的前三个元素，并返回由剩余元素组成的数组
let dropff = source.dropFirst(3)
print(dropff)

降维操作

import Foundation
let arrays = [[1,2,3,4],[9,8,7]]
//通过flatMap方法，获取每个子数组的元素，并放到一个一维数组
let flatt = arrays.flatMap{$0}
print(flatt)
 
let array2 = [[1,2,3,4],[5,nil,8]]
let flatt1 = arrays.flatMap{$0}
//若需在对数组进行降维操作时，丢弃值为nil的元素，可进行compactMap操作
let compactt = flatt1.compactMap{$0}

let array3 = [[1,2,3],[4,nil],nil]
let compp3 = array3.compactMap{$0}//子数组中的nil不可消除
print(compp3)

//flatMap方法可以用来减化Optional实例的解包操作
let ssstring : String? = "http://www.ni.com?bhub=vfdvgs"
//?表示ssstring字符串为Optional实例，它的值有可能为空，通过guard let语句，判断该变量的值是否为空
guard let ss = ssstring else{
    assert(false)
}
//将ss的值转换为URL对象，则将转化后的对象存储在finalUrl常量中，否则声明一个断言，结束程序的执行
guard let finalUrl = URL(string: ss) else
{
    assert(false)
}
//assert可以声明一个断言，来确保某个必要的条件是满足的，以便继续执行接下来的代码。如果条件满足了，那么代码像往常一样执行，否则就停止执行了。
finalUrl.query
//ssstring.flatMap(URL.init)?.query
if let finalUrlQuery = ssstring.flatMap(URL.init)?.query {
    print("查询参数: \(finalUrlQuery)")
} else {
    assert(false, "无法创建 URL 或没有查询参数")
}

解包操作是指从一个可选类型（Optional）中提取出其潜在的非 nil 值的过程。可选类型是一种可以持有值或者不持有任何值（即 nil）的特殊类型。当你声明一个变量或常量为可选类型时，它可能包含一个具体的值，也可能为空。

• flatMap(URL.init)
  • flatMap 方法在这里用于安全地解包 ssstring 并将其转换为 URL。如果 ssstring 是 nil 或者不能被成功转换为 URL，则 flatMap 的结果将是 nil。
• finalUrl.query
  • URL 类型有一个 query 属性，它返回 URL 中的查询字符串部分（即问号 ? 后面的部分）。
  • 在这个例子中，finalUrl.query 应该返回 "bhub=vfdvgs"。

字典

字典是一种存储多个相同类型的值的容器

import Foundation
var dictionaryy : Dictionary<String ,String> = ["iervb":"shiuvb","ergyv":"hbvgrh"]
print(dictionaryy)
var dictionaryyy = ["name":"o.O","age":10] as [String : Any]
var dictionaryy1 :Dictionary<String , Any> = ["name":"o.O","age":12]
dictionaryy1["name"]//
dictionaryy1["name"] = "O.o"//使用下标语法，修改字典中指定键的值
dictionaryy1["kkk"] = "ygsv"//添加指定的键和键对应的值
print(dictionaryy1)
dictionaryy1.count
dictionaryy1.isEmpty//判断是否没有键值对
//更新值，修改指定键的值
dictionaryy1.updateValue("jerry", forKey: "name")
print(dictionaryy1)

//移除首个键值对
dictionaryy1.popFirst()
print(dictionaryy1)

//删除字典中指定键的键值对
dictionaryy1.removeValue(forKey: "kkk")
print(dictionaryy1)

//获得字典对象中的首个键值对的键和值
dictionaryy.first?.key
dictionaryy.first?.value

for key in dictionaryy.keys
{
    print(">>>>\(key)")
}//遍历输出字典中的所有的键
for value in dictionaryy.values
{
    print(">>>>\(value)")
}//遍历字典中所有的值
for(key,value) in dictionaryy
{
    print(">>>\(key):\(value)")
}

let ddsort = Array(dictionaryy.keys).sorted()//对字典的键进行排序：将字典的键转换成数组，调用排序方法，进行升序排序
print(ddsort[0])

字典过滤和映射

import Foundation
let ddl = ["dd is ddd":384.54,"hbweuh":49.00,"njfin":34.98,"fiib":23.98]
let filterdic = ddl.filter{$0.value > 40.00}
print(filterdic)
//根据键的首部内容过滤字典
let filterhas = ddl.filter{$0.key.hasPrefix("dd")}

//获得字典中所有的key，并按照首字母分组
let grouplap = Dictionary(grouping: ddl.keys){$0.first}
print(grouplap)

//统计元素在数组中出现的次数，用字典表示
var dev = ["hh","hw","hh","gg"]
var devcout = [String:Int]()
//利用循环语句，统计数组中元素的数量
for de in dev
{
    devcout[de,default: 0] += 1
}
print(devcout)

//通过映射，批量修改字典的值
let scores = ["math":89,
              "english":90,
              "chinese":93,
              "history":95]
//通过map方法，使得各科分数都缩小一半
let mapss = scores.map{$0.value / 2}
//通过mapValue方法，对字典的值进行映射，作为整型的分数，转换成一个字符串
let mapvv = scores.mapValues { score -> String in
    "youer score is \(score)"
}
print(mapvv)
let score2 = ["math":"89",
              "english":"90",
              "chinese":"none",
              "history":nil]
let compaa = score2.compactMapValues{$0}//调用compactMapValues方法后，字典中的nil已经消失，但是值为none的键值对仍然存在
print(compaa)
//通过闭包将值转换成整型，无法转换成整型的none被丢弃
let compaa1 = score2.compactMapValues{Int($0 ?? "")}
print(compaa1)

集合

集合用来存储类型相同、没有确定顺序唯一的值，这些值被存储在一个集合中，是不重复和无序的

import Foundation
//定义一个集合
var scores :Set<Int> = Set<Int>()
var animals : Set<String> = ["tiger","mouse","zebra"]
var animals1 : Set<String> = ["lion","pig","mouse"]
print(animals)
//将数组转换成集合，转换后的集合自动去除数组中的重复元素，并变为无序
let array = ["hbb","bhbivb","bhbhb"]
let set = Set(array)

//通过调用集合的sorted方法，对集合中的元素进行排序，并返回排序后的数组
let sortarray : Array = animals.sorted()
//insert,remove 等等操作，大多与数组一致

//集合的合并
animals.union(animals1)
print(animals.union(animals1))
//集合的交
animals.intersection(animals1)
print(animals.intersection(animals1))
//判断第一个集合是否为第二个集合的子集或超集
animals.isSubset(of: animals1)
animals.isSuperset(of: animals1)
//判断两个集合是否有共同元素，isDisjoint(with:) 方法用来判断两个集合是否有任何共同的元素；如果没有共同元素，则返回 true，否则返回 false。
animals.isDisjoint(with: animals1)

操作符

import Foundation
//对布尔值进行反转
let x = false
let y = !x
//对浮点数值进行求余
8.truncatingRemainder(dividingBy: 2.5)
//加号运算符还可以使用两个字符串和数组之间
"hello" + "world"
[1,2] + [3,4]

运算符

import Foundation
//定义一个无符号的整型常量
let bits : UInt8 = 0b00101011
//取反运算
let fanbits = ~bits
let fbits : UInt8 = 0b11111000
let lbits : UInt8 = 0b00111111
//与运算
let rbits = fbits & lbits
//或运算
let obits = fbits ^ lbits
let bits1 : UInt8 = 4
//左移两位，扩大四倍
bits1 << 2
//区间运算符（a...b,包括a和b；a..<b,不包括b)