Ruby 中的 String 对象存储并操作一个或多个字节的任意序列，通常表示那些代表人类语言的字符。
最简单的字符串是括在单引号（单引号字符）内。在引号标记内的文本是字符串的值：
'This is a simple Ruby string literal'
如果您需要在单引号字符串内使用单引号字符，那么需要在单引号字符串使用反斜杠，这样 Ruby 解释器就不会认为这个单引号字符会终止字符串：
'Won\'t you read O\'Reilly\'s book?'
反斜杠也能转义另一个反斜杠，这样第二个反斜杠本身不会解释为转义字符。
以下是 Ruby 中字符串相关的特性。
表达式置换
表达式置换是一种使用 #{ 和 } 把任意 Ruby 表达式的值嵌入到字符串中的方式：
#!/usr/bin/ruby
x, y, z = 12, 36, 72
puts "The value of x is #{ x }."
puts "The sum of x and y is #{ x + y }."
puts "The average was #{ (x + y + z)/3 }."
这将产生以下结果：
The value of x is 12.
The sum of x and y is 48.
The average was 40.
一般的分隔字符串
通过一般的分隔字符串，您可以在以百分号字符（%）为前导的一对匹配的任意分隔字符（例如，!、 (、 {、 <，等等）内创建字符串。Q、 q 和 x 有特殊的意义。一般的分隔字符串可以是：
%{Ruby is fun.} 相当于 "Ruby is fun."
%Q{ Ruby is fun. } 相当于 " Ruby is fun. "
%q[Ruby is fun.] 相当于以单引号字符串
%x!ls! 相当于反勾号命令输出 `ls`
字符编码
Ruby 的默认字符集是 ASCII，字符可用单个字节表示。如果您使用 UTF-8 或其他现代的字符集，字符可能是用一个到四个字节表示。
您可以在程序开头使用 $KCODE 改变字符集，如下所示：
$KCODE = 'u'
下面是 $KCODE 可能的值。
| 编码 | 描述 | | ---- | ------------------------------------ | | a | ASCII （与 none 相同）。这是默认的。 | | e | EUC。 | | n | None （与 ASCII 相同）。 | | u | UTF-8。 |
字符串内建方法
我们需要有一个 String 对象的实例来调用 String 方法。下面是创建 String 对象实例的方式：
new [String.new(str="")]
这将返回一个包含 str 副本的新的字符串对象。现在，使用 str 对象，我们可以调用任意可用的实例方法。例如：
#!/usr/bin/ruby
myStr = String.new("THIS IS TEST")
foo = myStr.downcase
puts "#{foo}"
这将产生以下结果：
this is test
字符串 unpack 指令 下表列出了方法 String#unpack 的解压指令。
尝试下面的实例，解压各种数据。
"abc \0\0abc \0\0".unpack('A6Z6') #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3') #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*') #=> ["abc ", "abc "]
"aa".unpack('b8B8') #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c') #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS') #=> [-2, 65534]
"now=20is".unpack('M*') #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a') #=> ["h", "e", "l", "l", "o"]
Ruby 数组（Array）
Ruby 数组是任何对象的有序的、整数索引的集合。数组中的每个元素都与一个索引相关，并可通过索引进行获取。
数组的索引从 0 开始，这与 C 或 Java 中一样。一个负数的索引时相对于数组的末尾计数的，也就是说，索引为 -1 表示数组的最后一个元素，-2 表示数组中的倒数第二个元素，依此类推。
Ruby 数组可存储诸如 String、 Integer、 Fixnum、 Hash、 Symbol 等对象，甚至可以是其他 Array 对象。Ruby 数组不像其他语言中的数组那么刚性。当向数组添加元素时，Ruby 数组会自动增长。
创建数组
有多种方式创建或初始化数组。一种方式是通过 new 类方法：
names = Array.new
您可以在创建数组的同时设置数组的大小：
names = Array.new(20)
数组 names 的大小或长度为 20 个元素。您可以使用 size 或 length 方法返回数组的大小：
#!/usr/bin/ruby
names = Array.new(20)
puts names.size # 返回 20
puts names.length # 返回 20
这将产生以下结果：
20
20
您可以给数组中的每个元素赋值，如下所示：
#!/usr/bin/ruby
names = Array.new(4, "mac")
puts "#{names}"
这将产生以下结果：
macmacmacmac
您也可以使用带有 new 的块，每个元素使用块中的计算结果来填充：
#!/usr/bin/ruby
nums = Array.new(10) { |e| e = e * 2 }
puts "#{nums}"
这将产生以下结果：
024681012141618
数组还有另一种方法，[]，如下所示：
nums = Array.[](1, 2, 3, 4,5)
数组创建的另一种形式如下所示：
nums = Array[1, 2, 3, 4,5]
在核心 Ruby 中可用的 Kernel 模块有一个 Array 方法，只接受单个参数。在这里，该方法带有一个范围作为参数来创建一个数字数组：
#!/usr/bin/ruby
digits = Array(0..9)
puts "#{digits}"
这将产生以下结果：
0123456789
数组内建方法
我们需要有一个 Array 对象的实例来调用 Array 方法。下面是创建 Array 对象实例的方式：
Array.[](...) [or] Array[...] [or] [...]
这将返回一个使用给定对象进行填充的新的数组。现在，使用创建的对象，我们可以调用任意可用的实例方法。例如：
#!/usr/bin/ruby
digits = Array(0..9)
num = digits.at(6)
puts "#{num}"
这将产生以下结果：
6
实例
尝试下面的实例，压缩各种数据。
a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3") #=> "a b c "
puts a.pack("a3a3a3") #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc") #=> "ABC"
这将产生以下结果：
a b c
abc
ABC
Ruby 哈希（Hash）
哈希（Hash）是类似 "employee" => "salary" 这样的键值对的集合。哈希的索引是通过任何对象类型的任意键来完成的，而不是一个整数索引，其他与数组相似。
通过键或值遍历哈希的顺序看起来是随意的，且通常不是按照插入顺序。如果您尝试通过一个不存在的键访问哈希，则方法会返回 nil。
创建哈希
与数组一样，有各种不同的方式来创建哈希。您可以通过 new 类方法创建一个空的哈希：
months = Hash.new
您也可以使用 new 创建带有默认值的哈希，不带默认值的哈希是 nil：
months = Hash.new( "month" )
or
months = Hash.new "month"
当您访问带有默认值的哈希中的任意键时，如果键或值不存在，访问哈希将返回默认值：
#!/usr/bin/ruby
months = Hash.new( "month" )
puts "#{months[0]}"
puts "#{months[72]}"
这将产生以下结果：
month
month
#!/usr/bin/ruby
H = Hash["a" => 100, "b" => 200]
puts "#{H['a']}"
puts "#{H['b']}"
这将产生以下结果：
100
200
您可以使用任何的 Ruby 对象作为键或值，甚至可以使用数组，所以下面的实例是一个有效的实例：
[1,"jan"] => "January"
哈希内建方法
我们需要有一个 Hash 对象的实例来调用 Hash 方法。下面是创建 Hash 对象实例的方式：
Hash[[key =>|, value]* ] or
Hash.new [or] Hash.new(obj) [or]
Hash.new { |hash, key| block }
这将返回一个使用给定对象进行填充的新的哈希。现在，使用创建的对象，我们可以调用任意可用的实例方法。例如：
#!/usr/bin/ruby
$, = ", "
months = Hash.new( "month" )
months = {"1" => "January", "2" => "February"}
keys = months.keys
puts "#{keys}"
这将产生以下结果：
2, 1
标签：Hash,puts,介绍,数组,new,Array,数据结构,Ruby From： https://blog.csdn.net/licy__/article/details/143159518