01-ruby-overview/01.02-ruby-in-20-minutes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 20分钟体验 Ruby"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 介绍\n",
    "\n",
    "这是个不会超过20分钟的 Ruby 简介。阅读前请您先将 Ruby 安装好。（如果您还没有安装Ruby 的话请到 下载区 下载并安装。）\n",
    "\n",
    "## Ruby 的互动性\n",
    "\n",
    "打开 IRB\n",
    "\n",
    "* 如果您使用 Mac OS X 打开 Terminal 然后输入 `irb`，回车\n",
    "* 如果您使用 Linux，打开一个 Shell，然后输入 `irb`，回车\n",
    "* 如果您使用 Windows，打开 开始菜单 -> Ruby -> Interactive Ruby\n",
    "\n",
    "输入：`\"Hello World\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello World\""
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ruby 顺从您！\n",
    "\n",
    "刚才是怎么回事啊？难道我们刚写了世界上最短的 \"Hello World\" 程序吗？ 不是的。第二行显示的只是 IRB 给我们的上一个命令的返回值。 如果我们要打印 `\"Hello World\"` 的话，还需要更多一点代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "puts \"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`puts` 是 Ruby 语言里用来打印的基本命令。`puts` 命令永远返回 `nil`，`nil` 也是 Ruby 的空值。\n",
    "\n",
    "## 您的免费计算器\n",
    "\n",
    "我们已经可以使用 IRB 提供的免费计算器啦！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "三加二很简单。三减二呢？您可以试试啊。虽然输入的命令很短，不过您可以在原来命令的基础上进行修改。 试着按一下 上方键 看看是不是打出了原来输入的 `3 + 2`。 如果能正常显示出的话，您可以用左方键来移动光标直到 +，然后按退格删除它 并输入 *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面我们来试试次方："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Ruby 里 `**` 是”次方”的意思。但如果您想开根号呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Math.sqrt(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "等一下！上面那个东西是什么？您猜想：“它是不是真的对 `9` 开了平方呢？” 您猜对了！我们还是来仔细看一下。第一，什么是 `Math`？\n",
    "\n",
    "## 模块，给代码分组\n",
    "\n",
    "`Math` 是一个自带的数学模块。模块在 Ruby 里有两个作用。第一： 把功能相似的函数放到同一个名称下。`Math` 模块还有 `sin()` 和 `tan()` 这样的函数。\n",
    "\n",
    "接下来的是一个点。点是干什么用的？点是用来告诉一个接收者它所要接受的信息。 什么是信息？在这个例子里面，信息就是 `sqrt(9)`，意思就是调用 `sqrt` 函数， 并给它 `9` 作为参数。当然 `sqrt` 就是 “square root” 的缩写。\n",
    "\n",
    "这个函数的返回值是 `3.0`。您一定发现了它不光只是3，还多了小数部分。 这是因为大多数情况下，开方的结果并不是整数，所以 sqrt 始终会返回浮点数。\n",
    "\n",
    "如果我们想记住运算结果呢？存到变量里吧。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 4 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Math.sqrt(a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "尽管这是个非常好的计算器，我们已经要从基本的 `Hello World` 程序向更有意思的领域迈进了。\n",
    "\n",
    "如果您想说很多次”Hello”，却不想把手指累酸的话，是定义一个函数的时候啦！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":h"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def h\n",
    "  puts \"Hello World!\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`def h` 定义一个函数。它告诉 Ruby 我们的函数名字是 `h`。下一行是函数的内容， 正是我们前面看到过的那行代码：`puts \"Hello World!\"`。最后的一行 `end` 告诉 Ruby 函数的定义完成了。\n",
    "\n",
    "## 函数的周期简短而又频繁\n",
    "\n",
    "我们来试着把这个函数调用几次："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "h()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "很方便吧。在 Ruby 里调用函数就像提起 Ruby 的名字一样简单。如果函数不需要接受参数， 您只要提到它就够了。您可以加一对括号，但不是必需的。\n",
    "\n",
    "如果您想对一个人而不是全世界说您好呢？只要让 `h` 函数接受一个参数就可以了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":h"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def h(name)\n",
    "  puts \"Hello #{name}!\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Matz!\n"
     ]
    }
   ],
   "source": [
    "h(\"Matz\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "和期待的一样。让我们再仔细看看究竟发生了什么。\n",
    "\n",
    "## 在字符串中预留位置\n",
    "\n",
    "啥是 `#{name}` 啊？这是 Ruby 用来往字符串中插入信息的方法。大括号里面的代码会被替换为评估后的字符串 （如果他们还不是字符串的话）然后插入到包含大括号的原始字符串中去。 您可以用这个方法将人名大写："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":h"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def h(name = \"World\")\n",
    "  puts \"Hello #{name.capitalize}!\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Chris!\n"
     ]
    }
   ],
   "source": [
    "h \"chris\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里还有几个小窍门。第一是我们又一次省略了函数的括号。如果我们的命令看起来意图很明显的话， 函数的括号是可以省略的。另一个是函数缺省的参数值是 `World`。意思就是说 “如果 `name` 参数没有给出的话， `name` 的缺省值就设置为 `“World\"`。\n",
    "\n",
    "## 如何更有礼貌\n",
    "\n",
    "让我们更有礼貌一些，不光记住您的名字，还在您到来的时候欢迎您，并且始终彬彬有礼。 您可以开始使用对象了。我们先建立 ”Greeter” (有礼貌的人) 类。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":say_bye"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Greeter\n",
    "  def initialize(name = \"World\")\n",
    "    @name = name\n",
    "  end\n",
    "  def say_hi\n",
    "    puts \"Hi #{@name}!\"\n",
    "  end\n",
    "  def say_bye\n",
    "    puts \"Bye #{@name}, come back soon.\"\n",
    "  end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "新的关键字 `class`！ 这个关键字定义了一个新的类 `Greeter` 和它的一些函数。 特别留意一下 `@name`，这是一个实例变量。类里面的任何函数都可以使用实例变量。 您可以看到 `say_hi` 和 `say_bye` 函数都使用了它。\n",
    "\n",
    "下面我们要带着 `Greeter` 类出来活动活动了。\n",
    "\n",
    "我们来建立一个 `greeter` 对象然后使用它："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Greeter:0x007fc035a45c98 @name=\"Pat\">"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = Greeter.new(\"Pat\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Pat!\n"
     ]
    }
   ],
   "source": [
    "g.say_hi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bye Pat, come back soon.\n"
     ]
    }
   ],
   "source": [
    "g.say_bye"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当 `g` 对象被建立后，它就记住了名字属性的值 Pat。Hmm… 如果我们想直接读取名字的值呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "<main>: syntax error, unexpected tIVAR, expecting '('\ng.@name\n       ^",
     "traceback": [
      "\u001b[31mSyntaxError\u001b[0m: <main>: syntax error, unexpected tIVAR, expecting '('\ng.@name\n       ^",
      "\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"
     ],
     "output_type": "error"
    }
   ],
   "source": [
    "g.@name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "晕，做不到。\n",
    "\n",
    "## 揭开对象的面纱\n",
    "\n",
    "实例变量是被隐藏起来的，但他们并不是被完全的隐藏起来。 当您检查一个对象的时候还是可以看到他们的。Ruby采用了面向对象的思想，将内部属性保护了起来。\n",
    "\n",
    "到底 Greeter 有哪些函数呢？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:say_hi, :say_bye, :to_json, :instance_of?, :kind_of?, :is_a?, :tap, :public_send, :method, :public_method, :singleton_method, :remove_instance_variable, :lsmagic, :define_singleton_method, :instance_variable_set, :extend, :to_enum, :enum_for, :gem, :<=>, :===, :=~, :!~, :eql?, :respond_to?, :freeze, :inspect, :object_id, :send, :display, :to_s, :nil?, :hash, :class, :singleton_class, :clone, :dup, :itself, :taint, :tainted?, :untaint, :untrust, :untrusted?, :trust, :frozen?, :methods, :singleton_methods, :protected_methods, :private_methods, :public_methods, :instance_variable_get, :instance_variables, :instance_variable_defined?, :!, :==, :!=, :__send__, :equal?, :instance_eval, :instance_exec, :__id__]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Greeter.instance_methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "哇。。。有这么多！可我们只定义了两个啊，怎么回事？这里列出的其实是 `Greeter` 对象包含的 所有 的函数，当然也就包括了它所继承的类的函数了。如果我们只希望列出 Greeter 自己的函数，可以提供一个 `false` 参数给 `instance_methods`，表示我们不希望列出祖先类的函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:say_hi, :say_bye]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Greeter.instance_methods(false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "看起来好多了。我们来看看 `greeter` 会对哪些函数作出回应："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.respond_to?(\"name\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.respond_to?(\"say_hi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.respond_to?(\"to_s\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "它知道 `say_hi` 和 `to_s`（意思是把什么东西转换成字符串，这是每个对象都有的功能）， 但是它不知道 `name`。\n",
    "\n",
    "## 改变类吧，永远都不晚\n",
    "\n",
    "假如您想获取甚至改变名字属性呢？Ruby 提供了一个简单的方法来访问属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Greeter\n",
    "  attr_accessor :name\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 Ruby 里，您可以把一个类打开然后改变它。这些改变会对以后生成的甚至是已经生成的对象产生即时效果。 下面我们来建一个新的 Greeter 对象，然后看一看它的 `@name` 属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Greeter:0x007fc035958a10 @name=\"Andy\">"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = Greeter.new(\"Andy\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.respond_to?(\"name\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.respond_to?(\"name=\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Andy!\n"
     ]
    }
   ],
   "source": [
    "g.say_hi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Betty\""
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.name=\"Betty\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "#<Greeter:0x007fc035958a10 @name=\"Betty\">"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Betty\""
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Betty!\n"
     ]
    }
   ],
   "source": [
    "g.say_hi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`attr_accessor` 会自动为我们定义两个新的函数， `name` 用来读取变量的值， `name=` 用来给变量赋值。\n",
    "\n",
    "## 见面熟的 MegaGreeter！\n",
    "\n",
    "已经建立好的这个 greeter 不是那么有新意，它一次只能向一个人问好。如果我们有一个 MegaGreeter 可以同时向世界，一个人，甚至向一群人问好，那该多好啊？\n",
    "\n",
    "我们不再使用互动 Ruby 的解析器 IRB 了，而是把代码写到一个文件里。\n",
    "\n",
    "输入 “exit” 或者按下 Control-D 退出 IRB。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing ri20min.rb\n"
     ]
    }
   ],
   "source": [
    "%%file ri20min.rb\n",
    "#!/usr/bin/env ruby\n",
    "\n",
    "class MegaGreeter\n",
    "  attr_accessor :names\n",
    "\n",
    "  # Create the object\n",
    "  def initialize(names = \"World\")\n",
    "    @names = names\n",
    "  end\n",
    "\n",
    "  # Say hi to everybody\n",
    "  def say_hi\n",
    "    if @names.nil?\n",
    "      puts \"...\"\n",
    "    elsif @names.respond_to?(\"each\")\n",
    "      # @names is a list of some kind, iterate!\n",
    "      @names.each do |name|\n",
    "        puts \"Hello #{name}!\"\n",
    "      end\n",
    "    else\n",
    "      puts \"Hello #{@names}!\"\n",
    "    end\n",
    "  end\n",
    "\n",
    "  # Say bye to everybody\n",
    "  def say_bye\n",
    "    if @names.nil?\n",
    "      puts \"...\"\n",
    "    elsif @names.respond_to?(\"join\")\n",
    "      # Join the list elements with commas\n",
    "      puts \"Goodbye #{@names.join(\", \")}.  Come back soon!\"\n",
    "    else\n",
    "      puts \"Goodbye #{@names}.  Come back soon!\"\n",
    "    end\n",
    "  end\n",
    "\n",
    "end\n",
    "\n",
    "\n",
    "if __FILE__ == $0\n",
    "  mg = MegaGreeter.new\n",
    "  mg.say_hi\n",
    "  mg.say_bye\n",
    "\n",
    "  # Change name to be \"Zeke\"\n",
    "  mg.names = \"Zeke\"\n",
    "  mg.say_hi\n",
    "  mg.say_bye\n",
    "\n",
    "  # Change the name to an array of names\n",
    "  mg.names = [\"Albert\", \"Brenda\", \"Charles\",\n",
    "    \"Dave\", \"Engelbert\"]\n",
    "  mg.say_hi\n",
    "  mg.say_bye\n",
    "\n",
    "  # Change to nil\n",
    "  mg.names = nil\n",
    "  mg.say_hi\n",
    "  mg.say_bye\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "把这个文件储存到 “ri20min.rb”， 然后在命令行输入 “ruby ri20min.rb” 来运行它。 您应该可以看到："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "Goodbye World.  Come back soon!\n",
      "Hello Zeke!\n",
      "Goodbye Zeke.  Come back soon!\n",
      "Hello Albert!\n",
      "Hello Brenda!\n",
      "Hello Charles!\n",
      "Hello Dave!\n",
      "Hello Engelbert!\n",
      "Goodbye Albert, Brenda, Charles, Dave, Engelbert.  Come back soon!\n",
      "...\n",
      "...\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%run ri20min.rb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个例子里有很多新鲜的代码，我们还是来仔细的瞧瞧\n",
    "\n",
    "下面我们来看看这个新的程序。请注意由 (#) 开始的第一行。 在 Ruby 里面，任何代码中井字符后面的内容都会被解释器忽略。 而第一行有点特别，因为在 Unix 操作系统下， 井字符开头的第一行告诉了系统的 Shell 如何执行这个文件。其他井字符引导的注释只是起说明的作用。\n",
    "\n",
    "我们熟悉的 `say_hi` 函数也了有点变化：\n",
    "\n",
    "```ruby\n",
    "# Say hi to everybody\n",
    "def say_hi\n",
    "  if @names.nil?\n",
    "    puts \"...\"\n",
    "  elsif @names.respond_to?(\"each\")\n",
    "    # @names is a list of some kind, iterate!\n",
    "    @names.each do |name|\n",
    "      puts \"Hello #{name}!\"\n",
    "    end\n",
    "  else\n",
    "    puts \"Hello #{@names}!\"\n",
    "  end\n",
    "end\n",
    "```\n",
    "\n",
    "它现在会根据 `@names` 参数的不同而采取不同的行动。如果参数是 `nil`，它会打印三个点。没有理由和空气问好对吗？\n",
    "\n",
    "## 循环，迭代\n",
    "\n",
    "如果 `@names` 对象可以回应 `each` 函数，那它就是可以被迭代的， 于是我们对它做迭代，向每个人问好。最后如果 @names 是其他的类， 就把它转化为字符串，用默认的方式问好。\n",
    "\n",
    "下面看一看这个迭代结构\n",
    "\n",
    "```ruby\n",
    "@names.each do |name|\n",
    "  puts \"Hello #{name}!\"\n",
    "end\n",
    "```\n",
    "\n",
    "`each` 是一个可以接受代码块的函数。它在迭代每一个元素时都会调用一次之前所接受到的代码块。 代码块像是一个不需要命名的函数，和 `lambda` 类似。 在`| |`之间的就是传输给代码块的参数。\n",
    "\n",
    "具体来说就是在每一次循环中，`name` 首先被赋值为 `list` 里面一个对应元素的值， 然后作为参数传递到 `puts \"Hello #{name}!\"` 这句命令里。\n",
    "\n",
    "大多数编程语言都是用 `for` 循环来完成迭代的，比如在 C 里面：\n",
    "\n",
    "```c\n",
    "for (i=0; i<number_of_elements; i++)\n",
    "{\n",
    "  do_something_with(element[i]);\n",
    "}\n",
    "```\n",
    "\n",
    "这样也成，不过不那么优美。您需要一个没什么意思的 `i` 来监控列表长度和检测循环退出的判断。 Ruby 的方法对比来看就更清爽，所有的清理工作都被隐藏在 `each` 函数里了， 您只需要告诉它您想做什么。在 each 函数内部，实际上会去自动调用 `yield \"Albert\"`，`yield \"Brenda\"`，`yield \"Charles\"`，等等。\n",
    "\n",
    "## 代码块，让 Ruby 闪亮\n",
    "\n",
    "代码块最有用的地方是用来处理比迭代列表更繁琐的工作。除了一般家务活之外， 您可以用它来自动安装卸载或处理运行错误。真正做到让用户省心、放心。\n",
    "\n",
    "```ruby\n",
    "# Say bye to everybody\n",
    "def say_bye\n",
    "  if @names.nil?\n",
    "    puts \"...\"\n",
    "  elsif @names.respond_to?(\"join\")\n",
    "    # Join the list elements with commas\n",
    "    puts \"Goodbye #{@names.join(\", \")}.  Come back soon!\"\n",
    "  else\n",
    "    puts \"Goodbye #{@names}.  Come back soon!\"\n",
    "  end\n",
    "end\n",
    "```\n",
    "\n",
    "`say_bye` 函数并没有用到 `each`，而是查看 `@names` 是否支持 `join` 函数。如果是的话就调用，否则就简单的将变量转化为字符串。 这种不在乎类的作风就是常说的“鸭子型”，意思就是说“如果它走起来像鸭子，叫起来像鸭子， 那它一定是鸭子”。这种思想的好处就是不限制函数所支持的参数类别。 如果有人写了一个新的类，只要它像其他列表类一样回应 `join` 这个函数， 那它就可以被相应的其他函数所使用。\n",
    "\n",
    "## 让脚本跑起来\n",
    "\n",
    "这就是 MegaGreeter 类的所有内容了。剩下的代码就只是调用一下这个类的函数。 还有最后一点小技术在这里：\n",
    "\n",
    "```ruby\n",
    "if __FILE__ == $0\n",
    "```\n",
    "\n",
    "`__FILE__` 是一个魔法值，它存有现在运行的脚本文件的名字。`$0` 是启动脚本的名字。 代码里的比较结构的意思是 “如果这是启动脚本的话…” 这允许代码作为库调用的时候不运行启动代码， 而在作为执行脚本的时候调用启动代码。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 就这么多啦\n",
    "\n",
    "Ruby 20分钟体验已经结束了，但 Ruby 还有无数值得探索的地方：代码块与 `yield`， 模块与 `mixins`，等等。在简短的体验了 Ruby 语言后，希望您愿意进一步接触它。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "File.delete('ri20min.rb')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 参考资料\n",
    "\n",
    "* [Ruby in Twenty Minutes][ruby-in-twenty-minutes]\n",
    "\n",
    "[ruby-in-twenty-minutes]: https://www.ruby-lang.org/en/documentation/quickstart/ \"Ruby in Twenty Minutes\""
   ]
  }
 ],
 "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
}