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 教程的這一部分中，我們介紹了這些表達式。