Ruby

#!/usr/bin/env rubyputs "Hello, world!"

>>puts "Hello, world!"Hello, world!=> nil

a = '\n这是一个单引号的字符串，反斜线和变量插值不会被转义'b = %q{这是一个不可转义的字符串}c = "\n这是一个双引号的字符串，反斜线和变量插值会被转义\n#{a}"d = %Q{\n這是一個常量字串，特殊内容同样会被转义\n}e = <<BLOCK这是一个以Heredoc方式书写的常量字符串，可转义，结尾标志不可缩进BLOCKf = <<-BLOCK      这是一个可以缩进的Heredoc字符串    BLOCKg = <<~BLOCK      这是一个可以缩进的Heredoc字符串      缩进会被自动去掉，在2.3版本中引入    BLOCKh = %/\t这是一个可转义的的字符串\n/

class MyClass  def the_method    "general method"  endendmc = MyClass.newdef mc.the_method  "special for this instance."endmc.the_method

强大的反射机制与元编程

Ruby的反射功能相当惊人，甚至可以自行追踪程序运作，或是取出private变量、拦截方法的调用。常常与‘可以动态的修改对象’这项特色结合，做为‘元编程’的功能：程序在运行时，可以由程序员提供的信息，自行生成、修改类别或对象，这项功能大大的提高了撰写代码的效率。在Rails之中，就大量使用了这种特性。

以下为用Rails使用元编程的示例：

class Project < ActiveRecord::Base  belongs_to :portfolio  has_one    :project_manager  has_many   :milestonesend

在这个例子中，Project类别继承Base类别，Base类别内置的belongs_to、has_one、has_many方法，便会根据参数来修改Project类别的内容，并自行创建其他相关的方法。程序员可以更专心处理程序的运作，而不必为每个类别重复得撰写代码。

下面的代码可以在Ruby shell中运行，比如irb交互式命令行，或者保存为文件并运行命令ruby <filename>。

# Everything, including a literal, is an object, so this works:-199.abs                                                # 199"ruby is cool".length                                   # 12"Rick Astley".index("c")                                # 2"Nice Day Isn't It?".downcase.split(//).sort.uniq.join  # " '?acdeinsty"

• 一些转换：

puts "What's your favorite number?"number = gets.chompoutputnumber = number.to_i + 1puts outputnumber.to_s + ' is a bigger and better favorite number.'

集合

• 构造和使用数组：

a = ]p a           # 3.14p a.（2）# 3.14p a.reverse      # , 2, 1, 3.14, 'hi', 1]p a.flatten.uniq # 

• 构造和使用关联数组：

hash = { :water => 'wet', :fire => 'hot' }puts hash # Prints:  hothash.each_pair do |key, value| # Or:  hash.each do |key, value|puts "#{key} is #{value}"end# Prints:  water is wet#          fire is hothash.delete :water # Deletes :water => 'wet'hash.delete_if {|k,value| value=='hot'} # Deletes :fire => 'hot'

块和迭代器

• 有两个语法用于创建块：

{ puts "Hello, World!" } # Note the { braces }#ordo puts "Hello, World!" end

• 传参数的块使用闭包Closure：

# In an object instance variable (denoted with '@'), remember a block.def remember(&a_block)  @block = a_blockend# Invoke the above method, giving it a block which takes a name.remember {|name| puts "Hello, #{name}!"}# When the time is right (for the object) -- call the closure!@block.call("Jon")# => "Hello, Jon!"

• 从方法中返回闭包：

def create_set_and_get(initial_value=0) # Note the default value of 0  closure_value = initial_value  return Proc.new {|x| closure_value = x}, Proc.new { puts closure_value }endsetter, getter = create_set_and_get  # ie. returns two valuessetter.call(21)getter.call # => 21

• 迭代调用调用时提供的块：

def use_hello  yield "hello"end# Invoke the above method, passing it a block.use_hello {|string| puts string} # => 'hello'

• 使用块迭代数组：

array = array.each { |item| puts item }# => 1# => 'hi'# => 3.14array.each_index { |index| puts "#{index}: #{array}" }# => 0: 1# => 1: 'hi'# => 2: 3.14(3..6).each { |num| puts num }# => 3# => 4# => 5# => 6

像inject()方法可以接收一个参数和一个块。迭代的注入列表的每一个成员，执行函数时保存总和。这同函数编程语言中的foldl函数相类似，比如：

.inject(10) {|sum, element| sum + element} # => 19

首先块接收到了10（inject的参数）当作变量sum，并且1（数组的第一个元素）当作变量element；这会返回11。11又被当作下一步的sum变量，它加上3得到了14。14又被加上了5，最终返回结果19。

File.open('file.txt', 'w') do |file| # 'w' denotes "write mode".  file.puts 'Wrote some text.'end                                  # File is automatically closed hereFile.readlines('file.txt').each do |line|puts lineend# => Wrote some text.

• 使用枚举器和块求1到10的平方：

(1..10).collect {|x| x*x} # => 

类

下面的代码定义一个命名为Person的类。含有一个“initialize”方法，用于构选创建一个新对象，它还有两个方法，一个重载了<=>比较运算符（这样Array#sort可以使用age排序）另一个重载了to_s方法（这样Kernel#puts可以格式化输出），attr_reader是Ruby中元数据编程的例子：attr_accessor为实例变量定义了getter和setter方法，attr_reader只是一个getter方法。另外，方法中最后的声明是它的返回值，也允许显式的使用“return”语句。

class Person  attr_reader :name, :age  def initialize(name, age)    @name, @age = name, age  end  def <=>(person) # Comparison operator for sorting    @age <=> person.age  end  def to_s    "#@name (#@age)"  endendgroup = puts group.sort.reverse

• 下面按age倒序输出了三个名字：

Bob(33)Ash(23)Chris(16)

各种版本

Matz's Ruby interpreter, 最初也是最常见的Ruby版本, 简称MRI, 用C语言撰写.

JRuby，类似Python的Jython，一个可于Java上运行Ruby的语言，支持Java的接口和类别。最新发布版为9.1.6.0（2016-11-09），与Ruby 2.3兼容。它的官方网站为jruby.org。

mruby是一个轻量级的Ruby解释器，可以嵌入到其它应用程序中，或者作为库链接到应用中。