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

 生成范围型实例

0 ... 9                     // CountableClosedRange<Int>
Range<0 ... 9>              // Range<Int>
2.5 ..< 4.0                 // Range<Double>
"a" ... "x"                 // ClosedRange<String>
16...                       // CountablePartialRangeFrom<Int>
PartialRangeFrom(16)        // 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: 0, to: 100, by: 2) {
    ...
}

 ● 常和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] = [1, 2, 3]
var b: Array<Int> = Array<Int>(arrayLiteral: 1, 2, 3)
var c: Array<Int> = Array<Int>([1, 2, 3])

 ● 构造函数

 

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

 

 获取哈希表

 subscript来获取, h["sample"]

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

 ● 返回的都是可选型

 ● 增加元素

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

 ● 删除元素

sample["1"] = 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去接入哈希表, 值的更换等