Ruby和Ruby on Rails的安装 | Why·Liam·Blog
Ruby安装 在这里可以下载到适合您的最新的 Ruby 版本，当前稳定的版本是 2.0.0-p195 。下载前请先阅读 。
Ruby 源代码 如果您欲使之与您的平台更为兼容或者需要专一设置您的环境，那么从源代码安装是最好的解决方案。如果有预先做好的 packages 需要安装到您的平台上，这也是一个好的方法。
(md5: 9ae99deff8ea5) 稳定版 (推荐)
这里的 tar’ed 和 gzip’ed 文件是最新稳定的 CVS。它应该比上次发布的版本更稳定。
这里的 tar’ed 和 gzip’ed 文件是最新的 CVS。它可能包含一些没有解决的问题。 更多信息见
Windows 系统在 Windows 平台下安装 Ruby 有几个选择。第一个选择是仅安装编译好的二进制文件。第二个选择是直接执行“一步安装”程序，假如您不知道如何安装 Ruby,
将是您最好的选择。（这种安装方式除 Ruby 之外，捆绑一些额外的资源库。）
(md5: b2b0c7db6) 稳定版 (推荐)
(md5: 3ec2a8a34d5db1f09cc8cad3f8305c28) 稳定版 (推荐)
(md5: 489ee1bcd72e97f50b38b64fb354e661) 开发版 (实验)
(md5: 921db53c709ced229e24e1) 稳定版 (推荐)
Linux 系统许多 Linux 发行版中已经预装了 Ruby，如果您的系统上没有安装 Ruby，这里提供几个方式来安装。第一个方式是仅下载源代码，然后手工编译安装。 如果您不想从源代码编译浪费时间的话，许多平台都提供相应的机器体系结构的发行包，它们使 Ruby 的安装相当容易。 例如，在 Debian 或 Ubuntu 使用
apt-get 提供了一个简单而优雅的解决方案 ：
$ sudo apt-get install ruby irb rdoc
对于 irb 和 rdoc ，您需要激活 universe repository 。
OS X 系统Ruby 1.8.7 已经完全支持 Mac OS X Lion 以及许多流行的 Ruby gems (packages)。细节参考
Mac OS X Leopard 完全支持 Ruby 1.8.6 以及 Ruby on Rails, Mongrel, Capistrano 和其他流行的 Ruby gems （库）。细节请参考
。 Mac OS X Tiger 安装了 1.8.2 版本的 Ruby，如果您没有升级到 Leopard，Tiger 平台下安装最新版本的 Ruby 仍有多个选择。您可以使用为 OS X 定做的 。如果您正在寻找且能够快速运行 Rails 环境的安装包， 是一个不错的选择。使用
在技术上的可能会比较好一些。 使用 MacPorts，您可以这样来安装 Ruby …
$ port install ruby
Fink 为安装 Ruby 提供了图形接口（使用 Fink 命令）。 同时，由于 OS X 是基于 Unix，因此从源代码或采取其它有效的方法来安装也是相当的容易。 更为详细的安装 Ruby 及 Rails，详见 Dan Benjamin 写的优秀文章：
将快速的教您启动和运行。
Ruby On Rails安装1、安装ruby 不用说 是下载安装包：
，注意版本 – 害人不浅，后面会说到，我下的是1.8.6-26 装完后，可以用ruby -v 测试是否安装成功，如图，要是出现了版本 就说明安装成功了
2、ruby安装完成后，安装rails 在命令行下运行 gem install rails，会有四五个提示 一路Y，安装完后，依旧可以用rails -v， 来检测rails 是否安装成功
3、创建Web应用
还是命令行下输入 rails testweb，比如当前的路径是 C:\Documents and Settings\Administrator&rails testweb，便会在C:\Documents and Settings\Administrator下创建一个testweb文件夹。
PS：这里是可以加路径的 比如 rails C://test，具体可以看官方API:
4、在当前目录（testweb）下，运行 ruby script\server 启动服务，关于webrick服务器更多的信息可以访问
5、浏览器中输入，如果看到以下页面，说明OK
is licensed under a .由创作并维护的采用创作共用。本文首发于，版权所有，侵权必究。本文永久链接：推荐文章
记录生活，研究产品，分享设计，分析数据，讨论科技和商业，不定期扯淡。
如果觉得我的文章对您有用，请随意打赏。您的支持将鼓励我继续创作！windows和linux下Ruby的下载与安装 | 脚本语言
windows和linux下Ruby的下载与安装
在这里可以下载到适合您的最新的 Ruby 版本，当前稳定的版本是 1.8.6 。下载前请先阅读
Ruby 源代码
如果您欲使之与您的平台更为兼容或者需要专一设置您的环境，那么从源代码安装是最好的解决方案。如果有预先做好的 packages 需要安装到您的平台上，这也是一个好的方法。
(md5: 23dae1ecbbb8c5e1507683) 稳定版 (推荐)
这里的 tar'ed 和 gzip'ed 文件是最新稳定的 CVS。它应该比上次发布的版本更稳定。
这里的 tar'ed 和 gzip'ed 文件是最新的 CVS。它可能包含一些没有解决的问题。
更多信息见
Windows 系统
在 Windows 平台下安装 Ruby 有几个选择。第一个选择是仅安装编译好的二进制文件。第二个选择是直接执行“一步安装”程序，假如您不知道如何安装 Ruby ， 将是您最好的选择。（这种安装方式除 Ruby 之外，捆绑一些额外的资源库。）
(md5: 3b768d48ed4ec76e54f28d) 稳定版 (推荐)
(md5: d4ca9d289fb6c4208dd0) 稳定版 (推荐)
(md5: bcb369e36c8724) 开发版 (实验)
Linux 系统
许多 Linux 发行版中已经预装了 Ruby，如果您的系统上没有安装 Ruby，这里提供几个方式来安装。第一个方式是仅下载源代码，然后手工编译安装。 如果您不想从源代码编译浪费时间的话，许多平台都提供相应的机器体系结构的发行包，它们使 Ruby 的安装相当容易。
例如，在 Debian 或 Ubuntu 使用 apt-get 提供了一个简单而优雅的解决方案 ：% sudo apt-get install ruby irb rdoc
对于 irb 和 rdoc ，您需要激活 universe repository 。(整理)Ruby的基础知识
Last_Impression
发布时间: 11:18:48
xzyxuanyuan我的：||
&&&&&&&&&&&&
&&&&&路上的快速学习之道&&&&&&
13:32&1192人阅读&(5)&&
Ruby&基础知识整理
Ruby是面向对象的编程语言，她追求的是“简便快捷的面向对象编程”。Ruby是解释型语言，因此不需编译即可快捷地编程。同时Ruby具有类似&Perl的强大的文本处理功能，她可并不只是个玩具，您可以用她来进行实用的编程。此外，您还可以很方便地使用C语言来扩展Ruby的功能，因此可以把她当作各种库的前端来使用。
若您曾经“想要一种简单的面向对象的语言”，或者认为“Perl的功能虽然好用，但它的语法真让人受不了”，又或者觉得“lisp系列语言的思想不错，但到处都是括号真让人讨厌，最起码算式应该按照通常的样式书写”。那么，Ruby或许能让您满意。
归纳以来，Ruby有以下优点。
Ruby是解释型语言，其程序无需编译即可轻松执行。&
2变量无类型&
Ruby的变量没有类型，因此不必为静态的类型匹配而烦恼。相应地，错误检查功能也变弱了。&
3不需要变量声明&
所有变量均无需声明即可立即使用。另外，从变量名即可判断出是何种变量（局部变量，全局变量，实例变量）。
foo:局部变量
$foo:全局变量
@foo:类属性
4语法简单&
语法比较简单，类似Algol系语法。&
5不需要内存管理&
具有垃圾回收（Garbage Collect，GC）功能，能自动回收不再使用的对象。&
6一切都是对象&
Ruby从一开始就被设计成纯粹的面向对象语言，因此以整数等基本数据类型为首的所有东西都是对象，它们都有发送信息的统一接口。&
类，继承，方法&
Ruby当然具有面向对象语言的基本功能。&
7特殊方法&
可向某对象添加方法。例如，可以把GUI按钮被按下时的动作作为方法记述下来，还可以用它来进行原型库（prototypebase）的面向对象编程（有人这么干吧）。&
用模块进行混合插入（Mixin）&
Ruby故意舍弃了多重继承，但拥有混合插入功能。使用模块来超越类的界限来共享数据和方法等。&
该功能可以将循环抽象化。&
可以将某过程片段对象化。对象化后的该过程片段就称作闭包。&
10功能强大的字符串操作／正则表达式&
以Perl为样板创造出了功能强大的字符串操作和正则表达式检索功能。&
11拥有超长整数&
添加超长整数功能后，可以计算非常大的整数。例如计算400的阶乘也轻而易举。&
12具有错误处理功能&
错误处理功能可以使您编写代码处理出错情况。&
13可以直接访问OS&
Ruby可以使用（UNIX的）绝大部分的系统调用。单独使用Ruby也可以进行系统编程。&
14动态加载&
若OS支持的话，可以在运行时读入对象文件。&
但Ruby也有下列缺点。&
15Ruby On Rails，优点是不像Struts那样需要大量的配置文件，一切都采取默认的配置，包括访问路径，uri等，而这也是它的缺点，不能灵活的配置。
语言特征介绍:
Ruby将字符串像数字一样处理.我们用单引号('...')或双引号(&...&)将它们括起来. 单引号和双引号在某些情况下有不同的作用.一个由双引号括起来的字符串允许字符由一个前置的斜杠引出,而且可以用#{}内嵌表达式.而单引号括起来的字符串并不会对字符串作任何解释;你看到的是什么便是什么. 用+把几个串连起来,用*把一个串重复好几遍。
串联:&ruby
&word = &fo& + &o&
word = word * 2
&& &foofoo&
抽取字符(注意:在Ruby里,字符被视为整数):
&& 102&&&&&&&&&&& # 102 is ASCII code of `f'
&& 111&&&&&&&&&&& # 111 is ASCII code of `o'
(负的索引指从字符串尾算起的偏移量,而不是从串头.)
herb = &parsley&
&& &parsley&
herb[-2,2]
herb[0..3]
herb[-5..-2]
&&foo& == &foo&
&foo& == &bar&
通过在方括号里列出元素并用逗号将它们相互隔开来创建一个数组。Ruby的数组可以适应不同的对象类型。
ary = [1, 2, &3&]
一．&&&&&&&&&&&&&创建数组：Array.new(&anInteger=0,&anObject=nil&)
Array.new(2)
[nil,&nil]
Array.new(5,&&A&)
[&A&,&&A&,&&A&,&&A&,&&A&]
Array.new(2,&Hash.new)
就像前面提到的字符串一样.数组也可以相乘或相加：
ary + [&foo&, &bar&]
&& [1, 2, &3&, &foo&, &bar&]
&& [1, 2, &3&, 1, 2, &3&]
我们可用索引来访问数组的任意一部分.
&&&[2, &3&]
ary[-2..-1]
&& [2, &3&]
(负数索引表示到数组末尾的偏移,而不是从开头算起.)
数组可以和字符串互相转化,分别使用join和split：
str = ary.join(&:&)
&& &1:2:3&
str.split(&:&)
&&&[&1&, &2&, &3&]
一个关联数组不通过连续的数字索引来访问,而是通过任何类型的主键(key)访问.这样的数组有时被叫作哈希(hash)或者字典(dictionary).在Ruby里,我们趋向于用哈希这个术语.将一对对的元素用逗号分隔开,并用大括号({})括起来,这样就组成了一个哈希表.你用一个在哈希表里进行搜索,就像你在数组里用索引来提取数据一样.
h = {1 =& 2, &2& =& &4&}
&& {1=&2, &2&=&&4&}
h[5] = 10&&&& # appending value
&& {5=&10, 1=&2, &2&=&&4&}
h.delete 1&& # deleting value
&& {5=&10, &2&=&&4&}
条件控制语句
一．If语句
二．Case语句
循环控制语句
三．Loop语句
四．While语句
五．For语句
第一,和C一样break从循环中完全退出.第二,&next&跳到下一次循环迭代的开始(对应于C的&continue&).第三,Ruby有redo,它可以重新开始现在的迭代. 第四种方法是由循环内跳出的方法是&returen. return的结果是不仅从循环中跳出,而且会从含循环的方法中跳出.如果有参数,它会返回给方法调用,不然就返回nil.
Ruby的String类型有很多有用的迭代器:
&abc&.each_byte{|c| printf &&%c&&, c}; print &/n&
each_byte&是个用于字符串中每个字符的迭代器.每个字符串由局部变量c代替.
String的另一个迭代器是&each_line.
&a/nb/nc/n&.each_line{|l| print l}
可以用retry流程控制语句连接迭代循环,它会从头执行当前循环的迭代.
for i in 0..4
&&& &&&print i
&&& &&&if i == 2 and c == 0
&&& &&&&&c = 1
&& &&&&&&print &/n&
&&& &&&&&retry
&&& &&&end
&&& & print &/n&
yield有时会在一个迭代器的定义中出现.&yield将流程控制移至传递给迭代器的代码域。下面的例子定义了一个repeat迭代器,会依参数的设置执行多次代码域。
def repeat(num)
&&& &&&while num & 0
&&& &&&&&yield
&&& &&&&&num -= 1
&&& &&&end
repeat(3) { print &foo/n& }
在Ruby里,一个类的定义是在关键字class和end之间的一段代码.在域中的def开始定义类的一个方法,它对应于此类中中的某些特定的对象方法.
&&& &&&def speak
&&& &&&&&print &Bow Wow/n&
&&& &&&end
既然我们已有了Dog类,我们就可以用它来创造一只狗:
pochi = Dog.new
pochi.speak
继承和重载
class Bird
&&& &&&def preen
&&& &&&&&print &I am cleaning my feathers.&
&&& &&&end
&&& &&&def fly
&&& &&&&&print &I am flying.&
&&& &&&end
class Penguin&Bird
&&& &&&def fly
&&& &&&&&fail &Sorry. I'd rather swim.&
&&& &&&end
在子类里,我们可以通过重载父类方法来改变实体的行为.
class Human
&&& |&& def identify
&&& |&&&& print &I'm a person./n&
&&& |&& end
&&& |&& def train_toll(age)
&&& |&&&& if age & 12
&&& |&&&&&& print &Reduced fare./n&;
&&& |&&&& else
&&& |&&&&&& print &Normal fare./n&;
&&& |&&&& end
&&& |&& end
ruby& Human.new.identify
I'm a person.
ruby& class Student1&Human
&&& |&& def identify
&&& |&&&& print &I'm a student./n&
&&& |&& end
ruby& Student1.new.identify
I'm a student.
如果我们只是想增强父类的&identify&方法而不是完全地替代它,就可以用&super.
class Student2&Human
&&& |&& def identify
&&& |&&&& super
&&& |&&&& print &I'm a student too./n&
&&& |&& end
ruby& Student2.new.identify
I'm a human.
I'm a student too.
super&也可以让我们向原有的方法传递参数.
class Dishonest&Human
&&& |&& def train_toll(age)
&&& |&&&& super(11) # we want a cheap fare.
&&& |&& end
ruby& Dishonest.new.train_toll(25)
Reduced fare.
ruby& class Honest&Human
&&& |&& def train_toll(age)
&&& |&&&& super(age) # pass the argument we were given
&&& |&& end
ruby& Honest.new.train_toll(25)
Normal fare.
当我们在&最高层&而不是在一个类的定义里定义一个方法时会发生什么.
def square(n)
&&& |&& n * n
ruby& square(5)
我们的新方法看起来不属于任何类,但实际上Ruby将其分给Object类,也就是所有其它类的父类.因此,所有对象现在都可以使用这一方法.这本应是正确的,但有个小陷阱:它是所有类的私有(private)方法.我们将在下面讨论这是什么意思,但一个结果是它只能以函数的风格调用,像这样:
&&& |&& def fourth_power_of(x)
&&& |&&&& square(x) * square(x)
&&& |&& end
ruby& Foo.new.fourth_power_of 10
我们不允许向一个对象明确地运用这一方法:
&fish&.square(5)
ERR: (eval):1: private method `square' called for &fish&:String
class Test
&&& |&& def times_two(a)
&&& |&&&& print a,& times two is &,engine(a),&/n&
&&& |&& end
&&& |&& def engine(b)
&&& |&&&& b*2
&&& |&& end
&&& |&& private:engine&# this hides engine from users
ruby& test = Test.new
&& #&Test:0x4017181c&
ruby& test.engine(6)
ERR: (eval):1: private method `engine' called for #&Test:0x4017181c&
ruby& test.times_two(6)
6 times two is 12.
为实例添加新的方法
实例的行为取决于其类,但很多时候我们知道一个特定的实体需要特定的行为.在很多语言里,我们必须陷入另外再定义一个类的麻烦里,即使它只是用来接着实体化一次.在Ruby里,我们可以赋予任何对象属于其自身的方法.
class SingletonTest
&&& |&& def size
&&& |&&&& print &25/n&
&&& |&& end
ruby& test1 = SingletonTest.new
&& #&SingletonTest:0xbc468&
ruby& test2 = SingletonTest.new
&& #&SingletonTest:0xbae20&
ruby& def test2.size
&&& |&& print &10/n&
ruby& test1.size
ruby& test2.size
在这个例子里,test1和test2属于相同的类,但test2已被赋给一个重载的size方法,因而他们有不同的行为.一个仅属于某个对象的方法叫做单态方法.
单态方法常常用于图形用户界面(GUI)的元素的设计,在那里当不同的按钮被压下时将会激发不同的事件.
Ruby的模块非常类似类,除了:
l&&&&&&&&&模块不可以有实体
l&&&&&&&&&模块不可以有子类
l&&&&&&&&&模块由module...end定义.
实际上...模块的'模块类'是'类的类'这个类的父类.搞懂了吗?不懂?让我们继续看下去吧.
模块有两种用法.其一是将相近的方法和实体放在一个相对集中的域里.Ruby标准包里的Math模块就扮演着这一角色:
Math.sqrt(2)
&& 1.41421
ruby& Math::PI
&& 3.14159
::操作符告诉 Ruby 解释器在哪里找常数的值(可以想像,Math外的其它模块用PI表示其它的一些东西).如果我们想省掉 :: 直接调用一个模块的方法和常数,我们可以用&include:
include Math
ruby& sqrt(2)
&& 1.41421
&& 3.14159
模块的另一用法是糅和(mixin).某些OO语言,包括C++,允许多重继承(multiple inheritance),即从多个的父类里继承. 现实世界里一个多重继承的
例子是闹钟:你可以想像闹钟属于钟类同是属于带蜂音器的事物类.
Ruby并未特意实现真正的多重继承,但糅和技术是一很好的替代.记得模块无法实体化或子类化;但如果我们在类定义里include一个方法,
它的方法便实际上已加入,或&糅合&进这个类.
糅合可以视为一种寻求一切我们希望得到的特定属性的方法.举个例子,如果一个类有个 each 方法,把标准库里的Enumerable模块糅合进来就自然地赋予我们&sort&和&find&两个方法.
模块的使用令到我们获得多重继承的基本功能却可通过简单的树结构表述类关系,同时也可观地简化了语言的实现(Java的设计者也做了一个类似的选择).
我们总是希望对未知事件分类.当它发生时,向其它方法传递一块作为参数的代码是最容易地解决方法,也就是说我们希望像处理数据一样处理代码.
一个新的过程对象可以通过proc创建:
ruby& quux = proc {
&&& |&& print &QUUXQUUXQUUX!!!/n&
&& #&Proc:0x4017357c&
现在quux指向一个对象,像其它对象一样,它也有可以调用的行为.特别的,我们可以用call方法执行它:
ruby& quux.call
QUUXQUUXQUUX!!!
那么quux可以用做一个方法的参数吗?当然.
ruby& def run( p )
&&& |&& print &About to call a procedure.../n&
&&& |&& p.call
&&& |&& print &There: finished./n&
ruby& run quux
About to call a procedure...
QUUXQUUXQUUX!!!
There: finished.
trap方法令到我们可以对任何系统信号做出我们自己的选择.
ruby& inthandler = proc{ print &^C was pressed./n& }
&& #&Proc:0x&
ruby& trap &SIGINT&, inthandler
&& #&Proc:0x&
一般的,敲入^C将导致解释器退出.但现在一个信息被打印出来,解释器继续执行着,所以你不会丢失掉正在作业的工作.(你不会永远留在解释器里,你仍可以用&exit&或者按&^D退出)
最后在我们开始下一节之前还应注意的一点是:在将一个过程对象捆绑到一个信号之前,不是必须给这个过程对象命名的.一个等效的匿名(anonymous)过程对象像这样
ruby& trap &SIGINT&, proc{ print &^C was pressed./n& }
或着更简略,
ruby& trap &SIGINT&, 'print &^C was pressed./n&'
这种简写为你提供了一种方便和可读性更强的写小匿名过程的路子.
Ruby有三类变量,一种常量和两种严格意义上的伪变量(pseudo-variables).变量和常量都没有类型。在Ruby里我们不需要变量声明。
由首字母标识符将其分类:
[a-z]&or&_
唯一的例外是Ruby的伪变量:self,它永远指向当前正执行着的对象或未初始化变量的空值(meaningless
value)nil.虽然这两者的命名都像是局部变量,但&self&却是个由解释器把持的全局变量,而&nil实际上是个常量.既然只有这两种意外,他们并不会过多的干扰我们.
你并能向&self&或&nil&赋值.下面的例子中,&main作为self&的值,指向最高层的对象:
ruby& self
全局变量由$开头.它们可以在程序的任何位置访问到.在初始化前,全局变量有一个特殊的值nil.
ruby& $foo
ruby& $foo = 5
ruby& $foo
应谨慎使用全局变量.由于在任何地方都可以被写因此他们相当危险.滥用全局变量会导致很难隔离臭虫;同时也视为程序的设计未经严格考虑.当你发现必须要使用全局变量时,记得给它一个不会在其它地方一不小心就用到的描述性名字(像上面那样叫$foo可能不是一个好想法).
全局变量的好处是其可以被跟踪;你可以做一个当变量值改变时被调用的过程.
ruby& trace_var :$x, proc{print &$x is now &, $x, &/n&}
ruby& $x = 5
$x is now 5
当一个全局变量(改变时)作为一个过程的激发器,我们也管它叫活动变量(active
variable).比如说,它可用于保持GUI显示的更新.
这里列出了一些以$打头并跟单个字符的特殊变量.比如,$$包含了Ruby解释器的进程id,它是只读的.这里是主要的系统变量以及它们的含义(细节可在Ruby的中查到):
最近一次的错误信息
错误产生的位置
gets最近读的字符串
解释器最近读的行数(line number)
最近一次与正则表达式匹配的字符串
作为子表达式组的最近一次匹配
最近匹配的第n个子表达式(和$~[n]一样)
是否区别大小写的标志
输入记录分隔符
输出记录分隔符
Ruby脚本的文件名
命令行参数
解释器进程ID
最近一次执行的子进程退出状态
上面的&$_&和&$~&都有作用范围.它们的名字暗示其为全局的,但它们一般都是这样用的,关于它们的命名有历史上的原因.
一个实变量由@开头,它的范围限制在&self&对象内.两个不同的对象,即使属于同一个类,也可以拥有不同值的实变量.从对象外部来看,实变量不能改变甚至观察(比如,
Ruby的实变量从来不是公用的),除非方法由程序员明确声明.像全局变量一样,实变量在初始前的值是nil.
Ruby的实变量用不着声明.这暗含着对象的弹性结构.实际上,每个实变量都是在第一次出现时动态加入对象的.
ruby& class InstTest
&&& |&& def set_foo(n)
&&& |&&&& @foo = n
&&& |&& end
&&& |&& def set_bar(n)
&&& |&&&& @bar = n
&&& |&& end
ruby& i = InstTest.new
&& #&InstTest:0x83678&
ruby& i.set_foo(2)
&& #&InstTest:0x83678 @foo=2&
ruby& i.set_bar(4)
&& #&InstTest:0x83678 @foo=2, @bar=4&
注意上例中直到调用了&set_bar方法 i 才报告&@bar&的值.
局部变量由小写字母或下划线(_)开头.局部变量不像全局和实变量一样在初始化前含nil值.
ruby& $foo
ruby& @foo
ERR: (eval):1: undefined local variable or method `foo' for main(Object)
对局部变量的第一次赋值做的很像一次声明.如果你指向一个未初始化的局部变量,Ruby解释器会认为那是一个方法的名字;正如上面所见错误信息的.
一般的,局部变量的范围会是
proc{...}loop{...}def...endclass...endmodule...end整个程序(除非符合上面某个条件)
下面的例子,define?是一个检查标识符是否已定义的操作符.如果已定义它将返回标识符的描述,否则返回nil.正如你所见的,bar的范围是loop的局部变量;当loop退出时,bar无定义.
ruby& foo = 44; print foo, &/n&; defined? foo
&& &local-variable&
ruby& loop{bar=45; print bar, &/n&; break}; defined? bar
一个范围内的过程对象共享这个范围内的局部变量.这里,局部变量&bar由&main和过程对象&p1,
ruby& bar=0
ruby& p1 = proc{|n| bar=n}
&& #&Proc:0x8deb0&
ruby& p2 = proc{bar}
&& #&Proc:0x8dce8&
ruby& p1.call(5)
ruby& p2.call
注意开始的&bar=0&不能省略;此赋值允许bar的范围被&p1和&p2共享.不然&p1,
p2&将会分别生成并处理它们自己的局部变量&bar,&调用&p2&也将导致&未定义局部变量或方法&错误.
过程对象的强大在于它们能被作为参数传递:共享的局部变量即使传递出原范围也仍然有效.
ruby& def box
来源:http://blog.csdn.net/xzyxuanyuan/article/details/8904054