rubyinstaller for windows

　　rubyinstaller是一款搭建Ruby环境工具软件，RubyInstaller项目的目标是为Windows系统上的用户和开发人员提供一种简单的方法来快速开始使用Ruby，方法是提供一个Windows安装程序，其中包含针对Windows系统调整的功能齐全的基线MRI（Matz'Ruby Implementation）Ruby环境；虽然One-Click Ruby安装程序允许使用Ruby的标准RubyGems打包系统轻松增强和定制它们的Ruby安装，但系统还提供了诸如开发工具包之类的工具，使用户和开发人员能够在其本地Windows系统上构建本机Ruby C扩展；虽然在Windows上构建本机Ruby C扩展历来是一个问题，但系统提供的一键式Ruby安装程序，系统的开发工具和不断增长的Ruby on Windows用户和项目社区的组合将有助于使这成为过去的事情。强大又实用，需要的用户可以下载体验

官方介绍

　　Ruby是由一种开源的为简单快捷的面向对象编程（面向对象程序设计）而创的脚本语言，在20世纪90年代中期由日本的松本行弘（まつもとゆきひろ/Yukihiro Matsumoto）设计并开发而来，Ruby主要归根于Perl和Python两类语言（与C，C++，C#，java是不同大类），遵守GPL协议和Ruby License。目前Ruby可运行于多种平台，如 Windows、MAC OS 和 UNIX 的各种版本，在这里小编主要针对的是windows下Ruby编程语言的环境的配置与使用！

软件功能

　　Ruby是一种通用的、解释的编程语言。

　　Ruby是一种真正的面向对象编程语言。

　　Ruby可以安装在Windows和POSIX环境中。

　　Ruby可以被嵌入到超文本标记语言（HTML）。

　　Ruby可以用来编写通用网关接口（CGI）脚本。

　　Ruby可扩展性强，用Ruby编写的大程序易于维护。

软件特色

　　Ruby可用于开发的Internet和Intranet应用程序。

　　Ruby与C++和Perl等许多编程语言有着类似的语法。

　　Ruby支持许多GUI工具，比如Tcl/Tk、GTK和OpenGL。

　　Ruby是一种类似于Python和Perl的服务器端脚本语言。

　　Ruby有丰富的内置函数，可以直接在Ruby脚本中使用。

　　Ruby是开源的，在Web上免费提供，但需要一个许可证。

　　Ruby可以很容易地连接到DB2、MySQL、Oracle和Sybase。

　　Ruby语法简单，这使得新的开发人员能够快速轻松地学习Ruby。

安装步骤

　　1、浏览至此，需要的用户可以点击本网站提供的下载路径下载得到对应的程序安装包

　　2、通过解压功能将压缩包打开，找到主程序，双击主程序即可进行安装

　　3、需要完全同意上述协议的所有条款，才能继续安装应用程序，如果没有异议,请点击“同意”按钮

　　4、用户可以根据自己的需要点击浏览按钮将应用程序的安装路径进行更改

　　注意，在安装时，将系统变量，变量值等均加入到系统环境中，通过选择即可，如下图所示：

　　5、等待应用程序安装进度条加载完成即可，需要等待一小会儿

　　6、根据提示点击安装，弹出程序安装完成界面，点击完成按钮即可

配置方法

　　注意，在安装时，将系统变量，变量值等均加入到系统环境中，通过选择即可，如下图所示：

　　如果您没有选择上述选项，也可以手动进行系统环境的配置，方法如下：（以win7为例）

　　①右键单击“我的电脑”图标，选择“属性”按钮，选择“高级系统设置”选项

　　②选择“高级”选项卡中的“环境变量”属性

　　③在系统变量下，选择 Path，并点击 EDIT，在变量值列表的末尾添加 Ruby 目录，并点击 OK

　　④然后同样在系统变量下，选择 PATHEXT，并点击 EDIT。添加 .RB 和 .RBW 到变量值列表中，并点击 OK即可！

　　下面，您只需要一个流行的ruby编辑器即可，您可以使用任何简单的文本编辑器，比如 Notepad 或 Edit plus等，简单输出“hello world!”示例

使用说明

　　lass Array

　　数组是有序的，任何对象的整数索引集合。

　　数组索引从0开始，如在C或Java中。假定负索引相对于数组的末尾 - 也就是说，索引-1表示数组的最后一个元素，-2是数组中最后一个元素的倒数，依此类推。

　　创建数组

　　可以使用文字构造函数[]创建新数组。数组可以包含不同类型的对象。例如，下面的数组包含一个Integer，一个String和一个Float：

　　ary = [1，“two”，3.0]＃=> [1，“two”，3.0]

　　也可以通过显式调用:: new with zero，one（Array的初始大小）或两个参数（初始大小和默认对象）来创建数组。

　　ary = Array.new＃=> []

　　Array.new（3）＃=> [nil，nil，nil]

　　Array.new（3，true）＃=> [true，true，true]

　　请注意，第二个参数使用对同一对象的引用填充数组。因此，仅在需要使用本机不可变对象（如符号，数字，true或false）实例化数组时才建议使用它。

　　要创建具有单独对象的数组，可以传递块。此方法可以安全地与可变对象（如哈希，字符串或其他数组）一起使用：

　　Array.new（4）{Hash.new}＃=> [{}，{}，{}，{}]

　　这也是构建多维数组的快速方法：

　　empty_table = Array.new（3）{Array.new（3）}

　　＃=> [[nil，nil，nil]，[nil，nil，nil]，[nil，nil，nil]]

　　也可以使用由Kernel提供的Array（）方法创建数组，该方法尝试调用to_ary，然后调用to_a的参数。

　　数组（{：a =>“a”，：b =>“b”}）＃=> [[：a，“a”]，[：b，“b”]]

示例用法

　　除了通过Enumerable模块混合的方法之外，Array类还具有访问，搜索和操作数组的专有方法。

　　一些较常见的如下图所示。

　　访问元素

　　可以使用Array＃[]方法检索数组中的元素。它可以采用单个整数参数（数字索引），一对参数（开始和长度）或范围。负指数从结束开始计数，-1表示最后一个元素。

　　arr = [1,2,3,4,5,6]

　　arr [2]＃=> 3

　　arr [100]＃=>零

　　arr [-3]＃=> 4

　　arr [2,3]＃=> [3,4,5]

　　arr [1..4]＃=> [2,3,4,5]

　　arr [1 ..- 3]＃=> [2,3,4]

　　访问特定数组元素的另一种方法是使用at方法

　　arr.at（0）＃=> 1

　　slice方法以与Array＃[]相同的方式工作。

　　要为数组边界之外的索引引发错误，或者在发生这种情况时提供默认值，可以使用fetch。

　　arr = ['a'，'b'，'c'，'d'，'e'，'f']

　　arr.fetch（100）＃=> IndexError：数组边界外的索引100：-6 ... 6

　　arr.fetch（100，“oops”）＃=>“oops”

　　first和last的特殊方法将分别返回数组的第一个和最后一个元素。

　　arr.first＃=> 1

　　arr.last＃=> 6

　　要返回数组的前n个元素，请使用take

　　arr.take（3）＃=> [1,2,3]

　　drop与take相反，通过在删除n个元素后返回元素：

　　arr.drop（3）＃=> [4,5,6]

　　获取有关数组的信息

　　阵列始终跟踪自己的长度。要查询有关其包含的元素数的数组，请使用长度，计数或大小。

　　browsers = ['Chrome'，'Firefox'，'Safari'，'Opera'，'IE']

　　browsers.length＃=> 5

　　browsers.count＃=> 5

　　检查数组是否包含任何元素

　　browsers.empty？ ＃=> false

　　检查特定项是否包含在数组中

　　browsers.include？（'Konqueror'）＃=> false

　　将项添加到数组

　　可以使用push或＃<<将项添加到数组的末尾

　　arr = [1,2,3,4]

　　arr.push（5）＃=> [1,2,3,4,5]

　　arr << 6＃=> [1,2,3,4,5,6]

　　unshift将在数组的开头添加一个新项。

　　arr.unshift（0）＃=> [0,1,2,3,4,5,6]

　　使用insert，您可以在任何位置向数组添加新元素。

　　arr.insert（3，'apple'）＃=> [0,1,2，'apple'，3,4,5,6]

　　使用insert方法，您还可以一次插入多个值：

　　arr.insert（3，'orange'，'pear'，'grapefruit'）

　　＃=> [0,1,2，“橙色”，“梨”，“葡萄柚”，“苹果”，3,4,5,6]

　　从数组中删除项目

　　方法pop删除数组中的最后一个元素并返回它：

　　arr = [1,2,3,4,5,6]

　　arr.pop＃=> 6

　　arr＃=> [1,2,3,4,5]

　　要检索并同时删除第一个项目，请使用shift：

　　arr.shift＃=> 1

　　arr＃=> [2,3,4,5]

　　要删除特定索引处的元素：

　　arr.delete_at（2）＃=> 4

　　arr＃=> [2,3,5]

　　要删除数组中任何位置的特定元素，请使用delete：

　　arr = [1,2,2,3]

　　arr.delete（2）＃=> 2

　　arr＃=> [1,3]

　　如果需要从数组中删除nil值，一个有用的方法是紧凑的：

　　arr = ['foo'，0，nil，'bar'，7，'baz'，nil]

　　arr.compact＃=> ['foo'，0，'bar'，7，'baz']

　　arr＃=> ['foo'，0，nil，'bar'，7，'baz'，nil]

　　arr.compact！ ＃=> ['foo'，0，'bar'，7，'baz']

　　arr＃=> ['foo'，0，'bar'，7，'baz']

　　另一个常见的需求是从数组中删除重复的元素。

　　它具有非破坏性的uniq和破坏性方法uniq！

　　arr = [2,5,6,556,6,6,8,9,0,123,556]

　　arr.uniq＃=> [2,5,6,556,8,9,0,123]

迭代数组

　　与包含Enumerable模块的所有类一样，Array有一个每个方法，它定义了应该迭代哪些元素以及如何迭代。如果是每个Array，则Array实例中的所有元素将按顺序提供给提供的块。

　　请注意，此操作会使数组保持不变。

　　arr = [1,2,3,4,5]

　　arr.each {| a |打印a - = 10，“”}

　　#prints：-9 -8 -7 -6 -5

　　＃=> [1,2,3,4,5]

　　另一个有时有用的迭代器是reverse_each，它将以相反的顺序迭代数组中的元素。

　　words =％w [第一第二第三第四第五第六]

　　str =“”

　　words.reverse_each {| word | str + =“＃{word}”}

　　p str＃=>“第六第五第四第三第二第一”

　　map方法可用于基于原始数组创建新数组，但使用提供的块修改的值：

　　arr.map {| a | 2 * a}＃=> [2,4,6,8,10]

　　arr＃=> [1,2,3,4,5]

　　arr.map！ {| a | a ** 2}＃=> [1,4,9,16,25]

　　arr＃=> [1,4,9,16,25]

　　从数组中选择项目

　　可以根据块中定义的标准从数组中选择元素。选择可以以破坏性或非破坏性方式发生。虽然破坏性操作将修改它们被调用的数组，但非破坏性方法通常会返回带有所选元素的新数组，但保持原始数组不变。

　　非破坏性选择

　　arr = [1,2,3,4,5,6]

　　arr.select {| a | a> 3}＃=> [4,5,6]

　　arr.reject {| a | a <3}＃=> [3,4,5,6]

　　arr.drop_while {| a | a <4}＃=> [4,5,6]

　　arr＃=> [1,2,3,4,5,6]

　　破坏性选择

　　选择！拒绝！是相应的选择和拒绝的破坏性方法

　　类似于select与reject，delete_if和keep_if在提供相同块时具有完全相反的结果：

　　arr.delete_if {| a | a <4}＃=> [4,5,6]

　　arr＃=> [4,5,6]

　　arr = [1,2,3,4,5,6]

　　arr.keep_if {| a | a <4}＃=> [1,2,3]

　　arr＃=> [1,2,3]

　　在文件中

　　array.c

　　pack.c

　　宾语

　　包含的模块

　　枚举

　　公共类方法

　　[]（* args）点击切换源

　　返回使用给定对象填充的新数组。

　　数组。[]（1，'a'，/ ^ A /）＃=> [1，“a”，/ ^ A /]

　　数组[1，'a'，/ ^ A /]＃=> [1，“a”，/ ^ A /]

　　[1，'a'，/ ^ A /]＃=> [1，“a”，/ ^ A /]

　　静态VALUE

　　rb_ary_s_create（int argc，VALUE * argv，VALUE klass）

　　{VALUE ary = ary_new（klass，argc）;

　　if（argc> 0 && argv）{

　　ary_memcpy（ary，0，argc，argv）;

　　ARY_SET_LEN（ary，argc）;}

　　归来} new（size = 0，default = nil）单击以切换源

　　新的（阵列）

　　new（size）{| index |块}

　　返回一个新数组。

　　在第一种形式中，如果没有发送参数，则新数组将为空。发送大小和可选默认值时，将创建一个包含默认大小副本的数组。请注意，所有元素都将引用相同的默认对象。

　　第二种形式创建作为参数传递的数组的副本（通过在参数上调用#to_ary生成数组）。

　　first_array = [“Matz”，“Guido”]

　　second_array = Array.new（first_array）＃=> [“Matz”，“Guido”]

　　first_array.equal？ second_array＃=> false

　　在最后一种形式中，创建了给定大小的数组。通过将元素的索引传递给给定块并存储返回值来创建此数组中的每个元素。

　　Array.new（3）{| index | index ** 2}

　　＃=> [0,1,4]

　　常见问题

　　发送第二个参数时，同一个对象将用作所有数组元素的值：

　　a = Array.new（2，Hash.new）

　　＃=> [{}，{}]

　　a [0] ['cat'] ='猫'

　　a＃=> [{“cat”=>“feline”}，{“cat”=>“feline”}]

　　a [1] ['cat'] ='Felix'

　　a＃=> [{“cat”=>“Felix”}，{“cat”=>“Felix”}]

　　由于所有Array元素都存储相同的哈希值，因此对其中一个哈希值的更改将影响它们。

　　class BasicObject

　　BasicObject是Ruby中所有类的父类。这是一个明确的空白类。

　　BasicObject可用于创建独立于Ruby的对象层次结构的对象层次结构，代理对象（如Delegator类）或其他必须避免使用Ruby方法和类的命名空间污染的用法。

　　为了避免为其他用户污染BasicObject，应该创建一个适当命名的BasicObject子类，而不是直接修改BasicObject：

　　class MyObjectSystem

　　结束

　　BasicObject不包含内核（对于像puts这样的方法），而BasicObject在标准库的名称空间之外，因此如果不使用完整的类路径，将无法找到常见的类。

　　可以使用各种策略向BasicObject的子类提供标准库的有用部分。子类可以包含内核以获取puts，exit等。可以创建和包含自定义内核类模块，也可以通过method_missing使用委托：

　　class MyObjectSystem

　　DELEGATE = [：puts，：p]

　　def method_missing（name，* args，＆block）

　　超级除非DELEGATE.include？名称

　　:: Kernel.send（name，* args，＆block）

　　结束

　　def respond_to_missing？（name，include_private = false）

　　DELEGATE.include？（名称）或超级

　　结束

　　通过从类似:: File或:: Enumerator引用所需的常量，可以在BasicObject子类中获取对Ruby标准库中的类和模块的访问。与method_missing一样，const_missing可用于将常量查找委托给Object