4 stride swift

2016-11-02 18:32:22 youshaoduo 阅读数 16865

看了许多关于Swift  for循环的文章,发现基本上都是正序的for循环,对于逆序的我一直使用while循环,直到我发现了这个方法。。。

 

for i in (0...10).reversed() {
    print(i)
}


用这个就可以倒序for循环了

 

 

还有另一种比较优雅而且装X的方法

 

for i in stride(from: 3, through: 0, by: -1) {
     print(i)
}

 

 

 

Swift 的 stride 函数返回一个任意可变步长 类型值的序列。可变步长类型是可以设置偏移量的一维标量。

他有两个变种,

from,to,最后一个值将会严格小(大)于to的值

 

stride(from:3, to:0, by:-1) 表示3,2,1

 

from,through,最后一个值将会小(大)于等于through的值

 

 

stride(from:3, through:0, by:-1) 表示3,2,1,0

 

 

 

 

 

 

2018-02-28 04:26:00 weixin_30294021 阅读数 147

创建: 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去接入哈希表, 值的更换等

 

   
   

转载于:https://www.cnblogs.com/lancgg/p/8481745.html

2018-02-25 15:39:32 a946919805 阅读数 257

Swift包含了74个内置函数,但在 The Swift Programming Langage 一书中只介绍了其中的7个,其它的都没有在文档中体现。
这篇文章列举出了所有的Swift库函数。文中所谓的 内置函数 是指无需引入任何模块(比如说Fundation等)即可以直接使用的函数。
下面先来看看7个在文档中提到的库函数:
下面列出一些很实用,但未在文档中体现的库函数:
复制代码 代码如下:

//断言,参数如果为true则继续,否则抛出异常
//assert mentioned on page 55
assert(true)

//计算序列的元素个数
// countElements mentioned on page 79
countElements(“foo”) == 3

//返回一个新的序列,其中每个元素是一个元组,
//第一个值为原来元素所在的位置index,第二个为原来序列中的元素
// enumerate mentioned on page 94
for (i, j) in enumerate([“A”, “B”]) {
// “0:A”, “1:B” will be printed
println(“(i):(j)”)
}

//返回所有参数中的最小值
// min mentioned on page 246
min(8, 2, 3) == 2

//打印
// print mentioned on page 85
print(“Hello “)

//打印(带换行)
// println mentioned on page 4
println(“World”)

//排序
// sort mentioned on page 14
for i in sort([“B”, “A”]) {
// “A”, “B” will be printed
println(i)
}

abs(signedNumber):返回数字的绝对值
复制代码 代码如下:

abs(-1) == 1
abs(-42) == 42
abs(42) == 42
contains(sequence, element):如果某个序列sequence(比如说一个数组)包含指定的元素element,则返回true,否则返回false。
复制代码 代码如下:

var languages = [“Swift”, “Objective-C”]
contains(languages, “Swift”) == true
contains(languages, “Java”) == false
contains([29, 85, 42, 96, 75], 42) == true
dropFirst(sequence):返回一个去掉了首个元素的、新的序列(比如一个新数组)。
复制代码 代码如下:

var languages = [“Swift”, “Objective-C”]
var oldLanguages = dropFirst(languages)
equal(oldLanguages, [“Objective-C”]) == true

dropLast(sequence):返回一个去掉了最后一个元素的、新的序列(比如一个新数组)。
复制代码 代码如下:

var languages = [“Swift”, “Objective-C”]
var newLanguages = dropLast(languages)
equal(newLanguages, [“Swift”]) == true

dump(object):打印出某个对象object的所有信息
复制代码 代码如下:

var languages = [“Swift”, “Objective-C”]
dump(languages)
// Prints:
// ▿ 2 elements
// - [0]: Swift
// - [1]: Objective-C

equal(sequence1, sequence2):判断两个序列是否相等
复制代码 代码如下:

var languages = [“Swift”, “Objective-C”]
equal(languages, [“Swift”, “Objective-C”]) == true
var oldLanguages = dropFirst(languages)
equal(oldLanguages, [“Objective-C”]) == true

filter(sequence, includeElementClosure):对序列sequence中每个元素都执行includeElementClosure闭包,并将所有闭包结果为true的元素合成一个新序列sequence并返回。
复制代码 代码如下:

for i in filter(1…100, { $0 % 10 == 0 }) {
// 10, 20, 30, …
println(i)
assert(contains([10, 20, 30, 40, 50, 60, 70, 80, 90, 100], i))
}
find(sequence, element):返回序列sequence中某元素element的位置index。如果序列中不存在此元素,则返回nil。
复制代码 代码如下:

var languages = [“Swift”, “Objective-C”]
find(languages, “Objective-C”) == 1
find(languages, “Java”) == nil
find([29, 85, 42, 96, 75], 42) == 2
indices(sequence):返回序列sequence中所有元素的位置(indices是index的复数)
复制代码 代码如下:

equal(indices([29, 85, 42]), [0, 1, 2])
for i in indices([29, 85, 42]) {
// 0, 1, 2
println(i)
}

join(separator, sequence):将序列sequence通过分隔符separator连成一个字符串,并返回此字符串。
复制代码 代码如下:

join(“:”, [“A”, “B”, “C”]) == “A:B:C”
var languages = [“Swift”, “Objective-C”]
join(“/”, languages) == “Swift/Objective-C”
map(sequence, transformClosure):对序列sequence中每个元素都执行includeElementClosure闭包,并将所有闭包的结果合成一个新序列sequence并返回。
复制代码 代码如下:

equal(map(1…3, { 0 * 5 }), [5, 10, 15])  for i in map(1…10, {0 * 10 }) {
// 10, 20, 30, …
println(i)
assert(contains([10, 20, 30, 40, 50, 60, 70, 80, 90, 100], i))
}

max(comparable1, comparable2, etc.):返回参数中的最大值。
复制代码 代码如下:

max(0, 1) == 1
max(8, 2, 3) == 8

maxElement(sequence):返回序列sequence中的最大值。
复制代码 代码如下:

maxElement(1…10) == 10
var languages = [“Swift”, “Objective-C”]
maxElement(languages) == “Swift”

minElements(sequence):返回序列sequence中的最小值。
复制代码 代码如下:

minElement(1…10) == 1
var languages = [“Swift”, “Objective-C”]
minElement(languages) == “Objective-C”
reduce(sequence, initial, combineClosure):给定一个序列sequence,以及一个初始值initial,然后将initial和序列里的第1个元素作为参数传入combineClosure中进行运算,得到的结果保存到initial;然后再将initial和第2个元素传入combineClosure中计算,结果保存到initial;重复计算直到所有sequence中的元素都计算完毕,并返回最终的initial值。
复制代码 代码如下:

var languages = [“Swift”, “Objective-C”]
reduce(languages, “”, { 0+1 }) == “SwiftObjective-C”
reduce([10, 20, 5], 1, { 01 }) == 1000
reverse(sequence):返回逆序的序列sequence。
复制代码 代码如下:

equal(reverse([1, 2, 3]), [3, 2, 1])
for i in reverse([1, 2, 3]) {
// 3, 2, 1
println(i)
}
startsWith(sequence1, sequence2):如果序列sequence1中开头的元素跟序列sequence2中的所有元素都相等,则返回true,否则返回false。
复制代码 代码如下:

startsWith(“foobar”, “foo”) == true
startsWith(10..100, 10..15) == true
var languages = [“Swift”, “Objective-C”]
startsWith(languages, [“Swift”]) == true
上面提到的函数是我认为在Swift编程中会经常用到的函数。
完整74个内置函数:
复制代码 代码如下:

abs(…)
advance(…)
alignof(…)
alignofValue(…)
assert(…)
bridgeFromObjectiveC(…)
bridgeFromObjectiveCUnconditional(…)
bridgeToObjectiveC(…)
bridgeToObjectiveCUnconditional(…)
c_malloc_size(…)
c_memcpy(…)
c_putchar(…)
contains(…)
count(…)
countElements(…)
countLeadingZeros(…)
debugPrint(…)
debugPrintln(…)
distance(…)
dropFirst(…)
dropLast(…)
dump(…)
encodeBitsAsWords(…)
enumerate(…)
equal(…)
filter(…)
find(…)
getBridgedObjectiveCType(…)
getVaList(…)
indices(…)
insertionSort(…)
isBridgedToObjectiveC(…)
isBridgedVerbatimToObjectiveC(…)
isUniquelyReferenced(…)
join(…)
lexicographicalCompare(…)
map(…)
max(…)
maxElement(…)
min(…)
minElement(…)
numericCast(…)
partition(…)
posix_read(…)
posix_write(…)
print(…)
println(…)
quickSort(…)
reduce(…)
reflect(…)
reinterpretCast(…)
reverse(…)
roundUpToAlignment(…)
sizeof(…)
sizeofValue(…)
sort(…)
split(…)
startsWith(…)
strideof(…)
strideofValue(…)
swap(…)
swift_MagicMirrorData_summaryImpl(…)
swift_bufferAllocate(…)
swift_keepAlive(…)
toString(…)
transcode(…)
underestimateCount(…)
unsafeReflect(…)
withExtendedLifetime(…)
withObjectAtPlusZero(…)
withUnsafePointer(…)
withUnsafePointerToObject(…)
withUnsafePointers(…)
withVaList(…)

2017-11-23 22:45:39 leemboy 阅读数 2694

Swift for 语句


      一般来说,swift循环是递增式遍历。当然各种循环,swift都能办到。但其大多采用关键字形式实现,大部分开发者更喜欢直接使用C式循环代码。在swift3.0后,C语言形式被彻底废弃,因此从低版本升上来的代码如果是swift风格写法,按照提示基本可以直接fix。但如果很多循环实现都是基于C语言形式,那不得不讨论一下如何拯救这个可怕的习惯了。swift的循环语言特性跟python最为接近。所以,大多数python循环能处理的情况,swift都能办到。

1:如何遍历一个字典或者数组?

      首先要提的是swiftfor..in..语法,这个语法在python当中被称之为迭代。用于数组,字典之类的数据内容遍历。从作用上分析,是直接将数组元素赋值给变量,并取出,无需通过数组下标来取值。而针对于字典,除了取出key值,我们还可以同时取出关键字。具体代码如下


let list = [1,3,5,7,"string test"]

for i in list{

    print(i)

}

let dict = ["name":"key name","name1":"key1 name","name2":"key 2 name"]

for key in dict{

    print(key)

}

}

2:也许,我仅仅是需要一个计数器?

      更多时候,循环变量被用于约束循环的次数或者做为int类型进行引用,值得一提的是,swift支持直接区间遍历。在3.0版本之前,python的区间语法range关键词适用。在3.0以后。swift不推荐使用。并且基于自身语言特性,在使用时,需要额外加关键字。那么,我们如何用swift带来的语法糖写出漂亮的for循环呢 代码如下:


for i in 1..<10{

    print(i)

    // 打印结果为1-9

}

for i in 1...10{

    print(i)

    //打印结果为1-10

}

 

for i in Range(start: 1,end: 10){

    print(i)

    // 打印结果为1-9 不推荐使用

}

  3help 我真的需要递减! 

    这也许是swift的一个大坑了,当然解决方式很容易。只需要一个关键字即可实现,swift3.0之后稍有变化。对要遍历的区间调用reverse()方法,即可实现for循环的反向遍历,代码如下


for i in (0...10).reverse(){

    print(i)<br>    // 打印结果为10-0

}

  4:这就结束了吗

    当然不是啦,从语言特性上来上说,python对数组和循环的处理是最令人觉得舒适的。而在循环的处理上,几乎涵盖了python的所有特性,且大多也是以函数调用的方式来处理的。下面就要介绍一下平时可能会用到的一些方法。

4.1.enumerate

   如词,这是为遍历对象调用一个枚举方法,在对数组等结构进行遍历时,我们偶尔需要知道每次遍历的索引,那么就需要用到enumerate了,其返回对象是一个元组,形式为(xy),x代表遍历的索引值,y代表遍历的元素。代码如下:


for (index, i) in (1...10).enumerate(){

    print(index)// 遍历索引

    print(i) // 遍历元素

     

}

4.2 filter

     也许,你想要在循环就过滤掉一系列毫无意义的数据?,swift提供在循环时直接过滤的方法,代码如下:


for i in (1...10).filter({ i in i % 2 == 0}) {

    print(i)

    //输出结果为1-10之间的偶数

}

///////////补充一个漂亮的语法糖///////////

for i in (1...10).filter({ $0 % 2 == 0}) {//swift闭包可以省略参数且用$0匿名,第二个参数则用$1,以此类推

    print(i)

    //输出结果为1-10之间的偶数

}


2019-09-02 16:32:49 u011307204 阅读数 134

MemoryLayout

  • 获取数据类型占用内存的大小
var age = 10


MemoryLayout<Int>.size //实际占用的内存大小
MemoryLayout<Int>.stride //分配的内存大小
MemoryLayout<Int>.alignment //内存对齐参数

MemoryLayout<Int>.size(ofValue: age)
MemoryLayout<Int>.stride(ofValue: age)
MemoryLayout<Int>.alignment(ofValue: age)

enum Season {
    case spring, summer
}

var s = Season.spring
MemoryLayout<Season>.size(ofValue: s)
MemoryLayout<Season>.stride(ofValue: s)
MemoryLayout<Season>.alignment(ofValue: s)

swift for 循环

阅读数 8418