03-ruby-syntax/03.05-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "函数 `function` ，通常接受输入参数，并有返回值。\n",
    "\n",
    "它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。\n",
    "\n",
    "在支持面向对象的编程语言当中，函数依附于对象或者类型而存在，因此也被称作 **`Method`**(方法)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":add"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Add two numbers\n",
    "def add(x, y)\n",
    "  ret = x + y\n",
    "  return ret\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "函数通常有一下几个特征：\n",
    "- 使用 `def` 关键词来定义一个函数。\n",
    "-  `def` 后面是函数的名称，括号中是函数的参数，不同的参数用 `,` 隔开， `def foo` 的形式是必须要有的，参数可以为空，括号可以省略；\n",
    "- `def` 和 `end` 之间为函数的主体代码块；\n",
    "-  `return` 返回特定的值，一般可以省略，**Ruby**函数总是把最后一行的表达式的值作为返回值。\n",
    "\n",
    "**Ruby** 的语法非常灵活，你甚至可以把刚刚的函数改下成下面的形式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":add"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add x, y; x + y end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不过推荐的写法是下面的形式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":add"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(x, y)\n",
    "  x + y\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用函数时，只需要将参数换成特定的值传给函数，调用的括号可以省略。\n",
    "\n",
    "**Ruby** 并没有限定参数的类型，因此可以使用不同的参数类型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add 1, 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"foobar\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add('foo', 'bar')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"foobar\""
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add 'foo', 'bar'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这个例子中，如果传入的两个参数不可以相加，那么**Ruby**会将报错："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "String can't be coerced into Integer",
     "output_type": "error",
     "traceback": [
      "\u001b[31mTypeError\u001b[0m: String can't be coerced into Integer",
      "\u001b[37m<main>:1:in `+'\u001b[0m",
      "\u001b[37m<main>:1:in `add'\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": [
    "add(2, \"foo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果传入的参数数目与实际不符合，也会报错："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "ArgumentError",
     "evalue": "wrong number of arguments (given 3, expected 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[31mArgumentError\u001b[0m: wrong number of arguments (given 3, expected 2)",
      "\u001b[37m<main>:1:in `add'\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": [
    "add 1, 2, 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "ArgumentError",
     "evalue": "wrong number of arguments (given 1, expected 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[31mArgumentError\u001b[0m: wrong number of arguments (given 1, expected 2)",
      "\u001b[37m<main>:1:in `add'\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": [
    "add(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 具名参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当在 **Ruby** 中调用方法时，你不得不按照特定的顺序输入参数，有没有办法传入参数时，指定参数名称，像如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"barfoo\""
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(y='bar', x='foo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "语法没有报错，但是行为却不是预期的，上述代码其实等价于："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"barfoo\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 'bar'\n",
    "x = 'foo'\n",
    "add(y, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果希望使用具名参数，传统的做法是使用 `Hash` 参数，不过 `2.0` 之后，可以使用如下方式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":add2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add2(x:0, y:0)\n",
    "  x + y\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"foobar\""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add2(y:'bar', x:'foo')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果选择了具名参数的方式来定义函数，则如下的调用方式将 **不再支持**：\n",
    "\n",
    "```ruby\n",
    "add2(1, 2)\n",
    "add2('foo', 'bar')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设定参数默认值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以在函数定义的时候给参数设定默认值，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":quad"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def quad(x, a=1, b=0, c=0)\n",
    "  a*x**2 + b*x + c\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以省略有默认值的参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quad(2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以修改参数的默认值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quad(2.0, 1, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quad(2.0, 2, 0, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调用只可以省略最后的参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 接收不定参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用如下方法，可以使函数接受不定数目的参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":add"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(x, *args)\n",
    "  total = x\n",
    "  args.each do|arg|\n",
    "    total += arg\n",
    "  end\n",
    "  total\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里，`*args` 表示参数数目不定，可以看成一个数组，把第一个参数后面的参数当作数组中的元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "puts add(1, 2, 3, 4)\n",
    "puts add(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这样定义的函数不能使用关键词传入参数，要使用关键词，可以这样："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":add3"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add3(x, **kwargs)\n",
    "  total = x\n",
    "  kwargs.each do|k, v|\n",
    "    puts \"adding #{k}\"\n",
    "    total += v\n",
    "  end\n",
    "  total\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里， `**kwargs` 表示参数数目不定，本质是一个 `Hash`，关键词和值对应于键值对。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "adding y\n",
      "adding z\n",
      "adding w\n",
      "46"
     ]
    }
   ],
   "source": [
    "print add3(10, y:11, z:12, w:13)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再看这个例子，可以接收任意数目的位置参数和键值对参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args = [], kwargs = {}\n",
      "args = [1, 2], kwargs = {}\n",
      "args = [], kwargs = {:x=>\"bar\", :z=>10}\n",
      "args = [1, 2], kwargs = {:x=>\"bar\", :z=>10}\n"
     ]
    }
   ],
   "source": [
    "def foo(*args, **kwargs)\n",
    "  puts \"args = #{args}, kwargs = #{kwargs}\"\n",
    "end\n",
    "foo\n",
    "foo(1, 2)\n",
    "foo(x:'bar', z:10)\n",
    "foo(1, 2, x:'bar', z:10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不过要按顺序传入参数，先传入位置参数 `args` ，在传入关键词参数 `kwargs` 。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 返回多个值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "函数可以返回多个值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 120]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def calc(*args)\n",
    "  sum, prod = 0, 1\n",
    "  args.each do|arg|\n",
    "    sum = sum + arg\n",
    "    prod = prod * arg\n",
    "  end\n",
    "  return sum, prod\n",
    "end\n",
    "\n",
    "sum, prod = calc(1, 2, 3, 4, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "事实上，**Ruby**将返回的两个值变成了 `Array`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15, 120]"
     ]
    }
   ],
   "source": [
    "print calc(1, 2, 3, 4, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为这个 `Array` 中有两个值，所以可以使用\n",
    "\n",
    "```ruby\n",
    "sum, prod = calc(1, 2, 3, 4, 5)\n",
    "```\n",
    "\n",
    "给两个值赋值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "事实上，不仅仅返回值可以用 `Array` 表示，也可以将参数用 `Array` 以这种方式传入："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(x, y)\n",
    "  x + y\n",
    "end\n",
    "    \n",
    "z = [2, 3]\n",
    "add(*z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的 `*` 必不可少。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mimic Methods\n",
    "\n",
    "**Ruby** 中的关键字其实不少，但是却很少限制他们的用处，许多关键字甚至可以用作方法名，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "puts (2..5).begin\n",
    "puts (3..6).end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "So confused!\n"
     ]
    }
   ],
   "source": [
    "o = {}\n",
    "\n",
    "def o.if(expr)\n",
    "  yield unless expr\n",
    "end\n",
    "  \n",
    "o.if 1 > 2 do\n",
    "  puts \"So confused!\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "许多 **Ruby** 中看起来像关键字或者运算符的语句，其实都是方法调用。\n",
    "\n",
    "比如常见的 `puts`, `p`, `print`，`===`, `<=`, `<<`，`[]` 等。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "Hello World"
     ]
    }
   ],
   "source": [
    "puts(\"Hello World\")\n",
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "1\n",
      "true\n",
      "true\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "puts 'h'.==(\"h\")\n",
    "puts 'hello'.=~(/[aeiou]/)\n",
    "puts (1..5).===(3)\n",
    "puts 1.<=(5)\n",
    "puts 9.<=>(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 5]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "a.<<(5)\n",
    "\n",
    "puts a.[](-1)\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "你所看到的运算符，不过是语法糖而已。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ruby** 中的括号 `()` 其实一般只是起到分割的作用，并没有特殊的语法含义，一般用来改变表达式的优先级，或者防止歧义。\n",
    "\n",
    "以下两种方式，完全等价。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n",
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "puts add(1, 2)\n",
    "puts (add 1, 2)\n",
    "\n",
    "puts add(add(add(1, 2), 3), 4)\n",
    "puts (add (add (add 1, 2), 3), 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再来看个例子，熟悉 `LISP` 的同学应该觉得很眼熟吧。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(def add a, b\n",
    "  a + b\n",
    "end)\n",
    "\n",
    "(add 1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "正是由于 **Ruby** 灵活的语法规则，开发者有更多的自由，也使得使用 **Ruby** 定制`DSL`是件轻松和有趣的事情。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 更多特性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":my_func"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_func(a, b)\n",
    "  puts \"args: [#{a}, #{b}], callee: #{__callee__}, method: #{__method__}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 获取函数的更多信息\n",
    "\n",
    "因为 **Ruby** 中方法调用，括号可以省略，因此无法通过 `my_func` 来访问，因为这么写，是在调用函数 `my_func`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_func\n",
      "2\n",
      "[[:req, :a], [:req, :b]]\n",
      "[\"<main>\", 0]\n",
      "Object\n",
      "main\n"
     ]
    }
   ],
   "source": [
    "f = method(:my_func)\n",
    "\n",
    "puts f.name                   # 名称\n",
    "puts f.arity                  # 参数个数\n",
    "puts f.parameters             # 参数个数\n",
    "puts f.source_location        # 代码位置\n",
    "puts f.owner                  # 所在的类型\n",
    "puts f.receiver               # 关联的对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args: [hello, world], callee: my_func, method: my_func\n"
     ]
    }
   ],
   "source": [
    "f.call('hello', 'world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "gem\n",
      "-2\n",
      "[[:req, :dep], [:rest, :reqs]]\n",
      "[\"/usr/local/rvm/gems/ruby-2.4.1/gems/bundler-1.16.1/lib/bundler/rubygems_integration.rb\", 373]\n",
      "Kernel\n",
      "main\n"
     ]
    }
   ],
   "source": [
    "f = method(:gem)\n",
    "\n",
    "puts f.name                   # 名称\n",
    "puts f.arity                  # 参数个数\n",
    "puts f.parameters             # 参数个数\n",
    "puts f.source_location        # 代码位置\n",
    "puts f.owner                  # 所在的类型\n",
    "puts f.receiver               # 关联的对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `alias` 和 `undef`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args: [1, 2], callee: my_func, method: my_func\n",
      "args: [1, 2], callee: my_func2, method: my_func\n"
     ]
    }
   ],
   "source": [
    "alias :my_func2 :my_func\n",
    "\n",
    "my_func(1, 2)\n",
    "my_func2(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意 `__callee__` 和 `__mehtod__` 的区别。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before undef:\n",
      "args: [1, 2], callee: my_func, method: my_func\n",
      "After undef:\n",
      "undefined method `my_func' for main:Object\n",
      "Did you mean?  my_func2\n",
      "args: [1, 2], callee: my_func2, method: my_func\n"
     ]
    }
   ],
   "source": [
    "begin\n",
    "  puts \"Before undef:\"\n",
    "  my_func(1, 2)\n",
    "  undef :my_func\n",
    "  \n",
    "  puts \"After undef:\"\n",
    "  my_func(1, 2)\n",
    "rescue NameError => e\n",
    "  puts e.message\n",
    "end\n",
    "\n",
    "my_func2(1, 2)"
   ]
  }
 ],
 "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": 1
}