01-ruby-overview/01.03-ruby-from-other-languages.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 从其它语言到 Ruby"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当您初次看到 Ruby 语言代码的时候，它很可能让您想起您使用过的其他编程语言。这是当然的， 因为 Ruby 的大部分语法是 Perl、Python 和 Java（以及其他语言）的用户所熟悉的。 如果您曾经使用过这这些语言，学习 Ruby 就是小菜一碟。\n",
    "\n",
    "本文包含了两部分。第一部分简明扼要地概述了当你从 X 到 Ruby 语言的一些所见所闻； 第二部分介绍了 Ruby 语言主要特性以及与你所熟悉的语言之间的差异。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 重要的语言特性和一些小技巧\n",
    "\n",
    "这里介绍了学习 Ruby 语言时应该注意的 Ruby 语言的特性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 迭代器\n",
    "\n",
    "代码块和迭代是 Ruby 语言和其他语言不太一样的地方。我们可以以索引做循环（比如 C, C++, 或者 1.5 版本以前的 Java），或者以列表做循环（比如 Perl 的 `for (@a) {...}`， 还有 Python 的 `for i in aList: ...`），但是在 Ruby 中，我们常会看到\n",
    "\n",
    "```ruby\n",
    "some_list.each do |this_item|\n",
    "  # 我们在代码块内内部。\n",
    "  # 使用 this_item。\n",
    "end\n",
    "```\n",
    "\n",
    "关于更多 `each`（还有 `collect`、`find`、`inject`、`sort` 等）的信息，请参考 `ri Enumerable` （和 `ri Enumerable#some_method`）。\n",
    "\n",
    "### 一切表达方法皆有值\n",
    "\n",
    "表达式和语句没有区别。任何表达方法都有返回值，即使那个值是 `nil`，比如下面的用法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 10\n",
    "y = 11\n",
    "z = if x < y\n",
    "      true\n",
    "    else\n",
    "      false\n",
    "    end\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 符号不是轻量的字符串\n",
    "\n",
    "很多 Ruby 初学者都在想办法搞清楚什么是符号和怎么使用符号。\n",
    "\n",
    "符号最好的描述是身份证。一个符号代表了它是“谁”，而不是代表了它是“什么”。 打开 `irb` 来看一看他们的区别："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ":george.object_id == :george.object_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"george\".object_id == \"george\".object_id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`object_id` 函数返回的是对象的身份标识。如果两个对象有相同的 `object_id`， 那么他们就是相同的（指向同一个内存地址）。 可以看出，当符号在使用过一次后，任何相同字符的符号都会在内存中指向同一个对象地址。 也就是说任何相同字符的符号的 `object_id` 都是相同的。\n",
    "\n",
    "(“george”)的字符串的 `object_id` 并不相同，这表示他们在内存种指向不同对象地址。 每当您创建一个新的字符串的时候，Ruby 会在内存中为它分配新的空间。\n",
    "\n",
    "当您犹豫该用符号还是字符串的时候，想一下究竟字符的标识更重要（比如 Hash key）还是内容更重要 （比如前面例子里的 “george” ）。\n",
    "\n",
    "### 一切皆是对象\n",
    "\n",
    "“一切皆是对象”并不是夸张。即使是类和整型变量也都是对象，您可以想使用其他对象一样使用他们："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class MyClass\n",
    "  attr_accessor :instance_var\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "等同于(稍有区别)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<main>: warning: already initialized constant MyClass\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "MyClass"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyClass = Class.new do\n",
    "  attr_accessor :instance_var\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 可以改变的常量\n",
    "\n",
    "常量并不是真正恒定的。如果您修改了一个已初始化的常量，会触发警告，但程序不会中止。 当然这也不是说您“应该”改变常量。\n",
    "\n",
    "### 命名约定\n",
    "\n",
    "Ruby 强制了一些命名约定。大写字母开头的是一个常量；美元符号(`$`)开头的是全局变量； `@` 开头的是实例变量； `@@` 开头的是类变量。 然而函数的名字却可以大写字母开头。这可能会导致一些混淆，比如下面的例子：\n",
    "\n",
    "```ruby\n",
    "Constant = 10\n",
    "def Constant\n",
    "  11\n",
    "end\n",
    "```\n",
    "\n",
    "这里 `Constant` 是 10，而 `Constant()` 是 11。\n",
    "\n",
    "### 关键字参数\n",
    "\n",
    "类似 Python, 从 Ruby 2.0 开始，可以使用关键字参数定义方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Sending from A to B via mail.\""
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def deliver(from: \"A\", to: nil, via: \"mail\")\n",
    "  \"Sending from #{from} to #{to} via #{via}.\"\n",
    "end\n",
    "\n",
    "deliver(to: \"B\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Sending from B to A via Pony Express.\""
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deliver(via: \"Pony Express\", from: \"B\", to: \"A\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 通用真值\n",
    "\n",
    "Ruby 把任何不是 `nil` 和 `false` 的值当作真值。在 C，Python 和其他语言里，0 和一些其他的值， 比如空的列表，会被当作假值。看一看下面的 Python 代码（这个例子也可以被应用到其他语言）：\n",
    "\n",
    "```python\n",
    "# Python 中\n",
    "if 0:\n",
    "  print(\"0 为真\")\n",
    "else:\n",
    "  print(\"0 为假\")\n",
    "```\n",
    "\n",
    "这会打印出 “0 为假”，而在 Ruby 中：\n",
    "\n",
    "```ruby\n",
    "# Ruby 中\n",
    "if 0\n",
    "  puts \"0 为真\"\n",
    "else\n",
    "  puts \"0 为假\"\n",
    "end\n",
    "```\n",
    "\n",
    "会打印出 “0 为真”。\n",
    "\n",
    "### 权限声明应用至作用域底部\n",
    "\n",
    "下面的 Ruby 代码中\n",
    "\n",
    "```ruby\n",
    "class MyClass\n",
    "  private\n",
    "  def a_method; true; end\n",
    "  def another_method; false; end\n",
    "end\n",
    "```\n",
    "\n",
    "您可能认为 `another_method` 是公有的。并不是这样的，”private” 权限声明会一直应用到类声明底部， 或者直到另外一个权限声明开始起作用。函数默认是公开的：\n",
    "\n",
    "```ruby\n",
    "class MyClass\n",
    "  # a_method 为公有\n",
    "  def a_method; true; end\n",
    "\n",
    "  private\n",
    "  # another_method 为私有\n",
    "  def another_method; false; end\n",
    "end\n",
    "```\n",
    "\n",
    "`public`、`private` 和 `protected` 其实都是方法， 所以他们可以接受参数。如果您给他们传递一个符号的话，那么符号所代表的函数的可见性会被改变。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 函数访问\n",
    "\n",
    "在 Java 里，`public` 表示方法可以被任何人访问。`protected` 表示此类实例、继承此类的实例及在同一个包内的所有类的实例可以访问，其他人则不能。`private` 表示任何此类实例外的人都不能访问。\n",
    "\n",
    "Ruby 有些不同。`public` 还是公开的。`private` 表示只有非明确指定接收者（receiver）才允许调用。私有方法调用只允许 `self` 为接收者。\n",
    "\n",
    "`protected` 应该特别注意。受保护的方法可以被类及继承类的实例调用，同一个类的其他实例也可以调用。 来自[Ruby Language FAQ](http://ruby-doc.org/docs/ruby-doc-bundle/FAQ/FAQ.html) 的例子:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":=="
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Test\n",
    "  def identifier\n",
    "    99\n",
    "  end\n",
    "\n",
    "  def ==(other)\n",
    "    identifier == other.identifier\n",
    "  end\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Test:0x007fcf459e85b0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = Test.new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Test:0x007fcf491c9e20>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t2 = Test.new"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 == t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Test"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Test\n",
    "  protected :identifier\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 == t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Test"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Test\n",
    "  private :identifier\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "NoMethodError",
     "evalue": "private method `identifier' called for #<Test:0x007fcf491c9e20>",
     "output_type": "error",
     "traceback": [
      "\u001b[31mNoMethodError\u001b[0m: private method `identifier' called for #<Test:0x007fcf491c9e20>",
      "\u001b[37m<main>:6:in `=='\u001b[0m",
      "\u001b[37m<main>:in `<main>'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/backend.rb:72:in `eval'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/backend.rb:72:in `block in eval'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/backend.rb:55:in `eval_with_magic'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/backend.rb:71:in `eval'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/backend.rb:13:in `eval'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/kernel.rb:87:in `execute_request'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/kernel.rb:47:in `dispatch'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/kernel.rb:37:in `run'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/command.rb:70:in `run_kernel'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/lib/iruby/command.rb:34:in `run'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bundler/gems/iruby-a2d7f8bcd676/bin/iruby:5:in `<top (required)>'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bin/iruby:23:in `load'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bin/iruby:23:in `<main>'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bin/ruby_executable_hooks:15:in `eval'\u001b[0m",
      "\u001b[37m/usr/local/rvm/gems/ruby-2.4.1/bin/ruby_executable_hooks:15:in `<main>'\u001b[0m"
     ]
    }
   ],
   "source": [
    "t1 == t2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 类是开放的\n",
    "\n",
    "Ruby 的类是开放的。任何时候你都可以打开它进行增加和修改。即使像 `Fixnum` 这样的核心类，甚至是所有对象的父类 `Object` 类都可以打开。Ruby on Rails 在 `Fixnum` 类里定义了一大堆方法来处理时间问题。请看："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2006-01-01 14:00:00 +0800"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Integer\n",
    "  def hours\n",
    "    self * 3600 # number of seconds in an hour\n",
    "  end\n",
    "  alias hour hours\n",
    "end\n",
    "\n",
    "Time.mktime(2006, 01, 01) + 14.hours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 有趣的方法名\n",
    "\n",
    "Ruby 的方法名允许以问号或感叹号结尾。习惯上，以问号结尾的方法返回布尔值（如：如果接收者为空的话 `Array#empty?` 返回 `true` ）。潜在“危险”方法（如修改 `self` 或参数的方法，`exit!` 等）以感叹号结尾。也不是所有修改参数的方法以感叹号结尾。 比如 `Array#replace` 方法将当前列表替换成另一个列表。毕竟这些方法就是为此而生的，不修改自身就没什么意义了。\n",
    "\n",
    "### 单例方法（Singleton methods）\n",
    "\n",
    "单例方法是单一对象方法。只在定义过的对象上可用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Cheap car\""
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Car\n",
    "  def inspect\n",
    "    \"Cheap car\"\n",
    "  end\n",
    "end\n",
    "\n",
    "porsche = Car.new\n",
    "porsche.inspect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":inspect"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def porsche.inspect\n",
    "  \"Expensive car\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Expensive car\""
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "porsche.inspect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Cheap car\""
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "other_car = Car.new\n",
    "other_car.inspect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Missing methods\n",
    "\n",
    "针对不存在的方法，Ruby 同样会进行处理。它会将这个不存在的方法名作为参数传递给 `method_missing`。`method_missing` 默认会抛出一个 `NameError` 异常，可以根据你的应用场景重新定义这个方法，许多库都是这么做的。看下面这个例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Method __ was called, but not found. It has these arguments: a, b, 10\n"
     ]
    }
   ],
   "source": [
    "# id is the name of the method called, the * syntax collects\n",
    "# all the arguments in an array named 'arguments'\n",
    "class MyClass\n",
    "  def method_missing(id, *arguments)\n",
    "    puts \"Method #{id} was called, but not found. It has \" +\n",
    "         \"these arguments: #{arguments.join(\", \")}\"\n",
    "  end\n",
    "end\n",
    "\n",
    "MyClass.new.__(:a, :b, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "上面的代码会打印出调用细节，你也可以选择任何适当的方式处理这个消息。\n",
    "\n",
    "### 消息传递，非函数调用\n",
    "\n",
    "方法调用实际将一条 消息 传递给另一个对象："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# This\n",
    "puts 1 + 2\n",
    "# Is the same as this ...\n",
    "puts 1.+(2)\n",
    "# Which is the same as this:\n",
    "puts 1.send \"+\", 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 代码块也是对象，只是它们自己还不知道\n",
    "\n",
    "代码块（实际是闭包）广泛应用于标准库。可以使用 `yield` 调用一个代码块，或者像下面这样，通过一个特殊的参数将它变为一个 `Proc`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Proc"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def block(&the_block)\n",
    "  # Inside here, the_block is the block passed to the method\n",
    "  the_block # return the block\n",
    "end\n",
    "adder = block { |a, b| a + b }\n",
    "# adder is now a Proc object\n",
    "adder.class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调用 `lambda` 或 `Proc.new` 均可在方法外部创建代码块。\n",
    "\n",
    "### 方法同样也是对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "puts is an object!\n"
     ]
    }
   ],
   "source": [
    "method(:puts).call \"puts is an object!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 操作符是语法糖\n",
    "\n",
    "Ruby 中的大部分操作符仅仅是方法调用（根据一些优先级）的语法糖。例如，你可以覆盖 `Fixnum` 的 `+` 方法：\n",
    "\n",
    "```ruby\n",
    "class Fixnum\n",
    "  # 请不要这么做，虽然你可以\n",
    "  def +(other)\n",
    "    self - other\n",
    "  end\n",
    "end\n",
    "```\n",
    "\n",
    "你不需要 C++ 的 `operator+` 等。\n",
    "\n",
    "定义了 `[]` 和 `[]=` 方法后，你甚至拥有了数组风格的访问方法。要想定义一元操作符 `+` 和 `-`,你也必须定义相应的 `+@` 和 `-@` 方法。下面的操作符 不是 语法糖，它们不是方法，无法重新被定义：\n",
    "\n",
    "```ruby\n",
    "=, .., ..., not, &&, and, ||, or, ::\n",
    "```\n",
    "\n",
    "此外，`+=`、`*=` 等类似操作符只是 `var = var + other_var`、 `var = var * other_var`等的简写。因此也无法重新被定义。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从 Python 到 Ruby\n",
    "\n",
    "Python 是另一个很好的通用编程语言。从 Python 到 Ruby，你会发现 Ruby 需要学习更多一点的语法。\n",
    "\n",
    "### 相似点\n",
    "\n",
    "Ruby 与 Python 一样的地方……\n",
    "\n",
    "* 有交互式命令解释器（叫做 `irb`）。\n",
    "* 可以在命令行阅读文档（使用 `ri` 命令代替 Python 的 `pydoc`）。\n",
    "* 没有特殊的行终结符（除了通常的换行符）。\n",
    "* 与 Python 的三个引号类似，字符串字面量可以跨越多行。\n",
    "* 方括号用于列表，大括号用于字典（Ruby 中叫做 哈希）。\n",
    "* 数组操作相同（数组相加，会得到一个长数组；`a3 = [a1, a2]` 会得到一个二维数组）。\n",
    "* 对象是强、动态类型。\n",
    "* 一切皆是对象，变量只是对象的引用。\n",
    "* 尽管关键字有些许不同，但异常处理方式是一致的。\n",
    "* 拥有嵌入式文档工具（Ruby 的工具叫 `rdoc`）。\n",
    "* 同样好地支持函数式编程，比如：一级类型函数，匿名方法和闭包。\n",
    "\n",
    "### 相异点\n",
    "\n",
    "Ruby 与 Python 不同的地方……\n",
    "\n",
    "* 字符串是可变类型。\n",
    "* 可以新建常量（无意改变的变量）。\n",
    "* 有一些强制习惯用法（例如：类名以大写字母开头，变量以小写字母开头）。\n",
    "* 只有一种列表容器，且是可变类型。\n",
    "* 双引号字符串可以转义（像 `\\t`），有特殊的“替代表达式”语法（不用像 \"字符串\" `+` \"相\" `+` \"加\"这样，允许插入 Ruby 表达式结果到其他字符串）。单引号字符串与 Python 的 `r`\"原始字符串\" 一样。\n",
    "* 没有什么“新式”或者“旧式”类定义写法。只有一种写法（ Python 3 以上的版本没有这个问题，但不能向下兼容 Python 2）。\n",
    "* 不能直接访问属性。但在 Ruby 中，一切皆方法调用。\n",
    "* 方法调用的括号是可选的。\n",
    "* 有 `public`、`private`、`protected` 三种强制的访问控制类型，不像 Python 里面是用变量名加下划线表示。\n",
    "* “混入（`mixins`）”替代多重继承。\n",
    "* 你可以增加或修改内置类的方法。俩语言都允许你随时打开、修改类，但 Python 无法修改内置类，Ruby 无此限制。\n",
    "* `true` 和 `false` 代替 `True` 和 `False`（`nil` 代替 `None`）。\n",
    "* 判断真值时，只有 `false` 和 `nil` 当做假值。其余一切皆为真（包括 `0`、 `0.0`、 `\"\"` 和 `[]`）。\n",
    "* `elsif` 代替了 `elif`\n",
    "* `require` 替代 `import`。其他情况，使用相同。\n",
    "* 通常，代码之上（而不是之下的字符文档）的注释用来生成文档。\n",
    "* 虽然有很多语法糖需要记忆、学习，这也使得 Ruby 非常有趣且有效率。\n",
    "* 变量设置后无法取消（类似 Python 的 `del` 声明）。你可以将其重置为 `nil` 让 GC 回收旧的内容，但它仍然存在于符号表中。\n",
    "* `yield` 关键字作用是不一样的。在 Python 中，它会记住上一次返回时在函数体中调用的位置。外部代码有责任继续执行函数。而在 Ruby 中，yield 会执行作为方法最后一个参数传入的方法，然后立即执行。\n",
    "* Python 支持一种匿名函数，`lambdas`。而 Ruby 支持 `blocks`，`Procs` 和 `lambdas`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从 C/C++ 到 Ruby\n",
    "\n",
    "很难用一个列表来描述 Ruby 与 C 或 C++ 代码的不同之处，因为差异相当大。其中一个原因是 Ruby 的运行时帮你做了很多工作。与 C 的“不隐藏内部机制”原则不同——Ruby 的关注点在于将繁重的工作交由运行时，使用者站在运行时的肩上，活的更轻松。除非或直到做代码优化，使用 Ruby 不用费心“让编译器高兴” 。\n",
    "\n",
    "换句话说，Ruby 代码执行速度远远慢于“等价”的 C 或 C++ 代码是确定无疑的。相同的时间内，你头脑里关注的是如何快速的将一个 Ruby 程序运行起来，而且只需要很少的代码就可以做到。和把你搅成一锅粥的 C++ 相比，Ruby 要简单的多。\n",
    "\n",
    "Ruby 是动态类型语言，而不是静态类型。它在运行的时候运行时做尽可能多的事。例如，你不用关心 Ruby 程序“链接”（也就是载入和使用）到哪里或之前调用什么方法。\n",
    "\n",
    "可喜的是,事实证明 Ruby 和 C 之间的共生关系很和谐。Ruby 支持所谓“扩展模块”。这些模块由 C 语言编写，可以被 Ruby 程序调用（从外部来说，与其他 Ruby 模块表现和行为毫无二致）。通过这种方式,可以将性能关键部分从 Ruby 软件中切分出来,再由 C 语言打造。\n",
    "\n",
    "当然，Ruby 本身是由 C 语言写的。\n",
    "\n",
    "### 与 C 相似点\n",
    "\n",
    "Ruby 与 C 一样的地方……\n",
    "\n",
    "* 如果喜欢，你可以面向过程编程（但是实际上仍然是面向对象）。\n",
    "* 大多数的操作符是一样的（包括赋值操作和位操作）。但 Ruby 没有 `++` 或 `--` 。\n",
    "* 有 `__FILE__` 和 `__LINE__`。\n",
    "* 虽然没有 `const` 关键字，但常量还是有的。常量由命名约定约束——以大写字母开头的是常量。\n",
    "* 字符串使用双引号。\n",
    "* 字符串是可变类型。\n",
    "* 与 `man pages` 类似，在终端窗口内使用 `ri` 命令可以浏览大部分文档。\n",
    "* 可以使用同样的命令行调试器。\n",
    "\n",
    "### 与 C++ 相似点\n",
    "\n",
    "Ruby 与 C++ 一样的地方……\n",
    "\n",
    "* 几乎一样的操作符（甚至 `::`）。`<<` 常用于向列表内追加元素。值得注意的是：Ruby 使用 `.`，而不使用 `->`。\n",
    "* `public`、 `private` 和 `protected` 功能类似。\n",
    "* 继承语法仍然只用一个字符，由 < 变成 :。\n",
    "* 你可以将代码放进“模块”内，与 C++ 中使用 `namespace` 类似。\n",
    "* 为避免殃及池鱼，修改了异常（`Exceptions`）关键字， 但它们的工作类似。\n",
    "\n",
    "\n",
    "### 与 C 相异点\n",
    "\n",
    "Ruby 与 C 不同的地方……\n",
    "\n",
    "* 对象是强类型（变量名本身完全没有类型）。\n",
    "* 没有宏或预处理。没有类型转换。没有指针（也没有指针运算）。没有`typedef`，`sizeof`， `enums`。\n",
    "* 没有头文件。只需要在源码文件中定义你的函数（通常称作“方法”）和类即可。\n",
    "* 没有 `#define` 。使用常量代替。\n",
    "* 就 Ruby 1.8 而言，代码在运行时解释，而不是编译成任何机器码或二进制码。\n",
    "* 所有的变量存在于堆（`heap`）内。因此，不需要手动释放，垃圾回收器会帮你处理。\n",
    "* 参数通过引用传递给方法（如：函数），不是通过值传递。\n",
    "* 使用 `require 'foo'`，而不是 `#include <foo>` 或 `#include \"foo\"`。\n",
    "* 不能在程序中插入组合语言。\n",
    "* 行末尾没有分号。\n",
    "* `if` 和 `while` 条件表达式不需要括号。\n",
    "* 方法调用的括号（如：函数）通常可选。\n",
    "* 通常不使用括号，使用 `end` 关键字结束多行结构。\n",
    "* `do` 关键字用于所谓的“代码块”。没有像 C 语言那样的“`do statement`”。\n",
    "* “代码块”意义不同。意思是当方法执行时方法体内调用的一系列代码。\n",
    "* 没有变量声明。需要时再赋予一个新的名字即可。\n",
    "* 判断真值时，只有 `false` 和 `nil` 当做假值。其余一切皆为真（包括 `0`、 `0.0`、 `\"\"` 和 `[]`）。\n",
    "* 没有 `char` 类型，有的是只包含一个字符的字符串。\n",
    "* 字符串不是以空字节结束。\n",
    "* 数组字面量使用括号而不是花括号。\n",
    "* 数组中加入更多元素时，数组会自动变大。\n",
    "* 数组相加，返回的是一个新的更大的数组（当然，分配在堆（`heap`）上）而不是进行指针运算。\n",
    "* 基本上，一切皆表达式（也就是说，像 `while` 声明也会有右值）。\n",
    "\n",
    "\n",
    "### 与 C++ 相异点\n",
    "\n",
    "Ruby 与 C++ 不同的地方……\n",
    "\n",
    "* 没有明确引用。也就是在 Ruby 中，一切变量只是对象的一个自动非关联名称。\n",
    "* 对象是强类型也是动态类型。 运行时在运行的时候才知道方法调用是否可用。\n",
    "* “构造器”是 `initialize` 而不是类名。\n",
    "* 一切方法都是虚的。\n",
    "* “类”（静态）变量名总是以 `@@` 开头（像 `@@total_widgets` 这样）。\n",
    "* 你不是直接访问成员变量，所有公开的成员变量（ Ruby 中称为属性）都通过方法访问。\n",
    "* 使用 `self` 代替 `this`。\n",
    "* 有一些以 `?` 或 `!` 结尾的方法。这些符号实际是方法名的一部分。\n",
    "* 没有多重继承。然而 Ruby 有 “混入（`mixins`）”（比如，你可以“继承”某个模块的所有方法）。\n",
    "* 有一些强制命名约定（例如：类名以大写字母开头，变量以小写字母开头）。\n",
    "* 方法调用的括号是可选的。\n",
    "* 随时重新打开类并增加方法。\n",
    "* 不需要 C++ 模板（因为类型在运行时确定，所以可以给变量分配任意类型的对象），也没有类型转换。\n",
    "* 迭代有一点点区别。Ruby 中，不使用单独的迭代对象（像 `vector<T>::const_iterator iter`），当你的对象混入 `Enumerator` 模块，你就可以像 `my_obj.each` 这样调用方法。\n",
    "* 只有两种容器类型： 数组 `Array` 和哈希 `Hash`。\n",
    "* 无类型转换。 你会发现在 Ruby 中，这没有必要。\n",
    "* 内置多线程，就 Ruby 1.8 而言是“绿色线程”（只在解释器中实现）而非原生线程。\n",
    "* Ruby 标准库包含了单元测试库。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从 Java 到 Ruby\n",
    "\n",
    "Java 非常成熟，久经检验，且非常快（与那些反对java的人可能还在声称的相反）。但它也非常啰嗦。从 Java 到 Ruby，可以预见的是代码规模将大大缩小。你也可以期望使用相对少的时间快速出产原型。\n",
    "\n",
    "###  相似点\n",
    "\n",
    "Ruby 与 Java 一样的地方……\n",
    "\n",
    "* 垃圾回收器帮你管理内存。\n",
    "* 强类型对象。\n",
    "* 有 `public`、 `private` 和 `protected` 方法。\n",
    "* 拥有嵌入式文档工具（Ruby 的工具叫 `rdoc`）。`rdoc` 生成的文档与 `javadoc` 非常相似。\n",
    "\n",
    "### 相异点\n",
    "\n",
    "Ruby 与 Java 不同的地方……\n",
    "\n",
    "* 你不需要编译你的代码。你只需要直接运行它。\n",
    "* 有几个不同的流行的第三方GUI工具包。Ruby 用户可以尝试 WxRuby、 FXRuby、 Ruby-GNOME2、 Qt 或 Ruby 内置的 Tk。\n",
    "* 定义像类这样的东西时，可以使用 `end` 关键字，而不使用花括号包裹代码块。\n",
    "* 使用 `require` 代替 `import`。\n",
    "* 所有成员变量为私有。在外部，使用方法获取所有你需要的一切。\n",
    "* 方法调用的括号通常是可选的，经常被省略。\n",
    "* 一切皆对象，包括像 `2` 和 `3.14159` 这样的数字。\n",
    "* 没有静态类型检查。\n",
    "* 变量名只是标签。它们没有相应的类型。\n",
    "* 没有类型声明。按需分配变量名，及时可用（如：`a = [1,2,3]` 而不是 `int[] a = {1,2,3};`）。\n",
    "* 没有显式转换。只需要调用方法。代码运行之前，单元测试应该告诉你出现异常。\n",
    "* 使用 `foo = Foo.new(\"hi\")` 创建新对象，而非 `Foo foo = new Foo(\"hi\")`。\n",
    "* 构造器总是命名为“`initialize`” 而不是类名称。\n",
    "* 作为接口的替代，你将获得“混入（`mixins`）”。\n",
    "* 相比 XML，倾向于使用 YAML。\n",
    "* `nil` 替代 `null`。\n",
    "* Ruby 对 `==` 和 `equals()` 的处理方式与 Java 不一样。测试相等性使用 `==`（Java 中是 equals()）。测试是否为同一对象使用 `equals?()`（Java 中是 `==`）。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从 PHP 到 Ruby\n",
    "\n",
    "PHP 被广泛的应用在网页程序中，如果你想使用 Ruby on Rails，或者你需要一个更加讲究的多功能程序语言，Ruby 值得一看。\n",
    "\n",
    "### 相似点\n",
    "\n",
    "Ruby 与 PHP 一样的地方…\n",
    "\n",
    "* 和 PHP 一样，Ruby 是动态类型的程序语言，所以你不用担心声明变量的问题。\n",
    "* Ruby 有类，也有 `public`、`private` 和 `protected` 方法，并且你可以控制对他们的访问，就像 PHP 5 一样。\n",
    "* 一些变量以 `$` 符开头，和 PHP 一样 (但不总是一样)。\n",
    "* 也有 `eval` 。\n",
    "* 你可以使用字符串内嵌。但不是用 `\"$foo is a $bar\"` ，而是 `\"#{foo} is a #{bar}\"` ——跟 PHP 一样，这对用单引号包起来的字符串无效。\n",
    "* 有 Heredocs。\n",
    "* Ruby 有异常处理，就像 PHP 5 一样。\n",
    "* Ruby 也有非常广泛的标准函数库。\n",
    "* 数组和散列的工作会和你期望的一样，只要你把 `array()` 换成 `{` 和 `}` ： `array('a' => 'b')` 变成 `{'a' => 'b'}` 。\n",
    "* `true` 和 `false` 和 PHP 一样，但 `null` 变成了 `nil` 。\n",
    "\n",
    "### 相异点\n",
    "\n",
    "Ruby 与 PHP 不同的地方…\n",
    "\n",
    "* Ruby 是强类型语言，你需要使用 `to_s`、`to_i` 等方法使变量在字符串、整数等类型之间转换，而不能依赖编程语言去完成它。\n",
    "* 字符串、数字、数组、散列等都是对象。所以应该用 `-1.abs` 而不是 `abs(-1)`。\n",
    "* 调用方法时括号是可以省略的，除非需要明确哪些参数对应哪些调用方法时。\n",
    "* 取代了命名约定，例如下划线，标准函数库和扩展都被包装成模块和类。\n",
    "* 反射是 Ruby 对象与生俱来的能力，你不需要像在 PHP 5 中一样使用 Reflection 类。\n",
    "* 变量都是被引用的。\n",
    "* 沒有抽象类 `abstract` 或接口 `interface`。\n",
    "* 散列和数组不能互换使用。\n",
    "* 只有 `false` 和 `nil` 是假：`0`、`array()` 和 `\"\"` 在条件判断时均为真。\n",
    "* 几乎所有东西都是调用方法，甚至是 `raise` (PHP 的 `throw`)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 从 Perl 到 Ruby\n",
    "\n",
    "Perl 是极好的。Perl的文档非常棒。Perl 的社区也……非常棒。然而，Perl 语言相当的大且复杂。对于渴望一个更简单、内置优雅的面向对象特性的 Perl 使用者来说, Ruby可能适合你。\n",
    "\n",
    "### 相似点\n",
    "\n",
    "Ruby 与 Perl 一样的地方……\n",
    "\n",
    "* 与 CPAN 相似的包管理系统（尽管叫做 RubyGems）。\n",
    "* 内置正则,尽情享用吧！\n",
    "* 内置相当大数量的常用库。\n",
    "* 括号通常是可选的。\n",
    "* 字符串基本上一样。\n",
    "* 与 Perl 类似，有通用字符串分隔和正则表达式引用的语法。看起来像 `%q{this}`（单引号）、`%Q{this}` (双引号)和 `%w{this for a single-quoted list of words}`。如果喜欢，你也 `%Q|can|` `%Q(use)` `%Q^other^`。\n",
    "* 大括号变量插值，尽管它 `\"looks #{like} this\"` （你可以将任何 Ruby 代码放进 `#{}` 中）。\n",
    "* 使用反引号(`backticks`)调用 shell 命令。\n",
    "* 拥有嵌入式文档工具（Ruby 的工具叫 `rdoc`）。\n",
    "\n",
    "### 相异点\n",
    "\n",
    "Ruby 与 Perl 不同的地方……\n",
    "\n",
    "* 没有像 Perl 一样的上下文依赖规则。\n",
    "* 变量和它引用的对象不一样。取而代之的是，变量只是指向对象的引用。\n",
    "* 尽管 `$` 和 `@` 有时会作为变量的首字母，它们用来标明作用域（`$` 代表全局, `@` 用于实例变量, `@@` 用于类属性），而不是标明类型。\n",
    "* 列表字面量在方括号内，而不是圆括号内。\n",
    "* 列表组合不会将他们展开为一个大的列表，而是得到一个列表的列表。\n",
    "* `def` 代替 `sub`。\n",
    "* 每行结尾不需要分号。值得一提的是函数、类和分支定义以关键字 end 结尾。\n",
    "* 对象是强类型。类型间转换时需要手动调用 `foo.to_i`、 `foo.to_s` 等。\n",
    "* 没有 `eq`、 `ne`、 `lt`、 `gt`、 `ge`、 也没有 `le`。\n",
    "* 没有钻石操作符（`<>`），通常需要使用 `IO.some_method` 代替。\n",
    "* 胖箭头 `=>` 用于哈希字面量。\n",
    "* 没有 `undef`。Ruby 中有 `nil`。 `nil` 是一个对象（与 Ruby 其他东西一样）。和未定义的变量也不一样。作为布尔值时，它是假值。\n",
    "* 判断真值时，只有 `false` 和 `nil` 当做假值。其余一切皆为真（包括 `0`、 `0.0`、 `\"\"` 和 `[]`）。\n",
    "* 没有 [PerlMonks](http://www.perlmonks.org/)。 但是 ruby-talk 邮件列表是一个能获取到帮助的地方。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 参考资料\n",
    "\n",
    "* [Ruby From Other Languages][ruby-from-other-languages]\n",
    "\n",
    "[ruby-from-other-languages]: https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/ \"Ruby From Other Languages\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.4.1",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}