Ruby 表达式 · ZetCode 中文系列教程

# Ruby 表达式 > 原文： [https://zetcode.com/lang/rubytutorial/expressions/](https://zetcode.com/lang/rubytutorial/expressions/) 在 Ruby 教程的这一部分中，我们将讨论表达式。表达式是根据操作数和运算符构造的。表达式的运算符指示将哪些运算应用于操作数。表达式中运算符的求值顺序由运算符的优先级和关联性确定。运算符是特殊符号，表示已执行某个过程。编程语言的运算符来自数学。程序员处理数据。运算符用于处理数据。操作数是运算符的输入（参数）之一。 ## Ruby 运算符下表显示了按优先级排序的常见 Ruby 运算符（优先级最高）： | 类别 | 符号 | | --- | --- | | 解析，访问运算符 | `:: .` | | 数组运算符 | `[ ] [ ]=` | | 乘方 | `**` | | 否定，补码，一元加，减 | `! ~ + -` | | 乘，除，模 | `* / %` | | 加，减 | `+ -` | | 移位运算符 | `<< >>` | | 按位与 | `&` | | 按位异或，逻辑异或 | `^ |` | | 关系运算符 | `> >= < <=` | | 按位或，逻辑或 | `^ |` | | 相等，模式匹配运算符 | `<=> == === != =~ !~` | | 逻辑与 | `&&` | | 逻辑或 | <code>||</code> | | 范围运算符 | `.. ...` | | 三元 | `?:` | | 赋值运算符 | `= += -= *= **= /= %= &= |= ^= <<= >>= ||= &&=` | | 备选逻辑非 | `not` | | 备选逻辑或，与 | `or and` | 表的同一行上的运算符具有相同的优先级。一个运算符通常有一个或两个操作数。那些仅使用一个操作数的运算符称为一元运算符。那些使用两个操作数的对象称为二进制运算符。还有一个三元运算符`?:`，它可以处理三个操作数。某些运算符可以在不同的上下文中使用。例如`+`运算符。从上表中我们可以看到它在不同情况下使用。它添加数字，连接字符串，指示数字的符号。我们说运算符是重载。 ## Ruby 符号运算符有两个符号运算符：`+`和`-`。它们用于指示或更改值的符号。 ```ruby #!/usr/bin/ruby puts +2 puts -2 ``` +和-表示值的符号。加号可以用来表示我们有一个正数。可以将其省略，并且通常可以这样做。在下面的示例中，我们将使用减号。 ```ruby #!/usr/bin/ruby a = 1 puts a puts -(a) puts -(-(a)) ``` 减号更改值的符号。 ```ruby $ ./sign.rb 1 -1 1 ``` 这是示例的输出。 ## Ruby 赋值运算符赋值运算符=将值赋给变量。变量是值的占位符。在数学中，`=`运算符具有不同的含义。在等式中，`=`运算符是一个相等运算符。等式的左侧等于右侧。 ```ruby x = 1 puts x # prints 1 ``` 在这里，我们为`x`变量分配一个数字。 ```ruby x = x + 1 puts x # prints 2 ``` 先前的表达式在数学上没有意义。但这在编程中是合法的。该表达式将`x`变量加 1。右边等于 2，并且 2 分配给`x`。 ```ruby 3 = x; ``` 此代码示例导致语法错误。我们无法为字面值分配值。 ## Ruby 解析，成员访问运算符这两个运算符的优先级最高。这意味着始终要首先求值它们。 ```ruby #!/usr/bin/ruby class MyMath Pi = 3.1415926535 end module People Name = "People" end puts MyMath::Pi puts People::Name ``` 在第一个示例中，我们介绍`::`名称空间解析运算符。它允许访问在另一个类或模块内定义的常量，模块或类。它用于提供名称空间，以使方法和类名不会与不同作者的其他类冲突。 ```ruby class MyMath Pi = 3.1415926535 end module People Name = "People" end ``` 我们有一个简单的模块和一个类。每个都有一个定义的常数。 ```ruby puts MyMath::Pi puts People::Name ``` 我们使用`::`运算符从这两者访问常量。 ```ruby $ ./resolution.rb 3.1415926535 People ``` 这是`resolution.rb`程序的输出。点`.`运算符是成员访问运算符。它用于调用对象的方法。 ```ruby #!/usr/bin/ruby class Person def initialize name, age @name = name @age = age end def info "#{@name} is #{@age} years old" end end p = Person.new "Jane", 17 puts p.info puts "ZetCode".reverse ``` 在我们的示例中，我们有两个对象。一位用户定义和一位预定义。我们使用点运算符来处理这些对象。 ```ruby p = Person.new "Jane", 17 puts p.info ``` 在这两行中，点运算符调用两种方法：`new`和`info`。 ```ruby puts "ZetCode".reverse ``` 字符串是内置对象，具有反向方法。这被称为。 ```ruby $ ./memberaccess.rb Jane is 17 years old edoCteZ ``` 这是示例的输出。 ## Ruby 连接字符串在 Ruby 中，`+`运算符还用于连接字符串。当在不同的上下文中不同地使用运算符时，我们说它是重载。 ```ruby #!/usr/bin/ruby puts "Return " + "of " + "the " + "King" puts "Return ".+"of ".+ "the ".+"King" ``` 我们使用字符串连接运算符将三个字符串连接在一起。 ```ruby puts "Return " + "of " + "the " + "King" ``` 我们使用+运算符连接四个字符串。 ```ruby puts "Return ".+"of ".+ "the ".+"King" ``` 在后台，`+`运算符是 Ruby 方法。字符串字面值是一个对象。我们使用访问`.`运算符调用对象的方法。 ```ruby $ ./catstrings.rb Return of the King Return of the King ``` 这就是我们运行`catstrings.rb`程序时得到的。 ## Ruby 自增自减运算符 Ruby 没有此类运算符。 ```ruby x++; x = x + 1; ... y--; y = y - 1; ``` 这些是 C 中的递增，递减运算符。如果您熟悉 Java，C，C++ ，则知道这些运算符。它们在 Ruby 中不可用。 Python 语言也没有。 ## Ruby 算术运算符下表是 Ruby 中的算术运算符表。 | 符号 | 名称 | | --- | --- | | `+` | 加法 | | `-` | 减法 | | `*` | 乘法 | | `/` | 除法 | | `%` | 余数 | | `**` | 乘方 | 在下一个示例中，我们使用算术运算。 ```ruby #!/usr/bin/ruby a = 10 b = 11 c = 12 puts a + b + c puts c - a puts a * b puts c / 3 puts c % a puts c ** a ``` 在前面的示例中，我们使用加法，减法，乘法，除法和余数运算。这些都是数学所熟悉的。 ```ruby puts c % a ``` % 运算符称为余数或取模运算符。它找到一个数除以另一个的余数。例如，`9 % 4`，9 模 4 为 1，因为 4 两次进入 9 且余数为 1。 ```ruby $ ./arithmetic.rb 33 2 110 4 2 61917364224 ``` This is the output of the example. 接下来，我们将说明整数除法和浮点除法之间的区别。 ```ruby #!/usr/bin/ruby puts 5 / 2 puts 5 / 2.0 puts 5.0 / 2 puts 5.to_f / 2 ``` 在前面的示例中，我们将两个数字相除。 ```ruby puts 5 / 2 ``` 表达式中的两个操作数都是整数。我们已经完成了整数除法。除法运算的返回值为整数。当我们将两个整数相除时，结果是一个整数。 ```ruby puts 5 / 2.0 puts 5.0 / 2 puts 5.to_f / 2 ``` 如果其中一个值是浮点数（或两者皆有），则执行浮点除法。浮点值具有小数点。我们还可以调用`to_f`方法将整数转换为浮点数。 ```ruby $ ./division.rb 2 2.5 2.5 2.5 ``` 在这里，我们看到了`division.rb`程序的结果。 Ruby 还有其他执行除法的方法。这些可用作方法调用。 ```ruby #!/usr/bin/ruby puts 5.div 2.0 puts 5.fdiv 2 puts 5.quo 2 puts 5.0.quo 2.0 ``` 在上面的示例中，我们有`div`，`fdiv`和`quo`方法。 ```ruby puts 5.div 2.0 ``` `div`方法始终执行整数除法。即使操作数是浮点值。 ```ruby puts 5.fdiv 2 ``` `fdiv`方法始终执行浮点除法。 ```ruby puts 5.quo 2 puts 5.0.quo 2.0 ``` `quo`方法执行最精确的划分。如果两个操作数均为`float`，则返回`float`，否则返回有理数。 ```ruby $ ./otherdivision.rb 2 2.5 5/2 2.5 ``` ## Ruby 布尔运算符在 Ruby 中，我们具有以下逻辑运算符。布尔运算符也称为逻辑运算符。 | 符号 | 名称 | | --- | --- | | `&&` | 逻辑与 | | <code>||</code> | 逻辑或 | | `!` | 否定 | 布尔运算符处理真值。 Ruby 还有其他的布尔运算符。这些是`and`，`or` & `not`。除了它们的优先级较低之外，它们的作用相同。这种双重性来自 Perl 语言，在这种语言中，需要使用具有较低优先级的布尔运算符。 ```ruby #!/usr/bin/ruby x = 3 y = 8 puts x == y puts y > x if y > x then puts "y is greater than x" end ``` 许多表达式导致布尔值。布尔值用于条件语句中。 ```ruby puts x == y puts y > x ``` 关系运算符始终导致布尔值。这两行分别显示`false`和`true`。 ```ruby if y > x then puts "y is greater than x" end ``` 仅在满足括号内的条件时才执行`if`语句的主体。表达式`x > y`返回`true`，因此消息`"y`大于`x"`被打印到终端。下一个示例显示逻辑`and`运算符。 ```ruby #!/usr/bin/ruby puts true && true puts true && false puts false && true puts false && false ``` 仅当两个操作数均为`true`时，`and`运算符的计算结果才为`true`。 ```ruby $ ./andoperator.rb true false false false ``` 仅其中一个表达式为`true`。如果两个操作数中的任何一个为`true`，则逻辑或`||`运算符的计算结果为`true`。 ```ruby #!/usr/bin/ruby puts true || true puts true || false puts false || true puts false || false ``` 如果运算符的任一侧为真，则操作的结果为真。 ```ruby $ ./oroperator.rb true true true false ``` 三个表达式得出布尔值`true`。否定`!`表示真假和假真。 ```ruby #!/usr/bin/ruby puts !0 puts !1 puts !true puts !false puts ! (4<3) puts ! "Ruby".include?("a") ``` 该示例显示了否定运算符的作用。 ```ruby $ ./not.rb false false false true true true ``` This is the output of the example. `||`和`&&`运算符经过短路求值。短路求值意味着仅当第一个参数不足以确定表达式的值时才求值第二个参数：当逻辑的第一个参数的值等于`false`时，总值必须为`false`; 当逻辑或的第一个参数为`true`时，总值必须为`true`。短路求值主要用于提高性能。一个例子可以使这一点更加清楚。 ```ruby #!/usr/bin/ruby def one puts "Inside one" false end def two puts "Inside two" true end puts "Short circuit" if one && two puts "Pass" end puts "##############################" if two || one puts "Pass" end ``` 在示例中，我们有两种方法。它们在布尔表达式中用作操作数。我们将看看它们是否被调用。 ```ruby if one && two puts "Pass" end ``` 一种方法返回`false`。短路`&&`无法求值第二种方法。没有必要。一旦操作数为假，逻辑结论的结果始终为假。仅将`"Inside one"`打印到控制台。 ```ruby puts "##############################" if two || one puts "Pass" end ``` 在第二种情况下，我们使用`||`运算符，并使用`two`方法作为第一个操作数。在这种情况下，`"Inside two"`和`"Pass"`字符串将打印到终端。同样，也不必求值第二个操作数，因为一旦第一个操作数计算为`true`，则逻辑或始终为`true`。 ```ruby $ ./shortcircuit.rb Short circuit Inside one ############################## Inside two Pass ``` 我们看到了`shortcircuit.rb`程序的结果。 ## Ruby 关系运算符关系运算符用于比较值。这些运算符总是产生布尔值。 | 符号 | 含义 | | --- | --- | | `<` | 小于 | | `<=` | 小于或等于 | | `>` | 大于 | | `>=` | 大于或等于 | 关系运算符也称为比较运算符。 ```ruby #!/usr/bin/ruby p 3 < 4 p 3 > 5 p 3 >= 3 ``` `3 < 4`表达式返回`true`，因为 3 小于 4。`3 > 5`表达式返回`false`，因为 3 大于 5 并不成立。 ## Ruby 按位运算符小数对人类是自然的。二进制数是计算机固有的。二进制，八进制，十进制或十六进制符号仅是相同数字的符号。按位运算符使用二进制数的位。 | 符号 | 含义 | | --- | --- | | `~` | 按位取反 | | `^` | 按位异或 | | `&` | 按位与 | | <code>|</code> | 按位或 | | `<<` | 左移 | | `>>` | 右移 | 很少在像 Ruby 这样的高级语言中使用按位运算符。 ```ruby #!/usr/bin/ruby puts ~ 7 # prints -8 puts ~ -8 # prints 7 puts 6 & 3 # prints 2 puts 3 & 6 # prints 2 puts 6 ^ 3 # prints 5 puts 3 ^ 6 # prints 5 puts 6 | 3 # prints 7 puts 3 | 6 # prints 7 puts 6 << 1 # prints 12 puts 1 << 6 # prints 64 puts 6 >> 1 # prints 3 puts 1 >> 6 # prints 0 ``` 在上面的代码示例中，我们显示了所有 6 个运算符。 ```ruby puts ~ 7 # prints -8 puts ~ -8 # prints 7 ``` 按位取反运算符分别将 1 更改为 0，将 0 更改为 1。该运算符还原数字 7 的所有位。其中一位还确定数字是否为负。如果我们再一次对所有位取反，我们将再次得到 7。 ```ruby puts 6 & 3 # prints 2 puts 3 & 6 # prints 2 ``` 按位，运算符在两个数字之间进行逐位比较。仅当操作数中的两个对应位均为 1 时，位位置的结果才为 1。 ```ruby puts 6 ^ 3 # prints 5 puts 3 ^ 6 # prints 5 ``` 按位互斥或运算符在两个数字之间进行逐位比较。如果操作数中对应位中的一个或另一个（但不是全部）为 1，则位位置的结果为 1。 ```ruby puts 6 | 3 # prints 7 puts 3 | 6 # prints 7 ``` 按位或运算符在两个数字小体之间进行逐位比较。如果操作数中的任何对应位为 1，则位位置的结果为 1。 ```ruby puts 6 << 1 # prints 12 puts 1 << 6 # prints 64 puts 6 >> 1 # prints 3 puts 1 >> 6 # prints 0 ``` 按位移位运算符向右或向左移位。这些运算符也称为算术移位。 ## Ruby 复合赋值运算符复合赋值运算符由两个运算符组成。他们是速记员。 ```ruby #!/usr/bin/ruby a = 0 a = a + 1 a += 1 puts a b = 0 b = b - 8 b -= 8 puts b ``` `+=`和`-=`复合运算符是这些速记运算符之一。它们比完整的表达式可读性差，但是经验丰富的程序员经常使用它们。 ```ruby a = a + 1 a += 1 ``` 这两行是相同的。他们将 1 加到变量。其他复合运算符是： ```ruby -= *= **= /= %= &= |= <<= >>= ``` ## Ruby 运算符优先级运算符优先级告诉我们首先求值哪个运算符。优先级对于避免表达式中的歧义是必要的。以下表达式 28 或 40 的结果是什么？ ```ruby 3 + 5 * 5 ``` 像数学中一样，乘法运算符的优先级高于加法运算符。结果是 28。 ```ruby (3 + 5) * 5 ``` 要更改求值的顺序，可以使用括号。括号内的表达式始终首先被求值。 ```ruby #!/usr/bin/ruby puts 3 + 5 * 5 puts (3 + 5) * 5 puts ! true | true puts ! (true | true) ``` 在此代码示例中，我们显示一些常见的表达式。每个表达式的结果取决于优先级。 ```ruby puts 3 + 5 * 5 ``` 该行打印 28。乘法运算符的优先级高于加法。首先计算`5*5`的乘积。然后添加 3。 ```ruby puts ! true | true ``` 在这种情况下，否定运算符具有更高的优先级。首先，第一个`true`值与`|`运算符将`false`和`true`组合在一起，最后给出`true`。 ```ruby $ ./precedence.rb 28 40 true false ``` ## Ruby 关联性有时，优先级不能令人满意地确定表达式的结果。还有另一个规则称为关联性。运算符的关联性确定优先级与相同的运算符的求值顺序。 ```ruby 9 / 3 * 3 ``` 此表达式的结果是 9 还是 1？乘法，删除和模运算符从左到右关联。因此，该表达式的计算方式为：`(9 / 3) * 3`，结果为 9。算术，布尔，关系和按位运算符都是从左到右关联的。另一方面，赋值运算符是正确关联的。 ```ruby a = b = c = d = 0 print a, b, c, d # prints 0000 ``` 如果关联从左到右，则以前的表达式将不可能。复合赋值运算符从右到左关联。 ```ruby j = 0 j *= 3 + 1 puts j ``` 您可能期望结果为 1，但是由于关联性，实际结果为 0。首先求值右边的表达式，然后应用复合赋值运算符。 ## Ruby 范围运算符 Ruby 有两个范围运算符。它们用于快速创建一系列对象。通常是一系列数字或字母。 `..`范围运算符（两个点）创建一个包含范围。 `...`运算符（三个点）创建一个互斥范围，该范围的高值被排除在外。 ```ruby #!/usr/bin/ruby p (1..3).to_a p (1...3).to_a p ('a' .. 'l').to_a ``` 在示例中，我们使用了两个范围运算符来创建数字和字符的范围。 ```ruby p (1..3).to_a p (1...3).to_a ``` 这两行使用两个范围运算符创建两个范围。范围对象将转换为数组。第一个范围的值为 1、2 和 3，而第二个范围的值为 1 和 2。 ```ruby p ('a' .. 'l').to_a ``` 在这里，我们使用`..`范围运算符来创建从'a'到'l'的字母数组。 ```ruby $ ./range.rb [1, 2, 3] [1, 2] ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"] ``` 这是示例输出。 ## Ruby 三元运算符三元运算符`?:`是条件运算符。对于要根据条件表达式选择两个值之一的情况，它是一个方便的运算符。 ```ruby cond-exp ? exp1 : exp2 ``` 如果`cond-exp`为`true`，则求值`exp1`并返回结果。如果`cond-exp`为`false`，则求值`exp2`并返回其结果。 ```ruby #!/usr/bin/ruby age = 32 adult = age >= 18 ? true : false if adult then puts "Adult" else puts "Not adult" end ``` 在大多数国家/地区，成年取决于您的年龄。如果您的年龄超过特定年龄，则您已经成年。在这种情况下，我们可以使用三元运算符。 ```ruby adult = age >= 18 ? true : false ``` 首先，求值赋值运算符右侧的表达式。三元运算符的第一阶段是条件表达式求值。因此，如果年龄大于或等于 18，则返回`?`字符后的值。如果不是，则返回`:`字符后的值。然后将返回值分配给成人变量。 ```ruby $ ./ternary.rb Adult ``` 32 岁的成年人是成人。 ## 计算素数我们将计算素数。 ```ruby #!/usr/bin/ruby nums = (4..50).to_a puts "Prime numbers:" print "2 3 " nums.each do |i| not_prime = false (2..Math.sqrt(i).ceil).each do |j| not_prime = true if i % j == 0 end print i, " " unless not_prime end puts ``` 在上面的示例中，我们处理了几个运算符。质数（或质数）是一个自然数，它具有两个截然不同的自然数除数：1 和它本身。我们拾取一个数字并将其除以数字，从 2 到拾取的数字。实际上，我们不必尝试所有较小的数字，我们可以将数字除以所选数字的平方根。该公式将起作用。在算法的核心，我们使用余数除法运算符，也称为模运算符。 ```ruby nums = (4..50).to_a ``` 我们将从这些数字计算素数。 ```ruby print "2 3 " ``` 我们跳过了 2、3 个数字的计算。他们是素数。 ```ruby not_prime = false ``` `not_prime`是一个标志，指示所选的数字不是素数。我们假定所选的数字是质数，除非稍后证明。 ```ruby (2..Math.sqrt(i).ceil).each do |j| not_prime = true if i % j == 0 end ``` 如果我们仅对小于所讨论数字平方根的数字进行模除，就可以了。如果余数除法运算符针对任何`i`值返回 0，则说明该数字不是质数。 ```ruby print i, " " unless not_prime ``` 如果未设置`not_prime`标志，我们将打印数字。上面的示例旨在演示几个运算符。实际上，存在一种更简单的方法来计算质数。 Ruby 有一个用于计算素数的模块。 ```ruby #!/usr/bin/ruby require 'prime' Prime.each(50) do |i| print i, " " end puts ``` 使用 Ruby 素数模块计算最多 50 个素数的示例。 ```ruby require 'prime' ``` 我们包括主要模块。 ```ruby Prime.each(50) do |i| print i, " " end ``` 我们计算素数直至上限 -50。 ```ruby $ ./primes.rb 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 ``` 从此输出中，我们看到 2 和 50 之间的质数。在 Ruby 教程的这一部分中，我们介绍了这些表达式。