03-ruby-syntax/03.04-iterators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 迭代器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 简介"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在**Ruby**中，迭代器是允许循环遍历集合中的所有元素一个方法，它允许传入一个回调的代码块。迭代器方法只负责遍历需要遍历的元素，而对元素所做的处理则通过回调代码块来实现。\n",
    "\n",
    "常见的迭代器方法有`each`，`find`(aka: `detect`)，`map`(aka: `collect`)，`reduct`(aka: `inject`)。\n",
    "\n",
    "像这种，遍历集合的控制权在迭代器方法上，它将需要处理的值推送给需要它们的代码块。我们称这种迭代器为 **内部迭代器**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [2, 4, 6]\n",
    "\n",
    "a.each do|n|\n",
    "  puts n\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其好处是不需要对下标进行迭代，但是有些情况下，我们既希望获得下标，也希望获得对应的值，那么可以使用 `each_with_index` 函数，这样每次迭代都会返回一组 `(value, index)` 组成的数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pos 0 is 2\n",
      "pos 1 is 4\n",
      "pos 2 is 6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [2, 4, 6]\n",
    "\n",
    "a.each_with_index do|n, i|\n",
    "  puts \"pos #{i} is #{n}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 **Ruby** 中，你依然可以很轻松地使用 `for in` 语句来遍历集合，只要集合实现了 `each` 方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n",
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [2, 4, 6]\n",
    "\n",
    "for n in a\n",
    "  puts n\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 自定义迭代器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面我们来看一个例子，如何实现一个支持迭代器方法的对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class DownCounter\n",
    "\n",
    "  def initialize(value=10)\n",
    "    @value = value\n",
    "  end\n",
    "  \n",
    "  def each\n",
    "    @value.downto(0) do|i|\n",
    "      yield i\n",
    "    end\n",
    "  end\n",
    "  \n",
    "end\n",
    "\n",
    "counter = DownCounter.new(5)\n",
    "\n",
    "counter.each do|n|\n",
    "  puts n\n",
    "end\n",
    "\n",
    "for n in counter\n",
    "  puts n\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果需要对 `DownCounter` 对象遍历的时候，同时获得元素下标，这时的对象是默认不支持 `each_with_index` 方法的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counter.respond_to?(:each_with_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:each, :to_json, :instance_of?, :kind_of?, :is_a?, :tap, :public_send, :method, :public_method, :singleton_method, :remove_instance_variable, :define_singleton_method, :instance_variable_set, :extend, :lsmagic, :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": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "origin_methods = counter.methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 **Ruby** 中，当我们实现一个支持迭代方法的类型的时候，一般都需要继承 `Enumerable`，以便获取更多实用方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:max, :min, :to_a, :to_h, :include?, :find, :entries, :sort, :sort_by, :grep, :grep_v, :count, :detect, :find_index, :find_all, :select, :reject, :collect, :map, :flat_map, :collect_concat, :inject, :reduce, :partition, :group_by, :first, :all?, :any?, :one?, :none?, :minmax, :min_by, :max_by, :minmax_by, :member?, :each_with_index, :reverse_each, :each_entry, :each_slice, :each_cons, :each_with_object, :zip, :take, :take_while, :drop, :drop_while, :cycle, :chunk, :slice_before, :slice_after, :slice_when, :chunk_while, :sum, :uniq, :lazy, :to_set]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class DownCounter\n",
    "  include Enumerable\n",
    "end\n",
    "\n",
    "counter.methods - origin_methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pos 0 is 5\n",
      "pos 1 is 4\n",
      "pos 2 is 3\n",
      "pos 3 is 2\n",
      "pos 4 is 1\n",
      "pos 5 is 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "#<DownCounter:0x007ffc418d2968 @value=5>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counter.each_with_index do|n, i|\n",
    "  puts \"pos #{i} is #{n}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "0\n",
      "5\n",
      "reverse travel 0\n",
      "reverse travel 1\n",
      "reverse travel 2\n",
      "reverse travel 3\n",
      "reverse travel 4\n",
      "reverse travel 5\n",
      "[10, 8, 6, 4, 2, 0]\n"
     ]
    }
   ],
   "source": [
    "puts counter.max\n",
    "puts counter.min\n",
    "puts counter.first\n",
    "counter.reverse_each{|n| puts \"reverse travel #{n}\"}\n",
    "puts counter.collect{|n| 2 * n}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再来看一个例子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       ":each"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Collatz\n",
    "  include Enumerable\n",
    "    \n",
    "  def initialize(start)\n",
    "    @value = start\n",
    "  end\n",
    "  \n",
    "  def each\n",
    "    n = @value\n",
    "    \n",
    "    while n != 1\n",
    "      if n % 2 == 0\n",
    "        n /= 2\n",
    "      else\n",
    "        n = 3 * n + 1\n",
    "      end\n",
    "      yield n\n",
    "    end\n",
    "    \n",
    "  end\n",
    "  \n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里我们实现 [Collatz 猜想](https://zh.wikipedia.org/zh-hans/%E8%80%83%E6%8B%89%E5%85%B9%E7%8C%9C%E6%83%B3)：\n",
    "\n",
    "- 奇数 n：返回 3n + 1\n",
    "- 偶数 n：返回 n / 2\n",
    "\n",
    "直到 n 为 1 为止："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22,11,34,17,52,26,13,40,20,10,5,16,8,4,2,1,"
     ]
    }
   ],
   "source": [
    "Collatz.new(7).each do|n|\n",
    "  print \"#{n},\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 更多用法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 potato\n",
      "2 potato\n",
      "3 potato\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3.times do |i|\n",
    "  potatoes = i+1\n",
    "  puts \"#{potatoes} potato\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"<<elppa>><<ananab>><<yrrehc>>\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"apple\", \"banana\", \"cherry\"].map{|fruit| fruit.reverse}.inject(''){|s, item| s << \"<<#{item}>>\"}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意：`each`返回数组本身，链式调用的时候，会忽略代码块的返回值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"<<apple>><<banana>><<cherry>>\""
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"apple\", \"banana\", \"cherry\"].each{|fruit| fruit.reverse}.inject(''){|s, item| s << \"<<#{item}>>\"}"
   ]
  }
 ],
 "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
}