Ruby 數據類型 · ZetCode 中文系列教程

# Ruby 數據類型 > 原文： [https://zetcode.com/lang/rubytutorial/datatypes/](https://zetcode.com/lang/rubytutorial/datatypes/) 在 Ruby 教程的這一部分中，我們將討論數據類型。各種計算機程序（包括電子表格，文本編輯器，計算器和聊天客戶端）都可以處理數據。用于各種數據類型的工具是現代計算機語言的基本組成部分。數據類型是一組值，以及對這些值的允許操作。 ## Ruby 數據類型列表 Ruby 有幾種數據類型。所有數據類型均基于類。以下是 Ruby 識別的數據類型： * 布爾值 * 符號 * 數字 * 字符串 * 數組 * 哈希在以下示例中，我們具有所有重要的 Ruby 數據類型。 ```ruby #!/usr/bin/ruby h = { :name => "Jane", :age => 17 } p true.class, false.class p "Ruby".class p 1.class p 4.5.class p 3_463_456_457.class p :age.class p [1, 2, 3].class p h.class ``` 我們打印他們的類名稱。一個類是從每個對象創建的模板。 ```ruby p true.class, false.class ``` 布爾值由`true`和`false`對象表示。 ```ruby p "Ruby".class ``` 這是字符串。 ```ruby p 1.class p 4.5.class p 3_463_456_457.class ``` 這些是數字。 ```ruby p :age.class ``` 這是一個符號，一種特定于 Ruby 的數據類型。 ```ruby p [1, 2, 3].class p h.class ``` 這是兩個容器，數組和哈希。 ```ruby $ ./types.rb TrueClass FalseClass String Fixnum Float Bignum Symbol Array Hash ``` 該程序列出了屬于 Ruby 數據類型的類。 ## Ruby 布爾值我們的世界建立了雙重性。有天與地，水與火，陰與陽，男人與女人，愛與恨。這就是我們生存的“布爾”性質。在 Ruby 中，布爾數據類型可以具有兩個值之一：`true`或`false`。布爾是一種基本的數據類型：在計算機程序中非常常見的一種。快樂的父母正在等待孩子的出生。他們為兩種可能性都選擇了名稱。如果要成為男孩，他們選擇了約翰。如果要成為女孩，他們會選擇維多利亞。 ```ruby #!/usr/bin/ruby # kid.rb bool = [true, false] male = bool[rand(2)] if male puts "We will use name John" else puts "We will use name Victoria" end ``` 該程序使用隨機數生成器來模擬我們的情況。 ```ruby bool = [true, false] ``` 我們有一個`bool`變量。它是兩個布爾值的數組。用方括號創建一個數組。 ```ruby male = bool[rand(2)] ``` 我們使用`rand()`方法創建一個隨機數。該方法返回 0 或 1。返回的數字是`bool`數組的索引。 ```ruby if male puts "We will use name John" else puts "We will use name Victoria" end ``` 根據公變量，我們打印一條消息。如果將`male`變量設置為`true`，則選擇名稱 John。否則，我們選擇名稱 Victoria。諸如`if/else`語句之類的控制結構可使用布爾值。 ```ruby $ ./kid.rb We will use name Victoria $ ./kid.rb We will use name Victoria $ ./kid.rb We will use name John $ ./kid.rb We will use name John $ ./kid.rb We will use name John ``` 多次運行該程序。 ## Ruby 符號符號用于表示其他對象。使用符號代替字符串可以節省一些資源。符號是`Symbol`類的實例對象。通過在標識符（如`:name`）之前使用冒號來生成符號。幾個對象也具有`to_sym`方法。這些方法將那些對象轉換為符號。 Ruby 符號不能在運行時更改。 Ruby 符號通常用作哈希鍵，因為我們不需要鍵的字符串對象的全部功能。 ```ruby #!/usr/bin/ruby p :name p :name.class p :name.methods.size p "Jane".methods.size p :name.object_id p :name.object_id p "name".object_id p "name".object_id ``` 在第一個示例中，我們展示了一些使用 Ruby 符號的基本操作。 ```ruby p :name p :name.class ``` 我們將符號及其類輸出到控制臺。符號的類別為`Symbol`。 ```ruby p :name.methods.size p "Jane".methods.size ``` 我們比較了與符號和字符串實例關聯的方法的數量。字符串的方法數量是符號的兩倍以上。 ```ruby p :name.object_id p :name.object_id p "name".object_id p "name".object_id ``` 相同的符號具有相同的 ID。相同的字符串具有不同的 ID。 ```ruby $ ./symbols.rb :name Symbol 79 162 10328 10328 77344750 77344730 ``` 樣本輸出。符號可以用作標志。在這種情況下也可以使用常量。在 C/C++ 中，我們將使用枚舉。 ```ruby #!/usr/bin/ruby light = :on if light == :on puts "The light is on" else puts "The light is off" end light = :off if light == :on puts "The light is on" else puts "The light is off" end ``` 指示燈點亮或熄滅。對于這兩種狀態，我們都可以定義符號。 ```ruby light = :on ``` 燈亮。 ```ruby if light == :on puts "The light is on" else puts "The light is off" end ``` 程序的邏輯取決于`light`變量的狀態。符號通常用作哈希容器中的鍵。它們比字符串更有效。 ```ruby #!/usr/bin/ruby domains = {:sk => "Slovakia", :no => "Norway", :hu => "Hungary"} puts domains[:sk] puts domains[:no] puts domains[:hu] ``` 在腳本中，我們有一個域哈希。哈希中的鍵是符號。 ```ruby puts domains[:sk] puts domains[:no] puts domains[:hu] ``` 鍵用于訪問哈希值。在這里，我們打印哈希的三個值。 ```ruby $ ./symbols3.rb Slovakia Norway Hungary ``` 示例的輸出。 Ruby 解釋器在內部將一些引用存儲為符號。 ```ruby #!/usr/bin/ruby class Being def initialize @is = true end def say "I am being" end end b = Being.new p b.method :say p b.instance_variable_get :@is ``` 定義了`Being`類。該類具有一個自定義實例變量`@is`和`say`方法。這兩個實體由 Ruby 使用符號存儲。 ```ruby p b.method :say ``` `method`方法在`b`對象中查找具有給定名稱的接收器方法。我們在尋找`:say`符號。 ```ruby p b.instance_variable_get :@is ``` 我們使用`instance_variable_get`檢查`@is`是否是`b`對象的實例變量。在內部，變量存儲為`:@is`符號。 ```ruby $ ./symbols4.rb #<Method: Being#say> true ``` 生成的輸出。所有符號都存儲在符號表中。在下一個示例中，我們看一下表格。 `Symbol`類的`all_symbols`方法返回表中所有符號的數組。 ```ruby #!/usr/bin/ruby def info "info method" end @v = "Ruby" @@n = "16" p Symbol.all_symbols.include? :info p Symbol.all_symbols.include? :@v p Symbol.all_symbols.include? :@@n ``` 在 Ruby 腳本中創建方法，實例變量和類變量。我們檢查這些實體是否存儲在符號表中。 ```ruby p Symbol.all_symbols.include? :info ``` 我們檢查`:info`符號是否在符號表中。該行返回`true`。 ```ruby $ ./symbols5.rb true true true ``` 這三個符號都存在于 Ruby 符號表中。 ## Ruby 整數整數是實數的子集。它們寫時沒有小數或小數部分。整數屬于集合`Z = {..., -2, -1, 0, 1, 2, ......}`此集合是無限的。在計算機語言中，整數是原始數據類型。實際上，由于計算機的容量有限，因此計算機只能使用整數值的子集。整數用于計算離散實體。我們可以有 3、4 或 6 個人，但不能有 3.33 個人。我們可以有 3.33 公斤。整數是 Ruby 中`Fixnum`或`Bignum`類的實例對象。與 Java 或 C 這樣的語言不同，Ruby 中的整數是對象。這兩個類別的大小不同。 `Fixnum`數字是不超過一定限制的整數。該限制取決于機器。 `Bignum`值保存`Fixnum`范圍之外的整數。如果對`Fixnum`的任何操作超出其范圍，則該值將自動轉換為`Bignum`。程序員通常不需要關心整數的類類型。 ```ruby #!/usr/bin/ruby p -2 p 121 p 123265 p -34253464356 p 34867367893463476 p 1.class p 23453246.class p 234532423563456346.class p 2345324235632363463456456346.class p 5 / 2 p 5.div 2 ``` 在此示例中，我們處理整數。 ```ruby p -2 p 121 p 123265 p -34253464356 p 34867367893463476 ``` 這些是各種大小的正整數和負整數。 ```ruby p 1.class p 23453246.class p 234532423563456346.class p 2345324235632363463456456346.class ``` 我們打印這些整數的類。前兩個整數是`Fixnum`類的實例。另外兩個是`Bignum`類的實例。 ```ruby p 5 / 2 p 5.div 2 ``` 這兩行顯示整數除法。當我們使用整數除法運算符/方法除以兩個整數時，結果也是一個整數。 ```ruby $ ./integers.rb -2 121 123265 -34253464356 34867367893463476 Fixnum Fixnum Bignum Bignum 2 2 ``` 示例的輸出。可以在 Ruby 中使用不同的表示法指定整數：十進制，十六進制，八進制和二進制。據我們所知，通常使用十進制數。十六進制數字以`0x`字符開頭，八進制以`0`字符開頭，二進制以`0b`字符開頭。 ```ruby #!/usr/bin/ruby puts 122 puts 0x7a puts 0172 puts 0b1111010 ``` 在代碼示例中，我們以所有這些符號打印十進制 122。 ```ruby $ ./inotations.rb 122 122 122 122 ``` 示例的輸出。如果我們使用整數，那么我們將處理離散實體。我們將使用整數來計算蘋果。 ```ruby #!/usr/bin/ruby baskets = 16 apples_in_basket = 24 total = baskets * apples_in_basket puts "There are total of #{total} apples" ``` 在我們的程序中，我們計算了蘋果的總量。我們使用整數。 ```ruby $ ./apples.rb There are total of 384 apples ``` 程序的輸出。大數字很難閱讀。如果我們有一個像 245342395423452 這樣的數字，我們會發現很難快速閱讀。在計算機外部，大數字之間用空格或逗號分隔。為了提高可讀性，Ruby 允許整數包含下劃線。 Ruby 解釋器將忽略整數中的下劃線。 ```ruby #!/usr/bin/ruby p 23482345629 p 23_482_345_629 p 23482345629 == 23_482_345_629 ``` 該示例演示了下劃線的用法。 ```ruby p 23482345629 == 23_482_345_629 ``` 此行表明兩個數字相等。它打印真實。 ```ruby $ ./underscore.rb 23482345629 23482345629 true ``` 示例輸出。 ## Ruby 浮點數浮點數表示計算中的實數。實數測量連續的量，例如重量，高度或速度。在 Ruby 中，十進制數字是`Float`或`BigDecimal`類的對象。 `BigDecimal`類是 Ruby 的核心類，是 Ruby 標準庫的一部分。另外，我們也可以使用`Rational`對象。我們需要了解十進制數字并不精確。 Ruby 的官方文檔明確指出，浮點對象表示不精確的實數。 ```ruby #!/usr/bin/ruby p 15.4 p 0.3455 p -343.4563 p 12.5.class p -12.5.class p (5.0 / 2).class p 5.fdiv 2 p 12.to_f ``` 在上面的程序中，我們使用浮點值。 ```ruby p 15.4 p 0.3455 p -343.4563 ``` 在這里，我們打印三個十進制值。小數點有小數點字符。 ```ruby p 12.5.class p -12.5.class p (5.0 / 2).class ``` 上面的代碼行顯示了數字的類型。全部都是花車。至少在一個`Float`上應用整數除法也會產生`Float`。 ```ruby p 5.fdiv 2 p 12.to_f ``` 在這里，我們通過使用浮點`fdiv`除法和轉換`to_f`方法來創建浮點值。 ```ruby $ ./decimals.rb 15.4 0.3455 -343.4563 Float Float Float 2.5 12.0 ``` 輸出。默認情況下，顯示的十進制數字在小數點后最多 16 個數字。我們可以使用`sprintf`或`printf`方法控制浮點值的格式。 ```ruby #!/usr/bin/ruby p 1/3.0 p 1.fdiv 2 puts sprintf "%.4f" % (1/3.0) puts sprintf "%.7f" % (5/3.0) ``` 格式化十進制數字。 ```ruby p 1/3.0 p 13.fdiv 4 p 1.fdiv 2 ``` 第一行打印一個小數點后的 16 位。第二行在該點之后打印兩個數字，第三行打印。 ```ruby puts sprintf "%.4f" % (1/3.0) puts sprintf "%.7f" % (5/3.0) ``` 在這里，我們使用`sprintf`方法控制小數點后的值數量。 `sprintf`方法的格式說明符存在精度。它是`%`字符后的數字。 `f`是一個轉換說明符，表示我們正在處理浮點值。 ```ruby $ ./formatfloat.rb 0.3333333333333333 3.25 0.5 0.3333 1.6666667 ``` Output. Ruby 支持對浮點值使用科學計數法。也稱為指數表示法，它是一種寫數字太大或太小而不能方便地用標準十進制表示法寫的方式。 ```ruby #!/usr/bin/ruby p 1.2e-3 p 0.0012 p 1.5E-4 p 0.00015 ``` 該示例顯示了兩個用科學計數法表示的十進制數字。 ```ruby $ ./scientific.rb 0.0012 0.0012 0.00015 0.00015 ``` 這是上面程序的輸出。如前所述，浮點值有些不準確。對于許多計算，普通的浮點數足夠精確：如果我們的體重是 60kg 或 60.000023kg，那不是很重要。對于其他計算，包括許多科學和工程應用，精度至關重要。 Ruby 在標準庫中有一個`BigDecimal`。此類為非常大或非常準確的浮點數提供任意精度。 ```ruby #!/usr/bin/ruby require 'bigdecimal' sum = 0 1000.times do sum = sum + 0.0001 end p sum sum = BigDecimal.new("0") 1000.times do sum = sum + BigDecimal.new("0.0001") end puts sum.to_s('F') puts sum.to_s('E') ``` 在這個簡單的示例中，我們比較了`Float`與`BigDecimal`的精度。 ```ruby require 'bigdecimal' ``` 必須導入`BigDecimal`類。 ```ruby sum = 0 1000.times do sum = sum + 0.0001 end p sum ``` 我們形成一個循環，在該循環中，我們將一個小的浮點值添加到`sum`變量中。最后，將有一個小的誤差。 ```ruby sum = BigDecimal.new("0") 1000.times do sum = sum + BigDecimal.new("0.0001") end ``` 我們使用`BigDecimal`值進行相同的循環。 ```ruby puts sum.to_s('F') puts sum.to_s('E') ``` 總和以浮點數和工程符號形式打印。 ```ruby $ ./bigdecimal.rb 0.10000000000000184 0.1 0.1E0 ``` 輸出顯示，使用`BigDecimal`進行的計算比使用`Floats`進行的計算更為精確。假設一個短跑運動員跑了 1 個小時，跑了 9.87 秒。他的公里/小時速度是多少？ ```ruby #!/usr/bin/ruby distance = 0.1 time = 9.87 / 3600 speed = distance / time puts "The average speed of a sprinter is #{speed} km/h" ``` 在此示例中，必須使用浮點值。 ```ruby distance = 0.1 ``` 100m 是 0.1 公里。 ```ruby time = 9.87 / 3600 ``` 9.87s 是`9.87 / 60 * 60 h` ```ruby speed = distance / time ``` 為了獲得速度，我們將距離除以時間。 ```ruby $ ./speed.rb The average speed of a sprinter is 36.4741641337386 km/h ``` 這是`speed.rb`腳本的輸出。 ## Ruby 有理數 Ruby 支持有理數。有理數是精確數。使用有理數可以避免舍入誤差。在 Ruby 中，有理數是`Rational`類的對象。我們可以使用特殊的`to_r`方法從某些對象創建有理數。有理數是可以表示為兩個整數`a / b`的分數的任何數字，其中`b != 0`。由于`b`可以等于 1，所以每個整數都是有理數。 ```ruby #!/usr/bin/ruby puts 2.to_r puts "23".to_r puts 2.6.to_r p Rational 0 p Rational 1/5.0 p Rational 0.5 ``` 此示例顯示了一些有理數。 ```ruby puts 2.to_r ``` 在這里，我們使用`to_r`方法將 2 整數轉換為`2 / 1`有理數。 ```ruby p Rational 0.5 ``` 我們使用`Rational`類創建一個有理數。 ```ruby $ ./rational.rb 2/1 23/1 5854679515581645/2251799813685248 (0/1) (3602879701896397/18014398509481984) (1/2) ``` Output of the example. ## Ruby `nil`值 Ruby 具有特殊值`nil`。這是沒有值的。 `nil`是`NilClass`的單例對象。只有一個`nil`；我們不能再擁有更多了。 ```ruby #!/usr/bin/ruby puts nil p nil p $val p [1, 2, 3][4] p $val1 == $val2 ``` `nil`值的示例。 ```ruby puts nil p nil ``` 我們將`nil`值打印到控制臺。 `puts`方法打印一個空字符串； `p`方法顯示'nil'字符串。 ```ruby p $val ``` 當我們引用一個未設置的全局變量時，我們得到`nil`值。 ```ruby p [1, 2, 3][3] ``` 在此代碼行中，我們引用三元素數組的第四個元素。我們得到`nil`。 Ruby 中的許多方法都會為無效值返回`nil`。 ```ruby p $val1 == $val2 ``` 該行返回`true`。這是由于`nil`值是`NilClass`的單例對象這一事實的結果。 ```ruby $ ./nilvalue.rb nil nil nil true ``` Output. ## Ruby 字符串字符串是表示計算機程序中文本數據的數據類型。 Ruby 字符串是 unicode 字符的序列。字符串是`String`的實例。字符串字面值是用雙或單引號括起來的字符。字符串是非常重要的數據類型。它值得一章。這里我們僅舉一個小例子。 ```ruby #!/usr/bin/ruby p "Ruby" p 'Python' p "Ruby".size p "Ruby".upcase p 23.to_s ``` 在此程序中，我們使用 Ruby 字符串。我們使用`p`方法進行打印，因為我們在輸出中看到了數據類型。 ```ruby p "Ruby" p 'Python' ``` 我們在終端上打印兩個字符串字面值。第一個字面值用雙引號括起來，第二個字面值用單引號括起來。 ```ruby p "Ruby".size p "Ruby".upcase ``` 這兩行調用兩個字符串方法。 `size`方法返回字符串的大小：在本例中為 4 個字符。 `upcase`以大寫字母返回字符串。 ```ruby p 23.to_s ``` `to_s`方法將整數轉換為字符串。 ```ruby $ ./strings.rb "Ruby" "Python" 4 "RUBY" "23" ``` 在輸出中，我們看到用引號引起來的字符串。這是使用`p`方法的結果。 `print`和`puts`方法不這樣做。 ## Ruby 數組和哈希數組和哈希是對象的集合。他們將對象分組到一個位置。數組是對象的有序集合。哈希是鍵值對的集合。我們將只有一章介紹數組和哈希。以下示例僅簡要介紹了這兩個容器。 ```ruby #!/usr/bin/ruby nums = [1, 2, 3, 4] puts "There are #{nums.size} items in the array" nums.each do |num| puts num end domains = { :de => "Germany", :sk => "Slovakia", :us => "United States", :no => "Norway" } puts domains.keys puts domains.values ``` 這是一個有關 Ruby 數組和哈希的快速示例。 ```ruby nums = [1, 2, 3, 4] puts "There are #{nums.size} items in the array" nums.each do |num| puts num end ``` 這些行創建一個包含 4 個項目的數組。在第二行中，我們計算數組的項并將其合并到消息中。稍后，我們使用`each`方法遍歷數組，并將每個元素打印到控制臺。 ```ruby domains = { :de => "Germany", :sk => "Slovakia", :us => "United States", :no => "Norway" } puts domains.keys puts domains.values ``` 在這里，我們創建一個 Ruby 哈希。然后我們打印其鍵和值。 ```ruby $ ./arrayshashes.rb There are 4 items in the array 1 2 3 4 de sk us no Germany Slovakia United States Norway ``` Example output. ## Ruby 轉換我們經常一次處理多種數據類型。將一種數據類型轉換為另一種數據類型是編程中的常見工作。類型轉換或類型轉換是指將一種數據類型的實體更改為另一種。有兩種轉換類型：隱式轉換和顯式轉換。隱式類型轉換，也稱為強制轉換，是編譯器自動進行的類型轉換。 Ruby 只有顯式轉換。 Ruby 具有內置的轉換方法，例如`to_i`，`to_s`或`to_f`。 `Kernel`模塊具有一些進行轉換的公共方法，例如`Integer`，`String`或`Float`。這些方法不應與 Ruby 類混淆。 ```ruby #!/usr/bin/ruby p Array(1..6) p Complex 6 p Float 12 p Integer "34" p Rational 6 p String 22 ``` 這里我們展示`Kernel`轉換方法。 ```ruby $ ./convertmethods.rb [1, 2, 3, 4, 5, 6] (6+0i) 12.0 34 (6/1) "22" ``` Output of the example. ```ruby #!/usr/bin/ruby p "12".to_i p 12.5.to_i p nil.to_i p 12.to_f p "11".to_f p nil.to_f ``` 在上面的示例中，我們顯示了一些數值轉換。某些 Ruby 對象具有`to_i`和`to_f`方法，分別將對象轉換為整數和浮點數。 ```ruby p "12".to_i p 12.5.to_i p nil.to_i ``` 在此代碼中，我們將字符串，十進制和`nil`轉換為整數類型。 ```ruby p 12.to_f p "11".to_f p nil.to_f ``` 這三行將整數，字符串和`nil`轉換為十進制數據類型的對象。 ```ruby $ ./conversions.rb 12 12 0 12.0 11.0 0.0 ``` Example output. 第二個示例顯示了一些字符串轉換。 ```ruby #!/usr/bin/ruby p "12".to_i p "13".to_f p "12".to_r p "13".to_c p "Jane".to_sym v = "Ruby Python Tcl PHP Perl".split p v.class ``` 在上面的示例中，我們將字符串轉換為不同數據類型的對象。 ```ruby p "12".to_i p "13".to_f p "12".to_r p "13".to_c ``` 在這里，字符串將轉換為整數，十進制，有理數和復數。 ```ruby p "Jane".to_sym ``` 字符串成為符號。 ```ruby v = "Ruby Python Tcl PHP Perl".split p v.class ``` 在這里，我們使用`String`類的`split`方法將字符串轉換為數組。 ```ruby $ ./stringconv.rb 12 13.0 (12/1) (13+0i) :Jane Array ``` 這就是我們得到的。下一個小示例顯示了數組哈希轉換。 ```ruby #!/usr/bin/ruby h = {:de => "Germany", :sk => "Slovakia"} p h.to_a a = [:de, "Germany", :sk, "Slovakia", :hu, "Hungary", :no, "Norway"] p Hash[*a] ``` 在示例代碼中，我們創建了一個哈希并將其隱秘到數組中。然后，我們創建一個數組并將其轉換為哈希。 ```ruby h = {:de => "Germany", :sk => "Slovakia"} p h.to_a ``` 使用`to_a`方法創建哈希并將其轉換為數組。 ```ruby a = [:de, "Germany", :sk, "Slovakia", :hu, "Hungary", :no, "Norway"] p Hash[*a] ``` 創建一個數組并將其轉換為哈希。在此上下文中，星號是拆分運算符。這是從 Perl 提取的 Ruby 慣用語之一。它將數組拆分為幾個變量。 ```ruby $ ./h2a.rb [[:de, "Germany"], [:sk, "Slovakia"]] {:de=>"Germany", :sk=>"Slovakia", :hu=>"Hungary", :no=>"Norway"} ``` Output of the example. 在 Ruby 教程的這一部分中，我們介紹了數據類型及其轉換。