Swift 4简介系列1.7 — Swift运算符

Swift支持大多数标准运算符和其他编程语言使用。 此外，Swift可提高使用这些运算符时的安全性。

所有标准运算符均分为3种类型。 他们是：

• 一元运算符：一元运算符可用于单个操作数。 它可以放在操作数前面（前缀），也可以放在操作数后面（后缀）。 前缀一元运算符的示例是-variable1 ， -10和！variable2 。 后缀一元运算符的示例为variable3！
• 二进制运算符：二进制运算符在2个操作数之间工作。 二进制运算符的示例是a + b，c / d和e * f
• 三元运算符：三元运算符使用3个操作数。 Swift中只有一个三元运算符； 它是三元条件运算符（a？b：c）

在语句1 + 2中，加号是运算符 ，数字是操作数 。

赋值运算符

最常见和最基本的运算符是赋值运算符。 基本语法如下：

=

例：

  var sampleNumber1 = 0 

  sampleNumber1 = 256 

 让sampleNumber2 = 242 

  sampleNumber1 = sampleNumber2 

 打印（sampleNumber2） 

对于元组，我们可以一次将多个值分配给多个变量/常量。

例：

 令（a，b，c）=（12，2.78，“测试”） 
 一种 
  b 
  C 

赋值运算符不返回值

与其他编程语言不同， Swift赋值运算符不返回数字或布尔值 。

在C编程中，我们可以将赋值语句与if组合起来，例如a = b {…}。 在C编程中，如果赋值成功，则a = b将返回true。

我们无法在Swift中组合赋值和if语句，因为Swift中的赋值语句不会返回任何内容。 要比较分配的值，我们必须使用比较运算符。

算术运算符

与其他编程语言类似，我们具有标准的算术运算符，如下所示：

• 加法（+）
• 减法（-）
• 乘法（*）
• 部门（/）

上述算术运算符是二进制运算符，它在2个操作数之间起作用，如下例所示：

  12 + 54 

  132–65 

  23 * 65 

  9823/3 

  //对于除法，请注意浮点数据类型 
  9823 / 3.0 

附加说明：

• 请使用浮点数除法以获得准确的结果。
• 请注意，任何数字除以零将返回错误

如前所述，在数据类型部分，Swift中没有整数溢出。 对于任何整数溢出尝试，Swift将返回错误。

例：

 让intMax = Int.max 

  // intMax为9223372036854775807 

  //让test1 = intMax + 1 
  //以上语句将产生错误，删除注释进行测试 

余数运算符

余数运算符表示为％。 执行除法运算后，该运算符将返回余数。 例如，11％3将返回2的余数，而11％2将返回1的余数。请参见下面的示例。

例：

  11％3 

  10％3 

  11％2 

余数运算符规则

Swift使用以下公式： a =（b *一些乘数）+余数以得出余数。 b的符号总是忽略。 因此，％b和％-b始终给出相同的答案。 -a％b将给您负数。 另请注意，Swift余数运算符仅适用于整数，不适用于浮点数。

负数余数运算符

余数运算符也可以使用负数。 但是，只有当第一个操作数（股息）为负数时，余数才为负数。 如果除数为负，则余数仍为正。

例：

  11％3 

  -11％3 

  11％-3 

  -11％-3 

模和余数运算符

许多程序员在模数和余数运算符之间感到困惑。 某些编程语言将％用作模数运算符，而某些编程语言将％用作余数运算符 。

用正数进行除法时，模运算符和余数运算符产生相同的结果。 两种类型的运算符之间的区别在处理负数时有所不同。

请参见下面的示例：

以下是使用Swift的其余操作：

以下是Python 2.7中的模运算（在Mac OS中可用）

如上所示，如果股息和除数均为正数或负数； 操作员返回相同的结果。

但是，如果股息或除数为负，则结果将不同。

我们想检查除数是否为正； 如果将股息从正数转移到负数，余数将如何变化。

例：

 为-12…12中的我{ 

  print（“ \（i）％3是\（i％3）”） 
  } 

结果如下

从余数运算中，我们知道一旦股息为负，余数将为负。

对于模运算，无论股息为负还是正，余数始终为正。 此外，当分红为负时，mod的计算与Swift有所不同。 为了得出-11％3，Python使用公式（-倍数x倍数）+模数。 在我们的示例中，倍数推导为-4 x 3 = -12。 因此，-12 +模数= -11，因此模数为1。请注意，模数必须为正。 我们不能使用-9和-2（模数）来得出-11。

请注意，对于C类型的编程语言，例如C，C＃，Java，JavaScript和Swift； 实现是相同的。 诸如Python，Smalltalk，Perl，MATLAB，Haskell和Common LISP之类的编程语言正在使用另一种类型的实现。

另请注意，某些编程语言提供了两种不同的实现方式。 在Python中，要实现类似于Swift或C的余数运算，我们需要使用math.fmod。

上一节不是对余数和模运算之间差异的全面研究。 这只是提醒程序员，当我们使用模数和余数处理负数时，它们之间存在差异。

浮点数余数

要将余数用作浮点数，我们可以使用函数restder（_，_）或truncatingRemainder（dividingBy 🙂

两种功能产生不同的结果。 请参见下面的示例”

我们将不对此进行详细研究。

一元减号

我们可以使用一元减运算符（-）将正数转换为负数。 请参见下面的示例：

例：

 设a = 13 

 令b = -a 

 令c = -b 

注意：我们使用一元减运算符将正数转换为负数。 我们还可以使用相同的运算符将负数转换为正数，如上所示。

一元加号运算符在Swift中无效。

算术运算符的应用

例：

 令unitPrice = 25.5 
 令数量= 12546 
 让存款= 10034.80 

 交易量=单价*双倍（数量） 

 让折扣=金额* 0.05 

 让discountAmount =-折扣 

 让payableAmount =金额+ discountAmount 

  //从先前的代码继续 
 让salesTax =应付金额* 0.07 

 设totalAmount = payableAmount + salesTax 

 让CashPayment = totalAmount —存款 

 让totalUnitCost = totalAmount / 12546 

复合赋值运算符

复合赋值运算符（例如+ = x）是写a = a + x的一种简短形式。 我们有以下类型的复合赋值运算符：

• 加法（+ =）与a = a + x相同
• 减法（-=）与a = a — x相同
• 乘法（* =）与a = a * x相同
• 除（/ =）与a = a / x相同
• 余数（％=）与a = a％x相同

例：

  var a = 10 

  -= 1 

  * = 2 

  / = 2 

 一个+ = 2 

 一个％= 2 

注意：

复合语句不返回值。

您不能使用以下内容

让var551 = var54 + = 5

要么

让var551 =（var54 + = 5）

例：

 变数54 = 10 
  // let var551 =（var54 + = 5）//将生成错误警告 

比较运算符

比较运算符比较数字，如果测试为真，则返回。 以下是比较运算符：

• 等于（==）
• 不等于（！=）
• 大于（>）
• 小于（<）
• 大于或等于（> =）
• 小于或等于（<=）

每个比较都返回一个布尔值。

例：

  10 == 10 
  20 == 21 

  123！= 934 
  123！= 123 

  12476> 887 
  12476> 12476 
  12476> 12477 

  768 <409098 
  409098 <409098 
  409099 <409098 

范例2：

  1776> = 1775 
  1776> = 1776 
  1776> = 1777 

  7172 <= 7173 
  7172 <= 7172 
  7172 <= 7171 

我们还可以将元组与元组进行比较。 通过从左到右比较每个元素来进行比较。 对于相等（==）比较，系统将比较最左边的元素和右边的第一个元素； 如果相等且结果为true，则系统将继续比较第二个元素。 如果不相等 ，则系统将在第一次比较后返回false并停止比较操作。

 让originalTuples =（“ a”，12，2.78） 

  //仅当所有元素为true时为true 
  originalTuples ==（“ a”，12,2.78） 
  originalTuples ==（“ A”，12,2.78） 

同样，对于不相等的运算（！=），系统将比较每个元素。 如果结果为假（等于），则系统将比较下一个元素。 如果比较结果为真（不等于），系统将停止比较。

 让originalTuples =（“ z”，10，2.788） 

  //只有当所有元素为false时才为false 
  originalTuples！=（“ c”，12,98） 
  originalTuples！=（“ z”，10,2.788） 
  originalTuples！=（“ a”，10,2.78） 
  //前面的语句2.78是！= 2.788 

我们可以使用大于或小于符号来比较元组元素。 但是，系统将返回不相等的第一个元素的结果。 如果两个元组的第一个元素不相等，系统将返回结果对第一个元素的评估。 如果第一个元素都相等，则系统将返回第二个评估结果，而忽略其余评估结果。

 让originalTuples =（“ a”，14，2.7888） 

  //对于字符串或字符，它比较Unicode表中的排名 
  // b大于a 
  originalTuples>（“ b”，14，77.8） 
  //字符“ 2”小于“ a”，未将55.8与2.788进行比较 
  originalTuples>（“” 2“，14，55.8） 
  //返回前两个元素相等后的最后一个结果 
  originalTuples>（“ a”，14，0.8） 
  //返回前两个元素相等后的最后一个结果 
  originalTuples>（“ a”，14，55.8） 
  //返回第二个结果，因为第一个元素相等，忽略最后一个元素 
  originalTuples>（“ a”，56，0.08） 
  //返回第二个结果，因为第一个元素相等，忽略最后一个元素 
  originalTuples>（“ a”，3，55.8） 

注意：

请注意，我们可以比较数字以外的字符或字符串。 但是，我们不能对布尔变量使用大于或小于符号。 对布尔变量使用大于号（小于号）将产生错误。 对于布尔变量，我们可以使用相等或不相等的比较。

例：

以下示例显示元组与布尔变量的比较

 让someOriginalTuples =（true，false，12） 
  someOriginalTuples ==（false，false，12） 
  someOriginalTuples ==（true，false，12） 

如果我们使用大于或小于符号的布尔变量，它将产生错误。

重要的提示：

比较器运算符能够比较6个元素或更少的元组。 如果我们的元组具有7个或更多的元素，则必须单独实现比较。

例：

下面的示例显示可用于与比较运算符进行比较的元素元组的最大数量。

 让someOriginalTuples3 =（1、2、3、4、5、6） 
  someOriginalTuples3>（0，1，2，3，4，5） 

例：

如果我们比较一个元组中的7个或更多元素，下面的示例显示比较失败。

要执行7元素比较，请使用以下示例：

 让someOriginalTuples4 =（1、2、3、4、5、6、7） 
  someOriginalTuples4.0> 0 
  someOriginalTuples4.1> 1 
  someOriginalTuples4.2> 2 
  someOriginalTuples4.3> 3 
  someOriginalTuples4.4> 4 
  someOriginalTuples4.5> 5 
  someOriginalTuples4.6> 6 

三元条件运算符

三元运算符包括3个部分。 语法如下：

？：

系统将评估查询，如果表达式的评估结果为true，则系统将返回answer1的评估值。 如果查询为假，系统将返回答案2的评估值。

三元运算符是以下代码的精简版本：

  如果查询{ 

  回答1 

  }其他{ 

  回答2 

  } 

例：

  var result =“” 
 让student1 = 65 

 结果=学生1> 50？  “过关失败” 

 打印（“学生1 \（结果）”） 

三元运算符类似于以下代码：

  var result =“” 
 让student1 = 65 

 如果学生1> 50 { 
 结果=“通过” 
  }其他{ 
 结果=“失败” 
  } 

 打印（“学生1 \（结果）”） 

由于三元运算符难以理解，因此我们建议明智地使用它，并避免将多个三元运算合并为一个复合语句

零销售员

Nil-coalescing运算符（??）取消包装可选变量的值（如果它不是nil）。 如果可选变量为nil，它将默认为第二个提供的值。 语法如下：

??

例如，让我们考虑userDefineColor ?? defaultColor。 变量userDefineColor是可选的。 如果该变量中有值，则系统将解开该变量中的值。 另一方面，如果发现此变量为nil，则系统将使用值defaultColor。

整个构造可以使用以下程序形成：

  如果userDefineColor！= nil { 

  colorUsed = userDefineColor 

  }其他{ 

  colorUsed = defaultColor 

  } 

例：

 让defaultColor =“ red” 
 让userDefinedColor：String吗？  =无 

 让colorUsed = userDefinedColor？  defaultColor 

  print（“使用的颜色为\（colorUsed）。”） 

如果我们的可选内容包含值，那么该值将被解包和利用。

 让defaultColor =“ red” 
 让userDefinedColor：String吗？  =“绿色” 

 让colorUsed = userDefinedColor？  defaultColor 

  print（“使用的颜色为\（colorUsed）。”） 

范围运算符

有三种类型的范围运算符：闭合范围运算符，半开范围运算符和单面范围运算符。

近程运算符

闭合范围运算符由（…）表示。 近距离运算符包括开始编号和结束编号。 要使用封闭范围运算符，请遵循以下语法：

…

例：

我们可以使用近距离运算符来定义索引范围，如下例所示：

 用于1 ... 10中的索引{ 
 打印（“项目：\（索引）”） 
  } 

半开范围运算符

半开范围运算符由（.. <）表示。 它包括第一个数字和小于最后一个数字的数字（last_number_1）。 语法如下：

.. <

例

 对于1 .. <10 { 
  print（“ Item：\（index）”） 
  } 

当引用数组或任何从0开始并以总计数减去1结束的数据索引时，半范围运算符非常有用。

例：

 让myArrays = [0,1,2,3,4,5,6,7,8,9] 

 让计数= myArrays.count 

 用于索引在0 .. <count { 
  print（“ Number：\（index）”） 
  } 

范围运算符的应用

我们还可以将范围运算符用作数组中的下标。 下面列出的是将范围运算符与数组一起使用的示例。

 让someArrayA = [1,2,3,4,5,6,7,8,9,10] 
  someArrayA [0] 
  someArrayA [9] 
  someArrayA.count 
  someArrayA.last 

  someArrayA [3…7] 
  someArrayA [3 .. <7] 

我们还可以定义范围，并在下标之外的任何其他上下文中使用它：

  //定义封闭范围 
 让someRange1 = 1…10 
 用于someRange1 { 
 打印（索引） 
  } 
  //打印1到10 

  //定义半开范围 
 让someRange2 = 1 .. <16 
 用于someRange2 { 
 打印（索引） 
  } 
  //打印1到15 

单面范围运算符

单面范围运算符是没有开始或结束编号的范围运算符。 它可以应用于任何封闭范围运算符或半开范围运算符。

单边近距离算子

一侧近距离运算符可以写成

  ... 5 
  1 ... 

单边运算符的解释如下：

• …5-告诉系统从索引的开头（可以为0或1）到5（含）开始计数。
• 1… -告诉系统从1到索引的末尾计数。

单面半开范围操作员

一侧半开范围算子可以写成

  .. <10 

对于半开范围运算符，Swift仅支持单端半开范围运算符，且包含结束索引，如上所示。

如下屏幕所示，我们无法执行（0 .. <）。

下面列出的是单面范围运算符的应用示例。

 让someArrayB = [1,2,3,4,5,6,7,8,9,10] 
  someArrayB [0] 
  someArrayB [9] 
  someArrayB.count 
  someArrayB.last 

  someArrayB [3…7] 
  someArrayB [1…] 
  someArrayB […7] 

  someArrayB [3 .. <7] 
  someArrayB [.. <5] 

单面范围算子的极限

除了数组下标，我们还可以在任何其他上下文中使用单边范围运算符。 但是，如果范围是单面的，则有什么限制？ 范围限制为整数的最大值和最小值。

请参见下面的示例：

  //定义Int可以处理的最大1 t0范围 
 让someRange3 = 1… 
  someRange3.contains（100） 
  someRange3.contains（100000000） 
 让rangeMax = Int.max 
  someRange3.contains（rangeMax） 

  //定义范围从最小最小值到100 
 让someRange4 =…100 
  someRange4.contains（10000） 
  someRange4.contains（100） 
  someRange4.contains（-11000000） 
 让rangeMin = Int.min 
  someRange4.contains（rangeMin） 

  //定义范围从最小最小值到100 
 让someRange5 = .. <1000 
  someRange5.contains（1000） 
  someRange5.contains（999） 
  someRange5.contains（-766999） 
  someRange5.contains（rangeMin） 

请注意，如果输入的数字超出整数的范围，则会发生运行时或编译错误。

逻辑运算符

在Swift中，我们支持3个逻辑运算符，它们分别是NOT，AND和OR。

• NOT运算符表示为！
• AND运算符表示为&&
• OR运算符表示为||。

逻辑非运算符

我们可以使用逻辑NOT运算符作为一元前缀。 在真值前面的NOT表示假，反之亦然。 使用NOT运算符的语法如下：

！

例

 让myTruth =假 

 让myNewTruth =！myTruth 

  print（“我的真相是\（myTruth），而我的新真相是\（myNewTruth）。”） 

逻辑与运算符

我们将逻辑AND运算符用作2个操作数之间的二进制运算符。 使用AND运算符的语法如下：

&&

例

 让myDoorCode = true 

 让myFingerPrint = false 

 如果myDoorCode && myFingerPrint == true { 
 打印（“授予访问权限”） 
  }其他{ 
 打印（“访问被拒绝”） 
  } 

注意：

请注意，对于AND运算符，系统使用短路评估。 这意味着系统将评估最左边的条件语句，如果第一个评估为假，则系统将停止进一步评估，因为即使第二个评估为真，结果仍将为假。 我们应该将通常会产生错误结果的陈述放在评估的左侧，以提高效率。

逻辑或运算符

我们将逻辑OR运算符用作2个操作数之间的二进制运算符。 使用OR运算符的语法如下：

||

例：

 让myFingerPrint = false 

 如果myDoorCode ||  myFingerPrint == true { 
 打印（“授予访问权限”） 
  }其他{ 
 打印（“访问被拒绝”） 
  } 

注意：

同样，对于“或”运算符，系统也使用短路评估。 这意味着系统将评估最左边的条件语句，如果第一个评估为真，则系统将停止进一步评估，因为即使第二个评估为假，结果仍然为真。 我们应该将通常会产生真实结果的陈述放在评估的左侧，以提高效率。

复合逻辑运算符

我们使用多个逻辑运算符形成一个复合表达式。 系统将首先评估最左边的表达式，然后再评估右边的表达式。 请注意，但是&&优先于||。 您需要从左到右评估&&操作，然后评估||。 从左到右。

例：

 让myDoorCode = true 

 让myFingerPrint = false 

 让keyOverride = true 

 让overridePassCode = true 

 如果myDoorCode && myFingerPrint ||  keyOverride && overlayPassCode { 
 打印（“授予访问权限”） 
  }其他{ 
 打印（“访问被拒绝”） 
  } 

在上面的示例中，系统允许用户输入2种组合进入大门。 用户输入正确的门密码以及正确的指纹扫描，或者 用户可以将手动优先键与正确的优先密码一起使用。

为了提高可读性，以上示例应编写如下：

运算符AND优先于运算符OR

在构造复合语句时，请注意，与运算符OR相比，运算符AND具有更高的优先级。

请检查以下示例：

  //由于AND的优先级高于OR，因此以下结果为true 
 真实|| 错误&&错误 

  //要产生错误的结果，我们必须使用（），如下所示 
  （真||假）&&假 

更多示例：

 让condition1 = true 
 让condition2 =假 
 让condition3 = true 
 让condition4 =假 

  condition1 ||  condition2 && condition3 && condition4 
  //请注意，&&优先于|| 您需要从左到右评估&&操作，然后评估||。 从左到右 

例：

 真实|| 错误&&正确&&错误 
 是&&假|| 假|| 真正 
  true && true || 错误&&错误 
 假||  true && true || 假 

运算符优先级

运算符优先级是计算运算符的顺序。 考虑下面的示例：

例：

  42–20 * 12/3 + 5 * 6 + 54 
  //结果是46 

对于某些编程语言，所有算术运算符都具有相同的优先级。 这意味着系统将按从左到右的顺序评估计算。 如果我们从左到右评估，结果将是612。

但是，大多数编程语言都采用通用的优先级，即乘法和除法具有相同的优先级，但是它们的位置比加法和减法更高。

在上面的示例中，我们应该首先从左到右评估乘法和除法。 在对乘法和除法进行求值之后，我们从左到右开始求值的加法和减法。

要更改优先顺序，例如我们要先执行减法，可以添加括号以影响优先顺序。 括号的优先级高于其他算术运算符。

例：

  42–20 * 12/3 + 5 * 6 + 54 

  （42–20）* 12/3 + 5 *（6 + 54） 

在上面的示例中，系统将在恢复正常算术运算之前首先在括号中执行计算。 结果是不同的。

类似地，当我们使用上一部分所示的逻辑运算符时，也可以使用括号来影响求值顺序。

下面列出的是运算符优先级的简化表。 同一组中的所有运算符具有相同的优先级。 左联想表示系统将从左到右评估表达式。 右关联表示系统将从右到左评估表达式。 列表顶部的运算符的优先级高于列表底部的运算符。

显式括号

对于复杂的表达式，最好使用方括号或括号来组织表达式。 它还可以提高代码的可读性。

例：

 让condition5 = true 
 让condition6 =假 
 让condition7 = true 
 让condition8 =假 

 条件5 ||  condition6 && condition7 && condition8 
  //由于&&在||之前具有优先权，因此评估为true 

  //用括号括起来的结果可能会有所不同 
  （condition5 || condition6）&&（condition7 && condition8）