打包数据¶ ↑

某些 Ruby 核心方法处理数据的打包和解包

方法 Array#pack: 将数组 self 中的每个元素格式化为二进制字符串；返回该字符串。
方法 String#unpack: 从字符串 self 中提取数据，形成成为新数组元素的对象；返回该数组。
方法 String#unpack1：执行相同操作，但仅解包并返回第一个提取的对象。

这些方法中的每一个都接受一个字符串 template，该字符串由零个或多个指令字符组成，每个字符后跟零个或多个修饰符字符。

示例（指令 'C' 指定“无符号字符”）

[65].pack('C')      # => "A"  # One element, one directive.
[65, 66].pack('CC') # => "AB" # Two elements, two directives.
[65, 66].pack('C')  # => "A"  # Extra element is ignored.
[65].pack('')       # => ""   # No directives.
[65].pack('CC')               # Extra directive raises ArgumentError.

'A'.unpack('C')   # => [65]      # One character, one directive.
'AB'.unpack('CC') # => [65, 66]  # Two characters, two directives.
'AB'.unpack('C')  # => [65]      # Extra character is ignored.
'A'.unpack('CC')  # => [65, nil] # Extra directive generates nil.
'AB'.unpack('')   # => []        # No directives.

字符串 template 可以包含任何有效指令的混合（指令 'c' 指定“有符号字符”）

[65, -1].pack('cC')  # => "A\xFF"
"A\xFF".unpack('cC') # => [65, 255]

字符串 template 可以包含空格（将被忽略）和注释，每个注释都以字符 '#' 开头，并一直持续到下一个换行符（包括换行符）。

[0,1].pack("  C  #foo \n  C  ")    # => "\x00\x01"
"\0\1".unpack("  C  #foo \n  C  ") # => [0, 1]

任何指令都可以后跟以下任意修饰符

'*' - 指令将根据需要应用多次

[65, 66].pack('C*') # => "AB"
'AB'.unpack('C*')   # => [65, 66]

Integer count - 指令将应用 count 次

[65, 66].pack('C2') # => "AB"
[65, 66].pack('C3') # Raises ArgumentError.
'AB'.unpack('C2')   # => [65, 66]
'AB'.unpack('C3')   # => [65, 66, nil]

注意：%w[A a Z m] 中的指令以不同的方式使用 count；请参阅字符串指令。

如果元素不符合提供的指令，则仅编码最低有效位

[257].pack("C").unpack("C") # => [1]

打包方法¶ ↑

方法 Array#pack 接受可选关键字参数 buffer，该参数指定目标字符串（而不是新字符串）

[65, 66].pack('C*', buffer: 'foo') # => "fooAB"

该方法可以接受一个块

# Packed string is passed to the block.
[65, 66].pack('C*') {|s| p s }    # => "AB"

解包方法¶ ↑

方法 String#unpack 和 String#unpack1 都接受一个可选关键字参数 offset，该参数指定字符串中的偏移量

'ABC'.unpack('C*', offset: 1)  # => [66, 67]
'ABC'.unpack1('C*', offset: 1) # => 66

这两种方法都可以接受一个块

# Each unpacked object is passed to the block.
ret = []
"ABCD".unpack("C*") {|c| ret << c }
ret # => [65, 66, 67, 68]

# The single unpacked object is passed to the block.
'AB'.unpack1('C*') {|ele| p ele } # => 65

整数指令¶ ↑

每个整数指令都指定输入或输出数组中一个元素的打包或解包。

8 位整数指令¶ ↑

'c' - 8 位有符号整数（如 C signed char）

[0, 1, 255].pack('c*')  # => "\x00\x01\xFF"
s = [0, 1, -1].pack('c*') # => "\x00\x01\xFF"
s.unpack('c*') # => [0, 1, -1]

'C' - 8 位无符号整数（如 C unsigned char）

[0, 1, 255].pack('C*')    # => "\x00\x01\xFF"
s = [0, 1, -1].pack('C*') # => "\x00\x01\xFF"
s.unpack('C*')            # => [0, 1, 255]

16 位整数指令¶ ↑

's' - 16 位有符号整数，本机端序（如 C int16_t）

[513, -514].pack('s*')      # => "\x01\x02\xFE\xFD"
s = [513, 65022].pack('s*') # => "\x01\x02\xFE\xFD"
s.unpack('s*')              # => [513, -514]

'S' - 16 位无符号整数，本机端序（如 C uint16_t）

[513, -514].pack('S*')      # => "\x01\x02\xFE\xFD"
s = [513, 65022].pack('S*') # => "\x01\x02\xFE\xFD"
s.unpack('S*')              # => [513, 65022]

'n' - 16 位网络整数，大端序

s = [0, 1, -1, 32767, -32768, 65535].pack('n*')
# => "\x00\x00\x00\x01\xFF\xFF\x7F\xFF\x80\x00\xFF\xFF"
s.unpack('n*')
# => [0, 1, 65535, 32767, 32768, 65535]

'v' - 16 位 VAX 整数，小端序

s = [0, 1, -1, 32767, -32768, 65535].pack('v*')
# => "\x00\x00\x01\x00\xFF\xFF\xFF\x7F\x00\x80\xFF\xFF"
s.unpack('v*')
# => [0, 1, 65535, 32767, 32768, 65535]

32 位整数指令¶ ↑

'l' - 32 位有符号整数，本机端序（如 C int32_t）

s = [67305985, -50462977].pack('l*')
# => "\x01\x02\x03\x04\xFF\xFE\xFD\xFC"
s.unpack('l*')
# => [67305985, -50462977]

'L' - 32 位无符号整数，本机端序（如 C uint32_t）

s = [67305985, 4244504319].pack('L*')
# => "\x01\x02\x03\x04\xFF\xFE\xFD\xFC"
s.unpack('L*')
# => [67305985, 4244504319]

'N' - 32 位网络整数，大端序

s = [0,1,-1].pack('N*')
# => "\x00\x00\x00\x00\x00\x00\x00\x01\xFF\xFF\xFF\xFF"
s.unpack('N*')
# => [0, 1, 4294967295]

'V' - 32 位 VAX 整数，小端序

s = [0,1,-1].pack('V*')
# => "\x00\x00\x00\x00\x01\x00\x00\x00\xFF\xFF\xFF\xFF"
s.unpack('v*')
# => [0, 0, 1, 0, 65535, 65535]

64 位整数指令¶ ↑

'q' - 64 位带符号整数，本机字节序（如 C int64_t）

s = [578437695752307201, -506097522914230529].pack('q*')
# => "\x01\x02\x03\x04\x05\x06\a\b\xFF\xFE\xFD\xFC\xFB\xFA\xF9\xF8"
s.unpack('q*')
# => [578437695752307201, -506097522914230529]

'Q' - 64 位无符号整数，本机字节序（如 C uint64_t）

s = [578437695752307201, 17940646550795321087].pack('Q*')
# => "\x01\x02\x03\x04\x05\x06\a\b\xFF\xFE\xFD\xFC\xFB\xFA\xF9\xF8"
s.unpack('Q*')
# => [578437695752307201, 17940646550795321087]

平台相关整数指令¶ ↑

'i' - 平台相关宽度带符号整数，本机字节序（如 C int）

s = [67305985, -50462977].pack('i*')
# => "\x01\x02\x03\x04\xFF\xFE\xFD\xFC"
s.unpack('i*')
# => [67305985, -50462977]

'I' - 平台相关宽度无符号整数，本机字节序（如 C unsigned int）

s = [67305985, -50462977].pack('I*')
# => "\x01\x02\x03\x04\xFF\xFE\xFD\xFC"
s.unpack('I*')
# => [67305985, 4244504319]

'j' - 指针宽度带符号整数，本机字节序（如 C intptr_t）

s = [67305985, -50462977].pack('j*')
# => "\x01\x02\x03\x04\x00\x00\x00\x00\xFF\xFE\xFD\xFC\xFF\xFF\xFF\xFF"
s.unpack('j*')
# => [67305985, -50462977]

'J' - 指针宽度无符号整数，本机字节序（如 C uintptr_t）

s = [67305985, 4244504319].pack('J*')
# => "\x01\x02\x03\x04\x00\x00\x00\x00\xFF\xFE\xFD\xFC\x00\x00\x00\x00"
s.unpack('J*')
# => [67305985, 4244504319]

其他整数指令¶ ↑

'U' - UTF-8 字符

s = [4194304].pack('U*')
# => "\xF8\x90\x80\x80\x80"
s.unpack('U*')
# => [4194304]

'w' - BER 编码整数（参见 BER 编码）

s = [1073741823].pack('w*')
# => "\x83\xFF\xFF\xFF\x7F"
s.unpack('w*')
# => [1073741823]

整数指令的修饰符¶ ↑

对于以下指令，'!' 或 '_' 修饰符可以作为底层平台的本机大小的后缀。

'i', 'I' - C int，始终为本机大小。
's', 'S' - C short。
'l', 'L' - C long。
'q', 'Q' - C long long（如果可用）。
'j', 'J' - C intptr_t，始终为本机大小。

对于始终为本机大小的指令，本机大小修饰符将被忽略。

字节序修饰符也可以作为上述指令的后缀

'>' - 大端。
'<' - 小端。

浮点数指令¶ ↑

每个浮点数指令指定输入或输出数组中一个元素的打包或解包。

单精度浮点数指令¶ ↑

'F' 或 'f' - 本机格式

s = [3.0].pack('F') # => "\x00\x00@@"
s.unpack('F')       # => [3.0]

'e' - 小端

s = [3.0].pack('e') # => "\x00\x00@@"
s.unpack('e')       # => [3.0]

'g' - 大端

s = [3.0].pack('g') # => "@@\x00\x00"
s.unpack('g')       # => [3.0]

双精度浮点数指令¶ ↑

'D' 或 'd' - 本机格式

s = [3.0].pack('D') # => "\x00\x00\x00\x00\x00\x00\b@"
s.unpack('D')       # => [3.0]

'E' - 小端

s = [3.0].pack('E') # => "\x00\x00\x00\x00\x00\x00\b@"
s.unpack('E')       # => [3.0]

'G' - 大端

s = [3.0].pack('G') # => "@\b\x00\x00\x00\x00\x00\x00"
s.unpack('G')       # => [3.0]

浮点数指令可以是无穷大或非数字

inf = 1.0/0.0                  # => Infinity
[inf].pack('f')                # => "\x00\x00\x80\x7F"
"\x00\x00\x80\x7F".unpack('f') # => [Infinity]

nan = inf/inf                  # => NaN
[nan].pack('f')                # => "\x00\x00\xC0\x7F"
"\x00\x00\xC0\x7F".unpack('f') # => [NaN]

字符串指令¶ ↑

每个字符串指令指定输入或输出字符串中一个字节的打包或解包。

二进制字符串指令¶ ↑

'A' - 任意二进制字符串（空格填充；计数为宽度）；nil 被视为空字符串

['foo'].pack('A')    # => "f"
['foo'].pack('A*')   # => "foo"
['foo'].pack('A2')   # => "fo"
['foo'].pack('A4')   # => "foo "
[nil].pack('A')      # => " "
[nil].pack('A*')     # => ""
[nil].pack('A2')     # => "  "
[nil].pack('A4')     # => "    "

"foo\0".unpack('A')      # => ["f"]
"foo\0".unpack('A4')     # => ["foo"]
"foo\0bar".unpack('A10') # => ["foo\x00bar"] # Reads past "\0".
"foo ".unpack('A')       # => ["f"]
"foo ".unpack('A4')      # => ["foo"]
"foo".unpack('A4')       # => ["foo"]

russian = "\u{442 435 441 442}" # => "тест"
russian.size         # => 4
russian.bytesize     # => 8
[russian].pack('A')  # => "\xD1"
[russian].pack('A*') # => "\xD1\x82\xD0\xB5\xD1\x81\xD1\x82"
russian.unpack('A')  # => ["\xD1"]
russian.unpack('A2') # => ["\xD1\x82"]
russian.unpack('A4') # => ["\xD1\x82\xD0\xB5"]
russian.unpack('A*') # => ["\xD1\x82\xD0\xB5\xD1\x81\xD1\x82"]

'a' - 任意二进制字符串（空填充；计数为宽度）

["foo"].pack('a')    # => "f"
["foo"].pack('a*')   # => "foo"
["foo"].pack('a2')   # => "fo"
["foo\0"].pack('a4') # => "foo\x00"
[nil].pack('a')      # => "\x00"
[nil].pack('a*')     # => ""
[nil].pack('a2')     # => "\x00\x00"
[nil].pack('a4')     # => "\x00\x00\x00\x00"

"foo\0".unpack('a')     # => ["f"]
"foo\0".unpack('a4')    # => ["foo\x00"]
"foo ".unpack('a4')     # => ["foo "]
"foo".unpack('a4')      # => ["foo"]
"foo\0bar".unpack('a4') # => ["foo\x00"] # Reads past "\0".

'Z' - 与 'a' 相同，除了使用 '*' 添加或忽略空值

["foo"].pack('Z*')   # => "foo\x00"
[nil].pack('Z*')     # => "\x00"

"foo\0".unpack('Z*')    # => ["foo"]
"foo".unpack('Z*')      # => ["foo"]
"foo\0bar".unpack('Z*') # => ["foo"] # Does not read past "\0".

位字符串指令¶ ↑

'B' - 位字符串（高字节优先）

['11111111' + '00000000'].pack('B*') # => "\xFF\x00"
['10000000' + '01000000'].pack('B*') # => "\x80@"

['1'].pack('B0') # => ""
['1'].pack('B1') # => "\x80"
['1'].pack('B2') # => "\x80\x00"
['1'].pack('B3') # => "\x80\x00"
['1'].pack('B4') # => "\x80\x00\x00"
['1'].pack('B5') # => "\x80\x00\x00"
['1'].pack('B6') # => "\x80\x00\x00\x00"

"\xff\x00".unpack("B*") # => ["1111111100000000"]
"\x01\x02".unpack("B*") # => ["0000000100000010"]

"".unpack("B0")     # => [""]
"\x80".unpack("B1") # => ["1"]
"\x80".unpack("B2") # => ["10"]
"\x80".unpack("B3") # => ["100"]

'b' - 位字符串（低字节优先）

['11111111' + '00000000'].pack('b*') # => "\xFF\x00"
['10000000' + '01000000'].pack('b*') # => "\x01\x02"

['1'].pack('b0') # => ""
['1'].pack('b1') # => "\x01"
['1'].pack('b2') # => "\x01\x00"
['1'].pack('b3') # => "\x01\x00"
['1'].pack('b4') # => "\x01\x00\x00"
['1'].pack('b5') # => "\x01\x00\x00"
['1'].pack('b6') # => "\x01\x00\x00\x00"

"\xff\x00".unpack("b*") # => ["1111111100000000"]
"\x01\x02".unpack("b*") # => ["1000000001000000"]

"".unpack("b0")     # => [""]
"\x01".unpack("b1") # => ["1"]
"\x01".unpack("b2") # => ["10"]
"\x01".unpack("b3") # => ["100"]

十六进制字符串指令¶ ↑

'H' - 十六进制字符串（高四位字节优先）

['10ef'].pack('H*')    # => "\x10\xEF"
['10ef'].pack('H0')    # => ""
['10ef'].pack('H3')    # => "\x10\xE0"
['10ef'].pack('H5')    # => "\x10\xEF\x00"

['fff'].pack('H3')    # => "\xFF\xF0"
['fff'].pack('H4')    # => "\xFF\xF0"
['fff'].pack('H5')    # => "\xFF\xF0\x00"
['fff'].pack('H6')    # => "\xFF\xF0\x00"
['fff'].pack('H7')    # => "\xFF\xF0\x00\x00"
['fff'].pack('H8')    # => "\xFF\xF0\x00\x00"

"\x10\xef".unpack('H*')    # => ["10ef"]
"\x10\xef".unpack('H0')    # => [""]
"\x10\xef".unpack('H1')    # => ["1"]
"\x10\xef".unpack('H2')    # => ["10"]
"\x10\xef".unpack('H3')    # => ["10e"]
"\x10\xef".unpack('H4')    # => ["10ef"]
"\x10\xef".unpack('H5')    # => ["10ef"]

'h' - 十六进制字符串（低四位字节优先）

['10ef'].pack('h*') # => "\x01\xFE"
['10ef'].pack('h0') # => ""
['10ef'].pack('h3') # => "\x01\x0E"
['10ef'].pack('h5') # => "\x01\xFE\x00"

['fff'].pack('h3') # => "\xFF\x0F"
['fff'].pack('h4') # => "\xFF\x0F"
['fff'].pack('h5') # => "\xFF\x0F\x00"
['fff'].pack('h6') # => "\xFF\x0F\x00"
['fff'].pack('h7') # => "\xFF\x0F\x00\x00"
['fff'].pack('h8') # => "\xFF\x0F\x00\x00"

"\x01\xfe".unpack('h*') # => ["10ef"]
"\x01\xfe".unpack('h0') # => [""]
"\x01\xfe".unpack('h1') # => ["1"]
"\x01\xfe".unpack('h2') # => ["10"]
"\x01\xfe".unpack('h3') # => ["10e"]
"\x01\xfe".unpack('h4') # => ["10ef"]
"\x01\xfe".unpack('h5') # => ["10ef"]

指针字符串指令¶ ↑

'P' - 指向结构的指针（固定长度字符串）

s = ['abc'].pack('P')  # => "\xE0O\x7F\xE5\xA1\x01\x00\x00"
s.unpack('P*')         # => ["abc"]
".".unpack("P")        # => []
("\0" * 8).unpack("P") # => [nil]
[nil].pack("P")        # => "\x00\x00\x00\x00\x00\x00\x00\x00"

'p' - 指向空终止字符串的指针

s = ['abc'].pack('p')  # => "(\xE4u\xE5\xA1\x01\x00\x00"
s.unpack('p*')         # => ["abc"]
".".unpack("p")        # => []
("\0" * 8).unpack("p") # => [nil]
[nil].pack("p")        # => "\x00\x00\x00\x00\x00\x00\x00\x00"

其他字符串指令¶ ↑

'M' - 引用可打印的 MIME 编码；文本模式，但输入必须使用 LF，输出 LF；（参见 RFC 2045）

["a b c\td \ne"].pack('M') # => "a b c\td =\n\ne=\n"
["\0"].pack('M')           # => "=00=\n"

["a"*1023].pack('M') == ("a"*73+"=\n")*14+"a=\n"     # => true
("a"*73+"=\na=\n").unpack('M') == ["a"*74]           # => true
(("a"*73+"=\n")*14+"a=\n").unpack('M') == ["a"*1023] # => true

"a b c\td =\n\ne=\n".unpack('M')    # => ["a b c\td \ne"]
"=00=\n".unpack('M')    # => ["\x00"]

"pre=31=32=33after".unpack('M') # => ["pre123after"]
"pre=\nafter".unpack('M')       # => ["preafter"]
"pre=\r\nafter".unpack('M')     # => ["preafter"]
"pre=".unpack('M')              # => ["pre="]
"pre=\r".unpack('M')            # => ["pre=\r"]
"pre=hoge".unpack('M')          # => ["pre=hoge"]
"pre==31after".unpack('M')      # => ["pre==31after"]
"pre===31after".unpack('M')     # => ["pre===31after"]

'm' - Base64 编码字符串；计数指定每个换行符之间的输入字节，向下舍入到最接近的 3 的倍数；如果计数为零，则不添加换行符；（参见 RFC 4648）

[""].pack('m')             # => ""
["\0"].pack('m')           # => "AA==\n"
["\0\0"].pack('m')         # => "AAA=\n"
["\0\0\0"].pack('m')       # => "AAAA\n"
["\377"].pack('m')         # => "/w==\n"
["\377\377"].pack('m')     # => "//8=\n"
["\377\377\377"].pack('m') # => "////\n"

"".unpack('m')       # => [""]
"AA==\n".unpack('m') # => ["\x00"]
"AAA=\n".unpack('m') # => ["\x00\x00"]
"AAAA\n".unpack('m') # => ["\x00\x00\x00"]
"/w==\n".unpack('m') # => ["\xFF"]
"//8=\n".unpack('m') # => ["\xFF\xFF"]
"////\n".unpack('m') # => ["\xFF\xFF\xFF"]
"A\n".unpack('m')    # => [""]
"AA\n".unpack('m')   # => ["\x00"]
"AA=\n".unpack('m')  # => ["\x00"]
"AAA\n".unpack('m')  # => ["\x00\x00"]

[""].pack('m0')             # => ""
["\0"].pack('m0')           # => "AA=="
["\0\0"].pack('m0')         # => "AAA="
["\0\0\0"].pack('m0')       # => "AAAA"
["\377"].pack('m0')         # => "/w=="
["\377\377"].pack('m0')     # => "//8="
["\377\377\377"].pack('m0') # => "////"

"".unpack('m0')     # => [""]
"AA==".unpack('m0') # => ["\x00"]
"AAA=".unpack('m0') # => ["\x00\x00"]
"AAAA".unpack('m0') # => ["\x00\x00\x00"]
"/w==".unpack('m0') # => ["\xFF"]
"//8=".unpack('m0') # => ["\xFF\xFF"]
"////".unpack('m0') # => ["\xFF\xFF\xFF"]

'u' - UU 编码字符串

[0].pack("U")          # => "\u0000"
[0x3fffffff].pack("U") # => "\xFC\xBF\xBF\xBF\xBF\xBF"
[0x40000000].pack("U") # => "\xFD\x80\x80\x80\x80\x80"
[0x7fffffff].pack("U") # => "\xFD\xBF\xBF\xBF\xBF\xBF"

偏移指令¶ ↑

'@' - 从给定的字节偏移处开始打包；对于打包，如果需要，则填充空值

[1, 2].pack("C@0C") # => "\x02"
[1, 2].pack("C@1C") # => "\x01\x02"
[1, 2].pack("C@5C") # => "\x01\x00\x00\x00\x00\x02"

"\x01\x00\x00\x02".unpack("C@3C") # => [1, 2]
"\x00".unpack("@1C")              # => [nil]

'X' - 备份一个字节

[0, 1, 2].pack("CCXC")    # => "\x00\x02"
[0, 1, 2].pack("CCX2C")   # => "\x02"
"\x00\x02".unpack("CCXC") # => [0, 2, 2]

空字节指令¶ ↑

'x' - 空字节

[].pack("x0")                # => ""
[].pack("x")                 # => "\x00"
[].pack("x8")                # => "\x00\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x02".unpack("CxC") # => [0, 2]