RubyInstaller for Windows 编程语言 V2.2.3

RubyInstaller官方版是一款界面清晰、专业好用、安全可靠的编程环境搭建程序，RubyInstaller软件界面简洁大方，功能实用，其是专门针对搭建Ruby环境而开发，Ruby语言一般开发效率是JAVA的5倍，如果你想学习这种语言，可以先用RubyInstaller正式版搭配环境，使用起来非常的简单。

RubyInstaller软件功能

完全面向对象

在Ruby语言中，任何东西都是对象，包括其他语言中的基本数据类型，比如整数

变量没有类型

Ruby的变量可以保存任何类型的数据。

任何东西都有值

不管是数学或者逻辑表达式还是一个语句，都会有值。

ruby语言很优雅，可以做到不需要注释就可以读懂。

RubyInstaller软件特色

语法的使用是相当的简单

支持对普通的对象面向的功能

也可以对加载符进行重新的加载

也支持对错误的功能进行处理

也可对垃圾进行快速的回收

也支持对动态进行快速的载入

RubyInstaller安装方法

1、这本站下载站将您需要的附件包进行快速的下载，解压之后，点击RubyInstaller-2.3.3-x64.exe进行快速的安装；

2、可以快速的选择软件的安装过程中使用的语音，点击OK；

3、点击我接受软件的许可协议，点击Next；

4、可以对软件的安装位置进行选择，默认位置“C:Ruby23-x64”，建议安装在D盘，点击Install；

5、RubyInstaller正在进行快速的安装，请耐心等待........

6、RubyInstaller已经安装完成，点击Finish即可完成安装；

RubyInstaller配置方法

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

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

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

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

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

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

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

RubyInstaller使用说明

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”]]

RubyInstaller示例用法

除了通过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]

RubyInstaller迭代数组

与包含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]

RubyInstaller常见问题

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

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