向字符串末尾追加字符

向字符串末尾追加字符时， 使用 String#concat 或 << 运算符(String#<<)

s = 'abc' s.concat('def') p s #=> "abcdef" s = 'abc' s << 'def' p s #=> "abcdef"

<< 运算符还可以有以下的写

s = '' s << 'abc' <<　'def' p s #=> "abcdef"

当然，如果使用 += 运算符也会达到以上的相同效果， 但是 ruby 并不建意使用此方 法。 为什么呢？ 让我们来看看内存是如何工作的。

+= 方法	concat 方法
XXX|	XXX|
XXX| XXX|XXX|	XXX|XXX|
XXX| XXX|XXX| XXX|XXX|XXX|	XXX|XXX|XXX|

+= 方法是先复制原字符串后，在复本字符串尾部追加。 这种方法会吃掉大量的内存。 而 concat 方法是直接在原字符串尾部追加。我们在来测试一下两种方法的速度

# 约 30 秒 box = '' 50000.times{ box += 'xxx|' } # 约 0.05 秒 box = '' 50000.times{ box.concat('xxx|') }

Ruby 问题集(更新中)

1. 生成100个0到99之间的随机整数，找出它们之中的最大者和最小者，并统计大于50的整数个数

2. 1到11有4个"1"，1中一个"1"，10中一个"1"，11中两个"1"，1000中，有多少个"1"

3. 一个for语句循环10次产生10个100以内的随机数，要求数字不为0和不重复

4. 输入一个字符串，按相反顺序输出该字符串。如输入1234，输出4321。

5. 首先把你的生日列出来比如 1987/12/25。然后一位位的相加 1+9+8+7+1+2+2+5=35 把得出的数字再拆分，再加 3＋5＝8 最后向屏幕输出：8

6. 每只母鸡3元，每只公鸡4元，每只小鸡0.5元，如果花100元钱买100只鸡，请问有哪些可能？说明：每种鸡的数量都可以为零

7. 共有1000瓶汽水，每喝完后一瓶得到的一个空瓶子，每3个空瓶子又能换1瓶汽水，喝掉以后又得到一个空瓶子，问总共能喝多少瓶汽水，最后还剩余多少个空瓶子

8. 水仙花数指三位数中，每个数字的立方和和自身相等的数字，例如370，3 × 3 × 3 + 7 × 7 × 7 + 0 × 0 × 0 =370，请输出所有的水仙花数

9. 如果苹果 1元/个， 桔子 2 元/个， 芒果 4元/个，若是用10元去买，有几种组合呢？

10. 一只猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个,第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个，第10天早上想再吃时，发现只剩下一个桃子了。请问猴子第一天一共摘了多少个桃子？

删除行末的换行符或回车符

删除行末的换行符或回车符， 使用 String#chomp

p "line\n".chomp    #=> "line" p "line\r\n".chomp    #=> "line" p "line\r".chomp    #=> "line" p "line \t\n".chomp    #=> "line \t" p "line".chomp    #=> "line"

但是， 有时只想删除 \r\n 并不想删除 独立的 \r 或 \n 时，可以对 String#chomp的 删除模式进行设置

$\ = "\r\n" p "line\n".chomp    #=> "line\n" p "line\r\n".chomp    #=> "line" p "line\r".chomp    #=> "line\r" p "line \t\n".chomp    #=> "line \t\n" p "line".chomp    #=> "line"

还可以为 String#chomp 添加参数， 来实现将在已经设定模式内的某一字符删除

$\ = "\r\n" p "line\n".chomp("\n")    #=> "line" p "line\r\n".chomp("\n")    #=> "line" p "line\r".chomp("\n")    #=> "line" p "line \t\n".chomp("\n")    #=> "line \t" p "line".chomp("\n")    #=> "line"

在对一些文本文件进行处理时， 行末不仅有回车，还会有空格等字符。如果想一并删 除时， 使用 String#rstrip

p "line\n".rstrip    #=> "line" p "line\r\n".rstrip    #=> "line" p "line\r".rstrip    #=> "line" p "line\t \n".rstrip    #=> "line" p "line".rstrip    #=> "line"

字符的替换

查找到的第一个匹配字符进行替换， 使用 String#sub 所用匹配字符进行替换， 使用 String#gsub

p '字符字符字符'.sub(/字符/, 'zifu')    #=> "zifu字符字符" p '字符字符字符'.gsub(/字符/, 'zifu')    #=> "zifuzifuzifu"

sub 和 gsub 自身还代有 block 功能， 所以即使替换字符不是固定的字符，也可以 进行替换

queue = %w(我 爱 你) p '字符字符字符'.sub(/字符/) {queue.shift}    #=> "我字符字符" queue = %w(我 爱 你) p '字符字符字符'.gsub(/字符/) {queue.shift}    #=> "我爱你"

在 block 形式中， 当前的匹配作为参数传递给 block ，并且适当地设置 $1, $2 等 变量， 每次调用传入的匹配都将被 block 的返回值所替换

p 'FrontPage'.sub(/（.）([A-Z])/) {$1+' '+$2}    #=> "Front Page" p 'MyToDo'.gsub(/（.）([A-Z])/) {$1+' '+$2}    #=> "My To Do"

另一种替换方法是， 使用 String#tr

p 'hello'.tr('aiueo', '#')    #=> "h#ll#" p 'hello'.tr('^aiueo', '#')    #=> "#e##o" p 'hello'.tr('el', 'ip')    #=> "hippo" p 'hello'.tr('a-y', 'b-z')    #=> "ifmmp"

还可以使用指定区域的方法进行替换, String#[]=

# 替换最前端的 1byet 字符 str = 'Numa-' str[0, 1] = 'K' p str    #=> "Kuma-"

字符串分割

使用正则表达则进行字符串分割， Sting#split

p '2003,11,21,字符串,ACB'.split(/,/)     #=> ["2003", "11", "21", "字符串", "ACB"]

设置 Sting#split 的第二参数， 可以设定最大分割的个数

p '2003,11,21,字符串,ACB'.split(/,/， 3)     #=> ["2003", "11", "21，字符串，ACB"]

如果分割符也想原样保留的情况， 可以使用正则表达式的 （）

p '2003,11,21,字符串,ACB'.split(/（,）/)     #=> ["2003", ",", "11", ",", "21", ",", "字符串", ",", "ACB"]

正则表达式模式

表达式	可匹配
\A	匹配字符串的开始
\b	匹配词边界
\B	匹配埋词边界
\d	匹配0~9 中的任意一个数字
\D	匹配所有的非数字字符
\n	匹配换行符
\r	匹配回车
\s	匹配空格、制表符等空白字符的其中任意一个字符
\S	匹配所有非空白字符（"\s" 可匹配各个空白字符）
\t	匹配制表符
\w	匹配字母或数字或下划线： A~Z, a~z, 0~9, _
\W	匹配所有的字母、数字、下划线以外的一个字符
\z	匹配字符串的结尾
\Z	如果字符串以\n结尾，那么匹配\n前面的那个字符
+	匹配1个或多个
*	匹配0个或多个
{m,n}	匹配最少 m 个最多 n 个
{m,}	匹配最少 m 个
{m}	匹配刚好 m 个
[]	匹配其中任意一个字符
[^]	匹配其中字符之外的任意一个字符
()	(1). 在被修饰匹配次数的时候，括号中的表达式可以作为整体被修饰。(2). 取匹配结果的时候，括号中的表达式匹配到的内容可以被单独得到
m|n	匹配 m 或者 n 。 | 的优先级很低
.	匹配除了换行符（\n）以外的任意一个字符
^	匹配行首。要匹配 "^" 字符本身，请使用 "\^"
$	匹配行尾
-	区间符。例 a-z , 从a到z之之间的所有字母
\	匹配
?	匹配

取出字符串中的一部分

在字符串中，从给定的起始位置开始， 任意长度的字符

p 'abcdefghi'[3..3]    #=> "def" (从3开始3byte)

同样也可以使用给定的起始位置和结束位置，来从字符串中取出这一区间的字符

p 'abcdefghi'[3..5]    #=> "def" p 'abcdefghi'[3...6]    #=> "def"

以上的方法都是以byte单位为进行计算的
下面使用正则表达式来实现

# 从 a 开始取出3个字符 p 'abcdefghi'.slice(/a../)    #=> "abc" p 'abcdefghi'.slice(/x../)    #=> nil # 将所有匹配字符取出 p 'static int fact(int n)'.scan(/\w+/)     #=> ["static", "int", "fact", "int", "n"]

字母大小写的转换

将字符串中的所有大写字母转换成小写 String#upcase, 将字符串中的所有小写字母转换成大写 String#downcase

p 'aBcDeFg-->'.upcase    #=> "ABCDEFG-->" p 'aBcDeFg-->'.downcase    #=> "abcdefg-->"

upcase 和 downcase 方法只对字母有效， 其它的字符会原样输出。 如果想将字符串中某一指定字母进行大小写转换时， 使用的方法是String#tr

p 'abcdefghijklmn'.tr('acegikm', 'ACEGIKM')     #=> "AbCdEfGhIjKlMn"

将字符串的首字符转换成大写字母， 使用的方法是String#capitalize

p 'this is a pen'.capitalize    #-> "This is a pen"

大小写字母的相互转换, 使用的方法是String#swapcase

p 'aBcDeFg-->'.swapcase    #-> "AbCdEfG-->"

判断字母的大小写

使用正则表达式 /a-z/ 和 /A-Z/ 来对字母的大小写进行判断

# 小写字母 def lower?(str)     /[a-z]/ =~ str end # 大写字母 def upper?(str)     /[A-Z]/ =~ str end p '小写字母' if lower?('abcdefg')    #=> "小写字母" p '大写字母' if upper?('ABCDEFG')    #=> "大写字母"

lower? 方法是，当字符串含有小写字母时，返回值为true, 否则为false. 如果字符串 中既含大写字母又含小写字母时，以上的写法就不适用了。方法更完善的写法是：

# 小写字母 def lower?(str)     /\A[a-z]\z/ =~ str end # 大写字母 def upper?(str)     /\A[A-Z]\z/ =~ str end str = 'aBcDeFg' if lower?(str)     p '小写字母' elsif upper?(str)     p '大写字母' else     p '无法识别' end #=> "无法识别"

有关 \A 和 \z 的介绍请查看 => 从首字符或尾字符开始的查找

字符串的比较

使用 == 比较两个字符串的意思是否一样。

p '字符串' == '字符串'    #=> true p '字符串' == '字符'    #=> false

大小写字母进行比较时，字母的大小写是有区别的。如果想无区分比较时，可以将两者 同时转化成大写或小写字母后在进行比较。大小写的转化使用 String#downcase

p 'ABC' == 'Abc'    #=> false p 'ABC'.downcase == 'Abc'.downcase    #=> true

也可以不区分大小写对字母进行比较

$= = true p 'ABC' == 'Abc'    #=> false

注:
    $= 这是一种过时的用法了（ruby1.8版本以前）， 意思为除 nil 和 false 之外的任意值。如果一但设置此模式，所有匹配将于大小写无关，字符串比较将忽略大小写，而且字符串的 hash 值也会忽略大小写。（不推荐使用）

不仅如此，使用还可以使用 >, <, >=, <= 对字母的大小进行比较

p 'a' > 'b'    #=> false p 'abc' < 'xyz'    #=> true

ruby的日期型

使用 Time 类生成取当前时刻的对象

day = Time.now (或Time.new) p day.to_s   #=> "Sun May 20 23:48:45 JST 2008" p day.year    #=> 2008 p day.month    #=> 5 p day.day    #=> 20 p day.hour    #=> 23 p day.min    #=> 48 p day.sec    #=> 45 p day.wday    #=> 0

使用Time.gm类生成GMT时区时间

day = Time.gm(2008, 5, 20, 23, 59, 59)   #=> Sun May 20 23:59:59 UTC 2008 day = Time.local(2008, 5, 20, 23, 59, 59)   #=> Sun May 20 23:59:59 JST 2008

strftime方法中任意时刻的格式化符号

%A: 星期的名称(如:Sunday, Monday ... )
%a: 星期的名称缩写(如:Sun, Mon ... )
%B: 月份的名称(如:January, February ... )
%b: 月份的名称缩写(如:Jan, Feb ... )
%c: 日期,时刻
%d: 日(01-31)
%H: 24小时制的时间(00-23)
%I: 12小时制的时间(01-12)
%j: 一年中的通算日(001-366)
%M: 分(00-59)
%m: 月(01-12)
%p: 午前和午后(AM,PM)
%S: 秒(00-60)
%w: 一周的天数,周日(0)开始算起(0-6)
%X: 时刻
%x: 日期
%Y: 阳历
%Z: 时区

day = Time.now p day.strftime("Now, %A %B %d %X %Z %Y")   #=> "Now, Sunday May 20 23:33:37 JST 2008"

时刻的加减

day = Time.local(2008, 5, 20, 23, 59, 59)   #=> Sun May 20 23:59:59 JST 2008 day = day + 1   #=>  Mon May 21 00:00:00 JST 2008 day = Time.local(2000, 12, 31, 0, 0, 0)   #=> Sun Dec 31 00:00:00 JST 2000 day = day + 24*60*60   #=>  Mon Jan 01 00:00:00 JST 2008

时刻的求时差

day1 = Time.local(2007, 12, 31, 0, 0, 0)   #=> Sun Dec 31 00:00:00 JST 2007 day2 = Time.local(2008, 1, 2, 12, 30, 0)   #=> Tue Jan 02 12:30:00 JST 2008 days = (day2 - day1).divmod(24*60*60)   #=> [2.0, 45000.0] hours = days[1].divmod(60*60)   #=> [12.0, 1800.0] mins = hours[1].divmod(60)   #=> [30.0, 0.0]

当前日期

require 'date' day = Date::new(2008, 5, 31) p day.to_s    #=> "2008-05-31"

昨天,前天

require 'date' day = Date.new(2008, 5, 31) day = day + 1 p day.to_s    #=> "2008-06-01" day = Date.new(2008, 1, 1) day = day - 1 p day.to_s    #=> "2007-12-31"

下月,上月

require 'date' day = Date.new(2008, 1, 31) day = day >> 1 p day.to_s     #=> "2008-2-28" day = Date.new(2008, 5, 31) day = day << 1 p day.to_s     #=> "2008-04-30"

闰年

require 'date' day = Date.new(2000) p day.leap?    #=> true day = Date.new(2001) p day.leap?    #=> false

日期的格式化

require 'date' day = Date::new(2008, 1, 31) p day.year    #=> 2008 p day.month    #=> 1 p day.day    #=> 31 p day.wday    #=> 3

ruby的数值型

2进制,8进制,16进制向数值型转换

p 0b10000    #=> 16 p 020    #=> 16 p 0x10    #=> 16

数值型向2进制,8进制,16进制转换

s = 255.to_s(2)    #=> "11111111" s = "%b" % 255    #=> "11111111" s = sprintf("%o", 255)    #=> "377" s = format("%x", 255)    #=> "ff"

求商和余数的计算

i = 10 p i % 3    #=> 1 p i.divmod(3)    #=> [3, 1]

求绝对值的计算

i = -5 p i.abs    #=> 5 i=100 p i.abs    #=> 100

返回比float大的最小整数

f = 3.4 p f.ceil    #=> 4

返回比float小的最大整数

f = 3.4 p f.truncate    #=> 3

四舍五入到一个整数

f1 = 3.4 f2 = 3.5 p f1.round    #=> 3 p f2.round    #=> 4

返回float截掉小数点后的整数

f = 3.48 p f.to_i    #=> 3

取得一个随机数

p rand(100)    #=> 17

ruby的运算符

顺序	运算符	意义
高 | | | | | | | | | | | | | | | | | | | | | | | | | | | 低	::	在定义嵌套的类和模块的类外可通过使用 ":" 对其访问
	[]	数组操作符
	!	返回操作数的相反值
	~	按位取反
	+(单)	正号
	**	幂
	-(单)	负号
	*	乘
	/	除
	%	取模
	+	加
	-	减
	<<	左移
	>>	右移
	&	位与
	|	位或
	^	位异或
	<	小于
	>	大于
	<=	小于等于
	>=	大于等于
	<=>	比较大小。小于，等于，大于，分别返回 -1， 0 或 +1
	==	恒等于
	!=	不等于
	=~	肯定匹配
	!~	否定匹配
	===	用来比较case语句的目标和每个when从句的项
	&&	逻辑与
	||	逻辑或
	..	区间(含尾部元素)
	...	区间(不含尾部元素)
	?:	条件运算符
	=	负值
	not	返回操作数的相反值
	and	逻辑与
	or	逻辑或

ruby的字符型

单行字符串的输出:

str = 'hello the world' p str    #=> "hello the world" puts str    #=> hello the world

多行字符串的输出:

str = <<EOS     This is test.     Ruby, the Object Oriented Script Language. EOS puts str     #=>This is test.           Ruby, the Object Oriented Script Language.

字符串的结合:

str = 'hello' puts str + ' the world'    #=> hello the world

字符串的追加:

str = 'hello' str << ' the world' puts str    #=> hello the world

生成重复的字符串:

str = 'hello ' puts str*3    #=> hello hello hello

大小写字母的变换:

str = 'I Love Ruby' puts str.upcase    #=> I LOVE RUBY puts str.downcase    #=> i love ruby

字符串中的部分字符的取得:

str = "Apple Banana Orange" puts str[0..4]     #=> Apple puts str[6, 6]     #=> Banana

字符串中的部分字符的置换:

str = "Apple Banana Apple Orange" str[0..4] = "Vine"     #=> str = "Vine Banana Apple Orane" str[5, 6] = "Lemon"     #=> str = "Vine Lemon Apple Orange" str.sub("Apple", "Pine")     #=> str = "Pine Banana Apple Orange" str.gsub("Apple", "Pine")     #=> str = "Pine Banana Pine Orange"

字符串中变数的展开:

value = 123 puts "value is #{value}"     #=> value is 123

字符串中方法的展开:

def sub(str)     "Hello, #{str}." end puts "Say #{sub('Tomoya')}"     #=> Say Hello, Tomoya.

削除字符串头和尾的空格:

str = ' Hello, Ruby! ' p s.strip     #=> "Hello, Ruby!"

削除字符串尾部的换行:

str = 'Hello, Ruby!\n' p str.chomp    #=> "Hello, Ruby!" p str.strip    #=> "Hello, Ruby!"

字符型向数值型的转换:

str = '99' i = 1 puts i + str.to_i    #=> 100

数值型向字符型的转换:

str = '99' i = 1 p i.to_s + str    #=> "199"

字符型(数值型)向浮点小数型的转换:

str = '99' puts str.to_f    #=> 99.0

下一个字符串的取得:

p "9".succ    #>= "10" p "a".succ    #>= "b" p "AAA".succ    #>= "AAB" p "A99".succ    #>= "B00" p "A099".succ    #>= "A100"

检查字符串中是否有相同字符出现:

str = "Apple Banana Apple Orange" # 从左则开始查找 puts str.index("Apple")    #=> 0 puts str.index("Banana")    #=> 6 puts str.index("Apple", 6)    #=> 13 # 从右则开始查找 puts str.rindex("Apple")    #=> 13 puts str.rindex("Apple", 6)    #>= 0

字符串的居中,居左和居右:

str = "Ruby" p str.center(10)     #=> " Ruby " p str.ljust(10)    #=> "Ruby " p str.rjust(10)    #=> " Ruby"

让正式表达式 '.' 也能查找到换行

使用 Ruby 正则表达式中的 m 检索模式, 例:

p /./ =~ "\n"    #=> nil p /./m =~ "\n"    #=> 0

注:
    /../m 在 Ruby 的正则表达式中, m 为多行检索时,换行符会被看做普通字符来处理.

单词的检索

查找在某一字符串中是否含有匹配的单词. 如: 当我们想查找单词 spec 而又不想将 specifsction 一起查找出来时, 我们将要用到正则表达式的 \b (要注意是小写字母b).

p /\bspec\b/ =~ "Ruby spec"")    #=> 5 p /\bspec\b/ =~ "Ruby specifsction"")    #=> nil

因为一个汉字由4字节构成, 所以使用正则表达式的 \b 进行单词检索的方法, 只对英 文单词有效.

p /字符\b/ =~ "字符 abc"    #=> nil

单词的查找
说是单词的查找, 但单词的概念却是很模糊的. 如下提供了三种方法:

# 使用 Ruby 的正则表达式 \w 来实现查找 p " This is \ta 2pen.".scan(/\w+/)   #=> ["This", "is", "a", "2pen"]

# 使用 Ruby 的正则表达式 /[a-z]+/i 来实现查找 p " This is \ta 2pen.".scan(/[a-z]+/i)   #=> ["This", "is", "a", "pen"]

# 使用 Ruby 的String#split 方法来实现查找 p " This is \ta 2pen.".split(nil)   #=> ["This", "is", "a", "2pen."]

从首字符或尾字符开始的查找

在 Ruby 的正则表达式中, "首字符" 为 \A, "尾字符" 为 \z(注意z是小写字符)

p (/\Aa/ =~ "aiueo")    #=> 0 p (/\Ao/ =~ "aiueo")    #=> nil p (/a\z/ =~ "aiueo")    #=> nil p (/o\z/ =~ "aiueo")    #=> 4

注:
    我们经常会在正则表达式中看到, ^ 和 $ 运算符. 它们分别表示为 行首 和 行末.

p "abc\ndef\nghi\n".slice(/..$/m)    #=> "bc" p "abc\ndef\nghi\n".slice(/..\Z/m)    #=> "hi" p "abc\ndef\nghi\n".slice(/..\z/m)    #=> "i\n"

??:
    /../m 在 Ruby 的正则表达式中, m 为多行检索时,换行符会被看做普通字符来处理.
    \Z 在 Ruby 的正则表达式中, 表示字符串中的行末.

字符串的查找

查找匹配字符
用正则表达式查找匹配字符时,使用 =~ 运算符.

# 查找含有全角空格和半角空格. p ([\s\t] =~ 'a c')    #=>  1 p ([\s\t] =~ 'abc')    #=>  nil

查找匹配字符最初出现在位置
查找匹配字符最初出现在位置时,使用 String#index

p 'xxxabcabcabcxxx'.index('abc')    #=>  3 p 'xxxabcabcabcxxx'.index('.')     #=>  nil p 'xxx..............xxx'.index('.')     #=>  3

查找匹配字符最后出现在位置
查找匹配字符最后出现在位置时,使用 String#rindex

p 'xxxabcabcabcxxx'.rindex('abc')    #=>  9 p 'xxxabcabcabcxxx'.rindex('.')     #=>  nil p 'xxx..............xxx'.rindex('.')     #=>  16

取得匹配字符外的字符串
取得到匹配字符之后的字符串,使用 Regexp#match

m = /abc/.match('xxxabcabcabcxxx') p m.post_match    #=>  "abcabcxxx" m = 'xxxabcabcabcxxx'.match(/abc/) p m.post_match    #=>  "abcabcxxx"

查找字符串中匹配的所有字符
查找字符串中匹配的所有字符,使用 String#scan

# 查找字符串中的所有字母. str = "abc所\ndef有\nghi字符\n" str.scan(/[a-z]+/){ |s|     p s } #=>  "abc" #=>  "def" #=>  "ghi"

取得含有匹配字符的一行
含有匹配字符的复数行.使用 String#grep (Enumerble#grep)

# 输出含有字母 a 和 g 的一行. str = "abc所\ndef有\nghi字符\n" str.grep(/[ag]/){ |line|     p line } #=>  "abc所\n" #=>  "ghi字符\n"

以下的两种写法同上相同

str.grep(re){ |line|     # 处理内容 }

str.each{ |line|     if re =~ line         # 处理内容     end }

取得字符串的长度

说到取得字符串的长度,就会想到两种情况: byte数和字符数.

取得byte数
字符串byte数的取得将用到 String#lenght 和 String#size 这两种方法.虽然方法名称不同,但意义是相同的.

p "This is a string".length    # 16  p "This is a string".size    # 16

取得字符数
字符数的取得将用到 String#split 方法. 此方法是以字符为单位,将字符串分割成数组再计算组数大小.

p "这是字符串".split(//).length    # 10  p "这是字符串".split(//).size    # 10

Ruby概述

Ruby 简介

Ruby，一种为简单快捷面向对象编程（面向对象程序设计）而创的脚本语言，由日本人松本行弘（まつもとゆきひろ，英译：Yukihiro Matsumoto，外号matz）开发，遵守GPL协议和Ruby License。

Ruby的作者认为Ruby > (Smalltalk + Perl) / 2，表示Ruby是一个语法像Smalltalk一样完全面向对象、脚本执行、又有Perl强大的文字处理功能的编程语言。其他特色包括：

　　* 运算符重载
　　* 自动垃圾回收
　　* 弱类型（动态类型 | 标量变量）
　　* 变量无需声明 (不必事先宣告变量)
　　* 在Windows上，加载DLL
　　* 巨大的标准库(函式库；Library)


Ruby 历史

Ruby的作者于1993年2月24日开始编写Ruby，直至1995年12月才正式公开发布于fj（新闻组）。之所以称为Ruby，是因为Perl的发音与6月的诞生石pearl（珍珠）相同，因此Ruby以7月的诞生石ruby（红宝石）命名。

Ruby明显比其他类似的编程语言（如Perl或Python）年轻，又因为Ruby是日本人发明的，所以早期的非日文资料和程序都比较贫乏，所以现在在网上仍然可以找到Ruby的资料太少之类的批评。约于2000年，Ruby开始进入美国，英文的资料开始发展。

Ruby现在的稳定版本是1.8.6（2007年3月12日发布）。

2008年8月Ruby 1.8.7-p72 和 1.8.6-p287 发布。先前的发布版本不完全，新的版本包括了对之前发布的关于dl的漏洞的修正。


Ruby名字的由来

首先明确一点，Ruby并不是其他单词的缩写。受Perl的影响，Matz也想用一种宝石来命名他的新语言，他使用了他的一位同事的生肖石－红宝石。

后来，Matz意识到Ruby这个名字十分恰当，首先，在生肖石中，Pearl代表六月，而Ruby代表七月。
在字体大小上，Pearl大小是5pt, ruby的大小是5.5pt。所以Ruby这个名字对于一种Perl的后续语言十分合适。


Ruby 的理念

减少编程时候的不必要的琐碎时间，令编写程序的人高兴，是设计 Ruby 语言的 Matz 的一个首要的考虑；其次是良好的界面设计。他强调系统设计必须强调人性化，而不是一味从机器的角度设想。

　　“ 人们特别是电脑工程师们，常常从机器着想。他们认为：“这样做，机器就能运行的更快；这样做，机器运行效率更高；这样做，机器就会怎样怎样怎样。”实际上，我们需要从人的角度考虑问题，人们怎样编写程序或者怎样使用机器上应用程序。我们是主人，他们是仆人。 ”

　　遵循上述的理念，Ruby 语言通常非常直观，按照编程人认为它应该的方式运行。

　　Semantics

　　Ruby 是完全面向对象的：任何一点数据都是对象，包括在其他语言中的基本类型（比如：整数，布尔逻辑值），每个过程或函数都是方法。


Ruby 的特点

　　* 语法简单
　　* 普通的面向对象功能(类,方法调用等)
　　* 特殊的面向对象功能(Mixin,特殊方法等)
　　* 操作符重载
　　* 错误处理功能
　　* 迭代器和闭包
　　* 垃圾回收
　　* 动态载入(取决于系统架构)
　　* 可移植性高.不仅可以运行在多数UNIX上
　　 ,还可以运行在DOS,Windows,Mac,BeOS等平台上
　　* 运算符重载
　　* 自动垃圾回收
　　* 弱类型（动态类型 | 标量变量）
　　* 变量无需声明 (不必事先宣告变量)
　　* 在Windows上，加载DLL
　　* 巨大的标准库(函式库；Library)