Ruby使用“对象引用传递”
(使用Python术语。)
说Ruby使用“按值传递”或“按引用传递”并不是真正的描述性足够有帮助。我想现在大多数人都知道，这个术语(“值”vs“引用”)来自c++。
在c++中，“传递值”意味着函数获得变量的副本，对副本的任何更改都不会改变原始变量。对象也是如此。如果你通过值传递一个对象变量，那么整个对象(包括它的所有成员)都会被复制，对成员的任何更改都不会改变原始对象上的那些成员。(如果你通过值传递一个指针，这是不同的，但Ruby没有指针，AFAIK。)
class A {
public:
int x;
};
void inc(A arg) {
arg.x++;
printf("in inc: %d\n", arg.x); // => 6
}
void inc(A* arg) {
arg->x++;
printf("in inc: %d\n", arg->x); // => 1
}
int main() {
A a;
a.x = 5;
inc(a);
printf("in main: %d\n", a.x); // => 5
A* b = new A;
b->x = 0;
inc(b);
printf("in main: %d\n", b->x); // => 1
return 0;
}
输出:
in inc: 6
in main: 5
in inc: 1
in main: 1
在c++中，“引用传递”意味着函数可以访问原始变量。它可以分配一个全新的字面值整数，然后原始变量也会有这个值。
void replace(A &arg) {
A newA;
newA.x = 10;
arg = newA;
printf("in replace: %d\n", arg.x);
}
int main() {
A a;
a.x = 5;
replace(a);
printf("in main: %d\n", a.x);
return 0;
}
输出:
in replace: 10
in main: 10
如果参数不是一个对象，Ruby使用按值传递(在c++的意义上)。但是在Ruby中，所有的东西都是一个对象，所以在Ruby中没有c++意义上的值传递。
在Ruby中，“通过对象引用传递”(使用Python的术语)被使用:
在函数内部，对象的任何成员都可以有新的值赋给他们，这些变化将在函数返回.*后持续存在
在函数内部，将一个全新的对象赋值给变量会导致变量停止引用旧对象。但是在函数返回后，原始变量仍然会引用旧对象。
因此Ruby不使用c++意义上的“引用传递”。如果存在，那么将一个新对象分配给函数内的变量将导致在函数返回后忘记旧对象。
class A
attr_accessor :x
end
def inc(arg)
arg.x += 1
puts arg.x
end
def replace(arg)
arg = A.new
arg.x = 3
puts arg.x
end
a = A.new
a.x = 1
puts a.x # 1
inc a # 2
puts a.x # 2
replace a # 3
puts a.x # 2
puts ''
def inc_var(arg)
arg += 1
puts arg
end
b = 1 # Even integers are objects in Ruby
puts b # 1
inc_var b # 2
puts b # 1
输出:
1
2
2
3
2
1
2
1
*这就是为什么在Ruby中，如果你想在函数中修改一个对象，但在函数返回时忘记这些更改，那么你必须在对副本进行临时更改之前显式地创建一个对象的副本。
