asp.net怎么生成网站,建筑安全员证查询网上查询,广东省建设厅网站6,知名商城网站建设价格低文章目录 术语赋值运算符算数运算符基本四则算术运算符求余运算符一元负号运算符一元正号运算符 比较运算符三元运算符空合运算符区间运算符闭区间运算符半开区间运算符单侧区间运算符 逻辑运算符逻辑非运算符逻辑与运算符逻辑或运算符逻辑运算符组合计算 位运算符运算符优先级… 文章目录 术语赋值运算符算数运算符基本四则算术运算符求余运算符一元负号运算符一元正号运算符 比较运算符三元运算符空合运算符区间运算符闭区间运算符半开区间运算符单侧区间运算符 逻辑运算符逻辑非运算符逻辑与运算符逻辑或运算符逻辑运算符组合计算 位运算符运算符优先级使用括号来明确优先级 运算符是检查、改变、合并值的特殊符号或短语。例如加号将两个数相加如 let i 1 2。更复杂的运算例子包括逻辑与运算符 如 if enteredDoorCode passedRetinaScan。 Swift 支持大部分标准 C 语言的运算符且为了减少常见编码错误做了部分改进。如赋值符不再有返回值这样就消除了手误将判等运算符写成赋值符导致代码错误的缺陷。算术运算符-*/% 等的结果会被检测并禁止值溢出以此来避免保存变量时由于变量大于或小于其类型所能承载的范围时导致的异常结果。当然允许你使用 Swift 的溢出运算符来实现溢出。详情参见 溢出运算符。
Swift 还提供了 C 语言没有的区间运算符例如 a…b 或 a…b这方便我们表达一个区间内的数值。
本章节只描述了 Swift 中的基本运算符高级运算符 这章会包含 Swift 中的高级运算符及如何自定义运算符及如何进行自定义类型的运算符重载。
术语
运算符分为一元、二元和三元运算符:
一元运算符对单一操作对象操作如 -a。一元运算符分前置运算符和后置运算符前置运算符需紧跟在操作对象之前如 !b后置运算符需紧跟在操作对象之后如 c!。二元运算符操作两个操作对象如 2 3是中置的因为它们出现在两个操作对象之间。三元运算符操作三个操作对象和 C 语言一样Swift 只有一个三元运算符就是三目运算符a ? b : c。
受运算符影响的值叫操作数在表达式 1 2 中加号 是二元运算符它的两个操作数是值 1 和 2。
赋值运算符
下表列出了 Swift 语言的基本赋值运算 以下为赋值运算的简单实例
var A 10
var B 20
var C 100C A B
print(C A B 结果为\(C))C A
print(C A 结果为\(C))C - A
print(C - A 结果为\(C))C * A
print(C * A 结果为\(C))C / A
print(C / A 结果为\(C))上述代码输出结果为
C A B 结果为30
C A 结果为40
C - A 结果为30
C * A 结果为300
C / A 结果为30算数运算符
基本四则算术运算符
Swift 中所有数值类型都支持了基本的四则算术运算符
运算符描述实例加号A B 结果为 30-减号A − B 结果为 -10*乘号A * B 结果为 200/除号B % A 结果为 0
var A 10
var B 20print(A B 结果为\(A B))
print(A - B 结果为\(A - B))
print(A * B 结果为\(A * B))
print(B / A 结果为\(B / A))
A 1 // 类似 A
print(A 1 后 A 的值为 \(A))
B - 1 // 类似 B--
print(B - 1 后 B 的值为 \(B))以上代码输出的结果为
A B 结果为30
A - B 结果为-10
A * B 结果为200
B / A 结果为2
A 1 后 A 的值为 11
B - 1 后 B 的值为 19※注意 与 C 语言和 Objective-C 不同的是Swift 默认情况下不允许在数值运算中出现溢出情况。但是你可以使用 Swift 的溢出运算符来实现溢出运算如 a b。详情参见 溢出运算符。 求余运算符
求余运算符a % b是计算 b 的多少倍刚刚好可以容入 a返回多出来的那部分余数。
我们来谈谈取余是怎么回事计算 9 % 4你先计算出 4 的多少倍会刚好可以容入 9 中 你可以在 9 中放入2个 4那余数是 1。在 Swift 中可以表达为
9 % 4 // 等于 1为了得到 a % b 的结果% 计算了以下等式并输出 余数作为结果
a (b × 倍数) 余数当 倍数取最大值的时候就会刚好可以容入 a 中。把 9 和 4 代入等式中我们得 19 (4 × 2) 1。 同样的方法我们来计算 -9 % 4
-9 % 4 // 等于 -1把 -9 和 4 代入等式-2 是使 余数 与 -9 同符号时能取到的最大整数-9 (4 × -2) -1余数是 -1。 ※注意 在对负数 b 求余时b 的符号会被忽略。这意味着 a % b 和 a % -b 的结果是相同的。 示例
let a 9 % 4;
print(a: \(a));let b 9 % -4;
print(b: \(b));let c -9 % 4;
print(c: \(c));以上代码输出的结果为
a: 1
b: 1
c: -1一元负号运算符
数值的正负号可以使用前缀 -即一元负号符来切换
let three 3
let minusThree -three // minusThree 等于 -3
let plusThree -minusThree // plusThree 等于 3, 或 负负3print(three: \(three));
print(minusThree: \(minusThree));
print(plusThree: \(plusThree));上述代码输出结果
three: 3
minusThree: -3
plusThree: 3※注意 一元负号符-写在操作数之前中间没有空格。 一元正号运算符
一元正号符不做任何改变地返回操作数的值
let minusSix -6
let alsoMinusSix minusSix // alsoMinusSix 等于 -6print(minusSix: \(minusSix));
print(alsoMinusSix: \(alsoMinusSix));上述代码输出结果
minusSix: -6
alsoMinusSix: -6比较运算符
以下表格列出了 Swift 语言支持的比较运算符其中变量 A 为 10变量 B 为 20
运算符描述实例等于(A B) 为 false!不等于(A ! B) 为 true大于(A B) 为 false小于(A B) 为 true大于等于(A B) 为 false小于等于(A B) 为 true ※注意 Swift 也提供恒等和不恒等!这两个比较符来判断两个对象是否引用同一个对象实例。更多细节在 类与结构 章节的恒等运算符部分。 每个比较运算都返回了一个标识表达式是否成立的布尔值
let a 1 1 // true, 因为 1 等于 1
let b 2 ! 1 // true, 因为 2 不等于 1
let c 2 1 // true, 因为 2 大于 1
let d 1 2 // true, 因为 1 小于2
let e 1 1 // true, 因为 1 大于等于 1
let f 2 1 // false, 因为 2 并不小于等于 1print(type of a: \(type(of: a)), a value: \(a));
print(type of b: \(type(of: b)), a value: \(b));
print(type of c: \(type(of: c)), a value: \(c));
print(type of d: \(type(of: d)), a value: \(d));
print(type of e: \(type(of: e)), a value: \(e));
print(type of f: \(type(of: f)), a value: \(f));上述代码输出结果为
type of a: Bool, a value: true
type of b: Bool, a value: true
type of c: Bool, a value: true
type of d: Bool, a value: true
type of e: Bool, a value: true
type of f: Bool, a value: false如果两个元组的元素相同且长度相同的话元组就可以被比较。比较元组大小会按照从左到右、逐值比较的方式直到发现有两个值不等时停止。如果所有的值都相等那么这一对元组我们就称它们是相等的。例如
let aa (1, zebra) (2, apple) // true因为 1 小于 2
let bb (3, apple) (3, bird) // true因为 3 等于 3但是 apple 小于 bird
let cc (4, dog) (4, dog) // true因为 4 等于 4dog 等于 dogprint(type of aa: \(type(of: aa)), a value: \(aa));
print(type of bb: \(type(of: bb)), a value: \(bb));
print(type of cc: \(type(of: cc)), a value: \(cc));上述代码输出结果
type of aa: Bool, a value: true
type of bb: Bool, a value: true
type of cc: Bool, a value: true当元组中的元素都可以被比较时你也可以使用这些运算符来比较它们的大小。例如像下面展示的代码你可以比较两个类型为 (String, Int) 的元组因为 Int 和 String 类型的值可以比较。相反Bool 不能被比较也意味着存有布尔类型的元组不能被比较。
(blue, -1) (purple, 1) // 正常比较的结果为 true
(blue, false) (purple, true) // 错误因为 不能比较布尔类型※注意 Swift 标准库只能比较 7个 以内元素的元组比较函数。如果你的元组元素超过 7个 时你需要自己实现比较运算符。 三元运算符
三元运算符的特殊在于它是有三个操作数的运算符它的形式是 问题 ? 答案 1 : 答案 2。它简洁地表达根据 问题成立与否作出二选一的操作。如果 问题 成立返回 答案 1 的结果反之返回 答案 2 的结果。 三元运算符是以下代码的缩写形式
if question {answer1
} else {answer2
}这里有个计算表格行高的例子。如果有表头那行高应比内容高度要高出 50 点如果没有表头只需高出 20 点
let contentHeight 40
let hasHeader true
let rowHeight contentHeight (hasHeader ? 50 : 20) // rowHeight 现在是 90
print(rowHeight:\(rowHeight));上述代码输出的结果是
rowHeight:90上面的写法比下面的代码更简洁
let contentHeight 40
let hasHeader true
var rowHeight contentHeight
if hasHeader {rowHeight rowHeight 50
} else {rowHeight rowHeight 20
}
// rowHeight 现在是 90第一段代码例子使用了三元运算所以一行代码就能让我们得到正确答案。这比第二段代码简洁得多无需将 rowHeight 定义成变量因为它的值无需在 if 语句中改变。
三元运算为二选一场景提供了一个非常便捷的表达形式。不过需要注意的是滥用三元运算符会降低代码可读性。所以我们应避免在一个复合语句中使用多个三元运算符。
空合运算符
空合运算符a ?? b将对可选类型 a 进行空判断如果 a 包含一个值就进行解包否则就返回一个默认值 b。表达式 a 必须是 Optional 类型。默认值 b 的类型必须要和 a 存储值的类型保持一致。
空合运算符是对以下代码的简短表达方法
a ! nil ? a! : b上述代码使用了三元运算符。当可选类型 a 的值不为空时进行强制解包a!访问 a 中的值反之返回默认值 b。无疑空合运算符??提供了一种更为优雅的方式去封装条件判断和解包两种行为显得简洁以及更具可读性。 ※注意 如果 a 为非空值non-nil那么值 b 将不会被计算。这也就是所谓的短路求值。 下文例子采用空合运算符实现了在默认颜色名和可选自定义颜色名之间抉择
let defaultColorName red
var userDefinedColorName: String? //默认值为 nilvar colorNameToUse userDefinedColorName ?? defaultColorName // userDefinedColorName 的值为空所以 colorNameToUse 的值为 red
print(colorNameToUse 值为: \(colorNameToUse))上述代码输出的结果为
colorNameToUse 值为: reduserDefinedColorName 变量被定义为一个可选的 String 类型默认值为 nil。由于 userDefinedColorName 是一个可选类型我们可以使用空合运算符去判断其值。在上一个例子中通过空合运算符为一个名为 colorNameToUse 的变量赋予一个字符串类型初始值。 由于 userDefinedColorName 值为空因此表达式 userDefinedColorName ?? defaultColorName 返回 defaultColorName 的值即 red。
如果你分配一个非空值non-nil给 userDefinedColorName再次执行空合运算运算结果为封包在 userDefinedColorName 中的值而非默认值。
userDefinedColorName String()
userDefinedColorName yellowcolorNameToUse userDefinedColorName ?? defaultColorName
print(colorNameToUse 值为: \(colorNameToUse)) // userDefinedColorName 的值不为空所以 colorNameToUse 的值为 yellow上述代码输出的结果为
colorNameToUse 值为: yellow区间运算符
闭区间运算符
闭区间运算符a...b定义一个包含从 a 到 b包括 a 和 b的所有值的区间。a 的值不能超过 b。闭区间运算符在迭代一个区间的所有值时是非常有用的如在 for-in 循环中
for index in 1...5 {print(\(index) * 5 \(index * 5))
}上述代码输出结果为
1 * 5 5
2 * 5 10
3 * 5 15
4 * 5 20
5 * 5 25半开区间运算符
半开区间运算符a..b定义一个从 a 到 b 但不包括 b 的区间。 之所以称为半开区间是因为该区间包含第一个值而不包括最后的值。
半开区间的实用性在于当你使用一个从 0 开始的列表如数组时非常方便地从0数到列表的长度。
let names [Anna, Alex, Brian, Jack]
let count names.count
for i in 0..count {print(第 \(i 1) 个人叫 \(names[i]))
}上述代码输出结果为
第 1 个人叫 Anna
第 2 个人叫 Alex
第 3 个人叫 Brian
第 4 个人叫 Jack单侧区间运算符
闭区间操作符有另一个表达形式可以表达往一侧无限延伸的区间 —— 例如一个包含了数组从索引 2 到结尾的所有值的区间。在这些情况下你可以省略掉区间操作符一侧的值。这种区间叫做单侧区间因为操作符只有一侧有值。例如
let names [Anna, Alex, Brian, Jack]for name in names[2...] {print([2...] -- \(name));
}for name in names[...2] {print([...2] -- \(name));
}上述代码输出结果为
[2...] -- Brian
[2...] -- Jack[...2] -- Anna
[...2] -- Alex
[...2] -- Brian半开区间操作符也有单侧表达形式附带上它的最终值。就像你使用区间去包含一个值最终值并不会落在区间内。例如
for name in names[..2] {print([..2] -- \(name));
}上述代码输出结果为
[..2] -- Anna
[..2] -- Alex单侧区间不止可以在下标里使用也可以在别的情境下使用。你不能遍历省略了初始值的单侧区间因为遍历的开端并不明显。你可以遍历一个省略最终值的单侧区间然而由于这种区间无限延伸的特性请保证你在循环里有一个结束循环的分支。你也可以查看一个单侧区间是否包含某个特定的值就像下面展示的那样
let range ...5
let result1 range.contains(7) // false
let result2 range.contains(4) // true
let result3 range.contains(-1) // trueprint(result1: \(result1))
print(result2: \(result2))
print(result3: \(result3))上述代码输出结果为
result1: false
result2: true
result3: true逻辑运算符
逻辑运算符的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。
逻辑非!a逻辑与a b逻辑或a || b
逻辑非运算符
逻辑非运算符!a对一个布尔值取反使得 true 变 falsefalse 变 true。 它是一个前置运算符需紧跟在操作数之前且不加空格。读作 非 a 例子如下
let allowedEntry false
if !allowedEntry {print(ACCESS DENIED)
}
// 输出“ACCESS DENIED”上述代码输出结果为
ACCESS DENIEDif !allowedEntry 语句可以读作「如果非 allowedEntry」接下一行代码只有在「非 allowedEntry」为 true即 allowEntry 为 false 时被执行。
在示例代码中小心地选择布尔常量或变量有助于代码的可读性并且避免使用双重逻辑非运算或混乱的逻辑语句。
逻辑与运算符
逻辑与运算符a b表达了只有 a 和 b 的值都为 true 时整个表达式的值才会是 true。
只要任意一个值为 false整个表达式的值就为 false。事实上如果第一个值为 false那么是不去计算第二个值的因为它已经不可能影响整个表达式的结果了。这被称做短路计算short-circuit evaluation。
以下例子只有两个 Bool 值都为 true 的时候才允许进入 if
let enteredDoorCode true
let passedRetinaScan false
if enteredDoorCode passedRetinaScan {print(Welcome!)
} else {print(ACCESS DENIED)
}
// 输出“ACCESS DENIED”上述代码输出结果为
ACCESS DENIED逻辑或运算符
逻辑或运算符a || b是一个由两个连续的 | 组成的中置运算符。它表示了两个逻辑表达式的其中一个为 true整个表达式就为 true。
同逻辑与运算符类似逻辑或也是「短路计算」的当左端的表达式为 true 时将不计算右边的表达式了因为它不可能改变整个表达式的值了。
以下示例代码中第一个布尔值hasDoorKey为 false但第二个值knowsOverridePassword为 true所以整个表达是 true于是允许进入
let hasDoorKey false
let knowsOverridePassword true
if hasDoorKey || knowsOverridePassword {print(Welcome!)
} else {print(ACCESS DENIED)
}
// 输出“Welcome!”上述代码输出结果为
Welcome!逻辑运算符组合计算
我们可以组合多个逻辑运算符来表达一个复合逻辑
let enteredDoorCode true
let passedRetinaScan false
let hasDoorKey false
let knowsOverridePassword trueif enteredDoorCode passedRetinaScan || hasDoorKey || knowsOverridePassword {print(Welcome!)
} else {print(ACCESS DENIED)
}
// 输出“Welcome!”上述代码输出结果为
Welcome!※注意 Swift 逻辑操作符 和 || 是左结合的这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。 位运算符
位运算符用来对二进制位进行操作~,,|,^分别为取反按位与与按位与或按位与异或运算如下表实例
pqp qp | qp^q00000010111111010011
假设A 0011 1100B 0000 1101
运算符描述图解实例按位与。按位与运算符对两个数进行操作然后返回一个新的数这个数的每个位都需要两个输入数的同一位都为1时才为1(A B) 结果为 12二进制为 00001100|按位或。按位或运算符|比较两个数然后返回一个新的数这个数的每一位设置1的条件是两个输入数的同一位都不为0(即任意一个为1或都为1)(A | B) 结果为 61二进制为 00111101^按位异或。按位异或运算符^比较两个数然后返回一个数这个数的每个位设为1的条件是两个输入数的同一位不同如果相同就设为0(A ^B) 结果为 49二进制为 00110001~按位取反运算符~对一个操作数的每一位都取反(~A ) 结果为 -61二进制为 11000011按位左移。左移操作符将操作数的所有位向左移动指定的位数下图展示了11111111 111111111 左移一位的结果。蓝色数字表示被移动位灰色表示被丢弃位空位用橙色的0填充A 2 结果为 240二进制为 11110000按位右移。右移操作符将操作数的所有位向右移动指定的位数下图展示了11111111 111111111 右移一位的结果。蓝色数字表示被移动位灰色表示被丢弃位空位用橙色的0填充A 2 结果为 15二进制为 00001111
示例 func bitwiseOperator() {let A 60 // 二进制为 0011 1100let B 13 // 二进制为 0000 1101let binaryA insertPlaceholderZero(initialString: String(A, radix: 2));let binaryB insertPlaceholderZero(initialString: String(B, radix: 2));let resultAnd insertPlaceholderZero(initialString: String(AB, radix: 2));let resultOr insertPlaceholderZero(initialString: String(A|B, radix: 2));let resultEctopic insertPlaceholderZero(initialString: String(A^B, radix: 2));let resultNegation String(~A, radix: 2);print(\(binaryA) \(binaryB) 的结果为: \(resultAnd));print(\(binaryA) | \(binaryB) 的结果为: \(resultOr));print(\(binaryA) ^ \(binaryB) 的结果为: \(resultEctopic));print(~\(binaryA) 的结果为: \(resultNegation));}func insertPlaceholderZero(initialString: String) - String {var resultString String();var newInitialString String();newInitialString initialString.filter{ $0 ! - };let bitesNum Int(newInitialString.count / 8);let placeholderCount (bitesNum 1) * 8 - newInitialString.count;for _ in 0 .. placeholderCount {resultString.append(0);}resultString resultString newInitialString;resultString addSpaceSeparator(initialString: resultString);if (initialString.contains(-)) {resultString.insert(contentsOf: -, at: resultString.startIndex);}return resultString;}func addSpaceSeparator(initialString: String) - String {var resultString String();var characterArray Array(initialString);characterArray characterArray.reversed();for index in 0..initialString.count {let chara characterArray[index];resultString.insert(chara, at: resultString.startIndex);if ((index 1) % 4 0 index ! (characterArray.count - 1)) {resultString.insert( , at: resultString.startIndex);}}return resultString;}上述代码输出结果为
0011 1100 0000 1101 的结果为: 0000 1100
0011 1100 | 0000 1101 的结果为: 0011 1101
0011 1100 ^ 0000 1101 的结果为: 0011 0001
~0011 1100 的结果为: -111101运算符优先级
在一个表达式中可能包含多个有不同运算符连接起来的、具有不同数据类型的数据对象由于表达式有多种运算不同的运算顺序可能得出不同结果甚至出现错误运算错误因为当表达式中含多种运算时必须按一定顺序进行结合才能保证运算的合理性和结果的正确性、唯一性。
优先级从上到下依次递减最上面具有最高的优先级逗号操作符具有最低的优先级。
相同优先级中按结合顺序计算。大多数运算是从左至右计算只有三个优先级是从右至左结合的它们是单目运算符、条件运算符、赋值运算符。
基本的优先级需要记住
指针最优单目运算优于双目运算。如正负号。先乘除模后加减。先算术运算后移位运算最后位运算。请特别注意1 3 2 7 等价于 (1 (3 2))7逻辑运算最后计算
Swift 运算符优先级 (从高到低)
运算符实例位运算符 乘法运算符* % * /加法运算符 - - ^区间运算符… …类型转换运算符is asnil 的聚合运算??比较运算符! 逻辑与运算符逻辑或运算符||波浪箭头~三元运算符?:箭头函数( )赋值运算符| % / * ^ -
使用括号来明确优先级
为了一个复杂表达式更容易读懂在合适的地方使用括号来明确优先级是很有效的虽然它并非必要的。在上个关于门的权限的例子中我们给第一个部分加个括号使它看起来逻辑更明确
if (enteredDoorCode passedRetinaScan) || hasDoorKey || knowsOverridePassword {print(Welcome!)
} else {print(ACCESS DENIED)
}
// 输出“Welcome!”这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要请在可以让你代码变清晰的地方加个括号吧
