您的位置:首页 > 教育 > 培训 > swift小知识点

swift小知识点

2024/10/5 21:12:14 来源:https://blog.csdn.net/u013712343/article/details/140491585  浏览:    关键词:swift小知识点

1、

如果你需要接收用户的输入可以使用 readLine():

let theInput = readLine()

2、

类型别名对当前的类型定义了另一个名字,类型别名通过使用 typealias 关键字来定义。语法格式如下:

typealias newname = type

例如以下定义了 Int 的类型别名为 Feet:

typealias Feet = Int

3、

Swift 是一个类型安全(type safe)的语言。

由于 Swift 是类型安全的,所以它会在编译你的代码时进行类型检查(type checks),并把不匹配的类型标记为错误。这可以让你在开发的时候尽早发现并修复错误。
相比较之下,OC语言不是类型安全的语言。它允许在运行时进行一些类型不安全的操作。‌例如,‌定义一个NSString对象时,‌可以将其误传递给期望int类型的参数。

4、

Swift 的变量名也可以使用简单的 Unicode 字符,如下实例:

var 你好 = "你好世界"

print(你好)

5、

变量和常量可以使用 print(swift 2 将 print 替换了 println) 函数来输出。

在字符串中可以使用括号与反斜线来插入变量,如下实例:

import Cocoavar name = "菜鸟教程"
var site = "http://www.runoob.com"print("\(name)的官网地址为:\(site)")

以上程序执行结果为:

菜鸟教程的官网地址为:http://www.runoob.com

5、

Swift 的可选(Optional)类型,用于处理值缺失的情况。可选表示"那儿有一个值,并且它等于 x "或者"那儿没有值"。

Swfit语言定义后缀?作为命名类型Optional的简写,换句话说,以下两种声明是相等的:

var optionalInteger: Int?
var optionalInteger: Optional<Int>

在这两种情况下,变量 optionalInteger 都是可选整数类型。注意,在类型和 ?之间没有空格。

Optional 是一个含有两种情况的枚举,None 和 Some(T),用来表示可能有或可能没有值。任何类型都可以明确声明为(或者隐式转换)可选类型。当声明一个可选类型的时候,要确保用括号给 ? 操作符一个合适的范围。例如,声明可选整数数组,应该写成 (Int[])? 写成 Int[]? 会报错。

当你声明一个可选变量或者可选属性的时候没有提供初始值,它的值会默认为 nil。

可选项遵照 LogicValue 协议,因此可以出现在布尔环境中。在这种情况下,如果可选类型T?包含类型为T的任何值(也就是说它的值是 Optional.Some(T) ),这个可选类型等于 true,反之为 false。

如果一个可选类型的实例包含一个值,你可以用后缀操作符 !来访问这个值,如下所示:

optionalInteger = 42
optionalInteger! // 42

使用操作符!去获取值为nil的可选变量会有运行时错误。

你可以用可选链接和可选绑定选择性执行可选表达式上的操作。如果值为nil,任何操作都不会执行,也不会有运行报错。

可选类型类似于Objective-C中指针的nil值,但是nil只对类(class)有用,而可选类型对所有的类型都可用,并且更安全。

当你确定可选类型确实包含值之后,你可以在可选的名字后面加一个感叹号(!)来获取值。这个感叹号表示"我知道这个可选有值,请使用它。"这被称为可选值的强制解析(forced unwrapping)。

你可以在声明可选变量时使用感叹号(!)替换问号(?)。这样可选变量在使用时就不需要再加一个感叹号(!)来获取值,它会自动解析。如下表示:

var myString:String!

6、

使用可选绑定(optional binding)来判断可选类型是否包含值,如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在if和while语句中来对可选类型的值进行判断并把值赋给一个常量或者变量。

像下面这样在if语句中写一个可选绑定:

if let constantName = someOptional {statements
}

事例:

var myString:String?myString = "Hello, Swift!"if let yourString = myString {print("你的字符串值为 - \(yourString)")
}else{print("你的字符串没有值")
}

以上程序执行结果为:

你的字符串值为 - Hello, Swift!

7、

常量名也可以使用简单的 Unicode 字符,如下实例:

import Cocoalet 你好 = "你好世界"
print(你好)

8、

Swift 字面量

所谓字面量,就是指像特定的数字,字符串或者是布尔值这样,能够直接了当地指出自己的类型并为变量进行赋值的值。比如在下面:

let aNumber = 3         //整型字面量
let aString = "Hello"   //字符串字面量
let aBool = true        //布尔值字面量

9、

运算符描述实例
闭区间运算符闭区间运算符(a...b)定义一个包含从a到b(包括a和b)的所有值的区间,b必须大于等于a。 ‌ 闭区间运算符在迭代一个区间的所有值时是非常有用的,如在for-in循环中:1...5 区间值为 1, 2, 3, 4 和 5
半开区间运算符半开区间(a..<b)定义一个从a到b但不包括b的区间。 之所以称为半开区间,是因为该区间包含第一个值而不包括最后的值。1..< 5 区间值为 1, 2, 3, 和 4

10、

运算符优先级

在一个表达式中可能包含多个有不同运算符连接起来的、具有不同数据类型的数据对象;由于表达式有多种运算,不同的运算顺序可能得出不同结果甚至出现错误运算错误,因为当表达式中含多种运算时,必须按一定顺序进行结合,才能保证运算的合理性和结果的正确性、唯一性。

优先级从上到下依次递减,最上面具有最高的优先级,逗号操作符具有最低的优先级。

相同优先级中,按结合顺序计算。大多数运算是从左至右计算,只有三个优先级是从右至左结合的,它们是单目运算符、条件运算符、赋值运算符。

基本的优先级需要记住:

  • 指针最优,单目运算优于双目运算。如正负号。
  • 先乘除(模),后加减。
  • 先算术运算,后移位运算,最后位运算。请特别注意:1 << 3 + 2 & 7 等价于 (1 << (3 + 2))&7
  • 逻辑运算最后计算

Swift 运算符优先级 (从高到低):

运算符实例
位运算符>> &<< &>> >>
乘法运算符&* % & * /
加法运算符| &+ &- + -  ^
区间运算符..< ...
类型转换运算符is as
nil 的聚合运算??
比较运算符!= > < >= <= === ==
逻辑与运算符&&
逻辑或运算符||
波浪箭头~>
三元运算符?:
箭头函数( )
赋值运算符|= %= /= &<<= &>>= &= *= >>= <<= ^= += -=


11、

while 循环

运行一系列语句,如果条件为true,会重复运行,直到条件变为false。

repeat...while 循环

类似 while 语句区别在于判断循环条件之前,先执行一次循环的代码块。
控制语句描述

continue 语句

告诉一个循环体立刻停止本次循环迭代,重新开始下次循环迭代。

break 语句

中断当前循环。

fallthrough 语句

如果在一个case执行完后,继续执行下面的case,需要使用fallthrough(贯穿)关键字。

12、

字符串可以通过 + 号来连接,如:

let constA = "菜鸟教程:"
let constB = "http://www.runoob.com"var stringA = constA + constB

字符串长度使用 String.count 属性来计算.

你可以使用 == 来比较两个字符串是否相等:

Swift 的 String 类型表示特定序列的 Character(字符) 类型值的集合。 每一个字符值代表一个 Unicode 字符。

Swift 3 中的 String 需要通过 characters 去调用的属性方法,在 Swift 4 中可以通过 String 对象本身直接调用

String 的 append() 方法来实现字符串连接字符,如:

varA.append( varB )

13、

构造语法来创建一个由特定数据类型构成的空数组:
var someArray = [SomeType]()

创建一个初始化大小数组的语法:

var someArray = [SomeType](repeating: InitialValue, count: NumbeOfElements)

以下实例创建了一个类型为 Int ,数量为 3,初始值为 0 的空数组:

var someInts = [Int](repeating: 0, count: 3)

以下实例创建了含有三个元素的数组:

var someInts:[Int] = [10, 20, 30]

修改数组

你可以使用 append() 方法或者赋值运算符 += 在数组末尾添加元素,如下所示,我们初始化一个数组,并向其添加元素:

import Cocoavar someInts = [Int]()someInts.append(20)
someInts.append(30)
someInts += [40]

合并数组

我们可以使用加法操作符(+)来合并两种已存在的相同类型数组。新数组的数据类型会从两个数组的数据类型中推断出来:

import Cocoavar intsA = [Int](repeating: 2, count:2)
var intsB = [Int](repeating: 1, count:3)var intsC = intsA + intsB

14、

创建字典

我们可以使用以下语法来创建一个特定类型的空字典:

var someDict =  [KeyType: ValueType]()

以下是创建一个空字典,键的类型为 Int,值的类型为 String 的简单语法:

var someDict = [Int: String]()

以下为创建一个字典的实例:

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

我们可以根据字典的索引来访问数组的元素,语法如下:

var someVar = someDict[key]

修改字典

我们可以使用 updateValue(forKey:) 增加或更新字典的内容。如果 key 不存在,则添加值,如果存在则修改 key 对应的值。updateValue(_:forKey:)方法返回Optional值。

移除 Key-Value 对

我们可以使用 removeValueForKey() 方法来移除字典 key-value 对。如果 key 存在该方法返回移除的值,如果不存在返回 nil 。实例如下:

字典转换为数组

你可以提取字典的键值(key-value)对,并转换为独立的数组。实例如下:

import Cocoavar someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]let dictKeys = [Int](someDict.keys)
let dictValues = [String](someDict.values)

count 属性

我们可以使用只读的 count 属性来计算字典有多少个键值对:

15、

Swift 函数

Swift 定义函数使用关键字 func

定义函数的时候,可以指定一个或多个输入参数和一个返回值类型。

语法

func funcname(形参) -> returntype
{Statement1Statement2……Statement Nreturn parameters
}

元组作为函数返回值

函数返回值类型可以是字符串,整型,浮点型等。

元组与数组类似,不同的是,元组中的元素可以是任意类型,使用的是圆括号。

你可以用元组(tuple)类型让多个值作为一个复合值从函数中返回。

下面的这个例子中,定义了一个名为minMax(_:)的函数,作用是在一个Int数组中找出最小值与最大值。

import Cocoafunc minMax(array: [Int]) -> (min: Int, max: Int) {var currentMin = array[0]var currentMax = array[0]for value in array[1..<array.count] {if value < currentMin {currentMin = value} else if value > currentMax {currentMax = value}}return (currentMin, currentMax)
}let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("最小值为 \(bounds.min) ,最大值为 \(bounds.max)")

minMax(_:)函数返回一个包含两个Int值的元组,这些值被标记为min和max,以便查询函数的返回值时可以通过名字访问它们。

以上程序执行输出结果为:

最小值为 -6 ,最大值为 109

如果你不确定返回的元组一定不为nil,那么你可以返回一个可选的元组类型。

你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组,例如(Int, Int)?或(String, Int, Bool)?

注意
可选元组类型如(Int, Int)?与元组包含可选类型如(Int?, Int?)是不同的.可选的元组类型,整个元组是可选的,而不只是元组中的每个元素值。

没有返回值函数

下面是 runoob(_:) 函数的另一个版本,这个函数接收菜鸟教程官网网址参数,没有指定返回值类型,并直接输出 String 值,而不是返回它:

import Cocoafunc runoob(site: String) {print("菜鸟教程官网:\(site)")
}
runoob(site: "http://www.runoob.com")

 就好像是swift项目中的

  override func viewDidLoad() {

        super.viewDidLoad()

}

外部参数名

你可以在局部参数名前指定外部参数名,中间以空格分隔,外部参数名用于在函数调用时传递给函数的参数。

func pow(firstArg a: Int, secondArg b: Int) -> Int {var res = afor _ in 1..<b {res = res * a}print(res)return res
}
pow(firstArg:5, secondArg:3)

注意
如果你提供了外部参数名,那么函数在被调用时,必须使用外部参数名。

可变参数

可变参数可以接受零个或多个值。函数调用时,你可以用可变参数来指定函数参数,其数量是不确定的。

可变参数通过在变量类型名后面加入(...)的方式来定义。

import Cocoafunc vari<N>(members: N...){for i in members {print(i)}
}
vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Google", "Baidu", "Runoob")

常量,变量及 I/O 参数

一般默认在函数中定义的参数都是常量参数,也就是这个参数你只可以查询使用,不能改变它的值。

如果想要声明一个变量参数,可以在参数定义前加 inout 关键字,这样就可以改变这个参数的值了。

例如:

func  getName(_ name: inout String).........

此时这个 name 值可以在函数中改变。

一般默认的参数传递都是传值调用的,而不是传引用。所以传入的参数在函数内改变,并不影响原来的那个参数。传入的只是这个参数的副本。

当传入的参数作为输入输出参数时,需要在参数名前加 & 符,表示这个值可以被函数修改。

实例

import Cocoafunc swapTwoInts(_ a: inout Int, _ b: inout Int) {let temporaryA = aa = bb = temporaryA
}var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 现在的值 \(x), y 现在的值 \(y)")

swapTwoInts(_:_:) 函数简单地交换 a 与 b 的值。该函数先将 a 的值存到一个临时常量 temporaryA 中,然后将 b 的值赋给 a,最后将 temporaryA 赋值给 b。

需要注意的是,someInt 和 anotherInt 在传入 swapTwoInts(_:_:) 函数前,都加了 & 的前缀。

以上程序执行输出结果为:

x 现在的值 5, y 现在的值 1

使用函数类型

在 Swift 中,使用函数类型就像使用其他类型一样。例如,你可以定义一个类型为函数的常量或变量,并将适当的函数赋值给它:

var addition: (Int, Int) -> Int = sum

解析:

"定义一个叫做 addition 的变量,参数与返回值类型均是 Int ,并让这个新变量指向 sum 函数"。

sum 和 addition 有同样的类型,所以以上操作是合法的。

现在,你可以用 addition 来调用被赋值的函数了:

import Cocoafunc sum(a: Int, b: Int) -> Int {return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")

以上程序执行输出结果为:

输出结果: 129

函数类型作为参数类型、函数类型作为返回类型

我们可以将函数作为参数传递给另外一个参数:

import Cocoafunc sum(a: Int, b: Int) -> Int {return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")func another(addition: (Int, Int) -> Int, a: Int, b: Int) {print("输出结果: \(addition(a, b))")
}
another(addition: sum, a: 10, b: 20)

以上程序执行输出结果为:

输出结果: 129
输出结果: 30

函数嵌套

函数嵌套指的是函数内定义一个新的函数,外部的函数可以调用函数内定义的函数。

实例如下:

import Cocoafunc calcDecrement(forDecrement total: Int) -> () -> Int {var overallDecrement = 0func decrementer() -> Int {overallDecrement -= totalreturn overallDecrement}return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem())

以上程序执行输出结果为:

-30

16、

Swift 闭包

闭包(Closures)是自包含的功能代码块,可以在代码中使用或者用来作为参数传值。

Swift 中的闭包与 C 和 Objective-C 中的代码块(blocks)以及其他一些编程语言中的 匿名函数比较相似。

全局函数和嵌套函数其实就是特殊的闭包。 

闭包的形式有:

全局函数嵌套函数闭包表达式
有名字但不能捕获任何值。 有名字,也能捕获封闭函数内的值。 无名闭包,使用轻量级语法,可以根据上下文环境捕获值。

Swift中的闭包有很多优化的地方: 

语法

以下定义了一个接收参数并返回指定类型的闭包语法:

{(parameters) -> return type instatements
}

实例

import Cocoalet studname = { print("Swift 闭包实例。") }
studname()

以上程序执行输出结果为:

Swift 闭包实例。

以下闭包形式接收两个参数并返回布尔值:

{(Int, Int) -> Bool inStatement1Statement 2---Statement n
}
  1. 根据上下文推断参数和返回值类型
  2. 从单行表达式闭包中隐式返回(也就是闭包体只有一行代码,可以省略return)
  3. 可以使用简化参数名,如$0, $1(从0开始,表示第i个参数...)
  4. 提供了尾随闭包语法(Trailing closure syntax)

语法

以下定义了一个接收参数并返回指定类型的闭包语法:

{(parameters) -> return type instatements
}

实例

import Cocoalet studname = { print("Swift 闭包实例。") }
studname()

以上程序执行输出结果为:

Swift 闭包实例。

以下闭包形式接收两个参数并返回布尔值:

{(Int, Int) -> Bool inStatement1Statement 2---Statement n
}

Swift 标准库提供了名为 sorted(by:) 的方法,会根据您提供的用于排序的闭包函数将已知类型数组中的值进行排序。 

排序完成后,sorted(by:) 方法会返回一个与原数组大小相同,包含同类型元素且元素已正确排序的新数组。原数组不会被 sorted(by:) 方法修改。

sorted(by:)方法需要传入两个参数:

实例

import Cocoalet names = ["AT", "AE", "D", "S", "BE"]// 使用普通函数(或内嵌函数)提供排序功能,闭包函数类型需为(String, String) -> Bool。
func backwards(s1: String, s2: String) -> Bool {return s1 > s2
}
var reversed = names.sorted(by: backwards)print(reversed)

以上程序执行输出结果为:

["S", "D", "BE", "AT", "AE"]

      • 已知类型的数组
      • 闭包函数,该闭包函数需要传入与数组元素类型相同的两个值,并返回一个布尔类型值来表明当排序结束后传入的第一个参数排在第二个参数前面还是后面。如果第一个参数值出现在第二个参数值前面,排序闭包函数需要返回 true,反之返回 false

如果第一个字符串 (s1) 大于第二个字符串 (s2),backwards函数返回true,表示在新的数组中s1应该出现在s2前。 对于字符串中的字符来说,"大于" 表示 "按照字母顺序较晚出现"。 这意味着字母"B"大于字母"A",字符串"S"大于字符串"D"。 其将进行字母逆序排序,"AT"将会排在"AE"之前。

参数名称缩写

Swift 自动为内联函数提供了参数名称缩写功能,您可以直接通过$0,$1,$2来顺序调用闭包的参数。

实例

import Cocoalet names = ["AT", "AE", "D", "S", "BE"]var reversed = names.sorted( by: { $0 > $1 } )
print(reversed)

$0和$1表示闭包中第一个和第二个String类型的参数。

以上程序执行输出结果为:

["S", "D", "BE", "AT", "AE"]

如果你在闭包表达式中使用参数名称缩写, 您可以在闭包参数列表中省略对其定义, 并且对应参数名称缩写的类型会通过函数类型进行推断。in 关键字同样也可以被省略.

运算符函数

实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。

Swift 的String类型定义了关于大于号 (>) 的字符串实现,其作为一个函数接受两个String类型的参数并返回Bool类型的值。 而这正好与sort(_:)方法的第二个参数需要的函数类型相符合。 因此,您可以简单地传递一个大于号,Swift可以自动推断出您想使用大于号的字符串函数实现:

import Cocoalet names = ["AT", "AE", "D", "S", "BE"]var reversed = names.sorted(by: >)
print(reversed)

以上程序执行输出结果为:

["S", "D", "BE", "AT", "AE"]

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com