# Ruby 變量 > 原文： [https://zetcode.com/lang/rubytutorial/variables/](https://zetcode.com/lang/rubytutorial/variables/) 在 Ruby 教程的這一部分中，我們將更詳細地研究變量。 變量是存儲數據的地方。 每個變量都有一個唯一的名稱。 有一些命名約定適用于變量名。 變量保存對象。 更準確地說，它們是指位于計算機內存中的特定對象。 每個對象都是特定的數據類型。 有內置數據類型和自定義數據類型。 Ruby 屬于動態語言家族。 與 Java，C 或 Pascal 等強類型語言不同，動態語言不會將變量聲明為某些數據類型。 取而代之的是，解釋器在分配時確定數據類型。 隨著時間的流逝，Ruby 中的變量可以包含不同的值和不同類型的值。 ```ruby #!/usr/bin/ruby i = 5 puts i i = 7 puts i ``` 變量一詞來自這樣一個事實，即變量與常量不同，可以隨時間采用不同的值。 在上面的示例中，有一個名為`i`的變量。 首先為它分配一個值 5，然后給它一個不同的值 7。 ## Ruby 變量命名約定 像其他任何編程語言一樣，Ruby 也有一些變量標識符的命名約定。 Ruby 是區分大小寫的語言。 這意味著`age`和`Age`是兩個不同的變量名稱。 大多數語言區分大小寫。 BASIC 是一個例外。 這是一種不區分大小寫的語言。 雖然我們可以通過更改字符的大小寫來創建不同的名稱，但不建議這樣做。 ```ruby #!/usr/bin/ruby i = 5 p i I = 7 p I ``` 該代碼示例定義了兩個變量：`I`和`i`。 它們具有不同的值。 ```ruby ./case.rb 5 7 ``` `case.rb`示例的輸出。 Ruby 中的變量名可以由字母數字字符和下劃線`_`字符創建。 變量不能以數字開頭。 這使解釋器更容易區分文字數和變量。 變量名不能以大寫字母開頭。 如果標識符以大寫字母開頭，則在 Ruby 中將其視為常量。 ```ruby #!/usr/bin/ruby name = "Jane" placeOfBirth = "Bratislava" placeOfBirth = "Kosice" favorite_season = "autumn" n1 = 2 n2 = 4 n3 = 7 p name, placeOfBirth, favorite_season p n1, n2, n3 ``` 在此腳本中，我們顯示了一些有效的變量名。 變量名應為有意義的。 選擇變量的描述性名稱是一種很好的編程習慣。 這些程序更具可讀性。 ```ruby #!/usr/bin/ruby name = "Jane" place_of_birth = "Bratislava" occupation = "student" i = 5 while i > 0 do puts name i -= 1 end ``` 該腳本顯示了三個描述性變量名。 與`pob`相比，`place_of_birth`對程序員的描述更多。 通常認為在循環中選擇簡單的變量名是可以的。 ## Ruby 標記 變量標識符可以以也稱為信號符的特殊字符開頭。 標記是附加到標識符的符號。 Ruby 中的變量信號表示變量作用域。 這與 Perl 相反，后者的信號符號表示數據類型。 Ruby 變量信號為`$`和`@`。 ```ruby #!/usr/bin/ruby tree_name = "pine" $car_name = "Peugeot" @sea_name = "Black sea" @@species = "Cat" p local_variables p global_variables.include? :$car_name p self.instance_variables p Object.class_variables ``` 我們有四個范圍不同的變量。 范圍是可以引用變量的范圍。 我們使用特殊的內置方法來確定變量的范圍。 ```ruby tree_name = "pine" ``` 沒有符號的變量是局部變量。 局部變量僅在局部有效：例如，在方法，塊或模塊內部。 ```ruby $car_name = "Peugeot" ``` 全局變量以`$`字符開頭。 它們在任何地方都有效。 程序中應限制全局變量的使用。 ```ruby @sea_name = "Black sea" ``` 以`@`標記開頭的變量名稱是實例變量。 此變量在對象內部有效。 ```ruby @@species = "Cat" ``` 最后，我們有一個類變量。 此變量對特定類的所有實例均有效。 ```ruby p local_variables ``` `local_variables`給出了在特定上下文中定義的所有局部變量的數組。 我們的上下文是 Ruby 頂級。 ```ruby p global_variables.include? :$car_name ``` 同樣，`global_variables`產生一個全局數組。 我們不會將所有全局變量打印到終端，因為其中有很多。 每個 Ruby 腳本都以一堆預定義變量開頭。 取而代之的是，我們調用數組的`include?`方法來檢查是否在數組中定義了我們的全局變量。 還要注意，我們使用變量符號來引用變量。 （符號以冒號開頭。） ```ruby p self.instance_variables ``` `self`偽變量指向`instance_variables`方法的接收者。 在我們的例子中，接收者是`main`，這是 Ruby 頂級執行區域。 ```ruby p Object.class_variables ``` 最后，我們有一組類變量。 `main`是`Object`類的實例。 ```ruby $ ./sigils.rb [:tree_name] true [:@sea_name] [:@@species] ``` 示例的輸出。 我們看到變量的符號名稱。 ## Ruby 局部變量 局部變量是在 Ruby 源代碼的局部區域內有效的變量。 該區域也稱為本地范圍。 局部變量存在于 Ruby 模塊，方法，類的定義中。 ```ruby #!/usr/bin/ruby def method1 x = 5 p x end method1 p x ``` 我們有一個叫做`method1`的方法，它有一個變量。 該變量是局部的。 這意味著它僅在方法定義內有效。 我們只能在方法名稱和`end`關鍵字之間引用`x`變量。 ```ruby def method1 x = 5 p x end ``` 這是`method1`方法的定義。 在方法內部，我們創建一個本地`x`變量。 我們將變量的值打印到終端。 ```ruby method1 ``` 該方法被調用。 ```ruby p x ``` 我們嘗試引用方法定義之外的局部變量。 這導致`NameError`。 Ruby 解釋器找不到此類標識符。 ```ruby $ ./locals.rb 5 ./locals.rb:11:in `<main>': undefined local variable or method `x' for main:Object (NameError) ``` 運行示例將得到以上輸出。 以下示例是對先前示例的略微修改。 ```ruby #!/usr/bin/ruby x = 5 def method1 x = 10 p x end method1 p x ``` 我們有兩個`x`變量。 一個在`method1`內部定義，另一個在外部定義。 它們是兩個不同的局部變量。 他們不會互相沖突。 ```ruby x = 5 ``` 我們創建了一個本地`x`變量，該變量保留值 5。該變量在主執行區的本地范圍內有效。 在`method1`內部無效。 ```ruby def method1 x = 10 p x end ``` 在`method1`的定義內，定義了一個新的局部變量`x`。 它的值為 10。它存在于`method1`方法的主體中。 在`end`關鍵字之后，它不再存在。 ```ruby $ ./locals2.rb 10 5 ``` 輸出。 如果方法采用參數，則會為每個參數創建一個局部變量。 ```ruby #!/usr/bin/ruby def rectangle_area a, b puts local_variables return a * b end puts rectangle_area 5, 6 ``` 我們有一個方法定義，它有兩個值。 該方法返回矩形的面積。 ```ruby def rectangle_area a, b puts local_variables return a * b end ``` `rectangular_area`方法采用兩個參數。 它們是矩形的邊，我們將為其計算面積。 將自動為標識符`a`和`b`創建兩個局部變量。 我們調用`local_variables`方法來查看該方法中包含哪些局部變量。 ```ruby puts rectangle_area 5, 6 ``` 在這里，我們將兩個值傳遞給方法`rectangle_area`。 這些值將分配給在方法內部創建的兩個局部變量。 ```ruby $ ./parameters.rb a b 30 ``` 輸出顯示三件事。 前兩個是`rectangular_area`方法中局部變量的名稱。 第三是給定矩形的計算面積。 可以在另一個方法內部定義一個方法。 內部方法具有自己的局部變量。 ```ruby #!/usr/bin/ruby def method1 def method2 def method3 m5, m6 = 3 puts "Level 3" puts local_variables end m3, m4 = 3 puts "Level 2" puts local_variables method3 end m1, m2 = 3 puts "Level 1" puts local_variables method2 end method1 ``` 在這個 Ruby 腳本中，我們創建三個方法。 `method2`和`method3`是內部方法。 `method2`定義在`method1`內部，`method3`定義在`method2`內部。 每個方法的局部變量只能在定義它們的方法中訪問。 ```ruby $ ./lms.rb Level 1 m1 m2 Level 2 m3 m4 Level 3 m5 m6 ``` 從輸出中我們可以看到`method1`有兩個局部變量`m1`和`m2`。 內部的`method2`具有局部變量`m3`和`m4`。 最里面的方法`method3`具有局部變量`m5`和`m6`。 本節的最后一個示例將展示本地范圍的一些演示。 ```ruby module ModuleM m1, m2 = 4 puts "Inside module" puts local_variables end def method1 v, w = 3 puts "Inside method" puts local_variables end class Some x, y = 2 puts "Inside class" puts local_variables end method1 t1, t2 = 7 puts "Inside toplevel" puts local_variables ``` 在代碼示例中，我們在模塊，方法，類和頂層內部創建局部變量。 `local_variables`是`Kernel`模塊的一種方法，它返回所有當前的局部變量。 ```ruby module ModuleM m1, m2 = 4 puts "Inside module" puts local_variables end ``` 模塊是方法和常量的集合。 我們創建兩個局部變量`m1`和`m2`。 ```ruby def method1 v, w = 3 puts "Inside method" puts local_variables end ``` 在`method1`中創建了兩個局部變量`v`和`w`。 ```ruby class Some x, y = 2 puts "Inside class" puts local_variables end ``` `x`和`y`局部變量在`Some`類的定義內創建。 ```ruby t1, t2 = 7 ``` 最后，創建兩個屬于 Ruby 頂級本地范圍的本地變量。 ```ruby $ ./locals3.rb Inside module m1 m2 Inside class x y Inside method v w Inside toplevel t1 t2 ``` 輸出顯示每個局部作用域的局部變量。 ## Ruby 全局變量 全局變量在腳本中的任何地方都有效。 他們以 Ruby 中的`$`標記開頭。 不鼓勵使用全局變量。 全局變量很容易導致許多編程錯誤。 僅在有理由時才使用全局變量。 建議程序員盡可能使用局部變量來代替全局變量。 ```ruby #!/usr/bin/ruby $gb = 6 module ModuleM puts "Inside module" puts $gb end def method1 puts "Inside method" puts $gb end class Some puts "Inside class" puts $gb end method1 puts "Inside toplevel" puts $gb puts global_variables.include? :$gb ``` 在示例中，我們有一個全局變量`$gb`。 我們展示了可以在模塊，方法，類和頂級中引用該變量。 全局變量`$gb`在所有這些實體中均有效。 ```ruby $gb = 6 ``` 創建一個全局變量`$gb`； 它的值為 6。 ```ruby module ModuleM puts "Inside module" puts $gb end ``` 在模塊的定義內，我們打印全局變量的值。 ```ruby def method1 puts "Inside method" puts $gb end ``` 在方法的定義內，我們打印全局變量的值。 ```ruby class Some puts "Inside class" puts $gb end ``` 在類的定義內，我們打印全局變量的值。 ```ruby puts $gb puts global_variables.include? :$gb ``` 最后，在頂層執行區域中，我們將打印全局變量的值以及該變量是否在`global_variables`方法生成的數組中。 ```ruby $ ./globals.rb Inside module 6 Inside class 6 Inside method 6 Inside toplevel 6 true ``` 該示例的輸出確認了全局變量可在任何地方訪問。 當 Ruby 腳本啟動時，它可以訪問多個預定義的全局變量。 這些全局變量不被認為是有害的，可以幫助解決常見的編程工作。 ```ruby #!/usr/bin/ruby p $LOAD_PATH p $: ``` 該腳本顯示了`$LOAD_PATH`全局變量。 該變量列出了通過`load`和`require`方法搜索的目錄。 `$:`是`$LOAD_PATH`名稱的簡短同義詞。 更多全局變量將在本章的“預定義變量”部分中介紹。 ## Ruby 實例，類變量 在本節中，我們將簡要介紹實例變量和類變量。 它們將在面向對象的編程章節中更詳細地描述。 實例變量是屬于特定對象實例的變量。 每個對象都有其自己的對象變量。 實例變量以`@`標記開頭。 類變量屬于特定類。 從特定類創建的所有對象共享類變量。 類變量以`@@`字符開頭。 ```ruby #!/usr/bin/ruby class Being @@is = true def initialize nm @name = nm end def to_s "This is #{@name}" end def does_exist? @@is end end b1 = Being.new "Being 1" b2 = Being.new "Being 2" b3 = Being.new "Being 3" p b1, b2, b3 p b1.does_exist? p b2.does_exist? p b3.does_exist? ``` 我們創建一個自定義的`Being`類。 `Being`類具有一個類和一個實例變量。 ```ruby class Being @@is = true ``` `@@is`是一個類變量。 `Being`類的所有實例都共享此變量。 此示例的邏輯是`Being`是，`NotBeing`不是。 ```ruby def initialize nm @name = nm end ``` `initialize`方法是一個構造器。 創建對象時將調用該方法。 創建一個`@name`實例變量。 此變量特定于具體對象。 ```ruby def to_s "This is #{@name}" end ``` 當對象是打印方法的參數（例如`p`或`puts`）時，將調用`to_s`方法。 在我們的情況下，該方法給出了對象的簡短人類可讀描述。 ```ruby def does_exist? @@is end ``` `does_exist?`方法返回類變量。 ```ruby b1 = Being.new "Being 1" b2 = Being.new "Being 2" b3 = Being.new "Being 3" ``` 從`Being`類中創建了三個對象。 每個對象都有不同的名稱。 對象的名稱將存儲在實例方法中，該方法對于每個對象實例都是唯一的。 這將在`to_s`方法中使用，該方法給出了對象的簡短說明。 ```ruby p b1, b2, b3 ``` `p`方法將創建的對象作為三個參數。 它在每個這些對象上調用`to_s`方法。 ```ruby p b1.does_exist? p b2.does_exist? p b3.does_exist? ``` 最后，我們調用每個實例的`does_exist?`方法并打印其返回值。 這三個方法的輸出是相同的，因為每個方法都返回類變量。 ```ruby $ ./icvars.rb This is Being 1 This is Being 2 This is Being 3 true true true ``` 示例的輸出。 前三個消息是唯一的。 字符串存儲在對象的實例變量中。 真實值是類變量的值，它被調用了三次。 ## Ruby 環境&命令行變量 `ENV`常數允許訪問環境變量。 這是一個 Ruby 哈希。 每個環境變量都是`ENV`哈希的鍵。 `ARGV`常量保存命令行參數值。 它們在腳本啟動時由程序員傳遞。 `ARGV`是一個將參數存儲為字符串的數組。 `$*`是`ARGV`的別名。 `ENV`和`ARGV`都是全局常數。 ```ruby #!/usr/bin/ruby ARGV.each do |a| puts "Argument: #{a}" end ``` 在腳本中，我們遍歷`ARGV`數組并打印其每個值。 ```ruby $ ./commandline.rb 1 2 3 Argument: 1 Argument: 2 Argument: 3 ``` 我們給出了三個命令行參數。 它們被打印到控制臺，每個都打印在單獨的行上。 以下示例將處理環境變量。 ```ruby #!/usr/bin/ruby puts ENV['SHELL'] puts ENV['LANG'] puts ENV['TERM'] ``` 該腳本會將三個環境變量的值輸出到終端。 這些值取決于我們操作系統的 OS 設置。 ```ruby $ ./environment.rb /bin/bash en_US.utf8 xterm ``` 樣本輸出。 ## Ruby 偽變量 Ruby 具有一些稱為偽變量的變量。 它們不同于常規變量。 我們不能為偽變量賦值。 `self`是當前方法的接收者。 `nil`是`NilClass`的唯一實例。 它表示一個值的缺失。 `true`是`TrueClass`的唯一實例。 它表示布爾值`true`。 `false`是`FalseClass`的唯一實例。 它表示布爾值`false`。 `true`和`false`是布爾數據類型的值。 從另一個角度來看，它們是特定類的實例。 這是因為 Ruby 中的所有內容都是一個對象。 這看起來不必要地復雜。 但這是上述 Ruby 習慣用法的結果。 ```ruby #!/usr/bin/ruby p self p nil p true p false p self.class p nil.class p true.class p false.class ``` 這是偽變量的示例。 我們使用`p`方法打印所有四個偽變量。 然后我們找出所有它們的類名。 ```ruby p self ``` 在這種情況下，`self`偽變量返回主執行上下文。 ```ruby $ ./pseudo.rb main nil true false Object NilClass TrueClass FalseClass ``` 示例輸出。 在本節的第二個示例中，我們將進一步查看`self`。 ```ruby #!/usr/bin/ruby class Some puts self end class Other puts self end puts self ``` 如前所述，`self`引用了當前方法的接收者。 上面的示例顯示了不同接收器的三個示例。 ```ruby class Some puts self end ``` 接收器是稱為`Some`的類。 ```ruby class Other puts self end ``` 這是另一個接收器：名為`Other`的類。 ```ruby puts self ``` 第三個接收器是 Ruby 頂級。 ```ruby $ ./pseudoself.rb Some Other main ``` 示例輸出。 本節的最后一個示例將展示其他三個偽變量。 ```ruby #!/usr/bin/ruby if true puts "This message is shown" end if false puts "This message is not shown" end p $name p $age ``` 上面的示例顯示了正在使用的`true`，`false`和`nil`偽變量。 ```ruby if true puts "This message is shown" end ``` `true`用于布爾表達式。 該消息始終被打印。 ```ruby if false puts "This message is not shown" end ``` 此消息從不打印。 不滿足條件。 在布爾表達式中，我們總是得到一個負值。 ```ruby p $name p $age ``` 如果引用了全局值且尚未初始化，則它們包含`nil`偽變量。 它代表沒有值。 ```ruby $ ./pseudo2.rb This message is shown nil nil ``` 偽腳本`pseudo2.rb`的輸出。 ## Ruby 預定義變量 Ruby 有很多預定義的全局變量。 這是 Perl 語言的傳承。 Ruby 受 Perl 的強烈影響。 當 Ruby 腳本啟動時，它們是可訪問的。 我們為預定義的 Ruby 變量提供了一些示例。 ```ruby #!/usr/bin/ruby print "Script name: ", $0, "\n" print "Command line arguments: ", $*, "\n" puts "Process number of this script: #{$$}" ``` 已經使用了三個預定義變量：`$0`，`$*`和`$$`。 `$0`存儲當前腳本名稱。 `$*`變量存儲命令行參數。 并且`$$`存儲腳本的 PID（進程 ID）。 ```ruby $ ./predefined.rb 1 2 3 Script name: ./predefined.rb Command line arguments: ["1", "2", "3"] Process number of this script: 3122 ``` 樣本輸出。 `$?`全局變量存儲最后執行的子進程的退出狀態。 ```ruby #!/usr/bin/ruby system 'echo "Ruby"' puts $? %x[exit '1'] puts $? ``` 我們運行兩個外部子進程，并使用`$?`變量檢查其退出狀態。 ```ruby system 'echo "Ruby"' puts $? ``` 使用`system`方法，我們啟動了一個子進程。 這是一個`echo` bash 命令，該命令將消息輸出到終端。 ```ruby %x[exit '1'] puts $? ``` 在第二種情況下，我們以狀態 1 執行 bash `exit`命令。這一次，我們使用`%x`運算符在兩個選定的定界符之間執行命令。 我們選擇了`[]`字符。 ```ruby $ ./predefined2.rb Ruby pid 3131 exit 0 pid 3133 exit 1 ``` 第一個子進程以狀態 0 終止，第二個子進程以退出狀態 1 終止。 `$;`變量具有`String`類的`split`方法的默認分隔符。 ```ruby #!/usr/bin/ruby str = "1,2,3,4,5,6,7" p str.split $; = "," p str.split ``` 我們使用`$;`變量來控制如何使用`split`方法剪切字符串。 該方法帶有一個參數，該參數指示應在何處分割字符串。 如果省略該參數，則使用`$;`中的值。 ```ruby $; = "," p str.split ``` 我們為`$;`變量指定分隔符。 `split`方法不帶參數，因此使用`$;`的值。 ```ruby $ ./predefined3.rb ["1,2,3,4,5,6,7"] ["1", "2", "3", "4", "5", "6", "7"] ``` 在第一種情況下，字符串未拆分。 在第二種情況下，按照我們的預期正確分割了字符串。 在最后一個示例中，我們顯示了三個與正則表達式一起使用的全局預定義變量。 ```ruby #!/usr/bin/ruby "Her name is Jane" =~ /name/ p $` p $& p $' ``` 當我們在字符串上應用`=~`運算符時，Ruby 會設置一些變量。 `$&`變量的字符串與最后一個正則表達式匹配相匹配。 `` $` ``在`$&`之前有一個字符串，`$'`在`$&`之后有一個字符串。 ```ruby $ ./predefined4.rb "Her " "name" " is Jane" ``` Example output. 在 Ruby 教程的這一部分中，我們更深入地研究了 Ruby 變量。