官方网站：https://www.ruby-lang.org/zh_cn/
标准库API文档：http://ruby-doc.org/stdlib-2.3.0/

Ruby，一种为简单快捷的面向对象编程（面向对象程序设计）而创的脚本语言，在20世纪90年代由日本人松本行弘(Yukihiro Matsumoto)开发，遵守GPL协议和Ruby License。它的灵感与特性来自于 Perl、Smalltalk、Eiffel、Ada以及 Lisp 语言。Smalltalk 是一个真正的面向对象语言。Ruby，与 Smalltalk 一样，是一个完美的面向对象语言。使用 Ruby 的语法比使用 Smalltalk 的语法要容易得多。由 Ruby 语言本身还发展出了JRuby（Java平台）、IronRuby（.NET平台）等其他平台的 Ruby 语言替代品。Ruby的作者于1993年2月24日开始编写Ruby，直至1995年12月才正式公开发布于fj（新闻组）。因为Perl发音与6月诞生石pearl（珍珠）相同，因此Ruby以7月诞生石ruby（红宝石）命名。在 Ruby 社区，松本也被称为马茨（Matz）。

Ruby 经常位于全球编程语言成长和流行度指数的前十名（比如TIOBE）。造成 Ruby 如此快速成长的原因很大程度上是因为使用 Ruby 编写的 Web 框架 Ruby on Rails 非常受欢迎。

Ruby哲学是：“每一件事情总是有多种做法”（Having more than one way to do the same thing）。
所以程序员的创造力就完全被激发出来了。当你看到某个问题的一种前所未见又十分优雅的解决方案时，你会有一种混杂着强烈喜悦的惊讶的——写（优美的）Ruby能够激发人的灵感。

Ruby的元编程能力还有宽松的语法使得使用Ruby可以很轻松的开发DSL（Domain Specific Language）

Ruby吸收了很多语言（Lisp、Smalltalk等等）的特性，对于程序员来说了解一下Ruby对于开阔思路是很有帮助的，它能帮助你更好的看清你之前一直使用的语言的限制之处在哪。

特性

• Ruby 是开源的，在 Web 上免费提供，但需要一个许可证。
• Ruby 是一种通用的、解释的编程语言。
• Ruby 是一种真正的面向对象编程语言。
• Ruby 是一种类似于 Python 和 Perl 的服务器端脚本语言。
• Ruby 可以用来编写通用网关接口（CGI）脚本。
• Ruby 可以被嵌入到超文本标记语言（HTML）。
• Ruby 语法简单，这使得新的开发人员能够快速轻松地学习 Ruby。
• Ruby 与 C++ 和 Perl 等许多编程语言有着类似的语法。
• Ruby 可扩展性强，用 Ruby 编写的大程序易于维护。
• Ruby 可用于开发的 Internet 和 Intranet 应用程序。
• Ruby 可以安装在 Windows 和 POSIX 环境中。
• Ruby 支持许多 GUI 工具，比如 Tcl/Tk、GTK 和 OpenGL。
• Ruby 可以很容易地连接到 DB2、MySQL、Oracle 和 Sybase。
• Ruby 有丰富的内置函数，可以直接在 Ruby 脚本中使用。

安装

linux环境

sudo apt-get install ruby-full # Debian 或 Ubuntu 系统
sudo yum install ruby # CentOS, Fedora, 或 RHEL 系统
ruby -v
ruby 2.1.5p273 (2014-11-13) [x86_64-linux-gnu]

Ruby 命令行选项

Ruby 一般是从命令行运行，方式如下：

$ ruby [ options ] [.] [ programfile ] [ arguments … ]

解释器可以通过下列选项被调用，来控制解释器的环境和行为。

编码

如果出现乱码或者字符异常，尝试声明编码即可，同时必须设置编辑器保存文件的编码为utf-8。

#!/usr/bin/ruby -w
# -*- coding: UTF-8 -*-
puts "你好，世界！";

语法

让我们编写一个简单的 Ruby 程序。所有的 Ruby 文件扩展名都是 .rb。所以，把下面的源代码放在 test.rb 文件中。

#!/usr/bin/ruby -w
puts "Hello, Ruby!";

$ ruby test.rb
Hello, Ruby!

空白与行尾

在 Ruby 代码中的空白字符，如空格和制表符一般会被忽略，除非当它们出现在字符串中时才不会被忽略。然而，有时候它们用于解释模棱两可的语句。当启用 -w 选项时，这种解释会产生警告。

a + b 被解释为 a+b （这是一个局部变量）
a +b 被解释为 a(+b) （这是一个方法调用）

Ruby 把分号和换行符解释为语句的结尾。但是，如果 Ruby 在行尾遇到运算符，比如 +、- 或反斜杠，它们表示一个语句的延续。

标识符与保留字

标识符是变量、常量和方法的名称。Ruby 标识符是大小写敏感的。这意味着 Ram 和 RAM 在 Ruby 中是两个不同的标识符。
Ruby 标识符的名称可以包含字母、数字和下划线字符（ _ ）。

下表列出了 Ruby 中的保留字。这些保留字不能作为常量或变量的名称。但是，它们可以作为方法名。
BEGIN do next then
END else nil true
alias elsif not undef
and end or unless
begin ensure redo until
break false rescue when
case for retry while
class if return while
def in self FILE
defined? module super LINE

Here Document

“Here Document” 是指建立多行字符串。在 << 之后，您可以指定一个字符串或标识符来终止字符串，且当前行之后直到终止符为止的所有行是字符串的值。
如果终止符用引号括起，引号的类型决定了面向行的字符串类型。请注意<< 和终止符之间必须没有空格。

#!/usr/bin/ruby -w
# -*- coding : utf-8 -*-

print <<EOF
    这是第一种方式创建here document 。
    多行字符串。
EOF

print <<"EOF";                # 与上面相同
    这是第二种方式创建here document 。
    多行字符串。
EOF

print <<`EOC`                 # 执行命令
    echo hi there
    echo lo there
EOC

print <<"foo", <<"bar"          # 您可以把它们进行堆叠
    I said foo.
foo
    I said bar.
bar

BEGIN与END 语句

#!/usr/bin/ruby

puts "This is main Ruby Program"

END {
   puts "Terminating Ruby Program"
}
BEGIN {
   puts "Initializing Ruby Program"
}

Initializing Ruby Program
This is main Ruby Program
Terminating Ruby Program

注释

注释会对 Ruby 解释器隐藏一行，或者一行的一部分，或者若干行。您可以在行首使用字符（ # ）
或者，注释可以跟着语句或表达式的同一行的后面，
块注释会对解释器隐藏 =begin/=end 之间的行。

# 我是注释，请忽略我。

name = "Madisetti" # 这也是注释

# 这是注释。
# 这也是注释。
# 这也是注释。
# 这还是注释。

=begin
这是注释。
这也是注释。
这也是注释。
这还是注释。
=end

运算符

Ruby 支持一套丰富的运算符。大多数运算符实际上是方法调用。例如，a + b 被解释为 a.+(b)，其中指向变量 a 的 + 方法被调用，b 作为方法调用的参数。
对于每个运算符（+ - * / % ** & | ^ << >> && ||），都有一个相对应的缩写赋值运算符（+= -= 等等）。
逻辑运算符，三元运算符略过，语言通用。

算数运算符

常规语言通用略过
其中 代表指数 - 执行指数计算， 假设变量 a 的值为 10，变量 b 的值为 20， ab 将得到 10 的 20 次方

比较运算符

常规语言通用略过，其中

赋值运算符

常规语言通用略过，其中
= 指数且赋值运算符，执行指数计算，并赋值给左操作数 c = a 相当于 c = c ** a

并行赋值

a, b, c = 10, 20, 30
#并行赋值在交换两个变量的值时也很有用
a, b = b, c

位运算符

位运算符作用于位，并逐位执行操作。
假设如果 a = 60，且 b = 13，现在以二进制格式，它们如下所示：
a = 0011 1100
b = 0000 1101

a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011

范围运算符

在 Ruby 中，序列范围用于创建一系列连续的值 - 包含起始值、结束值（视情况而定）和它们之间的值。
在 Ruby 中，这些序列是使用 “..” 和 “…” 范围运算符来创建的。两点形式创建的范围包含起始值和结束值，三点形式创建的范围只包含起始值不包含结束值。
1..10 创建从 1 到 10 的范围
1…10 创建从 1 到 9 的范围

defined? 运算符

defined? 是一个特殊的运算符，以方法调用的形式来判断传递的表达式是否已定义。它返回表达式的描述字符串，如果表达式未定义则返回 nil。

点运算符 “.” 和双冒号运算符 “::”

您可以通过在方法名称前加上模块名称和一条下划线来调用模块方法。您可以使用模块名称和两个冒号来引用一个常量。
:: 是一元运算符，允许在类或模块内定义常量、实例方法和类方法，可以从类或模块外的任何地方进行访问。
请记住：在 Ruby 中，类和方法也可以被当作常量。
您只需要在表达式的常量名前加上 :: 前缀，即可返回适当的类或模块对象。
如果未使用前缀表达式，则默认使用主 Object 类。

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

运算符的优先级

下表按照运算符的优先级从高到低列出了所有的运算符。

数据类型

Ruby支持的数据类型包括基本的Number、String、Ranges、Symbols，以及true、false和nil这几个特殊值，同时还有两种重要的数据结构——Array和Hash。

数值(Number)

整型(Integer)
整型分两种，如果在31位以内（四字节），那为Fixnum实例。如果超过，即为Bignum实例。
整数范围从 -230 到 230-1 或 -262 到 262-1。在这个范围内的整数是类 Fixnum 的对象，在这个范围外的整数存储在类 Bignum 的对象中。
您可以在整数前使用一个可选的前导符号，一个可选的基础指标（0 对应 octal，0x 对应 hex，0b 对应 binary），后跟一串数字。下划线字符在数字字符串中被忽略。
您可以获取一个 ASCII 字符或一个用问号标记的转义序列的整数值。

123                  # Fixnum 十进制
1_234                # Fixnum 带有下划线的十进制
-500                 # 负的 Fixnum
0377                 # 八进制
0xff                 # 十六进制
0b1011               # 二进制
"a".ord              # "a" 的字符编码
?\n                  # 换行符（0x0a）的编码
12345678901234567890 # Bignum

浮点型
Ruby 支持浮点数。它们是带有小数的数字。浮点数是类 Float 的对象，且可以是下列中任意一个。

123.4                # 浮点值
1.0e6                # 科学记数法
4E20                 # 不是必需的
4e+20                # 指数前的符号

字符串(String)

Ruby 中的 String 对象用于存储或操作一个或多个字节的序列。
Ruby 字符串分为单引号字符串（’）和双引号字符串（”），区别在于双引号字符串能够支持更多的转义字符。

#!/usr/bin/ruby -w
puts 'escape using "\\"';
puts 'That\'s right';

escape using "\"
That's right

可以使用序列 #{ expr } 替换任意 Ruby 表达式的值为一个字符串。在这里，expr 可以是任意的 Ruby 表达式。

puts "Multiplication Value : #{24*60*60}";

Multiplication Value : 86400

name="Ruby"
puts name
puts "#{name+",ok"}"

Ruby
Ruby,ok 

转义字符

字符编码
Ruby 的默认字符集是 ASCII，字符可用单个字节表示。如果您使用 UTF-8 或其他现代的字符集，字符可能是用一个到四个字节表示。
您可以在程序开头使用 $KCODE 改变字符集

$KCODE = ‘u’

a ASCII （与 none 相同）。这是默认的。
e EUC。
n None （与 ASCII 相同）。
u UTF-8。

数组（Array）

Ruby 数组是任何对象的有序整数索引集合。数组中的每个元素都与一个索引相关，并可通过索引进行获取。
数组的索引从 0 开始，这与 C 或 Java 中一样。一个负数的索相对于数组的末尾计数的，也就是说，索引为 -1 表示数组的最后一个元素，-2 表示数组中的倒数第二个元素，依此类推。
Ruby 数组可存储诸如 String、 Integer、 Fixnum、 Hash、 Symbol 等对象，甚至可以是其他 Array 对象。
Ruby 数组不需要指定大小，当向数组添加元素时，Ruby 数组会自动增长。

names = Array.new
names = Array.new(20) #创建数组的同时设置数组的大小
puts names.size  # 返回 20
puts names.length # 返回 20

names = Array.new(4, "mac")
puts "#{names}"
#["mac", "mac", "mac", "mac"]

nums = Array.new(10) { |e| e = e * 2 }
puts "#{nums}"
#[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

nums = Array[1, 2, 3, 4,5]
nums = Array.[](1, 2, 3, 4,5)

digits = Array(0..9)
puts "#{digits}"
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

哈希（Hash）

哈希（Hash）是类似 “key” => “value” 这样的键值对集合。哈希类似于一个数组，只不过它的索引不局限于使用数字。
Hash 的索引（或者叫”键”）几乎可以是任何对象。
Hash 虽然和数组类似，但却有一个很重要的区别：Hash 的元素没有特定的顺序。 如果顺序很重要的话就要使用数组了。

months = Hash.new
# 创建带有默认值的哈希
months = Hash.new( "month" )
months = Hash.new "month"

#当您访问带有默认值的哈希中的任意键时，如果键或值不存在，访问哈希将返回默认值
puts "#{months[0]}"
puts "#{months[72]}"
#month
#month

H = Hash["a" => 100, "b" => 200]
puts "#{H['a']}"
puts "#{H['b']}"
#100
#200

范围（Range）

Ruby 支持范围，并允许我们以不同的方式使用范围：

• 作为序列的范围
• 作为条件的范围
• 作为间隔的范围

(1..5)        #==> 1, 2, 3, 4, 5
(1...5)       #==> 1, 2, 3, 4
('a'..'d')    #==> 'a', 'b', 'c', 'd'

#可以使用 to_a 方法把范围转换为列表。
range1 = (1..10).to_a #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#可以通过多种方式检查它们的内容
digits = 0..9
puts digits.include?(5)
ret = digits.min
puts "最小值为 #{ret}"
ret = digits.max
puts "最大值为 #{ret}"
ret = digits.reject {|i| i < 5 }
puts "不符合条件的有 #{ret}"
digits.each do |digit|
   puts "在循环中 #{digit}"
end

#其中每个集合的第一行包含单词 start，最后一行包含单词 end.
while gets
   print if /start/../end/
end

score = 70
result = case score
when 0..40
    "糟糕的分数"
when 41..60
    "快要及格"
when 61..70
    "及格分数"
when 71..100
       "良好分数"
else
    "错误的分数"
end
puts result

#检查指定值是否在指定的范围内。需要使用 === 相等运算符来完成计算
if ((1..10) === 5)
  puts "5 在 (1..10)"
end
if (('a'..'j') === 'c')
  puts "c 在 ('a'..'j')"
end
if (('a'..'j') === 'z')
  puts "z 在 ('a'..'j')"
end

迭代器(iterator)

迭代器是集合支持的方法。存储一组数据成员的对象称为集合。在 Ruby 中，数组(Array)和哈希(Hash)可以称之为集合。
迭代器返回集合的所有元素，一个接着一个。

each 迭代器

#each 迭代器总是与一个块关联。它向块返回数组的每个值，一个接着一个。值被存储在变量 i 中
ary = [1,2,3,4,5]
ary.each do |i|
   puts i
end

#当您想要对每个值进行一些操作以便获得新的数组时，您通常使用 collect 方法。例如，下面的代码会生成一个数组，其值是 a 中每个值的 10 倍。
a = [1,2,3,4,5]
b = a.collect{|x| 10*x}
puts b

collect 迭代器

collect 迭代器返回集合的所有元素。

a = [1,2,3,4,5]
b = Array.new
b = a.collect{ |x|x }
puts b

条件判断与循环

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
#if 表达式用于条件执行。值 false 和 nil 为假，其他值都为真。请注意，Ruby 使用 elsif，不是使用 else if 和 elif。
#如果 conditional 为真，则执行 code。如果 conditional 不为真，则执行 else 子句中指定的 code。
#通常我们省略保留字 then 。若想在一行内写出完整的 if 式，则必须以 then 隔开条件式和程式区块。
x=1
if x > 2
   puts "x 大于 2"
elsif x <= 2 and x!=0
   puts "x 是 1"
else
   puts "无法得知 x 的值"
end

#if修饰词组表示当 if 右边之条件成立时才执行 if 左边的式子。即如果 conditional 为真，则执行 code。
$debug=1
print "debug\n" if $debug

#unless式和 if式作用相反，即如果 conditional 为假，则执行 code。如果 conditional 为真，则执行 else 子句中指定的 code。
$var =  1
print "1 -- 这一行输出\n" if $var
print "2 -- 这一行不输出\n" unless $var

$var = false
print "3 -- 这一行输出\n" unless $var

#unless式和 if式作用相反，即如果 conditional 为假，则执行 code。如果 conditional 为真，则执行 else 子句中指定的 code。
x=1
unless x>2
   puts "x 小于 2"
else
  puts "x 大于 2"