Swift4 基本数据类型(范围型, Stride型, 数组, 字符串, 哈希表)

创建: 2018/02/28

完成: 2018/03/04

更新: 2018/05/03 给主要标题加上英语, 方便页内搜索

【任务表】TODO

范围型(Range)与Stride型

 与范围运算符相关的型的概要

T: 有界值型	运算符	型	用途
可比较，非可算 (Double, String等)	A..<B	Range<T>	表示范围
	A...B	ClosedRange<T>
可比较, 可算 (Int, Uint等)	A..<B	CountableRange<T>	表示范围, for-in迭代
	A...B	CountableClosedRange<T>

● 有上下限(A..<B, A...B)的叫有界值型

● 必须采用Comparable(也就是可以比大小)

● 可算类必须采用Collection, 可以一个一个拿出来(for-in)

● 都采用CustomString, 可以直接print输出

 单侧范围型与范围运算符

T: 有界值型	运算符	型	用途
可比较, (非可算)	..<B	PartialRangeUoTo<T>	表示范围
	...B	PartialRangeThrough<T>
可比较, 非可算	A...	PartialRangeFrom<T> T不可算	表示范围
可比较, 可算	A...	CountablePartialRangeFrom<T> T可算	表示范围 for-in迭代

● 下限范围型可算不可算由T决定

● 可比较可算的CountablePartialRangeFrom<T>采用了Sequence协议

可以for-in, 由于没有上限, 退出要自己break/return

 生成范围型实例

 ...                      // CountableClosedRange<Int>
Range< ... >              // Range<Int>
2.5 ..< 4.0                 // Range<Double>
"a" ... "x"                 // ClosedRange<String>
...                       // CountablePartialRangeFrom<Int>
PartialRangeFrom()        // PartialRangeFrom<Int>
...Float(0.5)               // PartialRangeThrough<Float>
PartialRangeUpTo(0.5)       // PartialRangeUpTo<Double>

● 是构造体

● 用运算符来生成实例，根据自身值型是否可算来确定类型

可算类型生成CountableRange<T>(A..<B), CountableClosedRange<T>(A...B), CountablePartialRangeFrom<T>(A...)

非可算类型生成非可算范围

● 可算类范围采用Sequence, 非可算不采用

● 可以用构造函数来生成(无视被指定型的可算非可算, 可算可变为非可算, 非可算不行!)

 范围型的属性与方法

● 属性

T: 有界值型

lowerBound: T { get }	范围的下限 ● 下面两个不存在该属性 PartialRangeUoTo<T>(..<B) PartialRangeThrough<T> (...B)
upperBound: T { get }	范围的上限 ● 下面两个不存在该属性 PartialRangeFrom<T>(A...) CountablePartialRangeFrom<T>(A...)

● 方法

contains(_:T) -> Bool	参数是否在范围内 也可以用 ~=, 左边范围, 右边参数 let sample = 0.0 ..< 3.1415926 sample.contains(0.5) // true sample ~= 0.5 // true
overlaps(_:Range<T>) -> Bool	参数与受体是否有重叠部分 单侧范围型不可用

 Stride型概要

● 范围和幅度构成的构造体

从范围内以幅度来获取值

● 构造函数

func stride(from: T, through: T, by: T.stride) -> StrideThrough<T> where T: Strideable // 包含终点
func stride(from: T, to: T, by: T.stride) -> StrideTo<T> where T: Strideable // 不包含终点

例

for x in stride(from: , to: , by: ) {
    ...
}

● 常和for-in一起用

● stride(from:to:by:) 可取范围不包含终点

stride(from:through:by:) 包含

 Stride型与Strideable协议

func stride(from: T, through: T, by: T.stride) -> StrideThrough<T> where T: Strideable

Stride生成函数返回的型采用Strideable协议

● Strideable的主要声明

public protocol Strideable: Comparable {
    associatedtype: Stride: SignedNumeric, Comparable // SignedNumeric: 带符号的数字
func distance(to: Self) -> Self.Stride // 减法, 计算差
func advanced(by: Self.Stride) -> Self // 加法, 返回加上参数的结果 }

差的结果不是Self, 如Stride<UInt>的差为Int (因为有负值)

采用该协议的型主要有: 整数(各种Int), Float, Double, 指针(UnsafePointer<T>)

 for-in与Sequence协议

采用Sequence或Collection的可用for-in

● Collection继承Sequence

● StrideTo<T>, StrideThrough<T>采用Sequence

● 数组Array构造体,

哈希表Dictionary构造体,

可算双侧范围型CountableRange<T>构造体(A..<B),

CountableClosedRange<T>构造体(A...B)

String构造体

采用Collection

数组(Array)

 数组, 哈希表，字符串, 可算双侧范围型等都是Collection

● 构造体, 值型(只有类的实例与闭包是参照型)

 变更Collection的内容

● 两种, 改变自身与返回新值

a.sort() // 改变自身

a.sorted() // 返回新值

 部分置换 

a[m...n] = ...

● 元素数不同也行

● m,n必须是有效值，不能超过范围

 子数组的型 

● ArraySlice<T>

● 和原数组的索引一样

● copy-on-write(所有值型都是)

● 作Array型参数时要型转换Array(subArray)

 数组的构造函数 

● 类型写法[T], Array[T]. 下面三个一样

var a: [Int] = [, , ]
var b: Array<Int> = Array<Int>(arrayLiteral: , , )
var c: Array<Int> = Array<Int>([, , ])

● 构造函数

init()	返回空数组
init<S>(_:S)	参数为采用了Sequence协议的类型的实例 ● 参数自身类型无限制,可以是子数组ArraySlice<T>, 两侧可算范围型CountableRange<T>, 两侧可算闭范围型    CountableClosedRange<T>，字符串
init(repeating:T, count:Int)	生成以repeating为元素, 长度为count的数组

 数组的属性 

count: Int { get }	返回元素个数
first: T? { get }	返回第一个元素 不存在时返回nil
last: T? { get }	返回最后一个元素 不存在时返回nil
isEmpty: Bool { get }	是否为空(元素数量是否为0)

 数组的方法 

主要方法, 不含带闭包的。采用Collection协议(继承Sequence协议)

T: 型参数, S: Sequence, C: Collection, Slice: ArraySlice

mutating: 改变受体自身

搜索	index(of: T) -> Int?	返回找到的第一个元素 找不到返回nil
子数列	prefix(_:Int) -> ArraySlice<T>	返回指定长度的数组开头
	suffix(_:Int) -> ArraySlice<T>	返回指定长度的数组末尾
	dropFirst(_:Int) -> ArraySlice<T>	删除指定长度的数组开头
	dropLast(_:Int) -> ArraySlice<T>	删除指定数量的数组结尾
末尾增加	mutating append(_:T)	在数组末尾增加参数元素
	mutating append(contentsOf: Sequence)	在数组末尾添加采用Sequence协议的型的实例
插入	mutating insert(_:T, at: Int)	在指定位置插入一个元素
	mutating insert(contentsOf: Collection, at: Int)	在指定位置插入采用Collection型的实例
删除	@discardableResult mutating remove(at: Int) -> T	删除指定位置的元素并返回该值
	mutating removeAll()	清空元素, 元素数量变0
	mutating removeFirst() -> T	删除并返回第一个值
	mutating removeLast() -> T	删除并返回末尾倒数第一个元素
	mutating removeFirst(_:Int)	删除指定长度的开头
	mutaing removeLast(_:Int)	删除结尾指定的长度
排序	mutating sort()	改变自身，将数组从小到大排序
	mutaing sorted() -> [T]	改变并返回一个新的自己
倒序	reversed() -> [T]	返回把要素逆序排列的结果

 数组的比较 

● ==, !=

比较基准: 元素数相等，对应元素相等

 有可变长度的参数的函数 

型名后面三个点...

func sample(a: Int, b: String...) -> Bool { ... }

● 与C不同, 不用逗号

● 任意地方都可以设置成长度变化的参数, 但是一个函数里最多只能有一个可变参数

前提: 可变参数的下一个参数带标签(也就是不能带_)

func sample(a: Int..., b: Bool) -> Bool { return false }

 多元数组

数组的元素也是数组

● 一般最多用到三次元 a[m][n]

字符串(String)与字符(Character)

 数组, 哈希表，字符串, 可算双侧范围型等都是Collection

● 构造体, 值型(只有类的实例与闭包是参照型)

 String的构造函数

init()	生成空字符串, 相当于""
init<T>(_:T)	参数型: Int, Float/Double, Bool, String, Character, Unicode.Scalar等 ● 相当于类型转换构造函数
init(describing: Subject)	获取参数的description字符串 ● 需要采用CustomStringConvertible协议 ● Debug用
init(repearting: Character, count: Int) init(repeating: String, count: Int)	将repeating重复count回生成字符串

 Character型 

可以容纳Unicode字符(包括ASCII字符)一个

● 没有独自的literal, 生成时用一个字符的字符串

● 特殊字符\u{}, 如\u{3085}

var sample1: Character = "a" // 用字面量来生成
var sample2: Character = "\u{3085}" // 特殊字符
var sample3: Character = Character("a") // 构造函数来生成

● 采用Comparable, 可比较。

函数参数和运算时可指定一个字符的字符串作为字符型

let a: Character = "a"
if a > "b" || a < "x" {
    ...
}

● 可以print

 Unicode.Scalar型 

表示Unicode字码, 21比特。

let sample1: Unicode.Scalar = "a"
let sample2: Unicode.Scalar = "0x83ef"
let sample3: Unicode.Scalar = Unicode.Scalar("c")

● Unicode型作为命名空间, 包含字码等型和常数信息

● 采用Comparable, 可比大小, 可以与一个字符的文字字面量比较

● 属性

value, 获取字码(UInt32型)

● Character的构造函数可以Unicode.Scalar型实例做参数

● 可以print

 合成字符与Character型 

● Swift的文字都是基于Unicode

● 一个Unicode字符除了单个字码外还有多个字码的组合

let gu: Character = "\u{30B0}"  // グ
let ku: Character = "\u{30AF}\u{3099}" // ク + ゙
print( gu == ku )

 从字符串取出字符 

● 字符串是Character的Collection, 采用Collection

String.Element = Character

● for-in, 取出来的型是Character

 字符串属性 

主要属性

Ch: Character, Index: String.Index, C: Collection

文字数	count: Int { get }	返回文字数
索引	startIndex: String.Index { get }	开头的索引
	endIndex: String.Index { get }	末尾的下一个的索引
索引列	Indices: Collection { get }	返回个字符的索引组成的Collection
开头元素	first: Character? { get }	返回开头字符 不存在则返回nil
末尾元素	last: Charaster? { get }	返回末尾元素 不存在则返回nil
是否为空	isEmpty: Bool { get }	返回是否为空
view	utf16: UTF16View { get set }	字符的其他表示方法 UTF16 是数值
	utf8: UTF8View { get  set }	字符的其他表示方法 UTF8 是数值
	unicodeScalars: UnicodeScalarView { get set }	Unicode.Scalar 获取具体值 unicodeScalars.value

 字符串方法 

主要方法

String采用Collection协议(更准确说是BodorectionalCollection, RangeReplaceableCollection)

索引操作	index(after:String.Index) -> String.Index	返回参数的下一下索引
	index(before:String.Index) -> String.Index	返回参数的上一个索引
	index(_:String.Index, offsetBy:Int) -> String.Index	返回指定位置向后offset个的索引
	distancfe(from: String.Index, to: String.Index) -> Int	返回所以索引间的差
搜索	index(of:Character) -> String.Index?	返回参数字符的索引(第一次出现位置) 找不到则返回nil
	contains(_:Character) -> Bool	是否包含参数字符
比较	hasPrefix(_:String) -> Bool	开头是否和参数一样
	hasSuffix(_:String) -> Bool	结尾是否和参数一样
子字符串	prefix(_:Int) -> SubString	返回从开头指定长度的子字符串
	prefix(through: String.Index) -> SubString	返回到指定位置的子字符串
	prefix(upTo: String.Inedx) -> SubString	返回到指定位置前的子字符串
	suffix(_:Int) -> SubString	返回到结尾指定长度的字符串
	suffix(from:String.Index) -> SubString	返回从指定位置到结尾的字符串
	dropFirst(_: Int=1) -> SubString	返回去掉开头指定长度的字符串的子字符串
	dropLast(_:Int=1) -> SubString	返回去掉末尾指定长度字符串的子字符串
	split(separator: Character) -> [SubString]	用指定字符分割字符串 返回分割结果组成的数组
	subscript(String.Index) -> Character { get }	获取指定位置的字符 例 str[str.startIndex]
	subscript(Range<String.Index>) -> SubString { get }	获取指定位置的字符串 例 str[str.startIndex..<str.endIndex]
增加	mutating append(_:T)	在末尾增加字符或者字符串
	mutating append(containsOf: Sequence)	在末尾添加以字符为元素的序列的元素 ● 如String, SubString, Array<String>等
置换	mutating replaceSubrange(_:Range<String.Index>, with: T)	替换指定范围 ● 第二参数可为字符串, 字符的Collection(Array<String>等)
插入	mutating insert(_:Character, at:String.Index)	在指定位置插入指定字符
	mutating insert(contentsOf:T, at:String.Index)	在指定位置插入字符串或字符的Collection ● 可为字符串, 字符的Collection(Array<String>等)
删除	mutating remove(at:String.Index) -> Character	删除指定位置并返回被删除的字符
	mutating removeSubrange(_:Range<String.Index>)	删除指定返回的字符串
	mutating removeAll()	删除全部 相当于 =""
	mutating removeFirst() -> Character	删除并返回第一个字符
	mutating removeFirst(_:Int)	删除开头开始指定长度的字符串 ● 不返回值
	mutating removeLast() -> Character	删除并返回最后一个字符
	mutating removeLast(_:Int)	删除末尾指定长度的字符串 ● 不返回值
大小写转换	lowercased() -> String	全部英语字母转为小写
	uppercased() -> String	全部英语字母转为大写

 字符串索引 

subscript(String.Index) -> Character { get } // 获取指定位置的字符 
// 例 str[str.startIndex]

subscript(Range<String.Index>) -> SubString { get }  // 获取指定位置的字符串 
// 例 str[str.startIndex..<str.endIndex]

 Foundation框架的功能

● 除了算数运算, 系统功能, 还包含ObjC库

● GUI应用下自动读取

# TODO: Supply [补充Foundation内Swift.String可用的方法 p156]

 复杂的字符插值

● \()插值可以嵌套

● 内部可以包含式子

多行的字符串字面表示方法

literal

 # TODO: Supply [补充该部分 p158] 

 作为文字码的Collection来操作字符串

utf16: UTF16View { get set }	字符的其他表示方法 UTF16来符号化的UInt16的Collection 是数值
utf8: UTF8View { get  set }	字符的其他表示方法 UTF8来符号化的UInt16的Collection 是数值
unicodeScalars: UnicodeScalarView { get set }	Unicode.Scalar的Collection ● 获取具体值 unicodeScalars.value

哈希表(Hash/Dictionary)

 数组, 哈希表，字符串, 可算双侧范围型等都是Collection

● 构造体, 值型(只有类的实例与闭包是参照型)

 哈希表的型声明与初始值

● 所有键必须同型, 所有值必须同型

var sample1 = [ "Swift": , "Objective-C":  ] //字面量来生成
var sample2: [String:Int] = [String, Int]() // 生成空哈希表, 相当于[:]
var sample3: [String:Int] = [:]
var sample4: Dictionary<String, Int> = Dictionary<String, Int>()//泛型

 获取哈希表

subscript来获取, h["sample"]

var sample = ["":, "":]
sample[""] // -> Int?  这里为1

● 返回的都是可选型

● 增加元素

sample[""] =  // 新键里放值

● 删除元素

sample[""] = nil // 要删除的地方的值设为nil

● 当key的值必须采用Hashable协议

各种Int, 实例(带误差, 不用), Bool, String, Character等

 哈希表的比较

用==与!=

● 相等含义: 双方键完全相同, 键所对值完全相同

● 值必须采用Equatable协议 (Comparable协议采用Equatable协议, 所以采用Comparable协议也行)

 哈希表的属性

元素数	count: Int { get }	返回哈希表的元素数
键	keys: Keys { get }	由键组成的Collection
值	values: Values { get }	由值组成的Collection
索引	startIndex: Dictionary.Index { get }	返回从开头开始获取元素的索引
索引列	Indices -> Sequence { get }	返回从小到大获取元素的索引列
开头元素	first: Element? { get }	获取开头元素 不存在则返回nil
是否为空	isEmpty: Bool { get }	返回是否为空

● 附属型

Key: 键型, Keys: Key的Collection

Value:值型, Values: Value的Collection

associatedtype Element = (key:Key, value:Value)

 哈希表的方法

索引 搜索	index(forKey: Dictionary.Key) -> Index?	返回键所对的索引 不存在则范围nil
更新	updateValue(_:Value, forKey:key) -> Value?	用第一参数更新key位置的值 返回原先的值, 原先不存在则返回nil
删除	removeValue(forKey:Key) -> Value	删除指定键的值 返回被删的值, 不存在则返回nil
	remove(at: Dictionary.Index) -> Element	删除指定索引处的元素 返回整个元素(key:Keys, value:Values)

● 不包括带闭包的

● Keys(键Collection), Values(值Collection)也可用Sequence, Collection的方法

 哈希表的索引与搜索的默认值

哈希表采用Collection

subscript(key: Key) -> Value? // 获取值
subscript(Dictionary.Index) -> Element { get }

●  不存在时返回nil

● 设定默认值

subscript(key: Key, default:@autoclosure () -> Value)) -> Value

呼出的写法

h[键, default: 默认值]

 哈希表与for-in

基本循环

for h in hashSample { ... } // 基本写法

通配符循环

for (key, value) in hashSample { ... } // key是键, value是值

键/值单个循环

for key in h.keys { ... } // 只要键的Collection
for value in h.values { ... } // 只要值的Collection

● 哈希表自身, 键列Keys, 值列Values共用索引

用key去接入哈希表, 值的更换等