03-ruby-syntax/03.07-scope.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 变量作用域"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在冯·诺依曼计算机体系结构的内存中，变量的属性可以视为一个六元组：（名字，地址，值，类型，生命期，作用域）。地址属性具有明显的冯·诺依曼体系结构的色彩，代表变量所关联的存储器地址。类型规定了变量的取值范围和可能的操作。生命期表示变量与某个存储区地址绑定的过程。根据生命期的不同，变量可以被分为四类：静态、栈动态、显式堆动态和隐式堆动态。作用域表征变量在语句中的可见范围，主要分为静态作用域和动态作用域两种。\n",
    "\n",
    "作用域是所有编程语言都需要了解的基础概念之一，它是是为了解决开发过程中变量名冲突发展起来的概念。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Ruby** 变量\n",
    "\n",
    "**Ruby** 中的变量主要有以下四种。\n",
    "\n",
    "- 局部变量（a_var）: 可见范围取决于作用域。\n",
    "- 全局变量（$a_var）：在程序的任何地方可见。\n",
    "- 实例变量（@a_var）：对定义该变量的类的实例及其实例方法可见，但不可以直接被类使用。\n",
    "- 类变量（@@a_var）：仅对定义该类变量的类及其子类可见。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 局部变量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> `Kernel#local_variables` 方法可以方便我们查看当前作用域中定义了哪些变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "undefined local variable or method `a_var' for main:Object\n",
      "locals is [:e, :_oh, :_ih, :title]\n"
     ]
    }
   ],
   "source": [
    "begin\n",
    "  puts a_var              # NameError，需要先声明才可以访问\n",
    "rescue NameError => e\n",
    "  puts \"#{e.message}\\nlocals is #{local_variables}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ruby** 语言是赋值即变量声明的语言，他没有与 **JavaScript** 语言的 `var x` 和 **Java** 的 `String str` 相当的变量声明。只能通过赋值语句来声明变量，但是却不需要该赋值语句真正被执行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    }
   ],
   "source": [
    "if false\n",
    "  a_var = 100\n",
    "end\n",
    "\n",
    "puts a_var.nil?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scope Gates\n",
    "\n",
    "每个 **Ruby** 作用域包含一组绑定，并且不同的作用域之间被 **Scope Gate** 分割开来。**Scope Gate** 的作用是关闭前一个作用域，同时打开一个新的作用域。**Ruby** 中使用 `class`，`module` 或 `def` 关键字来隔离作用域，也就是充当 **Scope Gate**。\n",
    "\n",
    "先来看个例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1\n",
    "def change_x\n",
    "  x = 2\n",
    "end\n",
    "\n",
    "change_x\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing change_x.py\n"
     ]
    }
   ],
   "source": [
    "%%file change_x.py\n",
    "\n",
    "x = 1\n",
    "def change_x():\n",
    "  x = 2\n",
    "\n",
    "change_x()\n",
    "print(\"x = {0}\".format(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 1\n",
      "\n"
     ]
    }
   ],
   "source": [
    "puts `python change_x.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如你所料，`x` 的值并没有真正被修改。这和 **Python** 表现是一致的，但是其深层的原理却有比较大的差别。\n",
    "\n",
    "在 **Python** 中，`change_x` 是一个闭包，它可以看到外部的 `x`，之所以没有修改成功，是因为 `change_x` 重新定义了本地变量 `x`，并把 `2` 赋值给了 `x`。\n",
    "\n",
    "在 **Ruby** 中，`change_x` 则是打开了一个全新的作用域，它是无法访问到外部的变量 `x` 的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing check_x.py\n"
     ]
    }
   ],
   "source": [
    "%%file check_x.py\n",
    "\n",
    "x = 1\n",
    "def check_x():\n",
    "  print(\"I can see x = {0} in check_x.\".format(x))\n",
    "\n",
    "check_x()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I can see x = 1 in check_x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "puts `python check_x.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们再来看一个多层 **Scope Gate** 的例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter MyModule locals: [:module1]\n",
      "enter MyClass locals: [:class2]\n",
      "exit MyClass locals: [:class2]\n",
      "exit MyModule locals: [:module1]\n",
      "my_method locals: [:method_3]\n",
      "my_method locals: [:method_3]\n",
      "main locals: [:main0, :obj, :_i7, :_7, :_i6, :_6, :_i5, :_5, :_i4, :_4, :_i3, :_3, :x, :_i2, :_2, :a_var, :_i, :_ii, :_iii, :_, :__, :___, :_i1, :_1, :e, :_oh, :_ih, :title]\n"
     ]
    }
   ],
   "source": [
    "main0 = 'main0'\n",
    "\n",
    "module MyModule\n",
    "  module1 = 'module1'\n",
    "  puts \"enter MyModule locals: #{local_variables}\"\n",
    "  \n",
    "  class MyClass\n",
    "    class2 = 'class2'\n",
    "    puts \"enter MyClass locals: #{local_variables}\"\n",
    "    \n",
    "    def my_method\n",
    "      method_3 = 'method3'\n",
    "      puts \"my_method locals: #{local_variables}\"\n",
    "    end\n",
    "    \n",
    "    puts \"exit MyClass locals: #{local_variables}\"\n",
    "  end\n",
    "  \n",
    "  puts \"exit MyModule locals: #{local_variables}\"\n",
    "end\n",
    "    \n",
    "obj = MyModule::MyClass.new\n",
    "obj.my_method\n",
    "obj.my_method\n",
    "  \n",
    "puts \"main locals: #{local_variables}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "容易看出程序打开了五个独立的作用域\n",
    "\n",
    "- 顶级作用域（`main0` 所在的作用域）\n",
    "- 进入 `MyModule` 时创建的作用域\n",
    "- 进入 `MyClass` 时创建的作用域\n",
    "- 第一次调用 `my_method()` 方法时创建的一个作用域\n",
    "- 第二次调用 `my_method()` 方法时创建的一个作用域\n",
    "\n",
    "如何知道每次调用同一方法时会重新创建新的作用域而不是重用已有的，我们通过一个程序来验证。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_method locals: [:v]\n",
      "my_method locals: [:v]\n",
      "v in binding1 is 81\n",
      "v in binding2 is 59\n",
      "binding1 variables is [:v2, :v]\n",
      "binding2 variables is [:v]\n"
     ]
    }
   ],
   "source": [
    "class MyClass\n",
    "  def my_method\n",
    "    v = rand(1..100)\n",
    "    puts \"my_method locals: #{local_variables}\"\n",
    "    binding\n",
    "  end \n",
    "end\n",
    "\n",
    "obj = MyClass.new\n",
    "binding1 = obj.my_method\n",
    "binding2 = obj.my_method\n",
    "\n",
    "puts \"v in binding1 is #{binding1.local_variable_get(:v)}\"\n",
    "puts \"v in binding2 is #{binding2.local_variable_get(:v)}\"\n",
    "\n",
    "binding1.local_variable_set(:v2, 1)\n",
    "\n",
    "puts \"binding1 variables is #{binding1.local_variables}\"\n",
    "puts \"binding2 variables is #{binding2.local_variables}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`class` / `module` 与 `def` 之间还有一点微妙的差别，在类和模块定义中的代码会被立即执行，相反，方法定义中的代码只有在方法被调用的时候才会被执行。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 顶级上下文（Top Level Context）\n",
    "\n",
    "当开始运行 **Ruby** 程序时，**Ruby** 虚拟机会创建一个名为 `main` 的对象作为当前对象，这个对象被称为顶级上下文，这个名字的由来是因为这时处在调用栈的顶层，这时要么还没调用任何方法，要么调用的所有方法都已经返回了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "main\n",
      "Object\n",
      "[:_i9, :_9, :binding1, :binding2, :_i8, :_8, :main0, :obj, :_i7, :_7, :_i6, :_6, :_i5, :_5, :_i4, :_4, :_i3, :_3, :x, :_i2, :_2, :a_var, :_i, :_ii, :_iii, :_, :__, :___, :_i1, :_1, :e, :_oh, :_ih, :title]\n"
     ]
    }
   ],
   "source": [
    "puts self\n",
    "puts self.class\n",
    "puts local_variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们现在运行代码的作用域就是顶级实例变量 `main` 所在的作用域。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 词法作用域"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "词法作用域(lexical scope)也叫静态作用域(static scope)。它其实是指作用域在词法解析阶段既确定了，不会改变。在 每个 **Scope Gate** 内部，**Ruby** 局部变量遵循词法作用域规则，代码块的开始和结束会开启和关闭一个新的词法作用域。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:inter1_v, :outer1_v, :inner1, :outer1, :outer2]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "module CleanRoom\n",
    "  \n",
    "  outer1 = lambda do\n",
    "    outer1_v = 0\n",
    "    inner1 = lambda do\n",
    "      inter1_v = 0\n",
    "      local_variables\n",
    "    end\n",
    "  end\n",
    "\n",
    "  outer2 = lambda do\n",
    "    outer2_v = 0\n",
    "    inner2 = lambda do \n",
    "      inner2_v = 0\n",
    "      outer1.call.call\n",
    "    end\n",
    "  end\n",
    "\n",
    "  outer2.call.call\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到 `inner1` 是在 `outer1` 中定义，调用是在 `inner2` 块中，可以看到在 `inner1` 中的可见的变量有定义在 `CleanRoom` 中的所有变量`[:outer1, :outer2]`，定义在 `outer1` 中的 `[:outer1_v, :inner1]` 和定义在 `inner1` 中的 `[:inner1_v]`。尽管执行是在 `outer2` 和 `inner2` 的内部，但是 `inner1` 并不能访问它们的变量定义。\n",
    "\n",
    "通俗地说，代码块会在定义时获取周围的绑定，也可以在代码块中定义额外的绑定，但这些绑定会在块定义结束时失效。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CleanRoom locals: [:outer1, :outer2]\n",
      "outer1 locals: [:outer1_v, :inner1, :outer1, :outer2]\n",
      "inner1 locals: [:inter1_v, :outer1_v, :inner1, :outer1, :outer2]\n"
     ]
    }
   ],
   "source": [
    "module CleanRoom\n",
    "  \n",
    "  outer1 = lambda do\n",
    "    outer1_v = 0\n",
    "    inner1 = lambda do\n",
    "      inter1_v = 0\n",
    "      puts \"inner1 locals: #{local_variables}\"\n",
    "    end\n",
    "    puts \"outer1 locals: #{local_variables}\"\n",
    "    inner1\n",
    "  end\n",
    "  \n",
    "  puts \"CleanRoom locals: #{local_variables}\"\n",
    "\n",
    "  outer2 = lambda do\n",
    "    outer2_v = 0\n",
    "    inner2 = lambda do \n",
    "      inner2_v = 0\n",
    "      outer1.call.call\n",
    "    end\n",
    "  end\n",
    "\n",
    "  outer2.call.call\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在代码块中，声明变量前，总是先往上查找上层环境是不是已经有该变量，如有，则直接重用，若没有则在当前块中声明该变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"new\""
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def foo()\n",
    "  x = 'old'\n",
    "  lambda do \n",
    "    x = 'new' \n",
    "  end.call\n",
    "  x\n",
    "end\n",
    "\n",
    "foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 动态作用域\n",
    "\n",
    "与词法作用域中作用域是源代码级别上的一块完整独立的范围不同，在动态作用域中，作用域则是进入该作用域开始直至离开这一时间轴上的完整独立的范围。与此相同的特征也体现在其他好多地方。比如，在某处理进行期间，一时改变某变量的值随后将原值返回的代码编写方式就相当于创建了自己专属的动态作用域。又如，异常处理与动态作用域也很相似，函数抛出异常时的处理方式受到调用函数的 try/ catch语句的影响。\n",
    "\n",
    "- 词法作用域：讨论代码的组织结构上的抽象，讨论的是“圈地”的问题（形式上的规范）。\n",
    "- 动态作用域：变量的可见性，完成对信息的隐藏，也就是处理“割据”问题（实际的占有）。\n",
    "\n",
    "现在局部变量很少会使用动态作用域，因为动态作用域中被改写的值会影响到被调用的函数，因此在引用变量时它是什么样的值，不看调用方的代码是无从得知的。如果只是为了获取调用处的值，完全可以通过参数传递来解决。动态作用域和词法作用域实现上的差别，可以参考[我之前的文章](https://github.com/jameszhan/blogs/blob/master/_posts/2015-04-01-build-interpret-from-zero.md#%E5%8A%A8%E6%80%81%E4%BD%9C%E7%94%A8%E5%9F%9F-vs-%E8%AF%8D%E6%B3%95%E4%BD%9C%E7%94%A8%E5%9F%9F)。  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由于 **Ruby** 局部变量不支持动态作用域，下面的例子，我们使用 **Perl** 语言来演示，它同时支持词法作用域和动态作用域。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing dynamic_scope.pl\n"
     ]
    }
   ],
   "source": [
    "%%file dynamic_scope.pl\n",
    "sub invoker {\n",
    "    local $x = 'invoker';\n",
    "    &func();\n",
    "}\n",
    "\n",
    "sub invoker2 {\n",
    "    local $x = 'invoker2';\n",
    "    &func();\n",
    "}\n",
    "\n",
    "$x = 'global';\n",
    "sub func {\n",
    "    print \"$x\\n\";\n",
    "}\n",
    "\n",
    "invoker();\n",
    "invoker2();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "invoker\n",
      "invoker2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "puts `perl dynamic_scope.pl`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 全局变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:$_, :$~, :$;, :$-F, :$@, :$!, :$SAFE, :$&, :$`, :$', :$+, :$=, :$KCODE, :$-K, :$,, :$/, :$-0, :$\\, :$stdin, :$stdout, :$stderr, :$>, :$<, :$., :$FILENAME, :$-i, :$*, :$:, :$-I, :$LOAD_PATH, :$\", :$LOADED_FEATURES, :$?, :$$, :$VERBOSE, :$-v, :$-w, :$-W, :$DEBUG, :$-d, :$0, :$PROGRAM_NAME, :$-p, :$-l, :$-a, :$fileutils_rb_have_lchmod, :$fileutils_rb_have_lchown]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "global_variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ruby** 中只要变量名称以 `$` 开头，这个变量就是全局变量。全局变量可以再任何作用域中访问。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$my_var is \n",
      "$my_var is 100\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[:$_, :$~, :$;, :$-F, :$@, :$!, :$SAFE, :$&, :$`, :$', :$+, :$=, :$KCODE, :$-K, :$,, :$/, :$-0, :$\\, :$stdin, :$stdout, :$stderr, :$>, :$<, :$., :$FILENAME, :$-i, :$*, :$:, :$-I, :$LOAD_PATH, :$\", :$LOADED_FEATURES, :$?, :$$, :$VERBOSE, :$-v, :$-w, :$-W, :$DEBUG, :$-d, :$0, :$PROGRAM_NAME, :$-p, :$-l, :$-a, :$fileutils_rb_have_lchmod, :$fileutils_rb_have_lchown, :$my_var]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def scope1\n",
    "  $my_var = 100\n",
    "end\n",
    "\n",
    "def scope2\n",
    "  puts \"$my_var is #{$my_var}\"\n",
    "end\n",
    "\n",
    "scope2\n",
    "scope1\n",
    "scope2\n",
    "\n",
    "global_variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "全局变量的问题在于系统中的任何部分都可以修改它们，我们几乎没法追踪谁把他们改成了什么。因此，基本的原则是：如非必要，尽可能少使用全局变量。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实例变量\n",
    "\n",
    "**Ruby** 中只要变量名称以 `@` 开头，这个变量就是实例变量，它总是属于某个实例。实例变量作用域本质是**动态作用域**，是进入该作用域开始直至离开这一时间轴上的完整独立的范围，也就进入这个实例开始，到离开这个实例结束。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "self: main, instance_variables: [:@a_var]，@a_var = 1\n",
      "self: AClass, instance_variables: [:@a_var]，@a_var = 2\n",
      "self: AClass, instance_variables: [:@a_var]，@a_var = 2\n",
      "self: main, instance_variables: [:@a_var]，@a_var = 1\n",
      "self: #<AClass:0x007fc9ae3b1828>, instance_variables: [:@a_var]，@a_var = 3\n",
      "self: #<AClass:0x007fc9ae3b1800>, instance_variables: [:@a_var]，@a_var = 6\n",
      "1\n",
      "2\n",
      "3\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "@a_var = 1\n",
    "puts \"self: #{self}, instance_variables: #{instance_variables}，@a_var = #{instance_variable_get(:@a_var)}\"\n",
    "class AClass\n",
    "  @a_var = 2\n",
    "  puts \"self: #{self}, instance_variables: #{instance_variables}，@a_var = #{instance_variable_get(:@a_var)}\"\n",
    "  \n",
    "  def a_method(init_var)\n",
    "    @a_var = init_var\n",
    "    puts \"self: #{self}, instance_variables: #{instance_variables}，@a_var = #{instance_variable_get(:@a_var)}\"\n",
    "  end\n",
    "  \n",
    "  puts \"self: #{self}, instance_variables: #{instance_variables}，@a_var = #{instance_variable_get(:@a_var)}\"\n",
    "end\n",
    "puts \"self: #{self}, instance_variables: #{instance_variables}，@a_var = #{instance_variable_get(:@a_var)}\"\n",
    "\n",
    "\n",
    "obj = AClass.new\n",
    "obj2 = AClass.new\n",
    "\n",
    "obj.a_method(3)\n",
    "obj2.a_method(6)\n",
    "\n",
    "puts self.instance_variable_get(:@a_var)\n",
    "puts AClass.instance_variable_get(:@a_var)\n",
    "puts obj.instance_variable_get(:@a_var)\n",
    "puts obj2.instance_variable_get(:@a_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一般地，我们可以认为 **Ruby** 所有的东西都是对象，也就是 `VALUE` 的实例，包括 `Class` 和 `Module`，接下来我们来分析一下上面的代码。\n",
    "\n",
    "代码开始，我们是在顶级上下文对象 `main` 当中，`@a_var = 1` 也就是给 `main` 对象声明一个 `@a_var` 的一个实例变量。\n",
    "\n",
    "执行完 `class AClass` 后，进入对象 `AClass` (`Class` 的实例)，`@a_var = 2` 也就是给 `AClass` 对象声明一个 `@a_var` 的一个实例变量。\n",
    "\n",
    "`def a_method ... end` 为AClass新增一个实例方法 `a_method`，注意，方法定义中的代码块这个时候并不会被执行。\n",
    "\n",
    "继续执行，执行完 `end` 后，离开对象 `AClass` 重新进入对象 `main`。\n",
    "\n",
    "`obj = AClass.new` 创建 `AClass` 实例 `obj`，`obj.a_method(3)` 执行过程简单来说，是先进入对象 `obj`，接着执行 `a_method` 中的代码块，最后退出对象 `obj`，重新进入 `main`。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ruby** 中的所有方法都是实例方法，执行方法的时候它总有一个接收者，也就是执行该方法的当前实例，如果不指定接收者，隐含的接收者总是 `self`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "self: main with instance_variables: [:@a_var, :@my_var]\n",
      "1\n",
      "self: main with instance_variables: [:@a_var, :@my_var]\n"
     ]
    }
   ],
   "source": [
    "def my_method1\n",
    "  @my_var = 1\n",
    "  puts \"self: #{self} with instance_variables: #{instance_variables}\"\n",
    "end\n",
    "\n",
    "def my_method2\n",
    "  puts @my_var\n",
    "  puts \"self: #{self} with instance_variables: #{instance_variables}\"\n",
    "end\n",
    "\n",
    "my_method1\n",
    "my_method2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实例变量的作用域属于实际占有它的对象，一旦进入该对象，该对象的所有方法都可以对它进行访问，而不用管它定义在哪里。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class ASuper\n",
    "  def initialize()\n",
    "    @my_var = 100\n",
    "  end\n",
    "end\n",
    "\n",
    "class ASubClass < ASuper\n",
    "  def show_my_var\n",
    "    @my_var\n",
    "  end\n",
    "end\n",
    "\n",
    "ASubClass.new.show_my_var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 类变量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**类变量** 顾名思义就是类独有的变量，但是其作用域，不同语言之间还是有一些差别。\n",
    "\n",
    "**Java** 中，类变量可以被类本身，类实例访问（不推荐），不能被子类本身或子类实例访问，读取修改的都是同一变量。\n",
    "\n",
    "**Python** 中，类变量可以被类本身，子类，类实例及子类实例访问，但是修改只可以通过类本身来修改，通过子类，类实例，或者子类实例赋值，不会修改类变量本身，等价于为子类，类实例，子类实例创建一个同名的变量。\n",
    "\n",
    "**Ruby** 中，类变量的作用域与 **Python** 比较类似，但是对同名修改的处理方式不一样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A::AA variables: [:@@aa_var]\n",
      "A variables: [:@@a_var]\n",
      "A variables: [:@@a_var]\n",
      "A::AA variables: [:@@aa_var]\n"
     ]
    }
   ],
   "source": [
    "class A\n",
    "  @@a_var = 6\n",
    "  \n",
    "  class AA\n",
    "    @@aa_var = 1\n",
    "    \n",
    "    def self.show\n",
    "      puts \"#{self} variables: #{class_variables}\"\n",
    "    end\n",
    "    puts \"#{self} variables: #{class_variables}\"\n",
    "  end\n",
    "  \n",
    "  def self.show\n",
    "    puts \"#{self} variables: #{class_variables}\"\n",
    "  end\n",
    "  \n",
    "  puts \"#{self} variables: #{class_variables}\"\n",
    "end\n",
    "\n",
    "A.show\n",
    "A::AA.show"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从这个例子可以看出，类变量是类间隔离的，即使它们存在嵌套定义关系。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B::BB variables: [:@@aa_var]\n",
      "B variables: [:@@a_var]\n",
      "B variables: [:@@a_var]\n",
      "B::BB variables: [:@@aa_var]\n"
     ]
    }
   ],
   "source": [
    "class B < A\n",
    "  \n",
    "  class BB < AA\n",
    "    puts \"#{self} variables: #{class_variables}\"\n",
    "  end\n",
    "  \n",
    "  puts \"#{self} variables: #{class_variables}\"\n",
    "end\n",
    "\n",
    "B.show\n",
    "B::BB.show"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "父类中定义的类变量，子类中可以访问。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "11\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "class C\n",
    "  @@c_var = 1\n",
    "  \n",
    "  def self.show_c\n",
    "    @@c_var\n",
    "  end\n",
    "  \n",
    "end\n",
    "\n",
    "class D < C\n",
    "  def self.set_c(v)\n",
    "    @@c_var = v\n",
    "  end\n",
    "end\n",
    "\n",
    "puts C.show_c\n",
    "puts D.show_c\n",
    "\n",
    "D.set_c(11)\n",
    "\n",
    "puts C.show_c\n",
    "puts D.show_c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到，子类中可以修改父类中的类变量，初看起来，这也不是什么大问题，我们接着再来看另外的例子。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "[]\n",
      "[:@@d_var]\n"
     ]
    }
   ],
   "source": [
    "class CC; end\n",
    "\n",
    "class DD < CC\n",
    "  @@d_var = 1\n",
    "  \n",
    "  def self.show_d\n",
    "    @@d_var\n",
    "  end\n",
    "\n",
    "end\n",
    "\n",
    "puts DD.show_d\n",
    "puts CC.class_variables(false)\n",
    "puts DD.class_variables(false)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "[:@@d_var]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "class CC\n",
    "  def self.set(v)\n",
    "    @@d_var = v\n",
    "  end\n",
    "end\n",
    "\n",
    "CC.set(100)\n",
    "puts DD.show_d\n",
    "\n",
    "puts CC.class_variables(false)\n",
    "puts DD.class_variables(false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调用父类的修改方法，声明了一个同名类变量，居然把子类的同名变量给改了。不仅如此，类变量在继承树的位置也上升到了父类，说明如果继承树上有几个类含有同名类变量，**Ruby** 会强制统一这些同名类变量。\n",
    "\n",
    "**Ruby** 中类变量陷阱还不止此，我们再来看一个例子："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "D\n",
      "C\n",
      "[:@@c_var]\n",
      "[:@@d_var]\n"
     ]
    }
   ],
   "source": [
    "class CCC\n",
    "  @@c_var = 'C'\n",
    "end\n",
    "\n",
    "class DDD\n",
    "  @@d_var = 'D'\n",
    "end\n",
    "\n",
    "class CCC\n",
    "  def DDD.value\n",
    "    @@c_var\n",
    "  end\n",
    "end\n",
    "\n",
    "class DDD\n",
    "  def CCC.value\n",
    "    @@d_var\n",
    "  end\n",
    "end\n",
    "\n",
    "puts CCC.value\n",
    "puts DDD.value\n",
    "\n",
    "puts CCC.class_variables\n",
    "puts DDD.class_variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过**Open Class**，我们很轻松地打破了类隔离的规则。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们再来看看类变量与实例之间的关系："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c\n",
      "new\n"
     ]
    }
   ],
   "source": [
    "class C\n",
    "  @@value = 'c'\n",
    "  \n",
    "  def show\n",
    "    @@value\n",
    "  end\n",
    "  \n",
    "  def set(v)\n",
    "    @@value = v\n",
    "  end\n",
    "    \n",
    "end\n",
    "\n",
    "obj = C.new\n",
    "puts obj.show\n",
    "obj.set('new')\n",
    "puts obj.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c\n",
      "new\n",
      "new\n"
     ]
    }
   ],
   "source": [
    "class CC \n",
    "  @@value = 'c'\n",
    "  \n",
    "  def self.value\n",
    "    @@value\n",
    "  end\n",
    "  \n",
    "end\n",
    "\n",
    "class DD < CC\n",
    "  def show\n",
    "    @@value\n",
    "  end\n",
    "  \n",
    "  def set(v)\n",
    "    @@value = v\n",
    "  end\n",
    "end\n",
    "\n",
    "obj = DD.new\n",
    "puts obj.show\n",
    "obj.set('new')\n",
    "puts obj.show\n",
    "puts CC.value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类实例和子类实例都可以访问和修改类变量，如果使用不小心，特别容易造成错误的修改，错误很难追踪。\n",
    "\n",
    "正是由于 **Ruby** 类变量的这些特性，特别容易导致错误，尤其是在元编程的时候，所以一般都不推荐在程序中使用类变量。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其实类变量主要的功能还是类间隔离，父子类之间共享类变量其实是没有必要的，上类中 `D` 继承 `C`，只是表明 `D` 的实例也是 `C` 的实例，但是 `D` 和 `C` 之间并没有从属关系，他们都是 `Class` 的实例。\n",
    "\n",
    "其实 **Ruby** 也可以轻松实现类似 **Java** 类变量的方案，那就是借助实例变量来模拟。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "class MyClass\n",
    "  class << self\n",
    "    \n",
    "    def val\n",
    "      @val\n",
    "    end\n",
    "    \n",
    "    def set(v)\n",
    "      @val = v\n",
    "    end\n",
    "    \n",
    "  end\n",
    "end\n",
    "\n",
    "puts MyClass.val\n",
    "MyClass.set(100)\n",
    "puts MyClass.val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "只所以可以这么做，是因为 `MyClass` 本身也是一个对象，它是 `Class` 的实例，因为实例变量只可以被对象自身访问。即便是 `MyClass` 的子类，也不能访问 `@val`。\n",
    "\n",
    "基于以上的事实，用 **Ruby** 编程的时候，如果不是有特殊的需求，尽量不要使用类变量，尤其是在 **Open Class** 的场景。"
   ]
  }
 ],
 "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
}