本文是关于 Ruby 的字符编码相关内容的一篇笔记，而不是一篇详细的教程。本文的主要内容参考Ruby 对多语言的支持。
Ruby 在1.9版之前堪称是对字符编码支持最差的语言之一，而现在变成了支持最好的语言之一。在 1.8 中，一个字符串就是一连串的字节，而 Ruby 1.9 则要复杂的多，看起来就像在处理单元就是一个个字符一样。例如：
#encoding: utf-8
"1个".size # 在 1.8 中返回的4（因为每个汉字占3个字节）， 而在 1.9 中返回的是2
在 1.9 中字符串是一串被编码的数据，字符串不仅包含着原始的字节，同时还附属着编码信息来指明如何处理这些字节。我们可以通过 encoding 这个方法来查看。
puts str.encoding.name # UTF-8
该代码表明应该用 utf-8 字符编码来处理 str 变量指向的一串字节。同时，我们可以通过 bytesize 方法来查看有多少个字节。
我们可以通过 force_encoding 方法来显式的指定应该用一个字符编码来处理特定的字符串。我们没有改变编码数据，我们仅仅改变了处理这些数据的规则而已。
abc = "abc"
puts abc.encoding.name # >> US-ASCII
abc.force_encoding("UTF-8")
puts abc.encoding.name # >> UTF-8
但是，这样做可能会很危险。因为我们所指定的字符编码规则可能会不能正确的处理这些字节。我们可以通过 valid_encoding? 方法来看看字节能够被顺利的处理。
# 数据有正确的 Encoding
puts latin1_resume.encoding.name # >> ISO-8859-1
puts latin1_resume.bytesize # >> 6
puts latin1_resume.valid_encoding? # >> true
# 发生了失误，设置了错误的 Encoding
latin1_resume.force_encoding("UTF-8")
# 数据没有改变，但是 Encoding 不一致了
puts latin1_resume.encoding.name # >> UTF-8
puts latin1_resume.bytesize # >> 6
puts latin1_resume.valid_encoding? # >> false
# 当需要使用这些数据时
latin1_resume =~ /\AR/ # !> ArgumentError:
# invalid byte sequence in UTF-8
如果我们想改变数据本身，我们应该使用 encode （或者 encode! ）这个方法。它会将字符转换成为另一个种编码形式。
# 合法的 Latin-1 数据
puts latin1_resume.encoding.name # >> ISO-8859-1
puts latin1_resume.bytesize # >> 6
puts latin1_resume.valid_encoding? # >> true
# 把数据转码到 UTF-8
transcoded_utf8_resume = latin1_resume.encode("UTF-8")
# 现在已经正确的转换到 UTF-8 了
puts transcoded_utf8_resume.encoding.name # >> UTF-8
puts transcoded_utf8_resume.bytesize # >> 8
puts transcoded_utf8_resume.valid_encoding? # >> true
值得注意的是，字符串的比较是依据的数据本身，也就是字节。
str = "中国"
puts str.encoding.name # >> UTF-8
# 把数据转码到 GBK
str2 = str.encode("GBK")
p str == str2 # >> false
因此，在处理一组字符串时，应该首先把它们转换成为相同的 Encoding。我们可以通过 compatible? 方法来测试两种编码的相容性。如果返回 false 则表明两种编码不相容，如果要对二者进行操作至少要转换一个数据。否则返回一个 Encoding 对象说明两者相容，可以进行字符串连接操作，连接后的字符串采用返回值所对应的编码。
# 两种不同 Encoding 的数据
p ascii_my # >> "My "
puts ascii_my.encoding.name # >> US-ASCII
p utf8_resume # >> "Résumé"
puts utf8_resume.encoding.name # >> UTF-8
# 检查相容性
p Encoding.compatible?(ascii_my, utf8_resume) # >> #<Encoding:UTF-8>
# 合并相容的数据
my_resume = ascii_my + utf8_resume
p my_resume # >> "My Résumé"
puts my_resume.encoding.name # >> UTF-8
显示迭代
Ruby 1.9 中的字符串不在是可以枚举的，也就不再包含 Enumerable 模块，同时也没有 each 这个方法。但是字符串依然提供了更加具体的几个迭代的方法。
utf8_resume = "Résumé"
utf8_resume.each_byte do |byte|
puts byte
end
# >> 82
# >> 195
# >> 169
# >> 115
# >> 117
# >> 109
# >> 195
# >> 169
utf8_resume.each_char do |char|
puts char
end
# >> R
# >> é
# >> s
# >> u
# >> m
# >> é
utf8_resume.each_codepoint do |codepoint|
puts codepoint
end
# >> 82
# >> 233
# >> 115
# >> 117
# >> 109
# >> 233
utf8_resume.each_line do |line|
puts line
end
# >> Résum
同时，上边的方法可以通过不指定块来获得 Enumerator 对象，不过还有一些方法是专门为这种用法准备的，返回数组形式。
p utf8_resume.bytes.first(3)
# >> [82, 195, 169]
p utf8_resume.chars.find { |char| char.bytesize > 1 }
# >> "é"
p utf8_resume.codepoints.to_a
# >> [82, 233, 115, 117, 109, 233]
p utf8_resume.lines.map { |line| line.reverse }
# >> ["émuséR"]
三种默认编码类型
源码的编码
刚才已经说明，每一个字符串都有一个 Encoding 对象，也就是说在创建字符串的时候就要为它指定一个 Encoding 对象。例如：
str = "A new string"
Ruby1.9 的实现方法是，所有的源码都有一个 Encoding 对象，当你在源码中创建字符串时，源码的 Encoding 对象会自动赋予给字符串。
现在，我们需要知道源码如何确定一个源码的 Encoding 对象。Ruby 为此提供了很多方法。
- 如果不指定，则 Ruby2.0 默认编码为 utf-8，而 Ruby1.9 默认编码则为 ASCII。
$ cat no_encoding.rb
p __ENCODING__
$ ruby no_encoding.rb
#<Encoding:UTF-8>
- 如果需要设定源码的 Encoding 对象，则有一种推荐的方法叫做 “神奇注释”。如果文件包含 Shebang ，这个“神奇注释”必须出现在第二行，否则必须出现在第一行。
# encoding: UTF-8
#!/usr/bin/env ruby -w
# encoding: UTF-8
注意，“神奇注释”的格式很松散，以下的所有形式效果都一样：
# encoding: UTF-8
# coding: UTF-8
# -*- coding: UTF-8 -*-
- 如果命令行使用了 -e 选项来执行 Ruby 代码，命令行会从所处环境获得源码的 Encoding。
$ echo $LC_CTYPE
en_US.UTF-8
$ ruby -e 'p __ENCODING__'
#<Encoding:UTF-8>
- Ruby 1.9 仍然支持来自 Ruby 1.8 的 -K* 形式开关，包括本文大量使用的 -KU 开关。不过，这种方法的存在只是为了向前兼容性，“神奇注释”才是王道。
$ ruby -KU no_encoding.rb
#<Encoding:UTF-8>
默认的外部编码和内部编码
字符串经常还可以通过另一种方法来创建：从 IO 对象读取。这时候我们就不能简单的将源码的 Encoding 对象赋值给字符串了，因为外码数据与源码无关。因此，IO 对象至少要附着一种 Encoding 对象。而 Ruby 为此提供了两种编码：外部编码和内部编码。
我们通过设置打开文件的模式来设定外部编码和内部编码，并通过 IO 对象的 external_encoding 和 internal_encoding 方法来访问外部编码和内部编码。
外部编码是数据在 IO 对象内所采用的编码，外部编码影响数据的读取；如果内部编码没有设定的话，返回数据也会采用外部编码的编码进行编码。
$ cat show_external.rb
open(__FILE__, "r:UTF-8") do |file|
puts file.external_encoding.name
p file.internal_encoding
file.each do |line|
p [line.encoding.name, line]
end
end
$ ruby show_external.rb
UTF-8
nil
["UTF-8", "open(__FILE__, \"r:UTF-8\") do |file|\n"]
["UTF-8", " puts file.external_encoding.name\n"]
["UTF-8", " p file.internal_encoding\n"]
["UTF-8", " file.each do |line|\n"]
["UTF-8", " p [line.encoding.name, line]\n"]
["UTF-8", " end\n"]
["UTF-8", "end\n"]
如果设置了内部编码，数据还是以外部编码读取，但是在创建字符串时会将其转到内部编码。这个程序带来了便利。
str1 = "中国"
str2 = nil
open("data.txt", "r:GBK") do |file|
str2 = file.read
end
puts str1 # >> 中国
puts str2 # >> 中国
p [str1.encoding.name, str1.bytes] # >> ["UTF-8", [228, 184, 173, 229, 155, 189]]
p [str2.encoding.name, str2.bytes] # >> ["GBK", [214, 208, 185, 250]]
p str1 == str2 # >> false
我们通过设置内部编码，将字符串转换成为内部编码。
str1 = "中国"
str2 = nil
open("data.txt", "r:GBK:UTF-8") do |file|
str2 = file.read
end
puts str1 # >> 中国
puts str2 # >> 中国
p [str1.encoding.name, str1.bytes] # >> ["UTF-8", [228, 184, 173, 229, 155, 189]]
p [str2.encoding.name, str2.bytes] # >> ["UTF-8", [228, 184, 173, 229, 155, 189]]
p str1 == str2 # >> true
在写模式下，外部编码以相同的方式工作。但是，此时你就没有必要显示的指定一个内部编码了，Ruby 会自动将输出的字符串的编码设为内部编码，如果需要的话将数据转换为外部编码。
open("data.txt", "w:UTF-16LE") do |file|
puts file.external_encoding.name # UTF-16LE
p file.internal_encoding # nil
data = "My data…"
file << data
end
如果不设置它们，内部编码默认值是 nil 。外部编码默认值会从环境中去取得，类似于通过命令行设定源码的方式。
$ echo $LC_CTYPE
en_US.UTF-8
$ ruby -e 'puts Encoding.default_external.name'
UTF-8
这两个 IO 相关的编码各自有一个全局性的设置方法：Encoding.default_external=() 和 Encoding.default_internal=() 。你可以把它们设定为 Encoding 对象或者所对应的字符串。
你也可以通过命令行开关来改变着两个编码的值。-E 开关可以同时设置这两个编码或者其中一个。
$ ruby -e 'p [Encoding.default_external, Encoding.default_internal]'
[#<Encoding:UTF-8>, nil]
$ ruby -E Shift_JIS \
> -e 'p [Encoding.default_external, Encoding.default_internal]'
[#<Encoding:Shift_JIS>, nil]
$ ruby -E :UTF-16LE \
> -e 'p [Encoding.default_external, Encoding.default_internal]'
[#<Encoding:UTF-8>, #<Encoding:UTF-16LE>]
$ ruby -E Shift_JIS:UTF-16LE \
> -e 'p [Encoding.default_external, Encoding.default_internal]'
[#<Encoding:Shift_JIS>, #<Encoding:UTF-16LE>]
其他细节
Encoding 对象的其他特性
Encoding 对象很简单，基本上只是表示了 Ruby 中编码的名称。另外，Encoding 对象存储了一些方法，在处理编码时很有用。
首先， list 包含 Ruby 中加载的所有 Encoding 对象。
$ ruby -e 'puts Encoding.list.first(3), "..."'
ASCII-8BIT
UTF-8
US-ASCII
...
其次，find 可以查找相应的编码。如果不存在则抛出一个 ArgumentError 的异常。
$ ruby -e 'p Encoding.find("UTF-8")'
#<Encoding:UTF-8>
$ ruby -e 'p Encoding.find("No-Such-Encoding")'
-e:1:in `find': unknown encoding name - No-Such-Encoding (ArgumentError)
from -e:1:in `<main>'
有些 Encoding 对象名称不只一个，通过 aliases 方法可以返回一个 hash，通过键可以获得它的别名。
$ puts Encoding.aliases["ASCII"]
US-ASCII
$ puts Encoding.aliases["US-ASCII"]
nil
$ p Encoding.find("ASCII") == Encoding.find("US-ASCII")
true
另外 Ruby 中有一些是还没有完全实现字符处理的空壳编码，我们可以利用 dummy? 方法来查看。
encode = Encoding.find("UTF-7")
p encode.dummy? # true
我们可以找出所有的空格编码。
Encoding.list.select(&:dummy?).map(&:name)
处理二进制
不是所有的数据都是文本的形式，Ruby 提供了一种 Ruby 独有的编码—— ASCII-8BIT，这种编码单纯的把数据看做原始的字节码。你可以理解为关闭了字符处理，而只是处理字节。
$ cat raw_bytes.rb
# encoding: UTF-8
str = "Résumé"
def str.inspect
{ data: dup,
encoding: encoding.name,
chars: size,
bytes: bytesize }.inspect
end
p str
str.force_encoding("BINARY")
p str
$ ruby raw_bytes.rb
{:data=>"Résumé", :encoding=>"UTF-8", :chars=>6, :bytes=>8}
{:data=>"R\xC3\xA9sum\xC3\xA9", :encoding=>"ASCII-8BIT", :chars=>8, :bytes=>8}
上述代码中 BINARY 只是 ASCII-8BIT 的别名。Ruby 通过使的 ASCII-8BIT 和 US-ASCII 编码相兼容来方便数据的处理，即 ASCII-8BIT 的意思是 ASCII 外加上了一些其他自己，这样将有助于数据处理你可以将其中部分数据视为 ASCII。例如，PNG 图片的头几个字节就包含一个完整的 ASCII 字符串“PNG”。通过 ASCII-8BIT ，我们可以一个简单的 US-ASCII 正则表达式来验证 PNG 签名。
$ cat png_sig.rb
sig = "\x89PNG\r\n\C-z\n"
png = /\A.PNG/
p({sig => sig.encoding.name, png => png.encoding.name})
if sig =~ png
puts "This data looks like a PNG image."
end
$ ruby png_sig.rb
{"\x89PNG\r\n\x1A\n"=>"ASCII-8BIT", /\A.PNG/=>"US-ASCII"}
This data looks like a PNG image.
另外，如果我们以字节的模式来读取数据，Ruby 会将编码回滚到 ASCII-8BIT。
$ cat binary_fallback.rb
open("ascii.txt", "w+:UTF-8") do |f|
f.puts "abc"
f.rewind
str = f.read(2)
p [str.encoding.name, str]
end
$ ruby binary_fallback.rb
["ASCII-8BIT", "ab"]
因此在字节模式下读取，你可以截断字符。如果你不想改变编码，你需要手动设置并检验。类似下面的实现方式：
$ cat read_to_char.rb
# encoding: UTF-8
open("ascii.txt", "w+:UTF-8") do |f|
f.puts "Résumé"
f.rewind
str = f.read(2)
until str.dup.force_encoding(f.external_encoding).valid_encoding?
str << f.read(1)
end
str.force_encoding(f.external_encoding)
p [str.encoding.name, str]
end
$ ruby read_to_char.rb
["UTF-8", "Ré"]
处理二进制数据还需要你了解 IO 对象的另一个情况，在 Windows 系统中，Ruby 会转换一些你读取的数据，转换的内容很简单：从 IO 对象中读取的 \r\n 会变成单一的 \n。这个功能可以让 Unix 上的脚本顺利的在具有不同行尾形式的平台上运行。这样做会带来一些额外的工作量：在读取非文本数据时，比如说二进制数据或像 UTF-16 这样和 ASCII 不兼容的编码，为了保证能够夸平台执行，你要提醒 Ruby 不要做这样的转换。
告知 Ruby 将数据视为二进制的，而不想做任何转换是很简单的。在调用 open() 时在操作模式后添加一个 b 就可以了。
open(path, "rb") do |f|
# ...
end
Ruby 1.9 对二进制标签有更严格的规则，如果 Ruby 认为需要（编码不兼容US-ASCII ？）而你没有提供这个标签的话它会发出一些抱怨。例如：
# Ruby 1.9 会让这个通过
open("utf_16.txt", "w:UTF-16LE") do |f|
f.puts "Some data."
end
# 但这个无法通过
open("utf_16.txt", "r:UTF-16LE") do |f|
# ...
end
很容易修复，把 b 添加上去就行了。不过将这个过去丢掉的 b 加入会产生一个副作用，添加 b 后 Ruby 会认为你想要的外部编码是 ASCII-8BIT 而不是默认的外部编码。
$ cat b_means_binary.rb
open("utf_16.txt", "r") do |f|
puts "Inherited from environment: #{f.external_encoding.name}"
end
open("utf_16.txt", "rb") do |f|
puts %Q{Using "rb": #{f.external_encoding.name}}
end
$ ruby b_means_binary.rb
Inherited from environment: UTF-8
Using "rb": ASCII-8BIT
另外，我们现在可以为打开的 IO 的方法添加一个 Hash 类型参数，可以设置 :mode，可以分别设置 :external_encoding 和 :internal_encoding，还可以设置 :binmode。下面是一些例子。
File.read("utf_16.txt", mode: "rb:UTF-16LE")
File.readlines("utf_16.txt", mode: "rb:UTF-16LE")
File.foreach("utf_16.txt", mode: "rb:UTF-16LE") do |line|
end
File.open("utf_16.txt", mode: "rb:UTF-16LE") do |f|
end
open("utf_16.txt", mode: "rb:UTF-16LE") do |f|
end
还有一个较为快捷的方式，直接使用新的 IO::binread() 方法，它和 IO.read(..., mode: "rb:ASCII-8BIT") 作用一样。
正则表达式编码
所有的数据都有编码，因此我们为正则表达式也附属了编码。
$ cat re_encoding.rb
# encoding: UTF-8
utf8_str = "résumé"
latin1_str = utf8_str.encode("ISO-8859-1")
binary_str = utf8_str.dup.force_encoding("ASCII-8BIT")
utf16_str = utf8_str.encode("UTF-16BE")
re = /\Ar.sum.\z/
puts "Regexp.encoding.name: #{re.encoding.name}"
[utf8_str, latin1_str, binary_str, utf16_str].each do |str|
begin
result = str =~ re ? "Matches" : "Doesn't match"
rescue Encoding::CompatibilityError
result = "Can't match non-ASCII compatible?() Encoding"
end
puts "#{result}: #{str.encoding.name}"
end
$ ruby re_encoding.rb
Regexp.encoding.name: US-ASCII
Matches: UTF-8
Matches: ISO-8859-1
Doesn't match: ASCII-8BIT
Can't match non-ASCII compatible?() Encoding: UTF-16BE
值得注意的是，正则表达式的默认编码类型不是 UTF-8 而是 US-ASCII，这样的好处是，它可以处理任何和 US-ASCII 兼容的数据。
如果正则表达式包含非 ASCII 字符，或者通过编码选项来显式指定，那么我们就可以得到一个非 ASCII 编码的正则表达式。
$ cat encodings.rb
# encoding: UTF-8
res = [
/…\z/, # source Encoding
/\A\uFEFF/, # special escape
/abc/u # Ruby 1.8 option
]
puts res.map { |re| [re.encoding.name, re.inspect].join(" ") }
$ ruby encodings.rb
UTF-8 /…\z/
UTF-8 /\A\uFEFF/
UTF-8 /abc/
Ruby 还支持 /e （EUC_JP）和 /s （Shift_JIS 的一个扩展 Windows-31J）也同样可以继续使用。Ruby 1.9 还支持原来的 /n 选项，不过因为遗留原因会产生一些错误，所以建议不要再用了。
在 Ruby 1.9.2 中，“正则表达式可以匹配任意和 ASCII 兼容的数据”这种概念有了一个新名称：
$ cat fixed_encoding.rb
[/a/, /a/u].each do |re|
puts "%-10s %s" % [ re.encoding, re.fixed_encoding? ? "fixed" : "not fixed" ]
end
$ ruby fixed_encoding.rb
US-ASCII not fixed
UTF-8 fixed
“编码锁定”的正则表达式，在处理不完全由 ASCII 字符组成（ascii_only?()）的字符串时，如果这个字符串包含与正则表达式不一样编码的内容就会抛出 Encoding::CompatibilityError 异常。如果 fixed_encoding?() 返回 false，正则表达式则可以用来处理任何与 ASCII 兼容的编码。甚至还有一个名为 FIXEDENCODING 的常量可以用来禁止对 ASCII 的降级处理：
$ cat force_re_encoding.rb
puts Regexp.new("abc".force_encoding("UTF-8")).encoding.name
puts Regexp.new( "abc".force_encoding("UTF-8"),
Regexp::FIXEDENCODING ).encoding.name
$ ruby force_re_encoding.rb
US-ASCII
UTF-8
注意，如果为 Regexp.new() 指定了 Regexp::FIXEDENCODING 参数，正则表达式就会使用传入的字符串的编码。你可以使用这种方式生成采用任何一种编码的正则表达式，包括前面提到的 ASCII-8BIT。
只要正则表达式的编码和数据的编码是兼容的，那么模式匹配功能就可以正常运行。
网友评论