svchost.exe占CPU 100%的解决方法

--------------------------------------------------------------------------------
现象：

机器启动运行几分钟后 svchost.exe就会占系统cpu资源的100%

拔掉网线就好了，重连上网后一会儿：svchost.exe又占cpu资源的99%；

解决：

假设你已经使用了免费杀毒软件排除了病毒和已经使用防间谍软件排除了恶意软件的影响：

想办法清空C:\WINDOWS\SoftwareDistribution 目录下所有的文件重启机器即可。

如果机器提示文件正在使用（"Automatic Updates"服务正在运行）无法删除相应目录：

则想办法打开控制面板==>管理工具==>服务，找到"Automatic Updates"，设置成手动启动，

重启后再删除 C:\WINDOWS\SoftwareDistribution。问题就解决了。

然后再打开控制面板==>管理工具==>服务，找到"Automatic Updates"，恢复成自动启动重启。

注意：重启后最好在上网条件比较好的地方让系统顺利完成一次系统自动更新。

原因分析：

先说说什么是svchost.exe：

简单的说没有这个服务机器几乎就上不了网了。很多应用服务都是以来于这个接口RPC的，

如果发现这个进程占了太多的CPU资源，直接把系统的RPC服务禁用了会是一场灾难：

因为连恢复这个界面的系统服务设置界面都无法使用了。恢复的方法需要使用注册表编辑器，

找到 HKEY_LOCAL_MACHINE >> SYSTEM >> CurrentControlSet >> Services >> RpcSs,

右侧找到Start属性，把它的值改为2再重启即可

造成svchost占系统CPU 100%的原因并非svchost服务本身：

以上的情况是由于Windows Update服务下载/安装失败而导致更新服务反复重试造成的。

而Windows的自动更新也是依赖于svchost服务的一个后台应用，从而表现为svchost.exe负载极高。

常发生这类问题的机器一般是上网条件（尤其是去国外网站）不稳定的机器，比如家里的父母的机器，

往往在安装机器几个月以后不定期发生，每个月的第二个星期是高发期：

因为最近几年MS很有规律的在每个月的第二个星期发布补丁程序）。

上面的解决方法并不能保证不重发作，但是为了svchost文件而每隔几个月重装一次操作系统

还是太浪费时间了。

教训：spoolsv.exe的问题都是应用遇到失败/例外情况后自动重试造成的，

本想为用户节省时间的设计，但是重试的频度过高反而导致了和病毒一样的效果。

      刚从学校出来工作，的确有一些不适应，不过还好了，慢慢应该养成良好的工作习惯，这样工作、生活才轻松些。
      公司五一放假七天，可BLOG比公司放假时间还要长，得改。
      手中现在两个项目，一个.NET项目，一个公司ERP项目，虽然是忙起来挺好，可是ROR没时间学了。以前一直玩的JAVA，现在好好学一下.NET以及SAP的标准流程也是不错的啊！

2006年优秀Flex大型网站欣赏

2006年Flex大型网站层出不穷，下面是国际上几个优秀的RIA应用。

AFR Access

更多的好网站，可以去
Adobe Flex Showcase Finder看到

面向对象脚本语言 Ruby 参考手册

目录

• 更新记录
• 卷首语
• Ruby的启动
  • 命令行选项
  • 关于解释器行
• 环境变量
• Ruby 语言样式
  • 对象
  • 类
  • 执行
  • 结束时的相关处理
  • 线程
  • 安全模型
  • 正则表达式
• Ruby的语法
  • 字句构造
  • 程序
  • 变量和常数
  • 字面值
  • 操作符表达式
  • 控制结构／异常处理
  • 方法调用
  • 类／方法的定义
• 标准库
  • 内部函数
  • 内部变量
  • 内部常数
  • 内部类／模块／异常类
• 附加库
• Ruby变更记录
  • ruby 1.6 特性
  • ruby 1.7 特性
  • ruby 1.8 特性
    • 1.6.8到1.8.0的变更点(总结)
  • ruby 1.9 特性
  • obsolete
  • 对应DOSISH
• 附录
  • 疑似BNF的Ruby语法
  • Ruby术语集
  • Ruby的运行平台
  • pack模板字符串
  • sprintf格式
  • Marshal格式
  • Ruby FAQ
  • Ruby的陷阱
  • Ruby/Tk FAQ
  • Ruby的相关书籍
  • Ruby Documentation Project (RDP)
  • HTML Help版和分立HTML
  • ReFe
• 索引
• 功能分类索引
• 发布条件

链接：http://rubycn.ce-lab.net/man/index.html

翻译：http://www.ruby-cn.org/

一切权利归原作者所有，转载请保留。

        没有必要浪费时间来谈论Ruby的历史，如果你没有听说过它，你可以去它的主页看看www.ruby-lang.org，或者去它的新闻组comp.lang.ruby。如果你知道Ruby，我将讲述我为什么会喜爱它。

1. 它是面向对象的。 这表示什么意义呢？ 如果问10个程序员，你也许会得到12种结果，你有你的看法，我不会试图去改变你的看法。但是有一点，Ruby提供了对数据和方法的封装，允许类的继承，对象的多态。不像其它语言（C++,Perl等），Ruby从设计的时候开始就是一种面向对象的语言。

2. 它是纯面向对象的语言。难道是我多余？不是这样的，之所以这么说，因为Ruby中一切都是对象，包括原始数据类型（primitive data types），比如字符串，整型，都表示的是一个对象，而不需要Java那样提供包装类（wrapper classes）。另外，甚至是常量，也会被当作对象来处理，所以一个方法的接收者，可以是一个数字常量。

3. 它是动态语言。 对于只熟悉像C++，Java这样静态语言的人来说，这是一个重大的概念上的差别。动态意味着方法和变量可以在运行时候添加和重定义。它减少了像C语言那样的条件编译（#ifdef），而且容易实现反射API（reflection API）。动态性使得程序能自我感知（self-aware），比如运行时类型信息，检测丢失的方法，用来检测增加方法的钩子等。在这些方面Ruby和Lisp和Smalltalk都有一些关系。

4. 它是一种解释执行的语言。这是一个负杂的问题，值得重点解释一下，也许这个特点会因为性能的原因而引起从优点变为缺点的争论。对于此，我有几点见解：1.第一：快速开发循环是一个巨大的好处，这要得意于Ruby的解释执行。2.多慢才叫慢呢？在说它慢之前先定一个慢的基准。3.也许有人要批评我了，但我还要说：处理器每年都在变得原来越快。4.如果你真的很在意你的速度，你可以用C开发一部分你的代码。5.最后，从某种意义上说，这是一个还在争论中的问题，没有一个语言天生就是解释型的，世界上没有哪个法律进制开发一个Ruby编译器出来。

5. 它理解正则表达式。 很多年之前，正则表达式只是用在UNIX的工具如grep或者sed中，或者在vi中进行一些一定的查找－替换等。Perl的出现解决了这些问题，而现在，Ruby同样也能做到这些。越来越多得人认识到了这种字符串和文本处理技术的难以置信的能力，如果你对此表示怀疑，那么请去看一下 Jeffrey Friedl的书Mastering Regular Expressions，然后，你就应该不会有什么怀疑了。

6. 它是多平台的。 Ruby可以运行在Linux，UNIX，Windows，BeOS，甚至MS-DOS。如果我没记错，甚至还有一个Amiga 版本的

7. 它是派生来的。 这是一件好事情吗？抛去书本上的知识，它是有用的。牛顿曾说过“我如果看得比别人远，那是因为我站在巨人的肩膀上”。Ruby同样也是站在巨人的肩膀上，它借鉴了Smalltalk, CLU, Lisp, C, C++, Perl, Kornshell等的优点。在我看来它的原则包括：1.不要重复制造轮子。2.不要修补没有损坏的东西。3.最后一个也是比较特别的，它能平衡（Leverage ）你已有的知识。你了解UNIX的文件和管道，没关系，你可以在Ruby中继续用，你用了两年的时间学习了printf 指示符，不必担心，Ruby中你也可以使用printf。你知道Perl的正则表达式处理，那么你也就学会了Ruby中的正则表达式。

8. 它是创新的。 是不是觉得这个和第七条矛盾了？也许是有一部分矛盾，每个硬币都有两面。一些Ruby的特点都是创新的东西，比如非常有用的Mix-in，也许这个特点会被后来的语言借鉴。（注：一位读者指出Lisp早在1979年就有mix-in了，这是我的疏忽；我应该找个更好的例子，并且能确信它。）

9. 它是非常高层次的语言。（Very High-Level Language ：VHLL) 这是一个容易引起争论的话题，因为这个术语还没有广泛使用。而且它的意思比起OOP来说还是有讨论余地的。我这么说，指的是Ruby能支持复杂的结构和这些结构的负杂的操作，而需要的指令非常少，这与最小努力原则（Principle of Least Effort）一致。

10. 它有一个灵巧的垃圾收集器。 像malloc和free 这样的例程已经是昨天的恶梦了，你不需要什么回收内存的操作，甚至是调用垃圾收集器。

11. 它是脚本语言。 不要因为此就认为它不够强大，它不是一个玩具。它是完全成熟的语言，用它能轻松的完成传统的脚本操作，比如运行外部程序，检查系统资源，使用管道，捕获输出等等。

12. 它是通用的。 Kornshell做的东西它也可以做，C语言做的东西它也可以做的很好。你可以用它写一个只运行一次的只有10行的程序，或者对一些遗留程序进行包装，你想写个web server，或者一个CGI，都可以用Ruby来写。

13. 它是多线程的。 Y你可以用一些简单的API来写多线程程序，甚至在MS-DOS上都可以。

14. 它是open source的。 你想看它的源代码吗？可以，你也可以提交补丁，参加广泛的社区，包括它的创造者。

15. 它是直觉得。 Ruby的学习曲线比较低，而如果你翻过了一个坎，你开始“猜测”事情是怎么工作的，而且你的猜测很多时候都是正确的。Ruby坚持最小惊讶（ Least Astonishment）的原则。

16. 它有异常机制。 像Java和 C++一样， Ruby 中也有异常机制，这意味着你不必因为返回值而将代码弄得凌乱不堪，很少的嵌套if语句，很少的意大利面条似的逻辑，更好的错误处理。

17. 它有一个高级的数组类：Array。 Ruby中数组都是动态的，你不必像pascal那样在声明它的大小，也不必像C，C++那样为它分配内存。它们是对象，所以你不必关心它们的长度，实际上你不能"走到末尾（walk off the end）"。这个类提供了各种方法，使得你能够根据索引，根据元素来访问数组内容，也可以反向处理数组。你也可以用数作作为set，队列，堆栈等。如果你想用查找表，可以用哈希结构。

18. 它是可以扩展的。 你可以用C或者Ruby来编写外部库（external libraries），同样，你也可以修改已有的类和对象。

19. 鼓励文档编程（literate programming）。 你可以在Ruby程序中嵌入注释或者文档，这些文档可以用Ruby的文档工具提取和处理。（真正的文档编程者可能认为这是必须的基本东西吧）

20. 创造性的使用标点符号和大写字母。 比如一个方法返回一个boolean型（Ruby中并没有这种说法），那么一般这个方法最后都以问号结尾，如果一个方法要修改接收者本身，或者具有破坏性，则用一个感叹号结尾，简单，直觉。所有常量，包括类名，都以大写字母开头，所有对象属性以@符号开头。这有匈牙利命名法的实用性，但是没有视觉上的丑陋性。

21. Reserved words aren't.It's perfectly allowable to use an identifier that is a so-called "reserved word" as long as the parser doesn't perceive an amibiguity. This is a breath of fresh air.（能用保留字作为变量吗？没看太懂。）

22. 支持迭代器。 这使得你可以给一个数组，list，tree等对象传递一个块，然后对它们的每个元素进行block调用。这个技术值得深入学习。

23. 它的安全性。 Ruby借鉴了Perl中基于$SAFE变量的分层控制机制 。这对于CGI程序来说非常有用，可以防止人们攻击web服务器。

24. Ruby中没有指针。 像 Java一样，和C++不同，Ruby中没有指针的概念，所以免除了关于指针语法和调试的头疼。当然，这也意味着最底层的程序开发将会很困难，比如访问一个设备的控制状态寄存器；但是，我们可以用一个C库来调用。（像C语言程序员有时候要使用汇编语言一样，Ruby程序员有时候也要使用C语言来完成一定的任务）

25. 它使得人们专注于细节。 Ruby中有很多同义词和别名，你也许不记得字符串或数组的长度是size还是length，没关系，它们任何一个都可以工作。对于Range来说，你可以使用begin 和end 或者使用 first 和 last，它们也都工作。你想拼写indices，结果写成了indexes，没关系，这两个都一样。

26. 非常灵活的语法。 方法调用时候括号可以省略，参数之间只需用逗号分割。类似Perl风格的数组定义可以让你不用全部使用引号和逗号定义一个字符串的数组。关键字return可以生路。

27. 丰富的库函数。 Ruby提供了线程，socket，有限对象持久化，CGI，服务器端可执行的，数据库等其它库函数，还有对Tk的支持等。还有很多其它的库函数。

28. 本身自带调试器（debugger）。 在完美的世界中，我们才不需要调试器，但是这个世界不是完美的。

29. 交互式执行。 可以用Ruby像Kornshell那样执行。 (这可能是本页最具争论的一点，我不得不承认，Ruby真的不是一个很好的shell。但我仍然坚持，基于Ruby的shell是一个不错的主意。）

30. 它是简明的。 不像Pascal那样要求if后面跟着then，while后面跟着do 。变量不需要声明，它们不需要类型。返回类型不必指定，关键字return 可以省略，它将返回最后一个表达式的值。另一方面，它也不像Perl或者C那样复杂难懂。

31. 它是面向表达式的（expression-oriented）。 你可以轻易的使用 x = if a<0 then b else c  这样的表达式。

32. 语法砂糖（syntax sugar）。 (像Mary Poppins解释：一勺语法的糖能使语义被接受) 。如果你想对数组x进行迭代，可以用for a in x。你也可以用a+=b代替a=a+b，这都行。很多操作符其实在Ruby中都是方法，这些方法的名字比较直观，短小，有着便利的语法。

33. 它支持操作符重载。 如果我没有记错的话，早在很久之前的SNOBOL就提供了这个功能，但是直到C++它才变得流行。虽然它可能乱用而出错，但是这仍是一个非常不错的优点。另外Ruby自动定义操作符的赋值版本，比如，如果你重定义了+，那么，你同时得到了一个+=操作符。

34. 支持无限精度的数字。 有人会关心 short, int, long吗，只需要使用 Bignum就行了，你可以轻松的实现365的阶乘。

35. 有幂操作符。 在很久以前，我们在BASIC和FORTRAN中使用它，然而当我们学习Pascal和C之后，我们才认识到这个操作符有多差劲。（我们被告知自己连它是怎么工作的都不知道－它使用了对数，迭代了吗，效率如何？），但是，我们真的关系这些吗？如果是，我们可以重写这个方法，否则，Ruby有非常好的**操作符可以用。

36. 强大的字符串处理。 If如果你想查找，判断，格式化，trim，定界（delimit），interpose，tokenize，你可以自己选择随便用哪一个来得到你想要的结果。

37. 规则很少引起异常。 Ruby的语法和语义比其它语言有条理，每种语言都有独特的一面，每条规则都会有异常发生，但是Ruby规则引起的异常就少的多了。

    ---

    ---

Ruby程序快速入门之数据结构

         就象许多程序语言一样，Ruby也提供了完整的数据结构来存储和管理数据与对象。数组是使用方括号和用逗号隔开的单个对象参考列表创建的。

presidents=["John"，"Richard"，"Gerald"，"Ronald"，"George"，"William"];

　　为了更为容易地创建一个充满单词的数组，Ruby提供了一个特殊的标志来消除双引号和逗号，见下面例子：

presidents= %w[ John Richard Gerald Ronald George William];

　　在其它编程语言中，"数组"一词经常意味着一组相同性质的对象的集合。但在Ruby中，不是这样。在Ruby中，一个"数组"可以是由不同性质的对象参考组成的集合。因此，下面是有效的数组表达形式：

order_date=Date.today() shirt_information=[14.5，"Long"，32，order_date]

　　在这个数组中，对象参考按顺序存储并索引。象Java一样，索引从0开始，索引可用来从数组中检索对象参考。下面的示例中请求的是，上面创建的shirt_information数组中的第3个元素（索引为2）。注意，你可以使用方括号标志或at方法来检索数组中的对象参考。

irb(main):003:0＞ shirt_information[2] =＞ 32 irb(main):004:0＞ shirt_information.at(2) =＞ 32

　　有趣的是，你还可以使用一个负数索引来引用数组中的元素。一个负数索引是从数组尾部开始计数的。

irb(main):005:0＞ shirt_information[-3] =＞ "Long"

　　数组是动态的，意味着数组的大小可以根据你的操作而动态地改变。你可以使用[index]=操作符来添加或替换一个数组中的元素。

irb(main):013:0＞ shirt_information =＞ [14.5， "Long"， 32， #<Date: 4907585/2，0，2299161＞] irb(main):014:0＞ shirt_information[1]="Medium" #change shirt length =＞ "Medium" irb(main):015:0＞ shirt_information[4]=49.99 #add shirt cost =＞ 49.99 irb(main):016:0＞ shirt_information =＞ [14.5， "Medium"， 32， #<Date: 4907585/2，0，2299161＞， 49.99]

　　你也可以使用数字对和范围来由数组的一部分创建一个新数组，通过使用一个[开始索引，元素数目]标志或[开始索引...结束索引]标志。

irb(main):019:0＞ shirt_information =＞ [14.5， "Long"， 32， #<Date: 4907585/2，0，2299161＞， 49.99] irb(main):020:0＞ shirt_dimensions = shirt_information[0，3] =＞ [14.5， "Long"， 32] irb(main):021:0＞ shirt_order = shirt_information[2..5] =＞ [32， #<Date: 4907585/2，0，2299161＞， 49.99] irb(main):030:0＞ shirt_information[-3，2] =＞ [32， #<Date: 4907585/2，0，2299161＞]

　　这个结合了赋值运算符([]=)的标志将产生一个很复杂的元素插入或代替操作。一个开始/结束索引或范围可以用在赋值操作符中。具体使用请参考下面的示例：

irb(main):001:0＞ test_array=["zero"， "one"， "two"， "three"， "four"] =＞ ["zero"， "one"， "two"， "three"， "four"] irb(main):002:0＞ #starting at the second element， replace the next two elements with a single element irb(main):003:0* test_array[1，2]=1 =＞ 1 irb(main):004:0＞ test_array =＞ ["zero"， 1， "three"， "four"] irb(main):005:0＞ #insert a new element after the second one (zero as a second parameter indicates "insert") irb(main):006:0* test_array[2，0]=2 =＞ 2 irb(main):007:0＞ test_array =＞ ["zero"， 1， 2， "three"， "four"] irb(main):008:0＞ #add an array of elements after element 5 irb(main):009:0* test_array[5，0]=[5，6，7] =＞ [5， 6， 7] irb(main):010:0＞ test_array =＞ ["zero"， 1， 2， "three"， "four"， 5， 6， 7] irb(main):011:0＞ #replace elements in the index range of 3..4 with the array assigned irb(main):012:0* test_array[3..4]=[3，4] =＞ [3， 4] irb(main):013:0＞ test_array =＞ ["zero"， 1， 2， 3， 4， 5， 6， 7]

　　最后，也许Ruby数组中最有力量的运算可以从数学操作符中找到答案-它们能够从现在数组创建新的数组。例如，+操作符允许你由两个数组的连接创建一个新数组，而*操作符允许你复制或连接一个数组自身若干次。

irb(main):033:0＞ shirt_information =＞ [14.5， "Long"， 32， #<Date: 4907585/2，0，2299161＞， 49.99] irb(main):034:0＞ pant_information=[34，32，59.99，order_date] =＞ [34， 32， 59.99， #<Date: 4907585/2，0，2299161＞] irb(main):035:0＞ shirt_information + pant_information =＞ [14.5， "Long"， 32， #<Date: 4907585/2，0，2299161＞， 49.99， 34， 32， 59.99， #<Date: 4907585/2，0，2299161＞] irb(main):036:0＞ shirt_information * 2 =＞ [14.5， "Long"， 32， #<Date: 4907585/2，0，2299161＞， 49.99， 14.5， "Long"， 32， #<Date: 4907585/2，0，2299161＞， 49.99] irb(main):037:0＞ array1 = [2，4，6，8，10] =＞ [2， 4， 6， 8， 10] irb(main):038:0＞ array2=[3，6，9] =＞ [3， 6， 9] irb(main):039:0＞ array1 - array2 =＞ [2， 4， 8， 10]

　　在Ruby中，与数组联系最密切的就是哈希表。在一个数组中，索引是一个整数。在Ruby中Hash类行为上与Array非常相似，但是它允许在集合中出现到参考对象的任何类型的对象"索引"（或键）。在另外的程序语言中，这可能被称为一个字典或地图或哈希地图。一般地，当使用哈希表时，你应该为集合中的每个元素提供两个对象参考。其中，一个对象参考用作键，另一个用作该键所指对象（即"值"）。用于指示一个键对象所指内容的标志是=＞符号。当创建哈希表时，键/值对可以在两个大括号之间被收集。作为一个哈希表的例子，你可以在哈希表中使用简单的字符串对象作为键来引用Date对象（值）。

holidays={"New Year"=＞Date.parse("2006-01-02")， "MLB Birthday"=＞ Date.parse("2006-01-16")， "Washington Birthday"=＞Date.parse("2006-02-20")， "Memorial Day"=＞Date.parse("2006-05-29")， "July 4th"=＞Date.parse("2006-07-05")}

　　为了检索纪念日的Date对象，你可以使用"Memorial Day"字符串键。

irb(main):004:0＞ holidays["Memorial Day"] =＞ # irb(main):005:0＞ holidays["Memorial Day"].to_s =＞ "2006-05-29"

　　如你所想，在数组和哈希表中还有另外许多方法来允许你存取和修改集合中的单个元素或改变全部集合本身。因此，在Ruby中，数组和哈希表都是功能极强的动态的数据结构。

　　一旦你有一个对象参考的集合，那么在编程中最常用的一项任务就是遍历该集合中的每一个元素并执行某些操作。Ruby当然也提供了数组和哈希表中的类似机制。Ruby提供的实现遍历集合的机制是该集合对象上的一组方法。Array中的方法（如each，each_index，delete_if）和Hash中的方法（如each，each_key，each_value，each_pair）允许你的编码进行集合遍历并执行特定的任务。事实上，Ruby中的许多类都包含迭代子（iterator）方法。例如，String就提供了一个iterator方法来执行字符串的以字符或字节为单位的遍历任务。然而，在你理解iterator方法前，你首先需要理解Ruby中代码块的概念。因为当遍历集合中的元素时，对于每一个iterator方法，都是通过传递一个代码块来执行的。

Downloadable Ruby Tutorials

Table of Contents

• Introduction
• Installation
• First Program
• Features
• Numbers
• Fun with Strings
• Variables and Assignment
• Scope
• Getting Input
• Names
• More on Ruby Methods
• Writing own Ruby Methods
• Method Missing
• More on Strings
• Simple Constructs
• Arrays
• Ranges
• Blocks and Procs
• Random Numbers
• Read/Write files
• Writing our own Class
• Including Other Files
• Ruby Open Classes
• Inheritance
• Duck Typing
• Overloading Methods
• Overriding Methods
• Symbols
• Hashes
• Exploring Time class
• Exceptions
• Access Control
• Syntactic Sugar
• Mutable and Immutable Objects
• Object Serialization
• Constants
• Modules/Mixins
• Self
• Regular Expressions
• Unit Testing
• Socket Programming
• SMTP class
• Web services
• Ruby/Tk
• Using Ruby/MySQL
• Ruby Tools
• Java to Ruby
• Ruby on Rails
• Solutions
• Ruby Quirks

都是英文版的，耐心看吧！

The Fastest Way to Learn Ruby

Wise Words

rubylearning.com is a thorough collection of Ruby study notes for those who are new to the language and in search of a solid introduction to Ruby's concepts and constructs - ruby-lang.org

Dive in to Learn Ruby.

My interest in Ruby was aroused after I read an article Ruby the Rival in November 2005. I started learning Ruby myself and made my own Ruby study notes. What's presented here is a result of that.

I'd like to thank everyone on the ruby-talk mailing list for their thoughts and encouragement; all of my wonderful PuneRuby RUG members, for their help in making these study notes far better than I could have done alone. I would like to specially thank Andy Tyrrell from UK, for his help in tweaking the Syntax Highlighter css.

Since these are my study notes, I have made extensive references to the blogs and articles of various Ruby Gurus and to the Ruby books from Apress, Manning, O'Reilly and Pragmatic Programmers; my acknowledgment and thanks to all of them.

If you notice any errors or typos, or have any comments or suggestions or good exercises I could include, or have any queries on any of the topics here, please let me know by filling out the contact form on this site. Good luck and I hope you find this site useful!

Ruby From Other Languages


When you first look at some Ruby code, it will likely remind you of other programming languages you’ve used. This is on purpose. Much of the syntax is familiar to users of Perl, Python, and Java (among other languages), so if you’ve used those, learning Ruby will be a piece of cake.

This document contains two major sections. The first attempts to be a rapid-fire summary of what you can expect to see when going from language X to Ruby. The second section tackles the major language features and how they might compare to what you’re already familiar with.

What to Expect: Language X to Ruby

• To Ruby From C and C++
• To Ruby From Java
• To Ruby From Perl
• To Ruby From PHP
• To Ruby From Python

Ruby From Other Languages

是ruby官方网站写的，比较了其他主流编程语言和ruby的异同之处，给出了ruby比较有特点的功能介绍。

http://www.ruby-lang.org/en/documentation/ruby-from-other-languages/

• 在 DOS 命令行窗口运行 rails student（本程序的工作目录是 C:\  ）
  
  C:\>rails student
        create
        create  app/controllers
        create  app/helpers
        create  app/models
        create  app/views/layouts
        create  config/environments
        create  components
        create  db
        create  doc
        create  lib
        create  lib/tasks
        create  log
        create  public/images
        create  public/javascripts
        create  public/stylesheets
        create  script/performance
        create  script/process
        create  test/fixtures
        create  test/functional
        create  test/integration
        create  test/mocks/development
        create  test/mocks/test
        create  test/unit
        create  vendor
        create  vendor/plugins
        create  tmp/sessions
        create  tmp/sockets
        create  tmp/cache
        create  tmp/pids
        create  Rakefile
        create  README
        create  app/controllers/application.rb
        create  app/helpers/application_helper.rb
        create  test/test_helper.rb
        create  config/database.yml
        create  config/routes.rb
        create  public/.htaccess
        create  config/boot.rb
        create  config/environment.rb
        create  config/environments/production.rb
        create  config/environments/development.rb
        create  config/environments/test.rb
        create  script/about
        create  script/breakpointer
        create  script/console
        create  script/destroy
        create  script/generate
        create  script/performance/benchmarker
        create  script/performance/profiler
        create  script/process/reaper
        create  script/process/spawner
        create  script/process/inspector
        create  script/runner
        create  script/server
        create  script/plugin
        create  public/dispatch.rb
        create  public/dispatch.cgi
        create  public/dispatch.fcgi
        create  public/404.html
        create  public/500.html
        create  public/index.html
        create  public/favicon.ico
        create  public/robots.txt
        create  public/images/rails.png
        create  public/javascripts/prototype.js
        create  public/javascripts/effects.js
        create  public/javascripts/dragdrop.js
        create  public/javascripts/controls.js
        create  public/javascripts/application.js
        create  doc/README_FOR_APP
        create  log/server.log
        create  log/production.log
        create  log/development.log
        create  log/test.log
  
  C:\>
  
  你可以看到，rails 已经为你生成了 student 应用程序的完整目录结构。
  Rails 不仅仅是一个运行时网络应用框架，它本身包含了丰富的脚本来帮你完成程序基本骨架的工作。
  运行 rails student 后， rails 将生成 student 应用程序的默认目录结构和初始化文件。
  
  Rails 开发的方式是： 由 rails 来生成默认的应用程序骨架，你所做的工作就是在默认目录结构中编辑文件增加应用程序逻辑就可以了。
  
  紧接着测试一下空的应用程序，看看 rails 默认给我们完成了什么工作。
  本程序的工作目录是 D:\railsdoc>, 上面 rails 已经给我们生成了student目录，进入 student 目录。
  
  运行 ruby script\server 。 这条命令是运行 script 目录下的 server 命令来启动 webrick 服务器。
  
  启动 webrick 服务器如下：
  
  C:\student>ruby script\server
  => Booting WEBrick...
  => Rails application started on http://0.0.0.0:3000
  => Ctrl-C to shutdown server; call with --help for options
  [2007-04-18 17:02:32] INFO  WEBrick 1.3.1
  [2007-04-18 17:02:32] INFO  ruby 1.8.6 (2007-03-13) [i386-mswin32]
  [2007-04-18 17:02:32] INFO  WEBrick::HTTPServer#start: pid=3692 port=3000
  
  打开浏览器 ，输入网址http://127.0.0.1:3000/ 你会看到类似的网页。
  
  
  
  
  暂时不要关闭这个窗口。
  
  Webrick 简介：
  
  Ruby 默认已经包含了丰富的软件，其中 webrick http 服务器就是其中之一。 这个程序包被用作 rubygem 的默认文档服务器。这是一个非常简单的纯 ruby 编写的服务器。如果你掌握了 webrick 你可以用几行代码来运行一个 web 服务器。
  
  打开编辑器，编写以下脚本
  require "webrick"
  httpd = WEBrick::HTTPServer.new(
  :DocumentRoot =>Dir::pwd + "/ruby",
  :Port => 80
  )
  trap(:INT){ httpd.shutdown }
  httpd.start
  然后保存到 c:\server.rb 下，双击 server.rb , 一个最简单的 http server 就运行了，它将 c:\ruby 目录作为服务器文档根目录。
  
  C:\student>ruby script\server
  => Booting WEBrick...
  => Rails application started on http://0.0.0.0:3000
  => Ctrl-C to shutdown server; call with --help for options
  [2007-04-18 17:02:32] INFO  WEBrick 1.3.1
  [2007-04-18 17:02:32] INFO  ruby 1.8.6 (2007-03-13) [i386-mswin32]
  [2007-04-18 17:02:32] INFO  WEBrick::HTTPServer#start: pid=3692 port=3000
  127.0.0.1 - - [18/Apr/2007:17:09:18 中国标准时间] "GET / HTTP/1.1" 200 7552
  - -> /
  127.0.0.1 - - [18/Apr/2007:17:09:19 中国标准时间] "GET /javascripts/prototype.js HTTP/1.1" 200 71260
• http://127.0.0.1:3000/ -> /javascripts/prototype.js
  127.0.0.1 - - [18/Apr/2007:17:09:19 中国标准时间] "GET /javascripts/effects.js HTTP/1.1" 200 38200
  http://127.0.0.1:3000/ -> /javascripts/effects.js
  127.0.0.1 - - [18/Apr/2007:17:09:19 中国标准时间] "GET /images/rails.png HTTP/1.1" 200 1787
  http://127.0.0.1:3000/ -> /images/rails.png
  

在浏览器窗口打开 http://127.0.0.1/

• 
  
  你将会看到 c:/ruby 目录的内容，我们的 ８ 行 ruby 代码就生成了一个简单 http 服务器。你不光可以定制文档根目录，你还可以象编写 java servlet 那样，为 webrick 编写 ruby servlet 代码。具体详细信息参看 www.webrick.org

从"Hello,World"开始 快速入门Ruby

　　最简单的"Hello,World"程序开始逐步深入了解Ruby的类、block、迭代器等特征

　　这是一个短小的Ruby入门。这里假设读者已经安装了Ruby，如果你没有安装的话，请在阅读文前访问Ruby官方网站进行下载并安装。

　　交互式的Ruby

　　打开IRB(交互式Ruby外壳)：

·    如果你使用Mac OS X，那么请打开终端窗口输入irb;

·    如果你使用Linux，那么请打开shell输入irb;

·    如果你使用windows，那么请在开始菜单中找到Ruby->fxri，并执行它。

　　Ok，在打开IRB之后，在其中输入"Hello World"。



 

Ruby听从你的安排!

　　发生了什么?我们刚才编写了世界上最短小的“Hello World”程序吗?这么说不太确切。第二行输出是IRB告诉我们：上一个表达式的评估结果。如果我们希望打印出“Hello World”，那么就还需要一点努力：

　　puts在Ruby中是一个简单的打印输出命令。后面的“=> nil”表示什么?——那是表达式的结果。Puts总是返回nil，这是Ruby中表示“绝对无值”(absolutely-positively-nothing value)的方式，看上去有些类似Java中的null。

你的免费计算器在这里!

　　无需做什么，我们就能把IRB作为一个简单的计算器使用：

　　这样就能计算3+2。够简单的!那么3乘以2如何?你可以在下面继续输入3*2，也可以回到上面(3+2处)重新修改你刚刚输入的计算公式。使用键盘上的向上键，使光标到达3+2那一行，再用左键移动光标到加号上，然后使用空格键进行修改。

　　下面，让我们尝试计算3的平方：

　　在Ruby语言中，**表示幂运算。那么如何计算平方根呢?

　　Ok，等一下，表达式中的sqrt(9)表示什么?你一定能猜到这是计算9的平方根。而Math表示什么?不要着急，下面就让我们进一步了解像Math这样的模块。

　　模块——按照主题分组的代码

　　Math是Ruby内建的数学模块。在Ruby中，模块提供了两种角色：一种角色是将类似的方法聚集在同一个“家族”名下。因此，Math也包括sin、tan这样的方法。第二种角色是一个圆点(dot)，它标记了消息的接收者。什么是消息?在上面的例子中，sqrt(9)便是消息，它意味着调用sqrt方法取出9的平方根。

　　Sqrt方法调用的结果是3.0。你可能注意到它并不是3。这是因为多数情况下，数字的平方根并不是整数，所以这里返回了一个浮点数。

　　那么我们如何记住这些计算结果呢?——将结果赋值给变量。

如何定义方法?

　　如何才能方便省事地随意输出字符串，而无需过多地劳烦我们的手指呢?——我们需要定义一个方法!

　　上面的代码中第一行“def h”标志着方法定义的开始。它告诉Ruby我们正在定义一个名为h的方法。下面一行是方法体：puts "Hello World"。最后，也就是第三行“end”通知Ruby我们完成了方法定义。Ruby的回应“=> nil”告诉我们它已经知道我们定义了此方法。

　　简短、重复地调用方法

　　现在，让我们尝试多次执行这个方法：

　　哈，这太容易了。在Ruby中调用某个方法只需将方法名提交给Ruby。当然，这是在方法没有参数的情况下。如果你愿意也可以添加一个空白的括号，但是这没有必要。

　　如果我们想对某个人说hello而不是整个“世界”(world)，那该怎么做?——重定义h方法使它接收name参数。

字符串中的奥秘

　　“#{name}”是什么意思?这是Ruby在某个字符串中插入其它字符的方式。在大括号之间放入的字符串(这里是指name)将被外部的字符串代替。你也可以使用字符串类内建的capitalize方法来确保某人名字的首字母大写：

　　上面的代码有两个地方需要说明：

　　第一，我们通过无括号的方式调用方法，因为括号是可选的;

　　第二，这里的默认参数值为“World”。也就是说在调用方法时如果没有提供name参数，则使用默认值“World”。

　　进化为Greeter!

　　我们是否需要一个真正的问候者(greeter)，他能记住你的名字、问候你、总是尊重地向你示好?那么这就最好建立一个“Greeter”类：

在上面的类代码中定义了一个称为Greeter的类和一些类方法，其中出现了一些新的“关键词”:请注意“@name”，它是类的实例变量，并对类中的所有方法(say_hi和say_bye方法)都有效。

　　如何让Greeter类发挥作用?现在让我们来建立一个Greeter对象并使用它!

　　Greeter类的实例对象g被建立后，它便接受了name参数(值为Pat)。那么我们能直接访问name吗?

　　看看上面的编译错误来看，这样直接访问name是行不通的。

　　窥视对象的内部

　　对象中的实例变量总是隐藏于其中，但也并非毫无踪迹可寻，通过审查(inspect)对象便会见到它们。当然还有其它的访问方法，但是Ruby采用了良好的面向对象的方式来保持数据的隐藏性。

喔!这么多方法，可是我们只定义了两个方法呀?其它的方法又出自何处?不要担心，instance_methods方法列出了Greeter对象的所有方法，其中包括父类中定义的方法。如果我们只想对Greeter类的方法进行列表的话，那么把false作为参数调用instance_methods方法即可。false意味着我们不需要父类定义的方法。



 

　　哈哈，这才是我们想要的。下面让我们看看Greeter对象能回应哪些方法：

 

　　它知道say_hi、to_s(此方法将对象转换为字符串，是任何对象都必备的默认方法，很想Java中的toString方法)，但它不知道name。

　　随时修改类定义

　　如何才能查看或者修改name呢?Ruby提供了访问对象变量的简单方法：

　　在Ruby语言中，你能够多次打开某个类并修改它。而修改所带来的变化将应用在此后建立的任何新对象中、甚至现存的此类对象中。下面让我们建立一个新对象并访问它的@name属性。

 

　　我们通过使用attr_accessor定义了两个方法：

·                                 　　“.name”用来获取name属性值;

·                                 　　“.name=”用来设置namee属性值。

　　这很类似在Java类中访问被Public修饰的成员变量。

向每个人问候，MegaGreeter不会漏掉一个人

　　Greeter并不完美，因为它只能一次服务一个人。所以我们在这里设计一个能够一次向全世界、世界上每个人或者在名单中的人发送问候的MegaGreeter类。在这里，我们将放弃从前的IRB交互模式，转而改为编写Ruby程序文件。

　　退出IRB的方法：输入“quit”、“exit”或者按下Control+D的组合键。

保存上面的代码到名为“ri20min.rb”的文件中，并使用“ruby ri20min.rb”的命令执行它。程序输出如下：

　　下面我们将深入了解一下上面的代码。

　　请注意上面代码中的起始行，它以#开头。在Ruby语言中，任何以#开头的行都被视为注释，并被解释程序忽略。

　　我们的say_hi方法已经发生了变化：

　　它查找@names参数并按照其参数值作出决定：

　　如果参数值为nil，它将打印三个圆点。

　　那么@names.respond_to?("each")表示什么?

循环——也叫迭代

　　如果@names对象具有each方法，那么它是可以被迭代的，进而可以对其进行迭代，从而问候列表中每个人。如果@names不具备each方法，则将它自动转换为字符串，并执行默认的问候。

　　each是一种方法，它接受一个代码块(block of code)，然后针对列表中的每个成员执行这个代码块，而在do和end之间的部分便是这个非常类似匿名函数的代码块。在管道符之间的变量是代码块的参数name，它作为代码块参数被绑定为列表成员，而代码块puts "Hello #{name}!"将使用这个参数进行输出。

　　大多数其它的编程语言使用循环遍历列表，下面是C语言的循环示例：

　　上面的代码显然可以工作，但它不够“优雅”!你不得不用i这个多余的循环变量，还需要指出列表的长度，然后再解释如何遍历列表。

　　Ruby的迭代方式则更加优雅，所有的内部管理细节都隐藏在each方法中，你所需做的就是告诉它如何处理其中的每个成员。

　　块(block)，Ruby边缘的高亮点!

　　块(block)的真正优势在于：能够处理比列表更加复杂的对象。除了在方法中可以处理简单的内部管理细节外，你还能处理setup、teardown和所有错误，而不让用户有所察觉。

　　say_bye方法没有使用each，而是检查@names是否具有join方法，如果具有join方法，则调用join方法。否则它将直接打印@names变量。

　　此方法并不关心变量的实际类型，这依赖于它所支持的那些被称为“Duck Typing”的方法：duck typing是动态类型的一种形式：变量的值自身隐含地决定了了变量的行为。这暗示了某个对象与其它实现了相同接口的对象之间是可交换的，不管对象之间是否具有继承关系。鸭子测试(duck test)是对duck typing的一种形象比喻——“如果它走路像鸭子，那么也一定像鸭子一样呷呷地叫，那么它必定是一只鸭子”。duck typing是某些编程语言的特性：如Smalltalk, Python, Ruby, ColdFusion。

　　Duck Typing的益处是无需对变量的类型进行严格地限制，如果某人使用一种新类型的列表类，只要它实现了与其它列表相同语义的join方法，便可以拿来使用。

启动脚本

　　文件上半部分是MegaGreeter类的代码，而后面剩下的部分则是对这些类方法的调用。而这是我们最后值得注意的一点：

　　__FILE__是一个“具有魔力”的变量，它代表了当前文件名。$0是用于启动程序的文件名。那么代码“if __FILE__ == $0”便意味着检查此文件是否为将被使用的主程序文件。这样做可以使程序文件作为代码库使用，而不是可执行代码;但当此文件被用作执行文件时，也可被执行。

　　如何进一步学习Ruby

　　到此便是本入门的尾声了。当然还有许多值得浏览的：Ruby提供的各种不同的控制结构;块和yield的使用;模块作为mixins使用等。希望这次Ruby初体验能使你对Ruby更感兴趣。

　　注：mixin在面向对象编程语言中是一种提供某些功能给子类继承的类，但mixin并不能实例化。从某个mixin继承并不是什么特殊的形式，而它更适于收集功能。某个子类甚至可以通过继承一个或者多个mixin选择继承它的全部或者多数功能。一个mixin能延期定义和绑定方法直到运行时，而属性和实例参数也将在编译时才被定义。这不同于多数常见的方式：定义所有的属性、方法，并在编译时进行初始化。

　　如果这样的话，请埋头翻阅我们的文档，那里有免费、丰富的在线手册和入门资源。或者如果你喜欢在啃书本的话，可以到图书列表中选择一些你所需要的。

版权声明：需Matrix授权发布,如需转载请联系Matrix


调试过的代码：

irb(main):001:0> "Hello World"

=> "Hello World"

irb(main):002:0> puts "hello world"

hello world

=> nil

irb(main):003:0> 3+2

=> 5

irb(main):004:0> def h

irb(main):005:1>   puts "hello world"

irb(main):006:1>   end

=> nil

irb(main):007:0> h

hello world

=> nil

irb(main):008:0> h()

hello world

=> nil

irb(main):009:0> def h(name)

irb(main):010:1>   puts "hello #{name}!"

irb(main):011:1>   end

=> nil

irb(main):012:0> h("keywen")

hello keywen!

=> nil

irb(main):013:0> def h(name = "keywen")

irb(main):014:1>   puts "hello #{name.capitalize}"

irb(main):015:1>   end

=> nil

irb(main):016:0> h"wen"

hello Wen

=> nil

irb(main):017:0> h

hello Keywen

=> nil

irb(main):018:0> class Greeter

irb(main):019:1>   def initialize (name ="keywen")

irb(main):020:2>     @name = name

irb(main):021:2>     end

irb(main):022:1>   def say_hi

irb(main):023:2>     puts "Hi #{@name}!"

irb(main):024:2>     end

irb(main):025:1>   def say_bye

irb(main):026:2>     puts "Bye #{@name},come back soon."

irb(main):027:2>     end

irb(main):028:1>   end

=> nil

irb(main):029:0> g = Greeter.new("Pat")

=> #<Greeter:0x7237aec @name="Pat">

irb(main):031:0> g.say_hi

Hi Pat!

=> nil

irb(main):032:0> g.say_bye

Bye Pat,come back soon.

=> nil

irb(main):034:0> Greeter.instance_methods

=> ["inspect", "clone", "public_methods", "display", "instance_variable_defined?", "equal?", "freeze", "methods", "respond_to?", "dup", "to_yaml_style", "instance_variables", "__id__", "eql?", "method", "pretty_print_inspect", "say_hi", "id", "send", "singleton_methods", "taint", "to_yaml_properties", "instance_variable_get", "frozen?", "instance_of?", "__send__", "to_a", "say_bye", "to_yaml", "type", "require_gem", "object_id", "instance_eval", "protected_methods", "require", "==", "h", "===", "taguri", "pretty_print_instance_variables", "instance_variable_set", "extend", "kind_of?", "pretty_print_cycle", "to_s", "gem", "taguri=", "class", "hash", "private_methods", "=~", "tainted?", "untaint", "nil?", "pretty_inspect", "is_a?", "pretty_print"]

irb(main):035:0> Greeter.instance_methods(false)

=> ["say_bye", "say_hi"]

irb(main):038:0> g.respond_to?("name")

=> false

irb(main):039:0> g.respond_to?("say_bye")

=> true

irb(main):040:0> g

=> #<Greeter:0x7237aec @name="Pat">

irb(main):041:0> class Greeter

irb(main):042:1>   attr_accessor:name

irb(main):043:1>   end

=> nil

irb(main):047:0> g = Greeter.new("keywen")

=> #<Greeter:0x71cef74 @name="keywen">

irb(main):048:0> g.respond_to?("name")

=> true

irb(main):049:0> g.respond_to?("name=")

=> true

irb(main):050:0> g.say_hi

Hi keywen!

=> nil

irb(main):051:0> g.name="wen"

=> "wen"

irb(main):052:0> g.say_hi

Hi wen!

=> nil

irb(main):053:0>

From Aptana

This page describes how to integrate RadRails into your installed version of Aptana.

Introduction

Add RadRails as a plugin to Eclipse v3.2 with Aptana to create a well-integrated IDE for JavaScript and Ruby. Make sure that you have Ruby and Rails installed before installing RadRails. See Installing Ruby on Rails for instructions.

Instructions

To add RadRails to Eclipse:

1.       From the Help menu, select Find and Install... to open the Install/Update wizard.

2.       On the Install/Update window, choose the Search for new features to install option.

3.       Add the two RadRails remote sites to Aptana.

a.       Click the New Remote Site... button to open a New Update Site pop-up window.

b.       In the New Update Site pop-up window, type "RadRails Release" in the Name field, and copy and paste the URL "http://updatesite.rubypeople.org/release" into the URL field.

c.       Click OK.

d.       Click the New Remote Site... button to add the second remote site for RadRails.

e.       In the New Update Site pop-up window, type "RadRails Update" in the Name field, and copy and paste the URL "http://radrails.sourceforge.net/update" into the URL field.

f.        Click OK.

4.       Choose the RadRails plugin(s) that you will be installing.

a.       On the Update sites to visit screen, check the boxes next to the two RadRails plugins.

b.       Click the Finish button.

Aptana displays a Search Results screen for the plugin that you selected.

5.       Install the plugin

a.       On the Search Results screen, check the boxes next to the RadRails plugins that you are installing and check the Show the latest version of a feature only box.

b.       Click the Next button to go to the Feature License screen.

c.       On the Feature License screen, choose the option for I accept the terms of the license agreement.

d.       Click the Next button to go to the Installation screen.

e.       Click the Finish button.

After a few seconds, a Verification pop-up window opens.

f.        On the Verification pop-up window, click the Install All button.

Aptana installs the plugin and prompts you to restart your workbench.

6.       On the prompt to restart your workbench prompt, click the Yes button to restart your workbench. If you click the No button, your changes will not take effect until you restart.

Ruby on Rails在windows下开发环境的搭建

 Ruby On Rails是在Ruby语言基础上的完成的web应用开发框架。下面介绍了本地安装ruby on rails的过程。

• 
  安装方法1
  
  注意：这是一种很麻烦的安装过程，建议下面的使用方法2
  
  

1. 下载ruby: 可以下载windows安装版，是一个可执行的安装文件。下载地址：
   
   http://rubyforge.org/frs/?group_id=167 该网站也有其他平台下的安装程序，然后安装即可。
2. 下载rails 及其插件: 其对应的地址如下：
   
   

   rails  http://rubyforge.org/frs/?group_id=307

   activesupport  http://rubyforge.org/frs/?group_id=570&release_id=4814

   rake  http://rubyforge.org/frs/?group_id=50&release_id=4770

   activerecord  http://rubyforge.org/frs/?group_id=182&release_id=5776

   actionmailer  http://rubyforge.org/frs/?group_id=361&release_id=5827

   actionpack  http://rubyforge.org/frs/?group_id=249&release_id=4816

   actionwebservice: http://rubyforge.org/frs/?group_id=567&release_id=5830

   下载后为了安装方便，可以放在同一目录下比如D:\RoR\

   
   
3. 安装rails : 依次安装插件，最后安装rails，插件之间有次序关系，但如果次序错误，系统会自动提示，安装语法如下：gem instll actionpack ，gen instll actionmailer 等等。
   
4. 在命令行下输入命令: ruby –v 查看ruby版本信息
   
   Rails blog 建立rails的一个工作目录，如果都运行正确的话，说明安装成功。
   

   运行Rails Blog后，系统会在当前目录下建立一个blog目录，这一目录下还包含许多子目录和文件，包括app目录，我们程序的主要部分；config目录：存储诸如数据库联接信息等配制;doc目录：生成对程序的文档；public目录：包括程序使用的资源文件，比如images，javascript等；log目录：程序运行时的log；vender目录：存放第三方的开发程序包。

   进入blog目录下输入命令： ruby script/server，然后打开浏览器，输入：http://localhost:3000则看到缺省的网页画面，实际上这一命令执行了rails自带的一个叫做webrick的小型web服务器，端口为3000。开发的时候用它来测试时比较方便的。
   
   
   

• 安装方法2
  
  建议：开始之时我用的以上的方法，这种其实很是麻烦，因为在下载文件时会下载不同版本的文件，最后在安装的时候可能产生文件没有对应上的问题，如果你的网络条件好的话，建议你可以选择远程自动安装 ，在console中D:\RoR的目录下执行gem install rails --include -independencices命令，然后就等着出现下面的信息
  
  D:\RoR>gem install rails --include -independencices
  Bulk updating Gem source index for: http://gems.rubyforge.or
  Successfully installed rails-1.2.3
  Successfully installed activesupport-1.4.2
  Successfully installed activerecord-1.15.3
  Successfully installed actionpack-1.13.3
  Successfully installed actionmailer-1.3.3
  Successfully installed actionwebservice-1.2.3
  Installing ri documentation for activesupport-1.4.2...
  Installing ri documentation for activerecord-1.15.3...
  Installing ri documentation for actionpack-1.13.3...
  Installing ri documentation for actionmailer-1.3.3...
  Installing ri documentation for actionwebservice-1.2.3...
  Installing RDoc documentation for activesupport-1.4.2...
  Installing RDoc documentation for activerecord-1.15.3...
  Installing RDoc documentation for actionpack-1.13.3...
  Installing RDoc documentation for actionmailer-1.3.3...
  Installing RDoc documentation for actionwebservice-1.2.3...
  
  
  或者C:\的目录下执行gem install rails --remote命令
  
  C:\>gem install rails --remote
  Need to update 20 gems from http://gems.rubyforge.org
  ....................
  complete
  Install required dependency activesupport? [Yn]  y
  Install required dependency activerecord? [Yn]  y
  Install required dependency actionpack? [Yn]  y
  Install required dependency actionmailer? [Yn]  y
  Install required dependency actionwebservice? [Yn]  y
  Successfully installed rails-1.2.3
  Successfully installed activesupport-1.4.2
  Successfully installed activerecord-1.15.3
  Successfully installed actionpack-1.13.3
  Successfully installed actionmailer-1.3.3
  Successfully installed actionwebservice-1.2.3
  Installing ri documentation for activesupport-1.4.2...
  Installing ri documentation for activerecord-1.15.3...
  Installing ri documentation for actionpack-1.13.3...
  Installing ri documentation for actionmailer-1.3.3...
  Installing ri documentation for actionwebservice-1.2.3...
  Installing RDoc documentation for activesupport-1.4.2...
  Installing RDoc documentation for activerecord-1.15.3...
  Installing RDoc documentation for actionpack-1.13.3...
  Installing RDoc documentation for actionmailer-1.3.3...
  Installing RDoc documentation for actionwebservice-1.2.3...
  
  
  这样就安装ok了，而且好的是安装的都是最新版本的文件，只是网络经常出问题，看运气了。

Ruby On Rails是一个在Ruby语言基础上的完成的web应用开发框架。下面介绍了本地安装ruby on rails的过程。

安装方法1
注意：这是一种很麻烦的安装过程，建议下面的使用方法2

1、下载ruby:：可以下载windows安装版，是一个可执行的安装文件。下载地址：
http://rubyforge.org/frs/?group_id=167 该网站也有其他平台下的安装程序，然后安装即可

2、下载rails 及其插件:：其对应的地址如下：

rails  http://rubyforge.org/frs/?group_id=307

activesupport  http://rubyforge.org/frs/?group_id=570&release_id=4814

rake  http://rubyforge.org/frs/?group_id=50&release_id=4770

activerecord  http://rubyforge.org/frs/?group_id=182&release_id=5776

actionmailer  http://rubyforge.org/frs/?group_id=361&release_id=5827

actionpack  http://rubyforge.org/frs/?group_id=249&release_id=4816

actionwebservice: http://rubyforge.org/frs/?group_id=567&release_id=5830

下载后为了安装方便，可以放在同一目录下比如D:\RoR\

3、安装rails :：依次安装插件，最后安装rails，插件之间有次序关系，但如果次序错误，系统会自动提示，安装语法如下：gem instll actionpack ，gen instll actionmailer 等等。
4、在命令行下输入命令:：ruby –v 查看ruby版本信息

Rails blog 建立rails的一个工作目录，如果都运行正确的话，说明安装成功。

运行Rails Blog后，系统会在当前目录下建立一个blog目录，这一目录下还包含许多子目录和文件，包括app目录，我们程序的主要部分；config目录：存储诸如数据库联接信息等配制;doc目录：生成对程序的文档；public目录：包括程序使用的资源文件，比如images，javascript等；log目录：程序运行时的log；vender目录：存放第三方的开发程序包。