- 注册时间
- 2007-4-5
- 最后登录
- 2008-5-18
⑤进阶
- 积分
- 574
|
楼主 |
发表于 2007-4-6 23:46:23
|
显示全部楼层
类方法的定义
Ruby 中的类方法是指类的特殊方法。在 Ruby 中，类也是对象。因此它就可以像普通对象一样来定义特殊方法。
因此，若能在类对象中定义方法的话，该方法就会成为类方法。具体的定义方法如下（模块也一样）。
# 特殊方法方式。
class Hoge
def Hoge.foo
end
end
# 在类定义的外侧也行
def Hoge.bar
end
# 若使用下面的方法的话，即使类名改变了，也不必更改方法定义
class Hoge
def self.baz
end
end
与定义有关的操作
alias
例子：
alias foo bar
alias :foo :bar
语法：
alias 新方法名 旧方法名
给方法或全局变量添加别名。可以给方法名指定一个标识符或 Symbol（不能写 obj.method 这样的表达式）。 alias 的参数不会被计算。
给方法添加别名时，别名方法将继承此刻的原始方法。此后，即使原始方法被重新定义，别名方法仍然保持着重定义前的老方法的特性。若您改变了某方法的内容后，又想使用修改前的方法时，别名会非常有用。
# 定义 foo 方法
def foo
"foo"
end
# 设定别名（避开方法定义）
alias :_orig_foo :foo
# 再定义 foo（利用以前的定义）
def foo
_orig_foo * 2
end
p foo # => "foofoo"
alias 表达式返回 nil。
标准库 内部函数
严格说来，Ruby 中没有函数，但 Kernel 模块中定义的方法（可以在任何地方用做函数，因此）可被其他语言当做函数来调用。若您对这些方法进行再定义时，就必需考虑到对其他方面的影响。
block_given?
若某方法带块则返回真，否则返回伪。请参考迭代器。
catch(tag) {|tag| .... }
运行块并返回它的值。若在块的运行过程中，遇到与 tag 同名的 throw 的话，将把 throw 的第二参数的值作为返回值。
嵌套的循环不会因为遇到 break 就一下子跳出。这时可使用 catch。
catch(:loop1) {
for i in 1..2
for j in 1..2
throw :loop1, j
end
end
}
eval(expr)
把字符串 expr 当作 Ruby 程序来运行并返回其结果。
exit
终止 Ruby 程序的运行。
exit 通过引发 SystemExit 异常来结束程序的运行。若有必要的话，可以使用 rescue 部分来捕捉到它。
loop { ... }
（只要不被中断就）反复对块进行计算。
open(file[, mode])
open(file[, mode]) {|io| ... }
打开 file 并返回 File 对象。mode 可以是下列字符串。省略时默认为 "r"。
• "r": 以读取模式打开文件。
• "w": 以写入模式打开文件。打开文件时，若文件已存在就清空文件内容。
• "a": 以写入模式打开文件。通常把写入内容添加到文件结尾。
若有“+”的话，就以读写两用模式（RDWR）打开文件。
• "r+": 将文件的读写位置设在开头。
• "w+": 与 "r+" 一样，打开文件时，若文件已存在就清空其内容。
• "a+": 与 "r+" 一样，打开文件时，若文件已存在，就把读写位置设在文件结尾。
可在上述任意一项后面添加“b”（如 "r+b"）标志。此时，将以二进制方式打开文件。
当 open 与块同时被调用时，open 将打开文件并执行块，当块的运行终止后就关闭文件。此时返回块的计算结果。请看下例。
open(path, mode) do |f|
...
end
# 等效代码
f = open(path, mode)
begin
...
ensure
f.close
end
p(obj, [obj2, ...])
以通俗易懂的方式输出 obj。等同于以下代码（请参考 Object#inspect）。
print obj.inspect, "\\n", obj2.inspect, "\\n", ...
Ruby 中通常输出为标准输出，然而 RGSS 重定义了该方法，变更为输出到 Windows 的信息框。
返回 nil。
print(arg[, ...])
依次输出参数。若把非字符串对象传给参数的话，将对该对象使用 to_s 方法将其变为字符串后输出。若是 nil 的话则输出字符串 "nil"。
Ruby 中通常输出为标准输出，然而 RGSS 重定义了该方法，变更为输出到 Windows 的信息框。
返回 nil。
raise
raise(message)
raise(exception)
raise(error_type, message)
引发异常。请参考 raise
rand(max)
产生一个 0 至 max（不含）之间的随机数。若未调用 srand 的话，就自动调用它。
若将 max 设为 nil 或 0 的话，将返回一个 0 至 1（不含）的实数型 Float 随机数。
sprintf(format[, arg[, ...]])
采用同 C 语言 sprintf 一样的方法对 format 字符串进行解释，格式化参数后返回结果。
详细信息请参考 sprintf 格式化。
srand([seed])
设定 rand 的随机数的种子，返回旧的初始值（第一次返回 0）。若省略初始值时，则以当前时刻生成一个种子。
throw(tag[, value])
跳到使用了相同的 tag 的 catch 块的终点（跳过方法）。若没有使用相同 tag 的 catch 的话，就以 NameError 结束线程。tag 可以是字符串或符号。value 将变为 catch 的返回值。
标准库 内部变量
内部变量是全局变量的一种，但是它的值并不仅限于全局。
根据变量值的作用域的不同，大致将内部变量划分如下。
局部域
$~
在当前作用域中，最后一次匹配成功的相关信息（MatchData 对象）。若对其进行设定的话, 则 $& 以及 $1 ... $9 等的值也会发生变化。
等同于 Regexp.last_match。
$&
在当前作用域中，正则表达式最后一次匹配成功的字符串。若最后一次匹配失败，则为 nil。
等同于 Regexp.last_match[0]。
$1
$2
$3 ...
分别存储着最后一次模型匹配成功时与第 n 个括号相匹配的值。若没有相应的括号时，其值为nil。
等同于 Regexp.last_match[1]，Regexp.last_match[2]，...。
全局域
$!
最近发生的异常的信息。由 raise 设定。
$DEBUG
调试模式标志。RGSS 在调试游戏时设置这个标志。
在 Ruby 的调试模式中发生异常的处理等与普通运行有一些的不同，然而对于 RGSS 没有必要了解这些。
标准库 内部类 Object
所有类的父类。它定义了对象的一般行为。
包含的模块
• Kernel
方法
self == other
若 self 等于 other 则返回真。默认情况下，它的效果等同于 equal? 。
应该根据各类的具体性质来重新定义该方法。
self === other
该方法通常用在 case 的比较句中。默认情况下，它的运作等同于 Object#== ，但在子类中进行归属检测时，需要对其进行适当的重定义。
class
返回被调的类。
clone
dup
生成某对象的拷贝并返回它。clone 生成的是完整的拷贝，它包括 freeze、特殊方法等信息，而 dup 则只拷贝对象的内容。
请注意，clone 和 dup 生成的都是「浅层（shallow）」拷贝。它们只拷贝对象本身，而不会拷贝对象的所指（例如数组的单元等）。
另外，如果对拷贝进行如下测试的话
obj.equal?(obj.clone)
通常都不成立。但是
obj == obj.clone
通常都会成立。
若想对 true、false、nil、Numeric 对象、Symbol 对象等进行拷贝时，会引发 TypeError 异常。
equal?(other)
若 other 就是 self 自己时，即返回真。该方法不能再定义。
freeze
禁止修改对象的内容，返回self。若强行修改则会引发 TypeError 异常。
frozen?
若某对象禁止修改其内容则返回真。
inspect
将某对象转为人工可读的字符串并返回该字符串。
instance_of?(klass)
若 self 为 klass 类的直接实例时，返回真。通常，当 obj.instance_of?(c) 成立时，obj.kind_of?(c) 也是成立的。
is_a?(mod)
kind_of?(mod)
只要 self 是下列任何一个类的实例就返回真，这些类是 mod 类和它的子类，以及包括 mod 模块的类和它的子类。
module M
end
class C < Object
include M
end
class S < C
end
obj = S.new
p obj.is_a? S # true
p obj.is_a? M # true
p obj.is_a? C # true
p obj.is_a? Object # true
p obj.is_a? Hash # false
nil?
若被调为 nil 则返回真。
object_id
返回与各个对象对应的唯一的整数。但是，为某对象分配整数的具体情形并不固定。
to_ary
若需要将对象隐式地转换为数组时，会在内部自动调用。
to_hash
若需要将对象隐式地转换为哈希表时，会在内部自动调用。
to_int
若需要将对象隐式地转换为整数时，会在内部自动调用。
to_s
将对象转换为字符串并返回该字符串。
如果把非字符串对象当做参数传给 print 或 sprintf 时，将调用该方法把非字符串对象转换为字符串。
to_str
若需要将对象隐式地转换为字符串时，会自动调用它。
私有方法
initialize
用户定义类的对象初始化方法。在对由 Class#new 新生成的对象进行初始化时要调用该方法。默认情况下，没有任何的动作。通常会在子类中根据需要对其进行再定义。传递给 Class#new 的参数会被原封不动地传递给 initialize。
标准库 内部类 Object Array
数组类。数组的单元可以是任意的 Ruby 对象。请参考数组表达式。
父类
• Object
包含的模块
• Enumerable
方法
self[nth]
返回第 nth 个数组单元。首单元算做第 0 个单元。若 nth 值为负，则看作是从尾部算起的索引值（尾单元算做第 -1 个单元）。若第 nth 个单元不存在，则返回 nil。
self[start, length]
以数组形式返回从第 start 个单元算起的 length 个数组单元。若 start 值为负，则看作是从尾部算起的索引值（尾单元算做第 -1 个单元）。若 length 超出从第 start 个单元算起的剩余长度时，超过部分将被忽略。若 length 为负，则返回 nil。
self[nth]=val
将第 nth 个数组单元的值设定为 val。若 nth 超出数组范围时，自动加长数组并以 nil 对新增部分进行初始化。
返回 val。
self[start, length]=val
将从索引 start 算起的 length 个数组单元替换为 val 的内容。若 val 不是数组时，则调用 val.to_ary 或使用 [val] 进行替换。返回 val。
ary = [0, 1, 2, 3]
ary[1, 2] = ["a", "b", "c"]
p ary # => [0, "a", "b", "c", 3]
ary[2, 1] = 99
p ary # => [0, "a", 99, "c", 3]
ary[1, 0] = ["inserted"]
p ary # => [0, "inserted", "a", 99, "c", 3]
self + other
将 self 和 other 的内容连起来后生成新数组并返回该数组。若 other 并非数组时则使用 other.to_ary 的返回值。若该返回值依然不是数组时，则引发 TypeError 异常。
a = [1, 2]
b = [8, 9]
p a + b # => [1, 2, 8, 9]
p a # => [1, 2] （没有变化）
p b # => [8, 9] （也没有变化）
self - other
集合的补集运算。从 self 中删除 other 的单元后生成一个新数组并返回该数组。
self & other
集合的交集运算。将同属于两个数组的单元重组为一个新数组并返回该数组。重复单元将被清除。
self | other
集合的并集运算。将任属两数组之一的单元重组为一个新数组并返回该数组。重复单元将被清除。
self <=> other
使用 <=> 来依次比较 self 和 other 中的各个单元。若 self 大则返回正整数，若相等返回 0，若小则返回负整数。如果各个单元均相等，且其中一个数组已到达尾部时，则认定较短的数组为小。
self == other
使用 == 来依次比较 self 和 other 中的各个单元，若所有单元均相等时返回真。
clear
删除数组中的所有单元。返回 self。
ary = [1, 2]
ary.clear
p ary # => []
clone
dup
生成一个与被调内容一样的新数组并返回它。clone 会拷贝 freeze、特殊方法等信息，而 dup 则只拷贝内容。然而，无论哪个方法都不会拷贝数组单元本身。
compact
compact!
compact 从 self 中删除值为 nil 的单元后生成新数组并返回它。compact! 是具有破坏性的，若对原数组进行了改动就返回 self，若没有进行改动则返回 nil。
ary = [1, nil, 2, nil, 3, nil]
p ary.compact # => [1, 2, 3]
p ary # => [1, nil, 2, nil, 3, nil]
ary.compact!
p ary # => [1, 2, 3]
p ary.compact! # => nil
concat(other)
将 other 连接到 self 末尾（该动作具有破坏性）。返回 self。
array = [1, 2]
a = [3, 4]
array.concat a
p array # => [1, 2, 3, 4]
p a # => [3, 4] # 没有变化
delete(val)
delete(val) { ... }
用 == 来分别比较 val 与每个数组单元，若相等则删除该单元。若发现了与 val 相等的单元就返回 val。
若没有发现与 val 相等的单元则返回 nil，若指定了块的话就对块进行计算并返回结果。
array = [1, 2, 3, 2, 1]
p array.delete(2) # => 2
p array # => [1, 3, 1]
# 若向无块的参数传递了 nil 时，则无法从其返回值中判断
# 到底有没有进行删除
ary = [nil,nil,nil]
p ary.delete(nil) # => nil
p ary # => []
p ary.delete(nil) # => nil
delete_at(pos)
删除 pos 所指位置的单元并返回它。若 pos 超出数组范围则返回 nil。
array = [0, 1, 2, 3, 4]
array.delete_at 2
p array # => [0, 1, 3, 4]
each {|item| .... }
依次使用每个单元来计算块。返回 self。
# 依次显示1、2、3
[1, 2, 3].each do |i|
puts i
end
each_index {|index| .... }
依次使用每个单元的索引来对块进行计算。同下。
(0 ... ary.size).each {|index| .... }
返回 self。
empty?
若数组单元数目为 0 则返回真。
include?(val)
若数组中包含 ==val 的单元就返回真。
index(val)
返回数组中第一个 ==val 的单元的位置。若没有与其相等的单元则返回 nil。
insert(nth, [val[, val2 ...]])
在索引为 nth 的单元前面插入第 2 参数以后的值。返回 self。其定义如下。
class Array
def insert( n, *vals )
self[n, 0] = vals
self
end
end
ary = ["foo", "bar", "baz"]
ary.insert 2, ’a’, ’b’
p ary # => ["foo", "bar", "a", "b", "baz"]
若没有指定任何 val 时，将不作任何动作。
length
size
返回数组长度。若数组为空则返回 0。
nitems
返回非 nil 单元的个数。
pop
删除末尾单元并返回它。若数组为空则返回 nil。
array = [1, [2, 3], 4]
p array.pop # => 4
p array.pop # => [2, 3]
p array # => [1]
p array.pop # => 1
p array.pop # => nil
p array # => []
push(obj1[, obj2 ...])
依次将 obj1、obj2 ... 添加到数组结尾。
返回 self。
array = [1, 2, 3]
array.push 4
array.push [5, 6]
array.push 7, 8
p array # => [1, 2, 3, 4, [5, 6], 7, 8]
reverse
reverse!
reverse 将所有单元以逆序重新排列生成新数组并返回它。reverse! 的逆序排列过程具有破环性。
reverse 通常返回新数组。reverse! 通常会返回 self。
shift
删除数组的首单元并返回它。剩余单元依次提前。若数组为空返回 nil。
sort
sort!
sort {|a, b| ... }
sort! {|a, b| ... }
对数组内容进行排序。若带块调用时，将把 2 个参数传给块，然后使用块的计算结果进行比较。若没有块时，使用 <=> 运算符进行比较。sort! 的对数组单元的排序过程具有破环性。
sort 将生成一个经过排序的新数组并返回它，sort! 通常会返回 self。
unshift(obj1[, obj2 ...])
依次将 obj1、obj2 ... 插到数组的头部。
返回 self。 |
|
发表于 2007-4-6 23:29:11
发表于 2007-4-6 23:38:31
gvar 
ivar 
条件运算符)