ruby参考手册
Ruby术语集
--按英文排序
A
AWK
由Alfred Aho(A)、Peter Weinberger(W)和Brian Kernighan(K)共通创建的一种小型脚本语言。
B
blade
ml archive (blade/ruby)
C
Coerce
进行数据类型变换的方法。如果某数值计算方法从参数那里获得了一个类型不明的实例时, 它会调用coerce方法来进行数据类型变换。coerce方法会返回参数中的数值和本身。
Ruby库的数值类型变换顺序为
Fixnum -> Bignum -> Rational -> Float -> Complex
D
Data
该类可将C中的指针处理成Ruby对象。由C指针、mark函数和free函数构成。如果您想使用C语言来扩充Ruby的功能的话, 就必须掌握该类的使用方法。相反地, 如果您没有这个打算的话, 它也就没什么用了。
defined?
该操作符可以检查某对象(表达式)是否已经被定义。若未被定义就返回nil,若已被定义,就以字符串形式返回它的种类。虽然defined?看似一个方法,实际上它是Ruby语法中的操作符, 它不会对参数进行计算。因此下面的表达式
defined? print("abc\n")
不会输出任何内容。
E
Eiffel
面向对象的编程语言。据说,早先matz在读了该语言作者所撰写的《Object-oriented Software Construction》之后顿觉恍然大悟。但奇怪的是Ruby与Eiffel却并不相似。如果硬要找出雷同之处的话, 可能只有两点: 1.Ruby的块以end结尾;2.Ruby也有rescue这个保留字。
end
该保留字表明了块的结束。据统计,大约有33%的人在看到这个end时会联想起Pascal(纯属杜撰)。但它并不和begin连用,因此它可能更接近于Ada或Eiffel。
Ruby之所以不使用C和Perl中的{},主要是因为以下原因
*
避开单句·复句的问题
例如在C语言中, 若想向下例中添加语句时
if (a==b)
c();
如果写成这样的话
if (a==b)
c();
d();
就会造成难以发现的bug。即使是Pascal也存在这个问题。
*
回避else的问题
与上例类似, 如果写出下面这样的语句的话
if (a==b)
if (c==d) foo();
else bar();
就会引起混乱。其实它的本意应该是
if (a==b) {
if (c==d) foo();
else bar();
}
这个样子。
*
提高可读性
可能您对此持有异议, 但有的人认为:用end来结束块的做法可以提高程序的可读性。
*
begin和case语法表达上的问题
说句实话，matz曾多次想把end用作变量。甚至探讨过在ruby语法中添加{ }的问题，但因为无法完美地解决begin和case的语法表达的问题，最终不得不放弃这个念头。恐怕这才是最大的理由吧。
ENV
该对象的运作方式与访问环境变量的Hash相同。实际上，它就是添加了特殊方法的Object类的实例。使用该对象来修改环境变量后，其变化将会影响到Ruby的子进程。
F
FAQ
Frequently Asked Questions
常见的问题和解答。Ruby FAQ尚处于不断完善的阶段，问题和解答是随时更新的。
G
goto
Ruby中没有该语句。这并不是因为“我们觉得不应该使用”goto，而是“实现其功能实在是太麻烦了”。实际上，您可以使用catch/throw或异常来实现goto的功能。
H
I
J
JARH
Just another Ruby hacker,
K
L
M
main
顶层中的self。因为self是必不可少的，所以它只是表明在顶层中有个Object类的实例--self而已。另外为了操作Object类，还特别定义了若干特殊方法。
已定义的特殊方法
* private
* public
* include
matz
Ruby的作者，也叫松本 行弘。请参考<URL:http://www.st.rim.or.jp/~fuku/cmail/>，另外，他还是3个孩子的父亲。
Mix-in
混合插入、糅合
就像在冰淇淋中混合多种配料可以做成美味的混合冰淇淋一样，在类中混合插入各种模块就可以添加相应的功能。请参考继承。
matz坚信滥用多重继承会导致继承关系的混乱，因此Ruby中不允许使用多重继承。同时为充分发挥继承功能的优势，Ruby支持两种继承关系：1.使用is-a语句的继承；2.使用Mix-in来共享并继承模块中的功能。
N
O
P
Perl
不必多说了罢
POLS
Principle of least surprise
Python
Ruby的劲敌。其功力深厚，可谓“千年蛇妖”。但matz认为Python的功能仍不完美，不然就不会创造Ruby了。最要命的是Python限定了名称长度(6个字符)。
Q
R
RAA
Ruby Application Archive(RAA)
RCR
Ruby Change Request
RD
Ruby Document
Ruby
面向对象的脚本语言。Ruby的意思是“紧跟在Perl(pearl是6月的诞生石，Ruby则是7月的诞生石)之后”。Ruby并不是其他单词的缩写。
S
Sather
面向对象的编程语言。其实matz钟爱Sather胜过Eiffel。但Ruby与Sather一点都不像。
self
表示被调的表达式。那为什么把它叫做self呢？因为如果把方法看作动词的话，那么被调就是该动作的主语，从方法的角度来看，被调当然就是自己了。一般人认为，Ruby对此并未深究，只不过是模仿Smalltalk的做法罢了。
Smalltalk
面向对象的编程语言。它奠定了现代面向对象 理论体系的基础。
super
在重定义的方法中调用上级方法。省略参数时，将使用主调方方法的参数来进行调用。
*
问题:
修改参数中给出的数值后再调用super的话，将会使用原来的值还是修改后的值呢？
def foo(a)
print a
end
def self.foo(a)
a=25
super
end
foo(5) # 5 or 25??
*
答案:
使用修改后的值(25)
T
Thread
原为Thread of control的缩略语，意指一系列的控制流。在Ruby中，一个程序内可以同时存在若干线程。
U
undef
将方法设置为未定义状态。继承 和Mix-in的功能都是在类中添加方法，而undef则可以取消方法。但是，如果取消了类所必需的方法(被其他方法所调用的方法)的话，其后果不堪设想。
V
W
X
Y
Z
--按拼音排序
A
B
被调
Receiver
方法的执行主体。也就是方法调用表达式的`.'中的左边部分。在方法内，可以使用self来表示它。另外，您可以使用@变量名的形式来访问被调的实例变量。
变量
Variable
贴在对象上的标签。Ruby的变量包括全局变量、局部变量和实例变量。因为常数的值不能改变，所以不是变量。但它也是一种标签，因此在这一点上它与变量是相同的。
C
常数
Constant
一旦定义了就不能再改变的变量。这个定义本身似乎就有点矛盾。
重定义
Override
即指再定义。重新定义超类或include模块中已经定义的方法。使用super即可调用原来的方法。
抽象数据类型
Abstract Data Type
将数据构造和对其进行操作的过程封装在一起，就形成了抽象数据类型。对抽象数据进行操作时，必须使用封装内的操作才行。其结果是不能从外部直接使用数据构造，同时一旦内部构造发生变化也不会对外界造成不良影响。我们把这个过程叫做封装。
初始化
Initialize
使对象(或“某事物”)变为“就绪”状态。对实例进行初始化操作时，需要重定义Object#initialize方法。类方法Class#new的默认定义就是对新生成的实例执行initialize方法。传给new的参数会被原封不动地传给initialize。另外，若带块调用时，该块会被传给initialize。
因此，不必对Class#new进行重定义。
辞典
Dictionary
根据给出的条目即可查出对应的定义。它是哈希表的别名。面向对象的始作俑者Smalltalk把类似哈希表的数据构造称作“辞典”，所以时至今日仍然有一些人把哈希表称作辞典。
D
大Endian
Big Endian
美洲大陆的原住民是Indian而并非Endian，那么这个Endian的词源是什么呢？其实它出自Jonathan Swift写的《格列佛游记》。这本书中的人们因为吃鸡蛋的方法不同而分成两类，从圆头开始吃的叫大Endian，从尖头开始吃的叫小Endian。在计算机业界，该词表示CPU等排列数据的一种方式，据说网络一族的人们喜欢大Endian。请参考字节顺序。
大规模退出
Non-Local Exit
它并不是那种发生在break, next, redo, retry, return等方法的范围内的普通退出，而是一种跨度极大的退出。只要没被捕捉到，它甚至会跳出方法调用的牢笼来引发中断。Ruby的大规模退出包括由异常引起的退出和catch/throw。
大多数的异常(包括由exit所引发的SystemExit在内)都会被rescue 捕捉到。但是若该异常不值得捕捉(例：内存分配失败／解释器的bug)的话，就会放他一马。
在catch/throw中，通常会从被throw的地方起一直跳转到与throw部分具有相同标签的catch部分为止。
迭代器
Iterator
即指调用带块方法。当初为了进行迭代操作而设置了带块方法，现在它仍然常被称作迭带器。虽然可以将那些进行迭代操作的方法叫做迭代器，但如果将所有带块方法的调用过程都看作迭带器的话，势必会引起混乱。
调用带块方法
我们把那些可接受代码段(块)的方法叫做带块方法。调用带块方法就是指调用这些带块方法的过程。
在带块方法中使用yield就可以执行块的内容。
当然了，如何处理给出的块，这完全取决于方法。所以，如果硬是把块传给一个不能带块的方法的话，也不会有什么结果，而且也不会发生错误。
动态绑定
Dynamic Binding
指在运行时根据操作对象的数据类型的不同来选择合适的过程(方法)。它可以提高程序的灵活性。它是面向对象的必要条件之一。在Ruby中变量是没有类型的，因此必然可以进行动态绑定。
动态局部变量
Dynamic Local Variable
它是一种特殊的局部变量。Ruby的局部变量的作用域是固定的，因此在编译时就会生成局部变量。动态局部变量则有所不同，每次执行时才会生成变量。在块中首次被赋值的局部变量就是动态局部变量，其作用域仅限于块的内部。这主要是为了让各个Thread都能拥有自己独立的变量而设的。
对象
Object
即指物体。举个例子，“爱”可能不是对象，但“情书”却是对象。甄别某事物是否属于对象，这可能是个哲学问题。或许正因为如此，面向对象也变得扑朔迷离起来。在计算机业界有人认为对象就是指内存中的特定空间。到底何谓对象，还真是个难题。另外，请参考封装和抽象数据类型。
多态
多态, Polymorphism
根据对象的不同选择合适的操作。在Ruby中的实现方法是，根据被调的对象的不同来选择不同的方法。
*
例
obj = "abc"
print obj.length, "\n" # => 3
obj = [1,2,3,4]
print obj.length, "\n" # => 4
F
方法
Method
对对象进行的操作。操作对象(被调)以self来表示。在Ruby中，除去内部类的对象以外，通常对象的构造都是动态确定的。某对象的性质由其内部定义的方法所决定。
封装
Encapsulation
将内部结构和算法隐藏起来，以确保只有特定的过程(也叫方法)才能直接操作数据，这种隔离方法就叫做封装。请参考抽象数据类型。
在Ruby中，只有方法可以操作实例变量，因此可以说Ruby中的封装是强制性的。
G
关联数组
Associative Array
哈希表的别名。因为哈希表可以使用任意的键来引出值，这就是“关联”特性。另外，可以将哈希表看作是使用非数字形式索引的数组，这是它的“数组”特性，因此它也叫做“关联数组”。以前是使用硬件来实现关联数组(也叫关联记忆)的功能的，但是随着计算速度的攀升以及关键算法(叫做“哈希表”，它是现在的哈希表的词源)的成功研发，现在只用软件就可以实现其功能了。
H
哈希表
Hash
Ruby中的一种从键到值的映像(mapping)。也叫做关联数组或辞典。哈希表之所以得此名，是因为在实现其功能时使用了一种叫做“哈希表”的算法。哈希的意思是“切碎”，是“hashed beef”中的“hash”。
函数
Function
严格地讲，Ruby中没有函数。但那些省略被调的方法调用看来确实很像函数，而且有的方法根本不需要self或实例变量等被调信息，事实上后者已成为函数了。所以有时也就网开一面地把这样的方法叫成函数了。
通常将这种函数(式的方法)的方法可视性设成了private，这样就只能以省略被调的形式来调用它们了。这类方法中比较有代表性的是 模块函数。
环境变量
Environment Variable
父进程传给子进程的值。使用ENV就可以访问环境变量。传给子进程只是环境变量的副本，因此子进程无法通过环境变量来向父进程传递信息。这就好比老子不会听小孩的话一样。
J
继承
Inheritance
主要依赖于从祖先或亲戚那里继承的功能，而自己只做一些补充性的工作。在现实世界中，这种行为是要遭到唾弃的，但在计算机世界里这却是个很经济的做法。继承也可以指在某类中添加新功能后生成一个新的类。继承可以用is-a的关系来加以诠释。例如，如果您要生成一个“理科学生”类的话，需要首先继承描述一般学生特征的“学生” 类，然后再添加“整天忙于应付实验”等特征后即可生成该类。若不存在is-a关系，而只想共享某些特性或功能时，我们推荐您使用Mix-in。
脚本
Script
脚本，特指由解释器进行处理的较短的程序。当然了，其中也不乏大作。
脚本语言
Script Language
脚本语言。
局部变量
Local Variable
只能在特定范围内使用的变量。该范围就是作用域。Ruby的作用域包括
* 程序整体
* 类·模块定义
* 方法定义
* 块
几种。只有块能访问外侧作用域的局部变量。局部变量的作用域 从该变量首次被赋值的位置起 直到该赋值位置所在的作用域结束为止。这个优先范围是静态决定的，与具体的运行情况无关。
K
块
Block
可用来构成循环或打家劫舍。
L
类方法
Class Method
就是类的方法。可分为两种：第一种是在所有的类的超类Class中定义的，且被所有的类所共享的方法；第二种是各个类所特有的特殊方法。这倒没什么问题。重要的是类方法中的self指的是类本身，这点需要牢记。
立即值
Immediate Value
实际的数值就保存在变量之中，这和引用是不同的。目前，Ruby中只有Fixnum、Symbol和nil/true/false是立即值。然而Ruby的某些版本并未将Fixnum算做立即值，这也无关紧要。在理论模型层面上，可以将所有的值都看作是对某对象的引用。
理论体系
Paradigm
类似于“思维方式”，这个词很难说得清楚。
M
面向对象
以对象为中心的理论体系。英语中的"Object-Oriented"是个形容词，可是到了日语中就变成名词了。似乎只要将对象置于思考的中心点就万事大吉了，但也要兼顾一下几点
* 继承
* 封装
*
多态
(或者动态绑定)
有人甚至把它看作是包治百病的“魔法”，但事实上世界并非如此简单。面对对象概念诞生至今已逾20个年头，它已经磨砺成为一把实用的利剑。
面向对象设计
Object-Oriented Design
以对象作为出发点的系统设计
面向对象编程
Object-Oriented Programming
以对象作为编程的中心。
面向对象分析
Object-Oriented Analysis
以对象为根本的系统分析。
模块函数
Module Function
在那些函数式的方法中，模块函数既可用作模块的方法，又可用作特殊方法。例如Math模块中的大部分方法都是模块函数。您既可以这样
Math.sqrt(2)
又可以这样
include Math
sqrt(2)
来使用它们。
N
内部类
Built-In Class
这些内部类被嵌入Ruby解释器内部，其实例的结构与普通对象有所不同。我们不建议您继承内部类。Ruby的内部类如下所示(实际上远不止这些，更多详情请参考内部类/模块/异常类)
* Array
* Bignum
* Class
* Data
* FalseClass
* File
* Fixnum
* Float
* Hash
* IO
* MatchData
* Module
* NilClass
* Proc
* Regexp
* String
* Struct
* Thread
* TrueClass
P
排序
Sort
将对象依次排列。只要元素是可数的(include了Enumerable)、且已定义了顺序(定义了<=>)的话，Ruby就可以对这些元素的集合进行排序。这并不仅限于数组，也适用于其他复杂对象的集合。
破坏性的
Destructive
因为String#chop!, Array#concat这种方法会直接改变被调的状态，因而会产生“破环性的作用”。不过您不必担心，因为它们不会损坏您的计算机。
Q
全局变量
Global Variable
在程序的各个角落中都可以使用的变量。比较危险，少用为佳。
R
S
实例
Instance
即指对象。在强调对象归属于某类时，常使用实例这个词。据说有好多人因为不了解对象和实例的关系，因而搞不懂面对对象到底是怎么一回事儿。
实例变量
Instance Variable
对象所特有的变量。Ruby实例变量名前都有一个@符号，您只能在方法内部使用它。
T
特殊方法
Singleton Method
专属于某特定对象的方法。请参考方法。在下列情况下，其他对象也可以继承该特殊方法。
* Kernel#clone时
* 定义了子类时
若在特殊方法中重定义了原先类中的方法时，可以使用super来调用原来的方法。
特殊类
Singleton Class
只对应于某特定对象的假想类。
W
文档
Document
matz最头疼的就是写文档了。他平时总是说“源代码就是文档。连bug也写得清清楚楚”，当然了谁都不以为然。
X
小Endian
Little Endian
开始有10个人，后来越来越少。在计算机业界中，它是表示一种排列数据的形式。据说有一家大的CPU制造商很喜欢小Endian。请参考字节顺序。
Y
异常
Exception
遇到非正常情况就会引发异常。发生异常时，只要没使用begin中的rescue进行捕捉的话，它将跨越方法调用的阻拦，进而中断程序(thread)的运行。有了异常处理功能之后，我们就不必再逐一检查Ruby程序中的每个异常情况了。发生异常的地点信息被保存在$@中，而异常本身的信息被保存在$!中。
Z
再定义
Redefinition
即指重定义。
字节顺序
Byte Order
将0x01020304这4个字节数据按照1,2,3,4或是4,3,2,1的顺序排列。前者叫做大Endian，而后者叫做小Endian。人们一直在争论哪种方法更好，但至今尚无定论。
Ruby的运行平台
在各方有志之士的努力下，Ruby已经被移植到多种平台。下面，就从OS或开发环境等方面对Ruby的运行环境做一个简要介绍。
关于安装和编译问题，请参考Ruby 安装指南。
* Unix
* Windows(Win32)
o Win32 native版
+ mswin32
+ MinGW (mingw, mingw32)
+ bccwin32
o Cygwin (cygwin)
* Mac
o Mac OS X
* BeOS
* MS-DOS
o DJGPP (djgpp)
* OS2 (os2_emx), (emx)
* VMS
* human68k
* GNU (GNU Hurd)
* WindowsCE
o mswince
pack模板字符串
下面就是Array#pack、String#unpack中所用到的模板字符的一览表。模板字符后面可以跟上表示"长度"的数字。若使用'*'来取代"长度"的话, 则表示"剩下的所有字符"之意。
长度的定义因模板字符的不同而有所差异, 大体上像
"iiii"
这样的连续字符可以写成
"i4"
这个样子。
在下面的说明中, short和long分别表示长度为2和4字节的数值(也就是通常32位机器所指的short和long的大小), 这与具体的系统无关。 若`s', `S', `l', `L'后面出现`_'或`!'(如"s!")的话, 则表示这个short或long的大小取决于具体的系统。
请注意: `i', `I' (int)的大小总是取决于系统的, 而`n', `N', `v', `V'的大小则是系统无关的(不能添加`!')。
模板字符串中的空格会被忽略。 ruby 1.7 特性: 另外,从`#'开始到换行处或者到模板字符串结尾之间的部分会被看做是注释。
在下面的说明中, 若针对某问题Array#pack和String#unpack有不同的解释时, 就使用/将两者分开, 即采用 "Array#pack的说明部分/String#unpack的说明部分" 的形式加以说明.
*
a
ASCII字符串(塞入null字符/保留后续的null字符或空格)
["abc"].pack("a") => "a"
["abc"].pack("a*") => "abc"
["abc"].pack("a4") => "abc\0"
"abc\0".unpack("a4") => ["abc\0"]
"abc ".unpack("a4") => ["abc "]
*
A
ASCII字符串(塞入空格/删除后续的null字符和空格)
["abc"].pack("A") => "a"
["abc"].pack("A*") => "abc"
["abc"].pack("A4") => "abc "
"abc ".unpack("A4") => ["abc"]
"abc\0".unpack("A4") => ["abc"]
*
Z
null终点字符串(与a相同 / 删除后续的null字符)
["abc"].pack("Z") => "a"
["abc"].pack("Z*") => "abc"
["abc"].pack("Z4") => "abc\0"
"abc\0".unpack("Z4") => ["abc"]
"abc ".unpack("Z4") => ["abc "]
*
b
位串(从下级位到上级位)
"\001\002".unpack("b*") => ["1000000001000000"]
"\001\002".unpack("b3") => ["100"]
["1000000001000000"].pack("b*") => "\001\002"
*
B
位串(从上级位到下级位)
"\001\002".unpack("B*") => ["0000000100000010"]
"\001\002".unpack("B9") => ["000000010"]
["0000000100000010"].pack("B*") => "\001\002"
*
h
16进制字符串(下级半字节(nibble)在先)
"\x01\xfe".unpack("h*") => ["10ef"]
"\x01\xfe".unpack("h3") => ["10e"]
["10ef"].pack("h*") => "\001\376"
*
H
16进制字符串(上级半字节在先)
"\x01\xfe".unpack("H*") => ["01fe"]
"\x01\xfe".unpack("H3") => ["01f"]
["01fe"].pack("H*") => "\001\376"
*
c
char (8bit 有符号整数)
"\001\376".unpack("c*") => [1, -2]
[1, -2].pack("c*") => "\001\376"
[1, 254].pack("c*") => "\001\376"
*
C
unsigned char (8bit 无符号整数)
"\001\376".unpack("C*") => [1, 254]
[1, -2].pack("C*") => "\001\376"
[1, 254].pack("C*") => "\001\376"
*
s
short (16bit 有符号整数, 取决于Endian) (s! 并非16bit, 它取决于short的大小)
小Endian:
"\001\002\376\375".unpack("s*") => [513, -514]
[513, 65022].pack("s*") => "\001\002\376\375"
[513, -514].pack("s*") => "\001\002\376\375"
大Endian:
"\001\002\376\375".unpack("s*") => [258, -259]
[258, 65277].pack("s*") => "\001\002\376\375"
[258, -259].pack("s*") => "\001\002\376\375"
*
S
unsigned short (16bit 无符号整数, 取决于Endian) (S!并非16bit,它取决于short 的大小)
小Endian:
"\001\002\376\375".unpack("S*") => [513, 65022]
[513, 65022].pack("s*") => "\001\002\376\375"
[513, -514].pack("s*") => "\001\002\376\375"
大Endian:
"\001\002\376\375".unpack("S*") => [258, 65277]
[258, 65277].pack("S*") => "\001\002\376\375"
[258, -259].pack("S*") => "\001\002\376\375"
*
i
int (有符号整数, 取决于Endian和int的大小)
小Endian, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("i*") => [67305985, -50462977]
[67305985, 4244504319].pack("i*") => RangeError
[67305985, -50462977].pack("i*") => "\001\002\003\004\377\376\375\374"
大Endian, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("i*") => [16909060, -66052]
[16909060, 4294901244].pack("i*") => RangeError
[16909060, -66052].pack("i*") => "\001\002\003\004\377\376\375\374"
*
I
unsigned int (无符号整数, 取决于Endian和int的大小)
小Endian, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("I*") => [67305985, 4244504319]
[67305985, 4244504319].pack("I*") => "\001\002\003\004\377\376\375\374"
[67305985, -50462977].pack("I*") => "\001\002\003\004\377\376\375\374"
大Endian, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("I*") => [16909060, 4294901244]
[16909060, 4294901244].pack("I*") => "\001\002\003\004\377\376\375\374"
[16909060, -66052].pack("I*") => "\001\002\003\004\377\376\375\374"
*
l
long (32bit 有符号整数, 取决于Endian) (l! 并非32bit, 它取决于long的大小)
小Endian, 32bit long:
"\001\002\003\004\377\376\375\374".unpack("l*") => [67305985, -50462977]
[67305985, 4244504319].pack("l*") => RangeError
[67305985, -50462977].pack("l*") => "\001\002\003\004\377\376\375\374"
*
L
unsigned long (32bit 无符号整数, 取决于Endian) (L! 并非32bit, 它取决于long的大小)
小Endian, 32bit long:
"\001\002\003\004\377\376\375\374".unpack("L*") => [67305985, 4244504319]
[67305985, 4244504319].pack("L*") => "\001\002\003\004\377\376\375\374"
[67305985, -50462977].pack("L*") => "\001\002\003\004\377\376\375\374"
*
q
ruby 1.7 特性: long long (有符号整数, 取决于Endian和long long 的大小) (在C中无法处理long long时, 就是64bit)
小Endian, 64bit long long:
"\001\002\003\004\005\006\007\010\377\376\375\374\373\372\371\370".unpack("q*")
=> [578437695752307201, -506097522914230529]
[578437695752307201, -506097522914230529].pack("q*")
=> "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
[578437695752307201, 17940646550795321087].pack("q*")
=> "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
*
Q
ruby 1.7 特性: unsigned long long (无符号整数, 取决于Endian和 long long 的大小) (在C中无法处理long long时, 就是64bit)
小Endian, 64bit long long:
"\001\002\003\004\005\006\007\010\377\376\375\374\373\372\371\370".unpack("Q*")
=> [578437695752307201, 17940646550795321087]
[578437695752307201, 17940646550795321087].pack("Q*")
=> "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
[578437695752307201, -506097522914230529].pack("Q*")
=> "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
*
m
被base64编码过的字符串。每隔60个八位组(或在结尾)添加一个换行代码。
Base64是一种编码方法, 它只使用ASCII码中的65个字符(包括[A-Za-z0-9+/]这64字符和用来padding的'='),将3个八位组(8bits * 3 = 24bits)中的二进制代码转为4个(6bits * 4 = 24bits)可印刷的字符。具体细节请参考RFC2045。
[""].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"
["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"].pack("m")
=> "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n"
["abcdefghijklmnopqrstuvwxyz"].pack("m3")
=> "YWJj\nZGVm\nZ2hp\namts\nbW5v\ncHFy\nc3R1\ndnd4\neXo=\n"
"".unpack("m") => [""]
"AA==\n".unpack("m") => ["\000"]
"AA==".unpack("m") => ["\000"]
"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n".unpack("m")
=> ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==\n".unpack("m")
=> ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
*
M
经过quoted-printable encoding编码的字符串
["a b c\td \ne"].pack("M") => "a b c\td =\n\ne=\n"
"a b c\td =\n\ne=\n".unpack("M") => ["a b c\td \ne"]
*
n
网络字节顺序(大Endian)的unsigned short (16bit 无符号整数)
[0,1,-1,32767,-32768,65535].pack("n*")
=> "\000\000\000\001\377\377\177\377\200\000\377\377"
"\000\000\000\001\377\377\177\377\200\000\377\377".unpack("n*")
=> [0, 1, 65535, 32767, 32768, 65535]
*
N
网络字节顺序(大Endian)的unsigned long (32bit 无符号整数)
[0,1,-1].pack("N*") => "\000\000\000\000\000\000\000\001\377\377\377\377"
"\000\000\000\000\000\000\000\001\377\377\377\377".unpack("N*") => [0, 1, 4294967295]
*
v
"VAX"字节顺序(小Endian)的unsigned short (16bit 无符号整数)
[0,1,-1,32767,-32768,65535].pack("v*")
=> "\000\000\001\000\377\377\377\177\000\200\377\377"
"\000\000\001\000\377\377\377\177\000\200\377\377".unpack("v*")
=> [0, 1, 65535, 32767, 32768, 65535]
*
V
"VAX"字节顺序(小Endian)的unsigned long (32bit 无符号整数)
[0,1,-1].pack("V*") => "\000\000\000\000\001\000\000\000\377\377\377\377"
"\000\000\000\000\001\000\000\000\377\377\377\377".unpack("V*") => [0, 1, 4294967295]
*
f
单精度浮点数(取决于系统)
IA-32 (x86) (IEEE754 单精度 小Endian):
[1.0].pack("f") => "\000\000\200?"
sparc (IEEE754 单精度 大Endian):
[1.0].pack("f") => "?\200\000\000"
*
d
双精度浮点数(取决于系统)
IA-32 (IEEE754 双精度 小Endian):
[1.0].pack("d") => "\000\000\000\000\000\000\360?"
sparc (IEEE754 双精度 大Endian):
[1.0].pack("d") => "?\360\000\000\000\000\000\000"
*
e
小Endian的单精度浮点数(取决于系统)
IA-32:
[1.0].pack("e") => "\000\000\200?"
sparc:
[1.0].pack("e") => "\000\000\200?"
*
E
小Endian的双精度浮点数(取决于系统)
IA-32:
[1.0].pack("E") => "\000\000\000\000\000\000\360?"
sparc:
[1.0].pack("E") => "\000\000\000\000\000\000\360?"
*
g
大Endian的单精度浮点数(取决于系统)
IA-32:
[1.0].pack("g") => "?\200\000\000"
sparc:
[1.0].pack("g") => "?\200\000\000"
*
G
大Endian的双精度浮点数(取决于系统)
IA-32:
[1.0].pack("G") => "?\360\000\000\000\000\000\000"
sparc:
[1.0].pack("G") => "?\360\000\000\000\000\000\000"
*
p
指向null终点字符串的指针
[""].pack("p") => "\310\037\034\010"
["a", "b", "c"].pack("p3") => " =\030\010\340^\030\010\360^\030\010"
[nil].pack("p") => "\000\000\000\000"
*
P
指向结构体(定长字符串)的指针
[nil].pack("P") => "\000\000\000\000"
["abc"].pack("P3") => "x*\024\010"
["abc"].pack("P4") => ArgumentError: too short buffer for P(3 for 4)
[""].pack("P") => ArgumentError: too short buffer for P(0 for 1)
*
u
被uuencode编码的字符串
[""].pack("u") => ""
["a"].pack("u") => "!80``\n"
["abc"].pack("u") => "#86)C\n"
["abcd"].pack("u") => "$86)C9```\n"
["a"*45].pack("u") => "M86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A\n"
["a"*46].pack("u") => "M86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A\n!80``\n"
["abcdefghi"].pack("u6") => "&86)C9&5F\n#9VAI\n"
*
U
utf-8
[0].pack("U") => "\000"
[1].pack("U") => "\001"
[0x7f].pack("U") => "\177"
[0x80].pack("U") => "\302\200"
[0x7fffffff].pack("U") => "\375\277\277\277\277\277"
[0x80000000].pack("U") => ArgumentError
[0,256,65536].pack("U3") => "\000\304\200\360\220\200\200"
"\000\304\200\360\220\200\200".unpack("U3") => [0, 256, 65536]
"\000\304\200\360\220\200\200".unpack("U") => [0]
"\000\304\200\360\220\200\200".unpack("U*") => [0, 256, 65536]
*
w
BER压缩整数
用7位来表现1字节, 这样就能以最少的字节数来表现任意大小的0以上的整数。各字节的最高位中除了数据的末尾以外,肯定还有个1(也就是说, 最高位可以表示数据伸展到的位置)。
BER是Basic Encoding Rules的缩略语(BER并非只能处理整数。ASN.1的编码中也用到了它)
*
x
读入null字节/1字节
*
X
后退1字节
*
@
向绝对位置移动
用例
下面是一些pack/unpack的用例。
其实有的问题并不需要使用pack, 但我们还是给了出它的例子。主要是因为pack很容易进行加密, 我们想向不愿使用pack的人提供一点新思路。
*
将数值(字符代码)的数组变为字符串的例子
p [82, 117, 98, 121].pack("cccc")
=> "Ruby"
p [82, 117, 98, 121].pack("c4")
=> "Ruby"
p [82, 117, 98, 121].pack("c*")
=> "Ruby"
s = ""
[82, 117, 98, 121].each {|c| s << c}
p s
=> "Ruby"
p [82, 117, 98, 121].collect {|c| sprintf "%c", c}.join
=> "Ruby"
p [82, 117, 98, 121].inject("") {|s, c| s << c}
=> "Ruby"
*
将字符串变为数值(字符代码)的数组的例子
p "Ruby".unpack('C*')
=> [82, 117, 98, 121]
a = []
"Ruby".each_byte {|c| a << c}
p a
=> [82, 117, 98, 121]
*
可以用"x"来处理null字节
p [82, 117, 98, 121].pack("ccxxcc")
=> "Ru\000\000by"
*
可以用"x"来读取字符
p "Ru\0\0by".unpack('ccxxcc')
=> [82, 117, 98, 121]
*
将Hex dump变为数值数组的例子
p "61 62 63 64 65 66".delete(' ').to_a.pack('H*').unpack('C*')
=> [97, 98, 99, 100, 101, 102]
p "61 62 63 64 65 66".split.collect {|c| c.hex}
=> [97, 98, 99, 100, 101, 102]
*
在二进制和16进制数的pack中, 指定的长度并不是指生成的字节数, 而是指位或半字节的个数
p [0b01010010, 0b01110101, 0b01100010, 0b01111001].pack("C4")
=> "Ruby"
p ["01010010011101010110001001111001"].pack("B32") # 8 bits * 4
=> "Ruby"
p [0x52, 0x75, 0x62, 0x79].pack("C4")
=> "Ruby"
p ["52756279"].pack("H8") # 2 nybbles * 4
=> "Ruby"
*
模板字符'a'的长度指定 只适用于一个字符串
p ["RUBY", "u", "b", "y"].pack("a4")
=> "RUBY"
p ["RUBY", "u", "b", "y"].pack("aaaa")
=> "Ruby"
p ["RUBY", "u", "b", "y"].pack("a*aaa")
=> "RUBYuby"
*
在模板字符"a"中, 若长度不够时, 就用null字符进行填充
p ["Ruby"].pack("a8")
=> "Ruby\000\000\000\000"
*
小Endian和大Endian
p [1,2].pack("s2")
=> "\000\001\000\002" # 在大Endian的系统中的输出
=> "\001\000\002\000" # 在小Endian的系统中的输出
p [1,2].pack("n2")
=> "\000\001\000\002" # 系统无关的大Endian
p [1,2].pack("v2")
=> "\001\000\002\000" # 系统无关的小Endian
*
网络字节顺序的 signed long
s = "\xff\xff\xff\xfe"
n = s.unpack("N")[0]
if n[31] == 1
n = -((n ^ 0xffff_ffff) + 1)
end
p n
=> -2
*
网络字节顺序的 signed long(第2个)
s = "\xff\xff\xff\xfe"
p n = s.unpack("N").pack("l").unpack("l")[0]
=> -2
*
IP地址
require 'socket'
p Socket.gethostbyname("localhost")[3].unpack("C4").join(".")
=> "127.0.0.1"
p "127.0.0.1".split(".").collect {|c| c.to_i}.pack("C4")
=> "\177\000\000\001"
*
sockaddr_in 结构体
require 'socket'
p [Socket::AF_INET,
Socket.getservbyname('echo'),
127, 0, 0, 1].pack("s n C4 x8")
=> "\002\000\000\a\177\000\000\001\000\000\000\000\000\000\000\000"
ruby 1.7 特性: 除了pack/unpack以外, 您还可以使用Socket.pack_sockaddr_in 和 Socket.unpack_sockaddr_in方法。
*
'\0'终点字符串的地址
模板字符 "p" 和 "P"是为了处理C语言层的接口而存在的(例如ioctl)。
p ["foo"].pack("p")
=> "8\266\021\010"
结果字符串看起来乱七八糟, 实际上它表示的是字符串"foo\0"的地址(二进制形式)。您可以像下面这样,把它变成您熟悉的形式
printf "%#010x\n", "8\266\021\010".unpack("L")[0]
=> 0x0811b638
在pack的结果被GC回收之前, 地址所指的对象(在本例中是"foo\0")保证不会被GC所回收.
您只能使用pack的结果来unpack("p")和unpack("P")。
p ["foo"].pack("p").unpack("p")
=> ["foo"]
p "8\266\021\010".unpack("p")
=> -:1:in `unpack': no associated pointer (ArgumentError)
from -:1
ruby 1.7 特性: "p"和"P"被解释为NULL指针, 它负责对nil进行特殊的处理。(下面是在普通的32bit机器上的结果)
p [nil].pack("p") #=> "\000\000\000\000"
p "\0\0\0\0".unpack("p") #=> [nil]
*
结构体的地址
例如, 表示
struct {
int a;
short b;
long c;
} v = {1,2,3};
的字符串是
v = [1,2,3].pack("i!s!l!")
(考虑到byte alignment的问题, 可能需要进行适当的padding才行)
您可以使用
p [v].pack("P")
=> "\300\265\021\010"
来获得指向该结构体的地址。
sprintf格式
Ruby的sprintf格式与C语言的sprintf(3)基本相同。但还是有些差别: 它没有针对C特有类型的修饰符,如short或long等; 它包含2进制数的指示符(%b); 它不支持sprintf的方言式的语法。
下面就对ruby的sprintf格式进行详细的说明。
sprintf格式的规格如下所示。[]中的部分是可选的。
%[指定参数$][标识符][宽度][.精度]指示符
若想输出`%'本身时, 请这样`%%'处理。
下面就分别介绍一下各元素的用法。
标识符
标识符包括`#', `+', ` '(空格), `-'和`0'这5个。
#
使用2进制、8进制、16进制的指示符(`b', `o', `x', `X')时, 会分别添加"0b", "0", "0x", "0X"前缀。
p sprintf("%#b", 10) # => "0b1010"
p sprintf("%#o", 10) # => "012"
p sprintf("%#x", 10) # => "0xa"
p sprintf("%#X", 10) # => "0XA"
对于浮点数 (`f', `e', `E', `g', `G'), 则必定在输出中添加"."。
p sprintf("%.0f", 10) # => "10"
p sprintf("%#.0f", 10) # => "10."
p sprintf("%.0e", 10) # => "1e+01"
p sprintf("%#.0e", 10) # => "1.e+01"
`g', `G'除了具有上述特性外, 还会在末尾添加多余的0。
p sprintf("%.05g", 10) # => "10"
p sprintf("%#.05g", 10) # => "10.000"
+
使输出字符串带上符号。如果是正数的话, 就会添加`+'。它只对数值指示符(`d', `i', `b', `o', `x', `X', `u', `f', `e', `E', `g', `G')起作用。另外, 如果是`b', `o', `x', `X', `u'的话, 则会为负数添加`-'。
p sprintf("%d", 1) # => "1"
p sprintf("%+d", 1) # => "+1"
p sprintf("%x", -1) # => "..f" # ".." 表示f无限延续
p sprintf("%+x", -1) # => "-1"
' '(空格)
与`+'相同, 用空格来代替正号`+'。它只对数值指示符(`d', `i', `b', `o', `x', `X', `u', `f', `e', `E', `g', `G')起作用。
p sprintf("%d", 1) # => "1"
p sprintf("%+d", 1) # => "+1"
p sprintf("% d", 1) # => " 1"
p sprintf("%x", -1) # => "..f"
p sprintf("% x", 1) # => " 1"
p sprintf("% x", -1) # => "-1"
-
使输出内容靠左. 若尚未指定宽度的话,则不起作用。
0
当输出内容靠右时, 使用`0'而并非空格来填充多余部分。
它只对数值指示符(`d', `i', `b', `o', `x', `X', `u', `f', `g', `G')起作用(对`e', `E'无效)
p sprintf("%010d", 10)
# => "0000000010"
与`#'一起使用时, 输出情况如下。
p sprintf("%#010x", 10) # => "0x0000000a"
p sprintf("%#010o", 10) # => "0000000012"
p sprintf("%#010b", 10) # => "0b00001010"
它等同于下例。
p sprintf("%#10.8x", 10) # => "0x0000000a"
p sprintf("%#10.9o", 10) # => "0000000012"
p sprintf("%#10.8b", 10) # => "0b00001010"
通常情况下, 会输出如下内容。
p sprintf("%#10x", 10) # => " 0xa"
p sprintf("%#10o", 10) # => " 012"
p sprintf("%#10b", 10) # => " 0b1010"
宽度
以非0数字开头的数串负责指定宽度。宽度是指生成字符串的宽度, 它不受后文中的精度的限制。
确定宽度时, 也会考虑标识符中附加的" ", "+","-", "0b", "0", "0x", "0X"的长度。
p sprintf("%#05x", 10) # => "0x00a"
宽度是指"必要的最小宽度". 若结果字符串的宽度超过指定宽度时, 指定宽度就会失效。
若将宽度指定为`*'时, 将从参数中取得宽度值。
p sprintf("%10s", "foo") # => " foo"
p sprintf("%*s", 10, "foo") # => " foo"
精度
紧跟在"."后面的数串表示精度(若只有"."的话，则为".0")。若遇到整数的指示符(`d', `i', `b', `o', `x', `X', `u')的话，精度表示数值部分的长度。
p sprintf("%10.5d", 1) # => " 00001"
p sprintf("%#10.5x", 1) # => " 0x00001"
p sprintf("%+10.5x", 1) # => " +00001"
若遇到浮点数的指示符(`f')的话，它表示小数部分的位数。
p sprintf("%10.5f", 1) # => " 1.00000"
p sprintf("%10.5f", 10) # => " 10.00000"
若遇到浮点数的指示符(`e', `E', `g', `G')的话，它表示有效位数。
p sprintf("%10.5e", 1) # => "1.00000e+00"
p sprintf("%10.5e", 10) # => "1.00000e+01"
p sprintf("%10.5g", 10) # => " 10"
p sprintf("%#10.5G", 10) # => " 10.000"
如果是字符串指示符(`s', `p')的话，将会按照精度的规定来检查参数中的字符串长度，并切除多余部分。若将宽度和精度设为同值的话，则只输出参数字符串中的符合精度规定的部分。
p sprintf("%10.2s", "foo") # => " fo"
p sprintf("%5.5s", "foo") # => # => " foo"
p sprintf("%5.5s", "foobar") # => # => "fooba"
若将精度设为`*'的话，将从参数中提取精度的值。
p sprintf("%.5s", "foobar") # => "fooba"
p sprintf("%.*s", 5, "foobar") # => "fooba"
指示符
指示符指出参数的类型，且是必选的。大体说来它包括：
* 表示字符串的指示符: `c', `s', `p'
* 表示整数的指示符: `d', `i', `u', `b', `o', `x', `X',
* 表示浮点数的指示符: `f', `g', `e', `E', `G'
这几类。
c
将参数的数值(0×255)看作是字符代码，并输出对应的字符。若参数并非数值、String、 nil, true或false的话，将尝试用to_int方法进行变换。
此时，只有标识符`-'和"宽度"的设定是有效的。
s
输出字符串。
若参数并非String对象的话，将使用to_s方法对其进行变换。
p
ruby 1.8 特性: 输出Object#inspect的结果。
p sprintf("%s", [1, 2, 3]) # => "123"
p sprintf("%p", [1, 2, 3]) # => "[1, 2, 3]"
d
i
以10进制整数的形式输出参数中的数值。
若参数并非整数，则使用与Integer函数相同的规则将其变为整数。
u
将参数的数值看作是无符号整数，并以10进制整数的形式输出它。
p sprintf("%u", -1) # => "..4294967295"
上面的代码会输出 p ".." + 0xffff_ffff.to_s。
ruby 1.7 特性: 在version 1.7中，不会附加".."。若是'%u'的话，则将参数看作是定长整数。此时，对于负整数n来说
printf("%u", n)
与
printf("%d", n & ~(-1 << n.size*8))
是一个意思。
b
o
x
X
分别以2进制、8进制、16进制、16进制(大写字母)字符串的形式输出整数。
若使用了`#' 标识符的话，则分别在前面添加"0b", "0", "0x", "0X"。
若没有使用`+', ` ' 标识符时，将在负数的前面(若有`#' 标识符，则在"0x"等的后面)添加".."。这表示最高位字符无限延伸，它采用了2的补数形式来表现负数。
p sprintf("%#b", 10) # => "0b1010"
p sprintf("%#o", 10) # => "012"
p sprintf("%#x", 10) # => "0xa"
# 对负数添加".."
p sprintf("%#b", -1) # => "0b..1"
p sprintf("%#o", -1) # => "0..7"
p sprintf("%#x", -1) # => "0x..f"
p sprintf("%10x", -1) # => " ..f"
p sprintf("%-10x", -1) # => "..f "
# 若指定了"精度"的话，则不会添加".."
p sprintf("%.10x", -1) # => "ffffffffff"
f
e
E
g
G
`f' 以小数点形式(xxx.xxx)输出数值。
`e' 以指数形式(x.xxxe+xx)输出数值。
`g' 的情况比较特殊。当指数小于-4或者超出精度范围时，它采用`e'方式进行输出。除此之外，它采用`f'方式进行输出。另外，它会删除小数部分尾部的0。
大写字母指示符(`E', `G')会将输出中的字母变为大写形式。
p sprintf("%f", 1.0) # => "1.000000"
p sprintf("%e", 1.0) # => "1.000000e+00"
p sprintf("%g", 1.0) # => "1"
p sprintf("%f", 10.1) # => "10.100000"
p sprintf("%e", 10.1) # => "1.010000e+01"
p sprintf("%g", 10.1) # => "10.1"
p sprintf("%g", 10 ** 6) # => "1e+06"
p sprintf("%g", 10 ** -5) # => "1e-05"
精度的缺省值为6。
若遇到无限大值或NaN(Not a Number)时，输出情况如下。
p sprintf("%f", 1.0/0) # => "inf"
p sprintf("%f", -1.0/0) # => "-inf"
p sprintf("%f", 0.0/0) # => "nan"
p sprintf("%E", 1.0/0) # => "INF"
p sprintf("%E", -1.0/0) # => "-INF"
p sprintf("%E", 0.0/0) # => "NAN"
指定参数
这部分的利用频率最低，所以放在最后。
nth$
表示将使用第nth个参数进行格式化操作。
p sprintf("%1$d, %1$x, %1$o", 10)
=> "10, a, 12"
p sprintf("%3$d, %2$x, %1$o", 1, 2, 3)
=> "3, 2, 1"
若您不想改变参数的顺序而只想改变格式的话，也可以使用它。
case ENV['LC_TIME']
when /^ja_JP/
fmt = "%1$d年%2$d月%3$d日"
else
fmt = "%2$02d/%03$2d/%1$02d"
end
p sprintf(fmt, 1, 4, 22)
=> "04/22/01"
您也可以先插入"*"，然后借用参数来设定"宽度"和"精度"的值。
p sprintf("%5.2f", 1); # => " 1.00"
p sprintf("%*.*f", 5, 2, 1); # => " 1.00"
p sprintf("%1$*2$.*3$f", 1, 5, 2); # => " 1.00"
Marshal格式
2002-04-04 草稿....
*
以4.8(对应于1.8)版的格式为蓝本
# 截至2003-05-02为止的格式版本如下所示
p Marshal.Dump(Object.new).unpack("cc").join(".")
=> ruby 1.6.0 (2000-09-19) [i586-linux]
"4.4"
=> ruby 1.6.1 (2000-09-27) [i586-linux]
"4.4"
=> ruby 1.6.2 (2000-12-25) [i586-linux]
"4.5"
=> ruby 1.6.3 (2001-03-19) [i586-linux]
"4.5"
=> ruby 1.6.4 (2001-06-04) [i586-linux]
"4.5"
=> ruby 1.6.5 (2001-09-19) [i586-linux]
"4.6"
=> ruby 1.6.6 (2001-12-26) [i586-linux]
"4.6"
=> ruby 1.6.7 (2002-03-01) [i586-linux]
"4.6"
=> ruby 1.6.7 (2002-09-06) [i586-linux]
"4.6"
=> ruby 1.7.3 (2002-09-06) [i586-linux]
"4.7"
=> ruby 1.7.3 (2002-09-20) [i586-linux]
"4.8"
=> ruby 1.8.0 (2003-08-03) [i586-linux]
"4.8"
* 本文兼顾了以前的版本，同时也指出了兼容性问题
* 还提到了Ruby的Marshal中的BUG(?)
nil
true
false
分别是'0', 'T', 'F'
p Marshal.Dump(nil).unpack("x2 a*")
# => ["0"]
此时，即使设置了实例变量也无法Dump。
class NilClass
attr_accessor :foo
end
nil.foo = 1
p nil.foo # => 1
p Marshal.Dump(nil).unpack("x2 a*") # => ["0"]
Fixnum
在'i'之后是表示Fixnum的数据结构。
以数值n为例，在表示数值部分的形式中(不仅限于Fixnum，在其它地方也是如此)，保存着
形式 1:
n == 0: 0
0 < n < 123: n + 5
-124 < n < 0: n - 5
这样的数值(1 byte)。之所以加减5，是为了有别于下面的形式。
例:
p Marshal.Dump(-1).unpack("x2 a*") # => "i\372"
p Marshal.Dump(0).unpack("x2 a*") # => "i\000"
p Marshal.Dump(1).unpack("x2 a*") # => "i\006"
p Marshal.Dump(2).unpack("x2 a*") # => "i\a" ("i\007")
若数值N超出形式1的范围时，则有下面的形式。
形式 2:
| len | n1 | n2 | n3 | n4 |
<-1-> <- len ->
byte bytes
len的值是-4 ～ -1, 1 ～ 4。这表示符号和后续的数据存在于n1 ～ n|len|。
# 举个更好的例子...
def foo(len, n1, n2 = 0, n3 = 0, n4 = 0)
case len
when -3; n4 = 255
when -2; n3 = n4 = 255
when -1; n2 = n3 = n4 = 255
end
n = (0xffffff00 | n1) &
(0xffff00ff | n2 * 0x100) &
(0xff00ffff | n3 * 0x10000) &
(0x00ffffff | n4 * 0x1000000)
# p "%x" % n
n = -((n ^ 0xffff_ffff) + 1) if len < 0
n
end
p Marshal.Dump(-125).unpack("x2 acC*") # => ["i", -1, 131]
p foo(-1, 131)
p Marshal.Dump(-255).unpack("x2 acC*") # => ["i", -1, 1]
p foo(-1, 1)
p Marshal.Dump(-256).unpack("x2 acC*") # => ["i", -1, 0]
p foo(-1, 0)
p Marshal.Dump(-257).unpack("x2 acC*") # => ["i", -2, 255, 254]
p foo(-2, 255, 254)
p Marshal.Dump(124).unpack("x2 acC*") # => ["i", 1, 124]
p foo(1, 124)
p Marshal.Dump(256).unpack("x2 acC*") # => ["i", 2, 0, 1]
p foo(2, 0, 1)
即使设定了实例变量，也无法Dump。
class Fixnum
attr_accessor :foo
end
99.foo = 1
p 99.foo # => 1
p 999.foo # => nil
p Marshal.Dump(99).unpack("x2 ac") # => ["i", 104]
instance of the user class
'C': String, Regexp, Array, Hash 的子类的实例变量
| 'C' | 类名(Symbol)的 Dump | 父类的实例的 Dump |
例 1:
class Foo < String # (or Regexp, Array, Hash)
end
p Marshal.Dump(Foo.new("foo")).unpack("x2 a a c a3 aca*")
# => ["C", ":", 8, "Foo", "\"", 8, "foo"]
^^^ (or '/', '[', '{')
例 2: 有实例变量(请参考instance variable)
class Foo < String # (or Regexp, Array, Hash)
def initialize(obj)
@foo = obj
super(obj)
end
end
p Marshal.Dump(Foo.new("foo")).unpack("x2 a a a c a3 aca3 caca4 aca*")
# => ["I", "C", ":", 8, "Foo", "\"", 8, "foo", 6, ":", 9, "@foo", "\"", 8, "foo"]
除此以外，将变为'o'。这是因为内部结构有所差异所致(请参考Object)
例:
class Foo
end
p Marshal.Dump(Foo.new).unpack("x2 a a c a*")
# => ["o", ":", 8, "Foo\000"]
'u'
若定义了_Dump、_load的话，就是'u'。因为无法Dump实例变量，所以必须使用_Dump/_load进行处理。
| 'u' | 类名(Symbol)的 Dump | _Dump 的结果的长度(Fixnum形式) |
| _Dump 的返回值 |
例:
class Foo
def self._load
end
def _Dump(obj)
"hogehoge"
end
end
p Marshal.Dump(Foo.new).unpack("x2 a aca3 c a*")
# => ["u", ":", 8, "Foo", 13, "hogehoge"]
'U' ruby 1.8 特性
若定义了marshal_Dump、marshal_load的话，就是'U'。因为无法Dump实例变量，所以必须使用marshal_Dump/marshal_load来处理。
| 'U' | 类名(Symbol)的 Dump | marshal_Dump 方法的返回值的 Dump |
例:
class Foo
def marshal_Dump
"hogehoge"
end
def marshal_load(obj)
end
end
p Marshal.Dump(Foo.new).unpack("x2 a aca3 a c a*")
# => ["U", ":", 8, "Foo", "\"", 13, "hogehoge"]
Object
'o'
| 'o' | 类名(Symbol)的 Dump | 实例变量的数量(Fixnum形式) |
| 实例变量名(Symbol) 的Dump(1) | 值(1) |
:
:
| 实例变量名(Symbol) 的Dump(n) | 值(n) |
例 1:
p Marshal.Dump(Object.new).unpack("x2 a a c a*")
# => ["o", ":", 11, "Object\000"]
例 2: 有实例变量
class Foo
def initialize
@foo = "foo"
@bar = "bar"
end
end
p Marshal.Dump(Foo.new).unpack("x2 a a c a3 c aca4 aca3 aca4 aca3")
# => ["o", ":", 8, "Foo", 7,
":", 9, "@bar", "\"", 8, "bar",
":", 9, "@foo", "\"", 8, "foo"]
Float
'f'
| 'f' | 数串的长度(Fixnum形式) | "%.16g" 的字符串 |
例:
p Marshal.Dump(Math::PI).unpack("x2 a c a*")
# => ["f", 22, "3.141592653589793"]
p Marshal.Dump(0.0/0).unpack("x2 a c a*") # => ["f", 8, "nan"]
p Marshal.Dump(1.0/0).unpack("x2 a c a*") # => ["f", 8, "inf"]
p Marshal.Dump(-1.0/0).unpack("x2 a c a*") # => ["f", 9, "-inf"]
p Marshal.Dump(-0.0).unpack("x2 a c a*") # => ["f", 9, "-0"]
Bignum
'l'
| 'l' | '+'/'-' | short的个数(Fixnum形式) | ... |
例:
p Marshal.Dump(2**32).unpack("x2 a a c a*")
# => ["l", "+", 8, "\000\000\000\000\001\000"]
# => ["l", "+", 8, "\000\000\001\000"] <- BUG: ruby version 1.6.3
String
'"'
| '"' | 长度(Fixnum形式) | 字符串 |
例:
p Marshal.Dump("hogehoge").unpack("x2 a c a*")
# => ["\"", 13, "hogehoge"]
Regexp
'/'
| '/' | 长度(Fixnum形式) | source字符串 | 选项 |
选项是 options的结果+汉字代码的flag值。
例:
p Marshal.Dump(/(hoge)*/).unpack("x2 a c a7 c")
# => ["/", 12, "(hoge)*", 0]
p Marshal.Dump(/hogehoge/m).unpack("x2 a c a8 c")
# => ["/", 13, "hogehoge", 4]
p Marshal.Dump(/hogehoge/e).unpack("x2 a c a8 c")
# => ["/", 13, "hogehoge", 32]
Array
'['
| '[' | 元素数(Fixnum形式) | 元素的 Dump | ... |
例:
p Marshal.Dump(["hogehoge", /hogehoge/]).unpack("x2 a c aca8 aca*")
# => ["[", 7, "\"", 13, "hogehoge", "/", 13, "hogehoge\000"]
Hash
'{'
| '{' | 元素数(Fixnum形式) | 键的 Dump | 值的 Dump | ... |
例:
p Marshal.Dump({"hogehoge", /hogehoge/}).unpack("x2 a c aca8 aca*")
# => ["{", 6, "\"", 13, "hogehoge", "/", 13, "hogehoge\000"]
Hash with default value ( not Proc )
'}'
| '}' | 元素数(Fixnum形式) | 键的 Dump | 值的 Dump | ... | 默认值 |
例:
h = Hash.new(true)
h["foo"] = "bar"
p Marshal.Dump(h).unpack("x2 a c aca3 aca*")
# => ["}", 6, "\"", 8, "foo", "\"", 8, "barT"]
若某Hash的默认对象是Proc的话，则无法Dump该Hash
h = Hash.new { }
Marshal.Dump(h)
=> -:2:in `Dump': cannot Dump hash with default proc (TypeError)
Struct
'S': 结构体类的实例的Dump
| 'S' | 类名(Symbol) 的 Dump | 成员数量(Fixnum形式) |
| 成员名(Symbol) 的 Dump | 值 | ... |
例:
Struct.new("XXX", :foo, :bar)
p Marshal.Dump(Struct::XXX.new).unpack("x2 a ac a11 c aca3a aca3a")
# => ["S", ":", 16, "Struct::XXX", 7,
":", 8, "foo", "0",
":", 8, "bar", "0"]
Class/Module (old format)
'M'
| 'M' | 长度(Fixnum形式) | 模块/类名 |
例: 因为已经无法dump这种形式，所以使用load进行说明。
class Mod
end
p Marshal.load([4,7, 'M', 3+5, 'Mod'].pack("ccaca*"))
# => Mod
Class/Module
'c', 'm'
| 'c'/'m' | 类名的长度(Fixnum 形式) | 类名 |
例:
class Foo
end
p Marshal.Dump(Foo).unpack("x2 a c a*") # => ["c", 8, "Foo"]
例 2: 无法dump类/模块的实例变量
module Bar
@bar = 1
end
p Bar.instance_eval { @bar }
Marshal.Dump(Bar, open("/tmp/foo", "w"))
# => 1
module Bar
end
p bar = Marshal.load(open("/tmp/foo"))
p bar.instance_eval { @bar }
# => nil
例 3: 无法dump类变量
module Baz
@@baz = 1
def self.baz
@@baz
end
end
p Baz.baz
Marshal.Dump(Baz, open("/tmp/foo", "w"))
# => 1
module Baz
def self.baz
@@baz
end
end
p baz = Marshal.load(open("/tmp/foo"))
baz.baz
# => Baz
-:3:in `baz': uninitialized class variable @@baz in Baz (NameError)
from -:7
Symbol
':'
| ':' | 符号名的长度(Fixnum形式) | 符号名 |
例:
p Marshal.Dump(:foo).unpack("x2 a c a*")
# => [":", 8, "foo"]
Symbol (link)
';'
| ';' | 表明Symbol实际状态的号码(Fixnum形式) |
在相应符号名已被dump/load时使用。该号码是内部管理的号码。(在dump/load时，会生成哈希表以便对Symbol进行管理。它表示记录位置)
例:
p Marshal.Dump([:foo, :foo]).unpack("x2 ac aca3 aC*")
# => ["[", 7, ":", 8, "foo", ";", 0]
p Marshal.Dump([:foo, :foo, :bar, :bar]).
unpack("x2 ac aca3 aC aca3 aC*")
# => ["[", 9, ":", 8, "foo", ";", 0, ":", 8, "bar", ";", 6]
instance variable
'I': Object, Class, Module 的实例以外的对象
| 'I' | 对象的 Dump | 实例变量的数量(Fixnum形式) |
| 实例变量名(Symbol) 的Dump(1) | 值(1) |
:
:
| 实例变量名(Symbol) 的Dump(n) | 值(n) |
因为Object的实例中包含实例变量，所以会采用其他的形式进行Dump(请参考Object)。该形式只针对Array 或 String 的实例。
例:
obj = String.new
obj.instance_eval { @foo = "bar" }
p Marshal.Dump(obj).unpack("x2 a ac c a c a4 aca*")
# => ["I", "\"", 0, 6, ":", 9, "@foo", "\"", 8, "bar"]
类或模块(Class/Module的实例)不会dump实例变量的信息。(请参考Class/Module)
link
'@'
| '@' | 表明对象实际状态的号码(Fixnum形式 |
在相应对象已被dump/load时使用。该号码是内部管理的号码。(在dump/load时，会生成哈希表以便对对象进行管理。它表示记录位置)
例:
obj = Object.new
p Marshal.Dump([obj, obj]).unpack("x2 ac aaca6c aca*")
# => ["[", 7, "o", ":", 11, "Object", 0, "@", 6, ""]
ary = []
ary.push ary
p Marshal.Dump(ary).unpack("x2 acac")
# => ["[", 6, "@", 0]
Marshal 的BUG
在ruby version 1.6中发现了下列BUG。括号()中列出的是正确的运作方式(1.7的运作方式)。
<= 1.6.7
* 类的clone中的实例是可以Dump的，但却不能加载(因为是无名类的对象，所以无法Dump)
* 当某对象通过include/extend无名Module而定义了特殊方法后，仍可以Dump/加载该对象(若某对象include了无名模块的话，则不能Dump该对象)
1.6.6, 1.6.7
* 拥有实例变量的Array和String是可以Dump的，但却不能加载(既能Dump，又能加载)
<= 1.6.5
* 类的clone中的实例是可以Dump的，但却不能正常加载。否则就会生成奇怪的对象(?)
* 特殊类被dump成为普通类了(特殊类是无法Dump的)
* 无名类是可以Dump的，但却不能加载(无名类是无法Dump的)
<= 1.6.4
* 模块可以Dump却不能加载(可以加载)
* 无名模块可以Dump却不能加载(无名模块是不能Dump的)
<= 1.6.3
* dump Float时，其保存精度偏低
<= 1.6.2
* dump时，无法保存正则表达式中/m, /x 选项的状态
1.6.2, 1.6.3
* 在1.6.2, 1.6.3中，Bignum可以Dump却不能加载。按理说其他版本也会有这个BUG，但因为没有测试脚本，所以无法证实。
<= 1.6.1
* dump时无法保存Range中的特定标识，该标识表明该范围中是否包含终点
下面就是测试脚本(请参考[RAA:RubyUnit])
# test for Marshal for ruby version 1.6
require 'rubyunit'
$version_dependent_behavior = true
# for test_userClass, test_userModule
module UserModule
def foo
end
end
class UserClass
def foo
end
end
class TestMarshal < RUNIT::TestCase
def assert_no_Dumpable(obj)
ex = assert_exception(TypeError) {
begin
# Marshal.Dump will cause TypeError or ArgumentError
Marshal.Dump obj
rescue ArgumentError
case $!.message
when /can't Dump anonymous/,
/cannot Dump hash with default proc/
raise TypeError
else
raise "unknown error"
end
end
}
end
def assert_Dumpable_but_not_equal(obj)
obj2 = Marshal.load(Marshal.Dump(obj))
assert(obj != obj2)
assert_equals(obj.type, obj2.type)
end
def assert_Dumpable_and_equal(obj)
obj2 = Marshal.load(Marshal.Dump(obj))
assert_equals(obj, obj2)
assert_equals(obj.type, obj2.type)
# check values of instance variable
ivars = obj.instance_variables
ivars2 = obj2.instance_variables
assert_equals(ivars, ivars2)
while ivars.size != 0
assert_equals(obj.instance_eval(ivars.shift),
obj2.instance_eval(ivars2.shift))
end
end
def test_Object
assert_Dumpable_but_not_equal Object.new
end
# object with singleton method
def test_Object_with_singleton_method
obj = Object.new
# On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)
class <<obj
def foo
end
end
# object has singleton method can't be Dumped
assert_no_Dumpable obj
end
# object with singleton method (with named module)
def test_Object_with_singleton_method2
obj = Object.new
# On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)
class <<obj
include UserModule
end
# On ruby version 1.6.0 - 1.6.7, no consider the singleton
# method with Mix-in.
# On ruby version 1.7, Dumpable object which is extended by
# named module.
assert_Dumpable_but_not_equal obj
end
# object with singleton method (with anonymous module)
def test_Object_with_singleton_method3
obj = Object.new
# On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)
class <<obj
include Module.new
end
if $version_dependent_behavior and RUBY_VERSION <= "1.6.7"
# On ruby version 1.6.0 - 1.6.7, no consider the singleton method with Mix-in.
assert_Dumpable_but_not_equal obj
else
# object has singleton method (wi
--按英文排序
A
AWK
由Alfred Aho(A)、Peter Weinberger(W)和Brian Kernighan(K)共通创建的一种小型脚本语言。
B
blade
ml archive (blade/ruby)
C
Coerce
进行数据类型变换的方法。如果某数值计算方法从参数那里获得了一个类型不明的实例时, 它会调用coerce方法来进行数据类型变换。coerce方法会返回参数中的数值和本身。
Ruby库的数值类型变换顺序为
Fixnum -> Bignum -> Rational -> Float -> Complex
D
Data
该类可将C中的指针处理成Ruby对象。由C指针、mark函数和free函数构成。如果您想使用C语言来扩充Ruby的功能的话, 就必须掌握该类的使用方法。相反地, 如果您没有这个打算的话, 它也就没什么用了。
defined?
该操作符可以检查某对象(表达式)是否已经被定义。若未被定义就返回nil,若已被定义,就以字符串形式返回它的种类。虽然defined?看似一个方法,实际上它是Ruby语法中的操作符, 它不会对参数进行计算。因此下面的表达式
defined? print("abc\n")
不会输出任何内容。
E
Eiffel
面向对象的编程语言。据说,早先matz在读了该语言作者所撰写的《Object-oriented Software Construction》之后顿觉恍然大悟。但奇怪的是Ruby与Eiffel却并不相似。如果硬要找出雷同之处的话, 可能只有两点: 1.Ruby的块以end结尾;2.Ruby也有rescue这个保留字。
end
该保留字表明了块的结束。据统计,大约有33%的人在看到这个end时会联想起Pascal(纯属杜撰)。但它并不和begin连用,因此它可能更接近于Ada或Eiffel。
Ruby之所以不使用C和Perl中的{},主要是因为以下原因
*
避开单句·复句的问题
例如在C语言中, 若想向下例中添加语句时
if (a==b)
c();
如果写成这样的话
if (a==b)
c();
d();
就会造成难以发现的bug。即使是Pascal也存在这个问题。
*
回避else的问题
与上例类似, 如果写出下面这样的语句的话
if (a==b)
if (c==d) foo();
else bar();
就会引起混乱。其实它的本意应该是
if (a==b) {
if (c==d) foo();
else bar();
}
这个样子。
*
提高可读性
可能您对此持有异议, 但有的人认为:用end来结束块的做法可以提高程序的可读性。
*
begin和case语法表达上的问题
说句实话，matz曾多次想把end用作变量。甚至探讨过在ruby语法中添加{ }的问题，但因为无法完美地解决begin和case的语法表达的问题，最终不得不放弃这个念头。恐怕这才是最大的理由吧。
ENV
该对象的运作方式与访问环境变量的Hash相同。实际上，它就是添加了特殊方法的Object类的实例。使用该对象来修改环境变量后，其变化将会影响到Ruby的子进程。
F
FAQ
Frequently Asked Questions
常见的问题和解答。Ruby FAQ尚处于不断完善的阶段，问题和解答是随时更新的。
G
goto
Ruby中没有该语句。这并不是因为“我们觉得不应该使用”goto，而是“实现其功能实在是太麻烦了”。实际上，您可以使用catch/throw或异常来实现goto的功能。
H
I
J
JARH
Just another Ruby hacker,
K
L
M
main
顶层中的self。因为self是必不可少的，所以它只是表明在顶层中有个Object类的实例--self而已。另外为了操作Object类，还特别定义了若干特殊方法。
已定义的特殊方法
* private
* public
* include
matz
Ruby的作者，也叫松本 行弘。请参考<URL:http://www.st.rim.or.jp/~fuku/cmail/>，另外，他还是3个孩子的父亲。
Mix-in
混合插入、糅合
就像在冰淇淋中混合多种配料可以做成美味的混合冰淇淋一样，在类中混合插入各种模块就可以添加相应的功能。请参考继承。
matz坚信滥用多重继承会导致继承关系的混乱，因此Ruby中不允许使用多重继承。同时为充分发挥继承功能的优势，Ruby支持两种继承关系：1.使用is-a语句的继承；2.使用Mix-in来共享并继承模块中的功能。
N
O
P
Perl
不必多说了罢
POLS
Principle of least surprise
Python
Ruby的劲敌。其功力深厚，可谓“千年蛇妖”。但matz认为Python的功能仍不完美，不然就不会创造Ruby了。最要命的是Python限定了名称长度(6个字符)。
Q
R
RAA
Ruby Application Archive(RAA)
RCR
Ruby Change Request
RD
Ruby Document
Ruby
面向对象的脚本语言。Ruby的意思是“紧跟在Perl(pearl是6月的诞生石，Ruby则是7月的诞生石)之后”。Ruby并不是其他单词的缩写。
S
Sather
面向对象的编程语言。其实matz钟爱Sather胜过Eiffel。但Ruby与Sather一点都不像。
self
表示被调的表达式。那为什么把它叫做self呢？因为如果把方法看作动词的话，那么被调就是该动作的主语，从方法的角度来看，被调当然就是自己了。一般人认为，Ruby对此并未深究，只不过是模仿Smalltalk的做法罢了。
Smalltalk
面向对象的编程语言。它奠定了现代面向对象 理论体系的基础。
super
在重定义的方法中调用上级方法。省略参数时，将使用主调方方法的参数来进行调用。
*
问题:
修改参数中给出的数值后再调用super的话，将会使用原来的值还是修改后的值呢？
def foo(a)
print a
end
def self.foo(a)
a=25
super
end
foo(5) # 5 or 25??
*
答案:
使用修改后的值(25)
T
Thread
原为Thread of control的缩略语，意指一系列的控制流。在Ruby中，一个程序内可以同时存在若干线程。
U
undef
将方法设置为未定义状态。继承 和Mix-in的功能都是在类中添加方法，而undef则可以取消方法。但是，如果取消了类所必需的方法(被其他方法所调用的方法)的话，其后果不堪设想。
V
W
X
Y
Z
--按拼音排序
A
B
被调
Receiver
方法的执行主体。也就是方法调用表达式的`.'中的左边部分。在方法内，可以使用self来表示它。另外，您可以使用@变量名的形式来访问被调的实例变量。
变量
Variable
贴在对象上的标签。Ruby的变量包括全局变量、局部变量和实例变量。因为常数的值不能改变，所以不是变量。但它也是一种标签，因此在这一点上它与变量是相同的。
C
常数
Constant
一旦定义了就不能再改变的变量。这个定义本身似乎就有点矛盾。
重定义
Override
即指再定义。重新定义超类或include模块中已经定义的方法。使用super即可调用原来的方法。
抽象数据类型
Abstract Data Type
将数据构造和对其进行操作的过程封装在一起，就形成了抽象数据类型。对抽象数据进行操作时，必须使用封装内的操作才行。其结果是不能从外部直接使用数据构造，同时一旦内部构造发生变化也不会对外界造成不良影响。我们把这个过程叫做封装。
初始化
Initialize
使对象(或“某事物”)变为“就绪”状态。对实例进行初始化操作时，需要重定义Object#initialize方法。类方法Class#new的默认定义就是对新生成的实例执行initialize方法。传给new的参数会被原封不动地传给initialize。另外，若带块调用时，该块会被传给initialize。
因此，不必对Class#new进行重定义。
辞典
Dictionary
根据给出的条目即可查出对应的定义。它是哈希表的别名。面向对象的始作俑者Smalltalk把类似哈希表的数据构造称作“辞典”，所以时至今日仍然有一些人把哈希表称作辞典。
D
大Endian
Big Endian
美洲大陆的原住民是Indian而并非Endian，那么这个Endian的词源是什么呢？其实它出自Jonathan Swift写的《格列佛游记》。这本书中的人们因为吃鸡蛋的方法不同而分成两类，从圆头开始吃的叫大Endian，从尖头开始吃的叫小Endian。在计算机业界，该词表示CPU等排列数据的一种方式，据说网络一族的人们喜欢大Endian。请参考字节顺序。
大规模退出
Non-Local Exit
它并不是那种发生在break, next, redo, retry, return等方法的范围内的普通退出，而是一种跨度极大的退出。只要没被捕捉到，它甚至会跳出方法调用的牢笼来引发中断。Ruby的大规模退出包括由异常引起的退出和catch/throw。
大多数的异常(包括由exit所引发的SystemExit在内)都会被rescue 捕捉到。但是若该异常不值得捕捉(例：内存分配失败／解释器的bug)的话，就会放他一马。
在catch/throw中，通常会从被throw的地方起一直跳转到与throw部分具有相同标签的catch部分为止。
迭代器
Iterator
即指调用带块方法。当初为了进行迭代操作而设置了带块方法，现在它仍然常被称作迭带器。虽然可以将那些进行迭代操作的方法叫做迭代器，但如果将所有带块方法的调用过程都看作迭带器的话，势必会引起混乱。
调用带块方法
我们把那些可接受代码段(块)的方法叫做带块方法。调用带块方法就是指调用这些带块方法的过程。
在带块方法中使用yield就可以执行块的内容。
当然了，如何处理给出的块，这完全取决于方法。所以，如果硬是把块传给一个不能带块的方法的话，也不会有什么结果，而且也不会发生错误。
动态绑定
Dynamic Binding
指在运行时根据操作对象的数据类型的不同来选择合适的过程(方法)。它可以提高程序的灵活性。它是面向对象的必要条件之一。在Ruby中变量是没有类型的，因此必然可以进行动态绑定。
动态局部变量
Dynamic Local Variable
它是一种特殊的局部变量。Ruby的局部变量的作用域是固定的，因此在编译时就会生成局部变量。动态局部变量则有所不同，每次执行时才会生成变量。在块中首次被赋值的局部变量就是动态局部变量，其作用域仅限于块的内部。这主要是为了让各个Thread都能拥有自己独立的变量而设的。
对象
Object
即指物体。举个例子，“爱”可能不是对象，但“情书”却是对象。甄别某事物是否属于对象，这可能是个哲学问题。或许正因为如此，面向对象也变得扑朔迷离起来。在计算机业界有人认为对象就是指内存中的特定空间。到底何谓对象，还真是个难题。另外，请参考封装和抽象数据类型。
多态
多态, Polymorphism
根据对象的不同选择合适的操作。在Ruby中的实现方法是，根据被调的对象的不同来选择不同的方法。
*
例
obj = "abc"
print obj.length, "\n" # => 3
obj = [1,2,3,4]
print obj.length, "\n" # => 4
F
方法
Method
对对象进行的操作。操作对象(被调)以self来表示。在Ruby中，除去内部类的对象以外，通常对象的构造都是动态确定的。某对象的性质由其内部定义的方法所决定。
封装
Encapsulation
将内部结构和算法隐藏起来，以确保只有特定的过程(也叫方法)才能直接操作数据，这种隔离方法就叫做封装。请参考抽象数据类型。
在Ruby中，只有方法可以操作实例变量，因此可以说Ruby中的封装是强制性的。
G
关联数组
Associative Array
哈希表的别名。因为哈希表可以使用任意的键来引出值，这就是“关联”特性。另外，可以将哈希表看作是使用非数字形式索引的数组，这是它的“数组”特性，因此它也叫做“关联数组”。以前是使用硬件来实现关联数组(也叫关联记忆)的功能的，但是随着计算速度的攀升以及关键算法(叫做“哈希表”，它是现在的哈希表的词源)的成功研发，现在只用软件就可以实现其功能了。
H
哈希表
Hash
Ruby中的一种从键到值的映像(mapping)。也叫做关联数组或辞典。哈希表之所以得此名，是因为在实现其功能时使用了一种叫做“哈希表”的算法。哈希的意思是“切碎”，是“hashed beef”中的“hash”。
函数
Function
严格地讲，Ruby中没有函数。但那些省略被调的方法调用看来确实很像函数，而且有的方法根本不需要self或实例变量等被调信息，事实上后者已成为函数了。所以有时也就网开一面地把这样的方法叫成函数了。
通常将这种函数(式的方法)的方法可视性设成了private，这样就只能以省略被调的形式来调用它们了。这类方法中比较有代表性的是 模块函数。
环境变量
Environment Variable
父进程传给子进程的值。使用ENV就可以访问环境变量。传给子进程只是环境变量的副本，因此子进程无法通过环境变量来向父进程传递信息。这就好比老子不会听小孩的话一样。
J
继承
Inheritance
主要依赖于从祖先或亲戚那里继承的功能，而自己只做一些补充性的工作。在现实世界中，这种行为是要遭到唾弃的，但在计算机世界里这却是个很经济的做法。继承也可以指在某类中添加新功能后生成一个新的类。继承可以用is-a的关系来加以诠释。例如，如果您要生成一个“理科学生”类的话，需要首先继承描述一般学生特征的“学生” 类，然后再添加“整天忙于应付实验”等特征后即可生成该类。若不存在is-a关系，而只想共享某些特性或功能时，我们推荐您使用Mix-in。
脚本
Script
脚本，特指由解释器进行处理的较短的程序。当然了，其中也不乏大作。
脚本语言
Script Language
脚本语言。
局部变量
Local Variable
只能在特定范围内使用的变量。该范围就是作用域。Ruby的作用域包括
* 程序整体
* 类·模块定义
* 方法定义
* 块
几种。只有块能访问外侧作用域的局部变量。局部变量的作用域 从该变量首次被赋值的位置起 直到该赋值位置所在的作用域结束为止。这个优先范围是静态决定的，与具体的运行情况无关。
K
块
Block
可用来构成循环或打家劫舍。
L
类方法
Class Method
就是类的方法。可分为两种：第一种是在所有的类的超类Class中定义的，且被所有的类所共享的方法；第二种是各个类所特有的特殊方法。这倒没什么问题。重要的是类方法中的self指的是类本身，这点需要牢记。
立即值
Immediate Value
实际的数值就保存在变量之中，这和引用是不同的。目前，Ruby中只有Fixnum、Symbol和nil/true/false是立即值。然而Ruby的某些版本并未将Fixnum算做立即值，这也无关紧要。在理论模型层面上，可以将所有的值都看作是对某对象的引用。
理论体系
Paradigm
类似于“思维方式”，这个词很难说得清楚。
M
面向对象
以对象为中心的理论体系。英语中的"Object-Oriented"是个形容词，可是到了日语中就变成名词了。似乎只要将对象置于思考的中心点就万事大吉了，但也要兼顾一下几点
* 继承
* 封装
*
多态
(或者动态绑定)
有人甚至把它看作是包治百病的“魔法”，但事实上世界并非如此简单。面对对象概念诞生至今已逾20个年头，它已经磨砺成为一把实用的利剑。
面向对象设计
Object-Oriented Design
以对象作为出发点的系统设计
面向对象编程
Object-Oriented Programming
以对象作为编程的中心。
面向对象分析
Object-Oriented Analysis
以对象为根本的系统分析。
模块函数
Module Function
在那些函数式的方法中，模块函数既可用作模块的方法，又可用作特殊方法。例如Math模块中的大部分方法都是模块函数。您既可以这样
Math.sqrt(2)
又可以这样
include Math
sqrt(2)
来使用它们。
N
内部类
Built-In Class
这些内部类被嵌入Ruby解释器内部，其实例的结构与普通对象有所不同。我们不建议您继承内部类。Ruby的内部类如下所示(实际上远不止这些，更多详情请参考内部类/模块/异常类)
* Array
* Bignum
* Class
* Data
* FalseClass
* File
* Fixnum
* Float
* Hash
* IO
* MatchData
* Module
* NilClass
* Proc
* Regexp
* String
* Struct
* Thread
* TrueClass
P
排序
Sort
将对象依次排列。只要元素是可数的(include了Enumerable)、且已定义了顺序(定义了<=>)的话，Ruby就可以对这些元素的集合进行排序。这并不仅限于数组，也适用于其他复杂对象的集合。
破坏性的
Destructive
因为String#chop!, Array#concat这种方法会直接改变被调的状态，因而会产生“破环性的作用”。不过您不必担心，因为它们不会损坏您的计算机。
Q
全局变量
Global Variable
在程序的各个角落中都可以使用的变量。比较危险，少用为佳。
R
S
实例
Instance
即指对象。在强调对象归属于某类时，常使用实例这个词。据说有好多人因为不了解对象和实例的关系，因而搞不懂面对对象到底是怎么一回事儿。
实例变量
Instance Variable
对象所特有的变量。Ruby实例变量名前都有一个@符号，您只能在方法内部使用它。
T
特殊方法
Singleton Method
专属于某特定对象的方法。请参考方法。在下列情况下，其他对象也可以继承该特殊方法。
* Kernel#clone时
* 定义了子类时
若在特殊方法中重定义了原先类中的方法时，可以使用super来调用原来的方法。
特殊类
Singleton Class
只对应于某特定对象的假想类。
W
文档
Document
matz最头疼的就是写文档了。他平时总是说“源代码就是文档。连bug也写得清清楚楚”，当然了谁都不以为然。
X
小Endian
Little Endian
开始有10个人，后来越来越少。在计算机业界中，它是表示一种排列数据的形式。据说有一家大的CPU制造商很喜欢小Endian。请参考字节顺序。
Y
异常
Exception
遇到非正常情况就会引发异常。发生异常时，只要没使用begin中的rescue进行捕捉的话，它将跨越方法调用的阻拦，进而中断程序(thread)的运行。有了异常处理功能之后，我们就不必再逐一检查Ruby程序中的每个异常情况了。发生异常的地点信息被保存在$@中，而异常本身的信息被保存在$!中。
Z
再定义
Redefinition
即指重定义。
字节顺序
Byte Order
将0x01020304这4个字节数据按照1,2,3,4或是4,3,2,1的顺序排列。前者叫做大Endian，而后者叫做小Endian。人们一直在争论哪种方法更好，但至今尚无定论。
Ruby的运行平台
在各方有志之士的努力下，Ruby已经被移植到多种平台。下面，就从OS或开发环境等方面对Ruby的运行环境做一个简要介绍。
关于安装和编译问题，请参考Ruby 安装指南。
* Unix
* Windows(Win32)
o Win32 native版
+ mswin32
+ MinGW (mingw, mingw32)
+ bccwin32
o Cygwin (cygwin)
* Mac
o Mac OS X
* BeOS
* MS-DOS
o DJGPP (djgpp)
* OS2 (os2_emx), (emx)
* VMS
* human68k
* GNU (GNU Hurd)
* WindowsCE
o mswince
pack模板字符串
下面就是Array#pack、String#unpack中所用到的模板字符的一览表。模板字符后面可以跟上表示"长度"的数字。若使用'*'来取代"长度"的话, 则表示"剩下的所有字符"之意。
长度的定义因模板字符的不同而有所差异, 大体上像
"iiii"
这样的连续字符可以写成
"i4"
这个样子。
在下面的说明中, short和long分别表示长度为2和4字节的数值(也就是通常32位机器所指的short和long的大小), 这与具体的系统无关。 若`s', `S', `l', `L'后面出现`_'或`!'(如"s!")的话, 则表示这个short或long的大小取决于具体的系统。
请注意: `i', `I' (int)的大小总是取决于系统的, 而`n', `N', `v', `V'的大小则是系统无关的(不能添加`!')。
模板字符串中的空格会被忽略。 ruby 1.7 特性: 另外,从`#'开始到换行处或者到模板字符串结尾之间的部分会被看做是注释。
在下面的说明中, 若针对某问题Array#pack和String#unpack有不同的解释时, 就使用/将两者分开, 即采用 "Array#pack的说明部分/String#unpack的说明部分" 的形式加以说明.
*
a
ASCII字符串(塞入null字符/保留后续的null字符或空格)
["abc"].pack("a") => "a"
["abc"].pack("a*") => "abc"
["abc"].pack("a4") => "abc\0"
"abc\0".unpack("a4") => ["abc\0"]
"abc ".unpack("a4") => ["abc "]
*
A
ASCII字符串(塞入空格/删除后续的null字符和空格)
["abc"].pack("A") => "a"
["abc"].pack("A*") => "abc"
["abc"].pack("A4") => "abc "
"abc ".unpack("A4") => ["abc"]
"abc\0".unpack("A4") => ["abc"]
*
Z
null终点字符串(与a相同 / 删除后续的null字符)
["abc"].pack("Z") => "a"
["abc"].pack("Z*") => "abc"
["abc"].pack("Z4") => "abc\0"
"abc\0".unpack("Z4") => ["abc"]
"abc ".unpack("Z4") => ["abc "]
*
b
位串(从下级位到上级位)
"\001\002".unpack("b*") => ["1000000001000000"]
"\001\002".unpack("b3") => ["100"]
["1000000001000000"].pack("b*") => "\001\002"
*
B
位串(从上级位到下级位)
"\001\002".unpack("B*") => ["0000000100000010"]
"\001\002".unpack("B9") => ["000000010"]
["0000000100000010"].pack("B*") => "\001\002"
*
h
16进制字符串(下级半字节(nibble)在先)
"\x01\xfe".unpack("h*") => ["10ef"]
"\x01\xfe".unpack("h3") => ["10e"]
["10ef"].pack("h*") => "\001\376"
*
H
16进制字符串(上级半字节在先)
"\x01\xfe".unpack("H*") => ["01fe"]
"\x01\xfe".unpack("H3") => ["01f"]
["01fe"].pack("H*") => "\001\376"
*
c
char (8bit 有符号整数)
"\001\376".unpack("c*") => [1, -2]
[1, -2].pack("c*") => "\001\376"
[1, 254].pack("c*") => "\001\376"
*
C
unsigned char (8bit 无符号整数)
"\001\376".unpack("C*") => [1, 254]
[1, -2].pack("C*") => "\001\376"
[1, 254].pack("C*") => "\001\376"
*
s
short (16bit 有符号整数, 取决于Endian) (s! 并非16bit, 它取决于short的大小)
小Endian:
"\001\002\376\375".unpack("s*") => [513, -514]
[513, 65022].pack("s*") => "\001\002\376\375"
[513, -514].pack("s*") => "\001\002\376\375"
大Endian:
"\001\002\376\375".unpack("s*") => [258, -259]
[258, 65277].pack("s*") => "\001\002\376\375"
[258, -259].pack("s*") => "\001\002\376\375"
*
S
unsigned short (16bit 无符号整数, 取决于Endian) (S!并非16bit,它取决于short 的大小)
小Endian:
"\001\002\376\375".unpack("S*") => [513, 65022]
[513, 65022].pack("s*") => "\001\002\376\375"
[513, -514].pack("s*") => "\001\002\376\375"
大Endian:
"\001\002\376\375".unpack("S*") => [258, 65277]
[258, 65277].pack("S*") => "\001\002\376\375"
[258, -259].pack("S*") => "\001\002\376\375"
*
i
int (有符号整数, 取决于Endian和int的大小)
小Endian, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("i*") => [67305985, -50462977]
[67305985, 4244504319].pack("i*") => RangeError
[67305985, -50462977].pack("i*") => "\001\002\003\004\377\376\375\374"
大Endian, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("i*") => [16909060, -66052]
[16909060, 4294901244].pack("i*") => RangeError
[16909060, -66052].pack("i*") => "\001\002\003\004\377\376\375\374"
*
I
unsigned int (无符号整数, 取决于Endian和int的大小)
小Endian, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("I*") => [67305985, 4244504319]
[67305985, 4244504319].pack("I*") => "\001\002\003\004\377\376\375\374"
[67305985, -50462977].pack("I*") => "\001\002\003\004\377\376\375\374"
大Endian, 32bit int:
"\001\002\003\004\377\376\375\374".unpack("I*") => [16909060, 4294901244]
[16909060, 4294901244].pack("I*") => "\001\002\003\004\377\376\375\374"
[16909060, -66052].pack("I*") => "\001\002\003\004\377\376\375\374"
*
l
long (32bit 有符号整数, 取决于Endian) (l! 并非32bit, 它取决于long的大小)
小Endian, 32bit long:
"\001\002\003\004\377\376\375\374".unpack("l*") => [67305985, -50462977]
[67305985, 4244504319].pack("l*") => RangeError
[67305985, -50462977].pack("l*") => "\001\002\003\004\377\376\375\374"
*
L
unsigned long (32bit 无符号整数, 取决于Endian) (L! 并非32bit, 它取决于long的大小)
小Endian, 32bit long:
"\001\002\003\004\377\376\375\374".unpack("L*") => [67305985, 4244504319]
[67305985, 4244504319].pack("L*") => "\001\002\003\004\377\376\375\374"
[67305985, -50462977].pack("L*") => "\001\002\003\004\377\376\375\374"
*
q
ruby 1.7 特性: long long (有符号整数, 取决于Endian和long long 的大小) (在C中无法处理long long时, 就是64bit)
小Endian, 64bit long long:
"\001\002\003\004\005\006\007\010\377\376\375\374\373\372\371\370".unpack("q*")
=> [578437695752307201, -506097522914230529]
[578437695752307201, -506097522914230529].pack("q*")
=> "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
[578437695752307201, 17940646550795321087].pack("q*")
=> "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
*
Q
ruby 1.7 特性: unsigned long long (无符号整数, 取决于Endian和 long long 的大小) (在C中无法处理long long时, 就是64bit)
小Endian, 64bit long long:
"\001\002\003\004\005\006\007\010\377\376\375\374\373\372\371\370".unpack("Q*")
=> [578437695752307201, 17940646550795321087]
[578437695752307201, 17940646550795321087].pack("Q*")
=> "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
[578437695752307201, -506097522914230529].pack("Q*")
=> "\001\002\003\004\005\006\a\010\377\376\375\374\373\372\371\370"
*
m
被base64编码过的字符串。每隔60个八位组(或在结尾)添加一个换行代码。
Base64是一种编码方法, 它只使用ASCII码中的65个字符(包括[A-Za-z0-9+/]这64字符和用来padding的'='),将3个八位组(8bits * 3 = 24bits)中的二进制代码转为4个(6bits * 4 = 24bits)可印刷的字符。具体细节请参考RFC2045。
[""].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"
["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"].pack("m")
=> "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n"
["abcdefghijklmnopqrstuvwxyz"].pack("m3")
=> "YWJj\nZGVm\nZ2hp\namts\nbW5v\ncHFy\nc3R1\ndnd4\neXo=\n"
"".unpack("m") => [""]
"AA==\n".unpack("m") => ["\000"]
"AA==".unpack("m") => ["\000"]
"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJT\nVFVWV1hZWg==\n".unpack("m")
=> ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
"YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXpBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWg==\n".unpack("m")
=> ["abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"]
*
M
经过quoted-printable encoding编码的字符串
["a b c\td \ne"].pack("M") => "a b c\td =\n\ne=\n"
"a b c\td =\n\ne=\n".unpack("M") => ["a b c\td \ne"]
*
n
网络字节顺序(大Endian)的unsigned short (16bit 无符号整数)
[0,1,-1,32767,-32768,65535].pack("n*")
=> "\000\000\000\001\377\377\177\377\200\000\377\377"
"\000\000\000\001\377\377\177\377\200\000\377\377".unpack("n*")
=> [0, 1, 65535, 32767, 32768, 65535]
*
N
网络字节顺序(大Endian)的unsigned long (32bit 无符号整数)
[0,1,-1].pack("N*") => "\000\000\000\000\000\000\000\001\377\377\377\377"
"\000\000\000\000\000\000\000\001\377\377\377\377".unpack("N*") => [0, 1, 4294967295]
*
v
"VAX"字节顺序(小Endian)的unsigned short (16bit 无符号整数)
[0,1,-1,32767,-32768,65535].pack("v*")
=> "\000\000\001\000\377\377\377\177\000\200\377\377"
"\000\000\001\000\377\377\377\177\000\200\377\377".unpack("v*")
=> [0, 1, 65535, 32767, 32768, 65535]
*
V
"VAX"字节顺序(小Endian)的unsigned long (32bit 无符号整数)
[0,1,-1].pack("V*") => "\000\000\000\000\001\000\000\000\377\377\377\377"
"\000\000\000\000\001\000\000\000\377\377\377\377".unpack("V*") => [0, 1, 4294967295]
*
f
单精度浮点数(取决于系统)
IA-32 (x86) (IEEE754 单精度 小Endian):
[1.0].pack("f") => "\000\000\200?"
sparc (IEEE754 单精度 大Endian):
[1.0].pack("f") => "?\200\000\000"
*
d
双精度浮点数(取决于系统)
IA-32 (IEEE754 双精度 小Endian):
[1.0].pack("d") => "\000\000\000\000\000\000\360?"
sparc (IEEE754 双精度 大Endian):
[1.0].pack("d") => "?\360\000\000\000\000\000\000"
*
e
小Endian的单精度浮点数(取决于系统)
IA-32:
[1.0].pack("e") => "\000\000\200?"
sparc:
[1.0].pack("e") => "\000\000\200?"
*
E
小Endian的双精度浮点数(取决于系统)
IA-32:
[1.0].pack("E") => "\000\000\000\000\000\000\360?"
sparc:
[1.0].pack("E") => "\000\000\000\000\000\000\360?"
*
g
大Endian的单精度浮点数(取决于系统)
IA-32:
[1.0].pack("g") => "?\200\000\000"
sparc:
[1.0].pack("g") => "?\200\000\000"
*
G
大Endian的双精度浮点数(取决于系统)
IA-32:
[1.0].pack("G") => "?\360\000\000\000\000\000\000"
sparc:
[1.0].pack("G") => "?\360\000\000\000\000\000\000"
*
p
指向null终点字符串的指针
[""].pack("p") => "\310\037\034\010"
["a", "b", "c"].pack("p3") => " =\030\010\340^\030\010\360^\030\010"
[nil].pack("p") => "\000\000\000\000"
*
P
指向结构体(定长字符串)的指针
[nil].pack("P") => "\000\000\000\000"
["abc"].pack("P3") => "x*\024\010"
["abc"].pack("P4") => ArgumentError: too short buffer for P(3 for 4)
[""].pack("P") => ArgumentError: too short buffer for P(0 for 1)
*
u
被uuencode编码的字符串
[""].pack("u") => ""
["a"].pack("u") => "!80``\n"
["abc"].pack("u") => "#86)C\n"
["abcd"].pack("u") => "$86)C9```\n"
["a"*45].pack("u") => "M86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A\n"
["a"*46].pack("u") => "M86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A86%A\n!80``\n"
["abcdefghi"].pack("u6") => "&86)C9&5F\n#9VAI\n"
*
U
utf-8
[0].pack("U") => "\000"
[1].pack("U") => "\001"
[0x7f].pack("U") => "\177"
[0x80].pack("U") => "\302\200"
[0x7fffffff].pack("U") => "\375\277\277\277\277\277"
[0x80000000].pack("U") => ArgumentError
[0,256,65536].pack("U3") => "\000\304\200\360\220\200\200"
"\000\304\200\360\220\200\200".unpack("U3") => [0, 256, 65536]
"\000\304\200\360\220\200\200".unpack("U") => [0]
"\000\304\200\360\220\200\200".unpack("U*") => [0, 256, 65536]
*
w
BER压缩整数
用7位来表现1字节, 这样就能以最少的字节数来表现任意大小的0以上的整数。各字节的最高位中除了数据的末尾以外,肯定还有个1(也就是说, 最高位可以表示数据伸展到的位置)。
BER是Basic Encoding Rules的缩略语(BER并非只能处理整数。ASN.1的编码中也用到了它)
*
x
读入null字节/1字节
*
X
后退1字节
*
@
向绝对位置移动
用例
下面是一些pack/unpack的用例。
其实有的问题并不需要使用pack, 但我们还是给了出它的例子。主要是因为pack很容易进行加密, 我们想向不愿使用pack的人提供一点新思路。
*
将数值(字符代码)的数组变为字符串的例子
p [82, 117, 98, 121].pack("cccc")
=> "Ruby"
p [82, 117, 98, 121].pack("c4")
=> "Ruby"
p [82, 117, 98, 121].pack("c*")
=> "Ruby"
s = ""
[82, 117, 98, 121].each {|c| s << c}
p s
=> "Ruby"
p [82, 117, 98, 121].collect {|c| sprintf "%c", c}.join
=> "Ruby"
p [82, 117, 98, 121].inject("") {|s, c| s << c}
=> "Ruby"
*
将字符串变为数值(字符代码)的数组的例子
p "Ruby".unpack('C*')
=> [82, 117, 98, 121]
a = []
"Ruby".each_byte {|c| a << c}
p a
=> [82, 117, 98, 121]
*
可以用"x"来处理null字节
p [82, 117, 98, 121].pack("ccxxcc")
=> "Ru\000\000by"
*
可以用"x"来读取字符
p "Ru\0\0by".unpack('ccxxcc')
=> [82, 117, 98, 121]
*
将Hex dump变为数值数组的例子
p "61 62 63 64 65 66".delete(' ').to_a.pack('H*').unpack('C*')
=> [97, 98, 99, 100, 101, 102]
p "61 62 63 64 65 66".split.collect {|c| c.hex}
=> [97, 98, 99, 100, 101, 102]
*
在二进制和16进制数的pack中, 指定的长度并不是指生成的字节数, 而是指位或半字节的个数
p [0b01010010, 0b01110101, 0b01100010, 0b01111001].pack("C4")
=> "Ruby"
p ["01010010011101010110001001111001"].pack("B32") # 8 bits * 4
=> "Ruby"
p [0x52, 0x75, 0x62, 0x79].pack("C4")
=> "Ruby"
p ["52756279"].pack("H8") # 2 nybbles * 4
=> "Ruby"
*
模板字符'a'的长度指定 只适用于一个字符串
p ["RUBY", "u", "b", "y"].pack("a4")
=> "RUBY"
p ["RUBY", "u", "b", "y"].pack("aaaa")
=> "Ruby"
p ["RUBY", "u", "b", "y"].pack("a*aaa")
=> "RUBYuby"
*
在模板字符"a"中, 若长度不够时, 就用null字符进行填充
p ["Ruby"].pack("a8")
=> "Ruby\000\000\000\000"
*
小Endian和大Endian
p [1,2].pack("s2")
=> "\000\001\000\002" # 在大Endian的系统中的输出
=> "\001\000\002\000" # 在小Endian的系统中的输出
p [1,2].pack("n2")
=> "\000\001\000\002" # 系统无关的大Endian
p [1,2].pack("v2")
=> "\001\000\002\000" # 系统无关的小Endian
*
网络字节顺序的 signed long
s = "\xff\xff\xff\xfe"
n = s.unpack("N")[0]
if n[31] == 1
n = -((n ^ 0xffff_ffff) + 1)
end
p n
=> -2
*
网络字节顺序的 signed long(第2个)
s = "\xff\xff\xff\xfe"
p n = s.unpack("N").pack("l").unpack("l")[0]
=> -2
*
IP地址
require 'socket'
p Socket.gethostbyname("localhost")[3].unpack("C4").join(".")
=> "127.0.0.1"
p "127.0.0.1".split(".").collect {|c| c.to_i}.pack("C4")
=> "\177\000\000\001"
*
sockaddr_in 结构体
require 'socket'
p [Socket::AF_INET,
Socket.getservbyname('echo'),
127, 0, 0, 1].pack("s n C4 x8")
=> "\002\000\000\a\177\000\000\001\000\000\000\000\000\000\000\000"
ruby 1.7 特性: 除了pack/unpack以外, 您还可以使用Socket.pack_sockaddr_in 和 Socket.unpack_sockaddr_in方法。
*
'\0'终点字符串的地址
模板字符 "p" 和 "P"是为了处理C语言层的接口而存在的(例如ioctl)。
p ["foo"].pack("p")
=> "8\266\021\010"
结果字符串看起来乱七八糟, 实际上它表示的是字符串"foo\0"的地址(二进制形式)。您可以像下面这样,把它变成您熟悉的形式
printf "%#010x\n", "8\266\021\010".unpack("L")[0]
=> 0x0811b638
在pack的结果被GC回收之前, 地址所指的对象(在本例中是"foo\0")保证不会被GC所回收.
您只能使用pack的结果来unpack("p")和unpack("P")。
p ["foo"].pack("p").unpack("p")
=> ["foo"]
p "8\266\021\010".unpack("p")
=> -:1:in `unpack': no associated pointer (ArgumentError)
from -:1
ruby 1.7 特性: "p"和"P"被解释为NULL指针, 它负责对nil进行特殊的处理。(下面是在普通的32bit机器上的结果)
p [nil].pack("p") #=> "\000\000\000\000"
p "\0\0\0\0".unpack("p") #=> [nil]
*
结构体的地址
例如, 表示
struct {
int a;
short b;
long c;
} v = {1,2,3};
的字符串是
v = [1,2,3].pack("i!s!l!")
(考虑到byte alignment的问题, 可能需要进行适当的padding才行)
您可以使用
p [v].pack("P")
=> "\300\265\021\010"
来获得指向该结构体的地址。
sprintf格式
Ruby的sprintf格式与C语言的sprintf(3)基本相同。但还是有些差别: 它没有针对C特有类型的修饰符,如short或long等; 它包含2进制数的指示符(%b); 它不支持sprintf的方言式的语法。
下面就对ruby的sprintf格式进行详细的说明。
sprintf格式的规格如下所示。[]中的部分是可选的。
%[指定参数$][标识符][宽度][.精度]指示符
若想输出`%'本身时, 请这样`%%'处理。
下面就分别介绍一下各元素的用法。
标识符
标识符包括`#', `+', ` '(空格), `-'和`0'这5个。
#
使用2进制、8进制、16进制的指示符(`b', `o', `x', `X')时, 会分别添加"0b", "0", "0x", "0X"前缀。
p sprintf("%#b", 10) # => "0b1010"
p sprintf("%#o", 10) # => "012"
p sprintf("%#x", 10) # => "0xa"
p sprintf("%#X", 10) # => "0XA"
对于浮点数 (`f', `e', `E', `g', `G'), 则必定在输出中添加"."。
p sprintf("%.0f", 10) # => "10"
p sprintf("%#.0f", 10) # => "10."
p sprintf("%.0e", 10) # => "1e+01"
p sprintf("%#.0e", 10) # => "1.e+01"
`g', `G'除了具有上述特性外, 还会在末尾添加多余的0。
p sprintf("%.05g", 10) # => "10"
p sprintf("%#.05g", 10) # => "10.000"
+
使输出字符串带上符号。如果是正数的话, 就会添加`+'。它只对数值指示符(`d', `i', `b', `o', `x', `X', `u', `f', `e', `E', `g', `G')起作用。另外, 如果是`b', `o', `x', `X', `u'的话, 则会为负数添加`-'。
p sprintf("%d", 1) # => "1"
p sprintf("%+d", 1) # => "+1"
p sprintf("%x", -1) # => "..f" # ".." 表示f无限延续
p sprintf("%+x", -1) # => "-1"
' '(空格)
与`+'相同, 用空格来代替正号`+'。它只对数值指示符(`d', `i', `b', `o', `x', `X', `u', `f', `e', `E', `g', `G')起作用。
p sprintf("%d", 1) # => "1"
p sprintf("%+d", 1) # => "+1"
p sprintf("% d", 1) # => " 1"
p sprintf("%x", -1) # => "..f"
p sprintf("% x", 1) # => " 1"
p sprintf("% x", -1) # => "-1"
-
使输出内容靠左. 若尚未指定宽度的话,则不起作用。
0
当输出内容靠右时, 使用`0'而并非空格来填充多余部分。
它只对数值指示符(`d', `i', `b', `o', `x', `X', `u', `f', `g', `G')起作用(对`e', `E'无效)
p sprintf("%010d", 10)
# => "0000000010"
与`#'一起使用时, 输出情况如下。
p sprintf("%#010x", 10) # => "0x0000000a"
p sprintf("%#010o", 10) # => "0000000012"
p sprintf("%#010b", 10) # => "0b00001010"
它等同于下例。
p sprintf("%#10.8x", 10) # => "0x0000000a"
p sprintf("%#10.9o", 10) # => "0000000012"
p sprintf("%#10.8b", 10) # => "0b00001010"
通常情况下, 会输出如下内容。
p sprintf("%#10x", 10) # => " 0xa"
p sprintf("%#10o", 10) # => " 012"
p sprintf("%#10b", 10) # => " 0b1010"
宽度
以非0数字开头的数串负责指定宽度。宽度是指生成字符串的宽度, 它不受后文中的精度的限制。
确定宽度时, 也会考虑标识符中附加的" ", "+","-", "0b", "0", "0x", "0X"的长度。
p sprintf("%#05x", 10) # => "0x00a"
宽度是指"必要的最小宽度". 若结果字符串的宽度超过指定宽度时, 指定宽度就会失效。
若将宽度指定为`*'时, 将从参数中取得宽度值。
p sprintf("%10s", "foo") # => " foo"
p sprintf("%*s", 10, "foo") # => " foo"
精度
紧跟在"."后面的数串表示精度(若只有"."的话，则为".0")。若遇到整数的指示符(`d', `i', `b', `o', `x', `X', `u')的话，精度表示数值部分的长度。
p sprintf("%10.5d", 1) # => " 00001"
p sprintf("%#10.5x", 1) # => " 0x00001"
p sprintf("%+10.5x", 1) # => " +00001"
若遇到浮点数的指示符(`f')的话，它表示小数部分的位数。
p sprintf("%10.5f", 1) # => " 1.00000"
p sprintf("%10.5f", 10) # => " 10.00000"
若遇到浮点数的指示符(`e', `E', `g', `G')的话，它表示有效位数。
p sprintf("%10.5e", 1) # => "1.00000e+00"
p sprintf("%10.5e", 10) # => "1.00000e+01"
p sprintf("%10.5g", 10) # => " 10"
p sprintf("%#10.5G", 10) # => " 10.000"
如果是字符串指示符(`s', `p')的话，将会按照精度的规定来检查参数中的字符串长度，并切除多余部分。若将宽度和精度设为同值的话，则只输出参数字符串中的符合精度规定的部分。
p sprintf("%10.2s", "foo") # => " fo"
p sprintf("%5.5s", "foo") # => # => " foo"
p sprintf("%5.5s", "foobar") # => # => "fooba"
若将精度设为`*'的话，将从参数中提取精度的值。
p sprintf("%.5s", "foobar") # => "fooba"
p sprintf("%.*s", 5, "foobar") # => "fooba"
指示符
指示符指出参数的类型，且是必选的。大体说来它包括：
* 表示字符串的指示符: `c', `s', `p'
* 表示整数的指示符: `d', `i', `u', `b', `o', `x', `X',
* 表示浮点数的指示符: `f', `g', `e', `E', `G'
这几类。
c
将参数的数值(0×255)看作是字符代码，并输出对应的字符。若参数并非数值、String、 nil, true或false的话，将尝试用to_int方法进行变换。
此时，只有标识符`-'和"宽度"的设定是有效的。
s
输出字符串。
若参数并非String对象的话，将使用to_s方法对其进行变换。
p
ruby 1.8 特性: 输出Object#inspect的结果。
p sprintf("%s", [1, 2, 3]) # => "123"
p sprintf("%p", [1, 2, 3]) # => "[1, 2, 3]"
d
i
以10进制整数的形式输出参数中的数值。
若参数并非整数，则使用与Integer函数相同的规则将其变为整数。
u
将参数的数值看作是无符号整数，并以10进制整数的形式输出它。
p sprintf("%u", -1) # => "..4294967295"
上面的代码会输出 p ".." + 0xffff_ffff.to_s。
ruby 1.7 特性: 在version 1.7中，不会附加".."。若是'%u'的话，则将参数看作是定长整数。此时，对于负整数n来说
printf("%u", n)
与
printf("%d", n & ~(-1 << n.size*8))
是一个意思。
b
o
x
X
分别以2进制、8进制、16进制、16进制(大写字母)字符串的形式输出整数。
若使用了`#' 标识符的话，则分别在前面添加"0b", "0", "0x", "0X"。
若没有使用`+', ` ' 标识符时，将在负数的前面(若有`#' 标识符，则在"0x"等的后面)添加".."。这表示最高位字符无限延伸，它采用了2的补数形式来表现负数。
p sprintf("%#b", 10) # => "0b1010"
p sprintf("%#o", 10) # => "012"
p sprintf("%#x", 10) # => "0xa"
# 对负数添加".."
p sprintf("%#b", -1) # => "0b..1"
p sprintf("%#o", -1) # => "0..7"
p sprintf("%#x", -1) # => "0x..f"
p sprintf("%10x", -1) # => " ..f"
p sprintf("%-10x", -1) # => "..f "
# 若指定了"精度"的话，则不会添加".."
p sprintf("%.10x", -1) # => "ffffffffff"
f
e
E
g
G
`f' 以小数点形式(xxx.xxx)输出数值。
`e' 以指数形式(x.xxxe+xx)输出数值。
`g' 的情况比较特殊。当指数小于-4或者超出精度范围时，它采用`e'方式进行输出。除此之外，它采用`f'方式进行输出。另外，它会删除小数部分尾部的0。
大写字母指示符(`E', `G')会将输出中的字母变为大写形式。
p sprintf("%f", 1.0) # => "1.000000"
p sprintf("%e", 1.0) # => "1.000000e+00"
p sprintf("%g", 1.0) # => "1"
p sprintf("%f", 10.1) # => "10.100000"
p sprintf("%e", 10.1) # => "1.010000e+01"
p sprintf("%g", 10.1) # => "10.1"
p sprintf("%g", 10 ** 6) # => "1e+06"
p sprintf("%g", 10 ** -5) # => "1e-05"
精度的缺省值为6。
若遇到无限大值或NaN(Not a Number)时，输出情况如下。
p sprintf("%f", 1.0/0) # => "inf"
p sprintf("%f", -1.0/0) # => "-inf"
p sprintf("%f", 0.0/0) # => "nan"
p sprintf("%E", 1.0/0) # => "INF"
p sprintf("%E", -1.0/0) # => "-INF"
p sprintf("%E", 0.0/0) # => "NAN"
指定参数
这部分的利用频率最低，所以放在最后。
nth$
表示将使用第nth个参数进行格式化操作。
p sprintf("%1$d, %1$x, %1$o", 10)
=> "10, a, 12"
p sprintf("%3$d, %2$x, %1$o", 1, 2, 3)
=> "3, 2, 1"
若您不想改变参数的顺序而只想改变格式的话，也可以使用它。
case ENV['LC_TIME']
when /^ja_JP/
fmt = "%1$d年%2$d月%3$d日"
else
fmt = "%2$02d/%03$2d/%1$02d"
end
p sprintf(fmt, 1, 4, 22)
=> "04/22/01"
您也可以先插入"*"，然后借用参数来设定"宽度"和"精度"的值。
p sprintf("%5.2f", 1); # => " 1.00"
p sprintf("%*.*f", 5, 2, 1); # => " 1.00"
p sprintf("%1$*2$.*3$f", 1, 5, 2); # => " 1.00"
Marshal格式
2002-04-04 草稿....
*
以4.8(对应于1.8)版的格式为蓝本
# 截至2003-05-02为止的格式版本如下所示
p Marshal.Dump(Object.new).unpack("cc").join(".")
=> ruby 1.6.0 (2000-09-19) [i586-linux]
"4.4"
=> ruby 1.6.1 (2000-09-27) [i586-linux]
"4.4"
=> ruby 1.6.2 (2000-12-25) [i586-linux]
"4.5"
=> ruby 1.6.3 (2001-03-19) [i586-linux]
"4.5"
=> ruby 1.6.4 (2001-06-04) [i586-linux]
"4.5"
=> ruby 1.6.5 (2001-09-19) [i586-linux]
"4.6"
=> ruby 1.6.6 (2001-12-26) [i586-linux]
"4.6"
=> ruby 1.6.7 (2002-03-01) [i586-linux]
"4.6"
=> ruby 1.6.7 (2002-09-06) [i586-linux]
"4.6"
=> ruby 1.7.3 (2002-09-06) [i586-linux]
"4.7"
=> ruby 1.7.3 (2002-09-20) [i586-linux]
"4.8"
=> ruby 1.8.0 (2003-08-03) [i586-linux]
"4.8"
* 本文兼顾了以前的版本，同时也指出了兼容性问题
* 还提到了Ruby的Marshal中的BUG(?)
nil
true
false
分别是'0', 'T', 'F'
p Marshal.Dump(nil).unpack("x2 a*")
# => ["0"]
此时，即使设置了实例变量也无法Dump。
class NilClass
attr_accessor :foo
end
nil.foo = 1
p nil.foo # => 1
p Marshal.Dump(nil).unpack("x2 a*") # => ["0"]
Fixnum
在'i'之后是表示Fixnum的数据结构。
以数值n为例，在表示数值部分的形式中(不仅限于Fixnum，在其它地方也是如此)，保存着
形式 1:
n == 0: 0
0 < n < 123: n + 5
-124 < n < 0: n - 5
这样的数值(1 byte)。之所以加减5，是为了有别于下面的形式。
例:
p Marshal.Dump(-1).unpack("x2 a*") # => "i\372"
p Marshal.Dump(0).unpack("x2 a*") # => "i\000"
p Marshal.Dump(1).unpack("x2 a*") # => "i\006"
p Marshal.Dump(2).unpack("x2 a*") # => "i\a" ("i\007")
若数值N超出形式1的范围时，则有下面的形式。
形式 2:
| len | n1 | n2 | n3 | n4 |
<-1-> <- len ->
byte bytes
len的值是-4 ～ -1, 1 ～ 4。这表示符号和后续的数据存在于n1 ～ n|len|。
# 举个更好的例子...
def foo(len, n1, n2 = 0, n3 = 0, n4 = 0)
case len
when -3; n4 = 255
when -2; n3 = n4 = 255
when -1; n2 = n3 = n4 = 255
end
n = (0xffffff00 | n1) &
(0xffff00ff | n2 * 0x100) &
(0xff00ffff | n3 * 0x10000) &
(0x00ffffff | n4 * 0x1000000)
# p "%x" % n
n = -((n ^ 0xffff_ffff) + 1) if len < 0
n
end
p Marshal.Dump(-125).unpack("x2 acC*") # => ["i", -1, 131]
p foo(-1, 131)
p Marshal.Dump(-255).unpack("x2 acC*") # => ["i", -1, 1]
p foo(-1, 1)
p Marshal.Dump(-256).unpack("x2 acC*") # => ["i", -1, 0]
p foo(-1, 0)
p Marshal.Dump(-257).unpack("x2 acC*") # => ["i", -2, 255, 254]
p foo(-2, 255, 254)
p Marshal.Dump(124).unpack("x2 acC*") # => ["i", 1, 124]
p foo(1, 124)
p Marshal.Dump(256).unpack("x2 acC*") # => ["i", 2, 0, 1]
p foo(2, 0, 1)
即使设定了实例变量，也无法Dump。
class Fixnum
attr_accessor :foo
end
99.foo = 1
p 99.foo # => 1
p 999.foo # => nil
p Marshal.Dump(99).unpack("x2 ac") # => ["i", 104]
instance of the user class
'C': String, Regexp, Array, Hash 的子类的实例变量
| 'C' | 类名(Symbol)的 Dump | 父类的实例的 Dump |
例 1:
class Foo < String # (or Regexp, Array, Hash)
end
p Marshal.Dump(Foo.new("foo")).unpack("x2 a a c a3 aca*")
# => ["C", ":", 8, "Foo", "\"", 8, "foo"]
^^^ (or '/', '[', '{')
例 2: 有实例变量(请参考instance variable)
class Foo < String # (or Regexp, Array, Hash)
def initialize(obj)
@foo = obj
super(obj)
end
end
p Marshal.Dump(Foo.new("foo")).unpack("x2 a a a c a3 aca3 caca4 aca*")
# => ["I", "C", ":", 8, "Foo", "\"", 8, "foo", 6, ":", 9, "@foo", "\"", 8, "foo"]
除此以外，将变为'o'。这是因为内部结构有所差异所致(请参考Object)
例:
class Foo
end
p Marshal.Dump(Foo.new).unpack("x2 a a c a*")
# => ["o", ":", 8, "Foo\000"]
'u'
若定义了_Dump、_load的话，就是'u'。因为无法Dump实例变量，所以必须使用_Dump/_load进行处理。
| 'u' | 类名(Symbol)的 Dump | _Dump 的结果的长度(Fixnum形式) |
| _Dump 的返回值 |
例:
class Foo
def self._load
end
def _Dump(obj)
"hogehoge"
end
end
p Marshal.Dump(Foo.new).unpack("x2 a aca3 c a*")
# => ["u", ":", 8, "Foo", 13, "hogehoge"]
'U' ruby 1.8 特性
若定义了marshal_Dump、marshal_load的话，就是'U'。因为无法Dump实例变量，所以必须使用marshal_Dump/marshal_load来处理。
| 'U' | 类名(Symbol)的 Dump | marshal_Dump 方法的返回值的 Dump |
例:
class Foo
def marshal_Dump
"hogehoge"
end
def marshal_load(obj)
end
end
p Marshal.Dump(Foo.new).unpack("x2 a aca3 a c a*")
# => ["U", ":", 8, "Foo", "\"", 13, "hogehoge"]
Object
'o'
| 'o' | 类名(Symbol)的 Dump | 实例变量的数量(Fixnum形式) |
| 实例变量名(Symbol) 的Dump(1) | 值(1) |
:
:
| 实例变量名(Symbol) 的Dump(n) | 值(n) |
例 1:
p Marshal.Dump(Object.new).unpack("x2 a a c a*")
# => ["o", ":", 11, "Object\000"]
例 2: 有实例变量
class Foo
def initialize
@foo = "foo"
@bar = "bar"
end
end
p Marshal.Dump(Foo.new).unpack("x2 a a c a3 c aca4 aca3 aca4 aca3")
# => ["o", ":", 8, "Foo", 7,
":", 9, "@bar", "\"", 8, "bar",
":", 9, "@foo", "\"", 8, "foo"]
Float
'f'
| 'f' | 数串的长度(Fixnum形式) | "%.16g" 的字符串 |
例:
p Marshal.Dump(Math::PI).unpack("x2 a c a*")
# => ["f", 22, "3.141592653589793"]
p Marshal.Dump(0.0/0).unpack("x2 a c a*") # => ["f", 8, "nan"]
p Marshal.Dump(1.0/0).unpack("x2 a c a*") # => ["f", 8, "inf"]
p Marshal.Dump(-1.0/0).unpack("x2 a c a*") # => ["f", 9, "-inf"]
p Marshal.Dump(-0.0).unpack("x2 a c a*") # => ["f", 9, "-0"]
Bignum
'l'
| 'l' | '+'/'-' | short的个数(Fixnum形式) | ... |
例:
p Marshal.Dump(2**32).unpack("x2 a a c a*")
# => ["l", "+", 8, "\000\000\000\000\001\000"]
# => ["l", "+", 8, "\000\000\001\000"] <- BUG: ruby version 1.6.3
String
'"'
| '"' | 长度(Fixnum形式) | 字符串 |
例:
p Marshal.Dump("hogehoge").unpack("x2 a c a*")
# => ["\"", 13, "hogehoge"]
Regexp
'/'
| '/' | 长度(Fixnum形式) | source字符串 | 选项 |
选项是 options的结果+汉字代码的flag值。
例:
p Marshal.Dump(/(hoge)*/).unpack("x2 a c a7 c")
# => ["/", 12, "(hoge)*", 0]
p Marshal.Dump(/hogehoge/m).unpack("x2 a c a8 c")
# => ["/", 13, "hogehoge", 4]
p Marshal.Dump(/hogehoge/e).unpack("x2 a c a8 c")
# => ["/", 13, "hogehoge", 32]
Array
'['
| '[' | 元素数(Fixnum形式) | 元素的 Dump | ... |
例:
p Marshal.Dump(["hogehoge", /hogehoge/]).unpack("x2 a c aca8 aca*")
# => ["[", 7, "\"", 13, "hogehoge", "/", 13, "hogehoge\000"]
Hash
'{'
| '{' | 元素数(Fixnum形式) | 键的 Dump | 值的 Dump | ... |
例:
p Marshal.Dump({"hogehoge", /hogehoge/}).unpack("x2 a c aca8 aca*")
# => ["{", 6, "\"", 13, "hogehoge", "/", 13, "hogehoge\000"]
Hash with default value ( not Proc )
'}'
| '}' | 元素数(Fixnum形式) | 键的 Dump | 值的 Dump | ... | 默认值 |
例:
h = Hash.new(true)
h["foo"] = "bar"
p Marshal.Dump(h).unpack("x2 a c aca3 aca*")
# => ["}", 6, "\"", 8, "foo", "\"", 8, "barT"]
若某Hash的默认对象是Proc的话，则无法Dump该Hash
h = Hash.new { }
Marshal.Dump(h)
=> -:2:in `Dump': cannot Dump hash with default proc (TypeError)
Struct
'S': 结构体类的实例的Dump
| 'S' | 类名(Symbol) 的 Dump | 成员数量(Fixnum形式) |
| 成员名(Symbol) 的 Dump | 值 | ... |
例:
Struct.new("XXX", :foo, :bar)
p Marshal.Dump(Struct::XXX.new).unpack("x2 a ac a11 c aca3a aca3a")
# => ["S", ":", 16, "Struct::XXX", 7,
":", 8, "foo", "0",
":", 8, "bar", "0"]
Class/Module (old format)
'M'
| 'M' | 长度(Fixnum形式) | 模块/类名 |
例: 因为已经无法dump这种形式，所以使用load进行说明。
class Mod
end
p Marshal.load([4,7, 'M', 3+5, 'Mod'].pack("ccaca*"))
# => Mod
Class/Module
'c', 'm'
| 'c'/'m' | 类名的长度(Fixnum 形式) | 类名 |
例:
class Foo
end
p Marshal.Dump(Foo).unpack("x2 a c a*") # => ["c", 8, "Foo"]
例 2: 无法dump类/模块的实例变量
module Bar
@bar = 1
end
p Bar.instance_eval { @bar }
Marshal.Dump(Bar, open("/tmp/foo", "w"))
# => 1
module Bar
end
p bar = Marshal.load(open("/tmp/foo"))
p bar.instance_eval { @bar }
# => nil
例 3: 无法dump类变量
module Baz
@@baz = 1
def self.baz
@@baz
end
end
p Baz.baz
Marshal.Dump(Baz, open("/tmp/foo", "w"))
# => 1
module Baz
def self.baz
@@baz
end
end
p baz = Marshal.load(open("/tmp/foo"))
baz.baz
# => Baz
-:3:in `baz': uninitialized class variable @@baz in Baz (NameError)
from -:7
Symbol
':'
| ':' | 符号名的长度(Fixnum形式) | 符号名 |
例:
p Marshal.Dump(:foo).unpack("x2 a c a*")
# => [":", 8, "foo"]
Symbol (link)
';'
| ';' | 表明Symbol实际状态的号码(Fixnum形式) |
在相应符号名已被dump/load时使用。该号码是内部管理的号码。(在dump/load时，会生成哈希表以便对Symbol进行管理。它表示记录位置)
例:
p Marshal.Dump([:foo, :foo]).unpack("x2 ac aca3 aC*")
# => ["[", 7, ":", 8, "foo", ";", 0]
p Marshal.Dump([:foo, :foo, :bar, :bar]).
unpack("x2 ac aca3 aC aca3 aC*")
# => ["[", 9, ":", 8, "foo", ";", 0, ":", 8, "bar", ";", 6]
instance variable
'I': Object, Class, Module 的实例以外的对象
| 'I' | 对象的 Dump | 实例变量的数量(Fixnum形式) |
| 实例变量名(Symbol) 的Dump(1) | 值(1) |
:
:
| 实例变量名(Symbol) 的Dump(n) | 值(n) |
因为Object的实例中包含实例变量，所以会采用其他的形式进行Dump(请参考Object)。该形式只针对Array 或 String 的实例。
例:
obj = String.new
obj.instance_eval { @foo = "bar" }
p Marshal.Dump(obj).unpack("x2 a ac c a c a4 aca*")
# => ["I", "\"", 0, 6, ":", 9, "@foo", "\"", 8, "bar"]
类或模块(Class/Module的实例)不会dump实例变量的信息。(请参考Class/Module)
link
'@'
| '@' | 表明对象实际状态的号码(Fixnum形式 |
在相应对象已被dump/load时使用。该号码是内部管理的号码。(在dump/load时，会生成哈希表以便对对象进行管理。它表示记录位置)
例:
obj = Object.new
p Marshal.Dump([obj, obj]).unpack("x2 ac aaca6c aca*")
# => ["[", 7, "o", ":", 11, "Object", 0, "@", 6, ""]
ary = []
ary.push ary
p Marshal.Dump(ary).unpack("x2 acac")
# => ["[", 6, "@", 0]
Marshal 的BUG
在ruby version 1.6中发现了下列BUG。括号()中列出的是正确的运作方式(1.7的运作方式)。
<= 1.6.7
* 类的clone中的实例是可以Dump的，但却不能加载(因为是无名类的对象，所以无法Dump)
* 当某对象通过include/extend无名Module而定义了特殊方法后，仍可以Dump/加载该对象(若某对象include了无名模块的话，则不能Dump该对象)
1.6.6, 1.6.7
* 拥有实例变量的Array和String是可以Dump的，但却不能加载(既能Dump，又能加载)
<= 1.6.5
* 类的clone中的实例是可以Dump的，但却不能正常加载。否则就会生成奇怪的对象(?)
* 特殊类被dump成为普通类了(特殊类是无法Dump的)
* 无名类是可以Dump的，但却不能加载(无名类是无法Dump的)
<= 1.6.4
* 模块可以Dump却不能加载(可以加载)
* 无名模块可以Dump却不能加载(无名模块是不能Dump的)
<= 1.6.3
* dump Float时，其保存精度偏低
<= 1.6.2
* dump时，无法保存正则表达式中/m, /x 选项的状态
1.6.2, 1.6.3
* 在1.6.2, 1.6.3中，Bignum可以Dump却不能加载。按理说其他版本也会有这个BUG，但因为没有测试脚本，所以无法证实。
<= 1.6.1
* dump时无法保存Range中的特定标识，该标识表明该范围中是否包含终点
下面就是测试脚本(请参考[RAA:RubyUnit])
# test for Marshal for ruby version 1.6
require 'rubyunit'
$version_dependent_behavior = true
# for test_userClass, test_userModule
module UserModule
def foo
end
end
class UserClass
def foo
end
end
class TestMarshal < RUNIT::TestCase
def assert_no_Dumpable(obj)
ex = assert_exception(TypeError) {
begin
# Marshal.Dump will cause TypeError or ArgumentError
Marshal.Dump obj
rescue ArgumentError
case $!.message
when /can't Dump anonymous/,
/cannot Dump hash with default proc/
raise TypeError
else
raise "unknown error"
end
end
}
end
def assert_Dumpable_but_not_equal(obj)
obj2 = Marshal.load(Marshal.Dump(obj))
assert(obj != obj2)
assert_equals(obj.type, obj2.type)
end
def assert_Dumpable_and_equal(obj)
obj2 = Marshal.load(Marshal.Dump(obj))
assert_equals(obj, obj2)
assert_equals(obj.type, obj2.type)
# check values of instance variable
ivars = obj.instance_variables
ivars2 = obj2.instance_variables
assert_equals(ivars, ivars2)
while ivars.size != 0
assert_equals(obj.instance_eval(ivars.shift),
obj2.instance_eval(ivars2.shift))
end
end
def test_Object
assert_Dumpable_but_not_equal Object.new
end
# object with singleton method
def test_Object_with_singleton_method
obj = Object.new
# On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)
class <<obj
def foo
end
end
# object has singleton method can't be Dumped
assert_no_Dumpable obj
end
# object with singleton method (with named module)
def test_Object_with_singleton_method2
obj = Object.new
# On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)
class <<obj
include UserModule
end
# On ruby version 1.6.0 - 1.6.7, no consider the singleton
# method with Mix-in.
# On ruby version 1.7, Dumpable object which is extended by
# named module.
assert_Dumpable_but_not_equal obj
end
# object with singleton method (with anonymous module)
def test_Object_with_singleton_method3
obj = Object.new
# On ruby version 1.6.0 - 1.6.2, cause parse error (nested method)
class <<obj
include Module.new
end
if $version_dependent_behavior and RUBY_VERSION <= "1.6.7"
# On ruby version 1.6.0 - 1.6.7, no consider the singleton method with Mix-in.
assert_Dumpable_but_not_equal obj
else
# object has singleton method (wi