03-ruby-syntax/03.03-loop-statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 循环"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "循环的作用在于将一段代码重复执行多次。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## while 循环"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "while <condition> [do]\n",
    "    <statesments>\n",
    "end\n",
    "```\n",
    "\n",
    "```\n",
    "<statement> while <condition>\n",
    "```\n",
    "\n",
    "```\n",
    "begin\n",
    "    <statesments>\n",
    "end while <condition>\n",
    "```\n",
    "\n",
    "**Ruby** 会循环执行`<statesments>` 或 `<statement>`，直到`<condition>`不满足为止。\n",
    "\n",
    "例如，计算数字`0`到`1000000`的和："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "499999500000\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "total = 0\n",
    "\n",
    "while i < 1000000 do\n",
    "    total += i\n",
    "    i += 1\n",
    "end\n",
    "\n",
    "puts total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "499999500000\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "total = 0\n",
    "\n",
    "begin\n",
    "  total += i\n",
    "  i += 1\n",
    "end while i < 1000000\n",
    "  \n",
    "puts total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "之前提到，`nil` 会被当成 `false` ，因此可以用 `while` 循环来读取容器中的所有元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perform King Lear\n",
      "Perform Macbeth\n",
      "Perform Hamlet\n"
     ]
    }
   ],
   "source": [
    "plays = ['Hamlet', 'Macbeth', 'King Lear']\n",
    "\n",
    "puts \"Perform #{plays.pop()}\" while plays.any?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "循环每次从 `plays` 中弹出一个元素，一直到 `plays` 中拿出的元素为空为止。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for 循环"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "for <variable> in <target> [do]\n",
    "    <indented block of code>\n",
    "end\n",
    "```\n",
    "\n",
    "`for` 循环会遍历完`<target>`中所有元素为止。\n",
    "\n",
    "上一个例子可以改写成如下形式："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perform Hamlet\n",
      "Perform Macbeth\n",
      "Perform King Lear\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[\"Hamlet\", \"Macbeth\", \"King Lear\"]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plays = ['Hamlet', 'Macbeth', 'King Lear']\n",
    "\n",
    "for play in plays\n",
    "  puts \"Perform #{play}\" \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 `for` 循环时，注意尽量不要改变 `plays` 的值，否则可能会产生意想不到的结果。\n",
    "\n",
    "之前的求和也可以通过 `for` 循环来实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "499999500000"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "for i in (0...1000000)\n",
    "    total += i\n",
    "end\n",
    "print total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`for` 循环隐式依赖于目标对象的 `each` 方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10,9,8,7,6,5,4,3,2,1,"
     ]
    }
   ],
   "source": [
    "class CountDown\n",
    "  \n",
    "  def initialize(value = 10)\n",
    "    @value = value\n",
    "  end\n",
    "  \n",
    "  def each()\n",
    "    value = @value\n",
    "    while value > 0\n",
    "      yield value \n",
    "      value -= 1\n",
    "    end\n",
    "  end\n",
    "    \n",
    "end\n",
    "\n",
    "for i in CountDown.new\n",
    "  print i, ','\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不要使用 `for in`，总是使用 `obj.each`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10,9,8,7,6,5,4,3,2,1,"
     ]
    }
   ],
   "source": [
    "ReverseNumber.new.each{|i| print i, ','}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "499999500000"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "(0...1000000).each do|i|\n",
    "    total += i\n",
    "end\n",
    "print total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perform Hamlet\n",
      "Perform Macbeth\n",
      "Perform King Lear\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[\"Hamlet\", \"Macbeth\", \"King Lear\"]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plays = ['Hamlet', 'Macbeth', 'King Lear']\n",
    "\n",
    "plays.each{|play| puts \"Perform #{play}\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `until` 循环\n",
    "\n",
    "类似于 `while`，**Ruby**还提供了 `until` 语句，不过它们对条件的判断是相反。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "499999500000\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "total = 0\n",
    "\n",
    "until i >= 1000000 do\n",
    "    total += i\n",
    "    i += 1\n",
    "end\n",
    "\n",
    "puts total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "499999500000\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "total = 0\n",
    "\n",
    "begin\n",
    "  total += i\n",
    "  i += 1\n",
    "end until i >= 1000000\n",
    "  \n",
    "puts total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perform King Lear\n",
      "Perform Macbeth\n",
      "Perform Hamlet\n"
     ]
    }
   ],
   "source": [
    "plays = ['Hamlet', 'Macbeth', 'King Lear']\n",
    "\n",
    "puts \"Perform #{plays.pop()}\" until plays.empty?   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## next 语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "遇到 `next` 的时候，程序会返回到循环的最开始重新执行，类似于其他语言中的 `continue` 。\n",
    "\n",
    "例如在循环中忽略一些特定的值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "values = [7, 6, 4, 7, 19, 2, 1]\n",
    "i = 0\n",
    "\n",
    "while i < values.length\n",
    "  e = values[i]\n",
    "  i += 1\n",
    "  next if e % 2 != 0\n",
    "  puts e / 2\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[7, 6, 4, 7, 19, 2, 1]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = [7, 6, 4, 7, 19, 2, 1]\n",
    "\n",
    "for i in values\n",
    "  next if i % 2 != 0\n",
    "  puts i / 2\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[7, 6, 4, 7, 19, 2, 1]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "values = [7, 6, 4, 7, 19, 2, 1]\n",
    "\n",
    "values.each do|i|\n",
    "  next if i % 2 != 0\n",
    "  puts i / 2\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## break 语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "遇到 `break` 的时候，程序会跳出循环，不管循环条件是不是满足："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start\n",
      "process\n",
      "process\n",
      "process\n"
     ]
    }
   ],
   "source": [
    "command_list = ['start', \n",
    "                'process', \n",
    "                'process',\n",
    "                'process', \n",
    "                'stop', \n",
    "                'start', \n",
    "                'process', \n",
    "                'stop']\n",
    "\n",
    "while command = command_list.shift()\n",
    "  break if command == 'stop'      \n",
    "  puts(command)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在遇到第一个 `'stop'` 之后，程序跳出循环。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start\n",
      "process\n",
      "process\n",
      "process\n"
     ]
    }
   ],
   "source": [
    "command_list = ['start', \n",
    "                'process', \n",
    "                'process',\n",
    "                'process', \n",
    "                'stop', \n",
    "                'start', \n",
    "                'process', \n",
    "                'stop']\n",
    "\n",
    "for command in command_list\n",
    "  break if command == 'stop'      \n",
    "  puts(command)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start\n",
      "process\n",
      "process\n",
      "process\n"
     ]
    }
   ],
   "source": [
    "command_list = ['start', \n",
    "                'process', \n",
    "                'process',\n",
    "                'process', \n",
    "                'stop', \n",
    "                'start', \n",
    "                'process', \n",
    "                'stop']\n",
    "\n",
    "command_list.each do|command|\n",
    "  break if command == 'stop'      \n",
    "  puts(command)\n",
    "end"
   ]
  }
 ],
 "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
}