03-ruby-syntax/03.02-conditional-statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 判断语句"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 基本用法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "判断，基于一定的条件，决定是否要执行特定的一段代码，例如判断一个数是不是正数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey!\n",
      "x is positive\n"
     ]
    }
   ],
   "source": [
    "x = 0.5\n",
    "if x > 0 then\n",
    "  puts \"Hey!\"\n",
    "  puts \"x is positive\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这里，如果 `x > 0` 为 `false` ，那么程序将不会执行两条 `puts` 语句。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一个完整的 `if` 结构通常如下所示：\n",
    "    \n",
    "```\n",
    "if <condition 1> [then]\n",
    "    <statement 1>\n",
    "    <statement 2>\n",
    "elsif <condition 2> [then]\n",
    "    <statements>\n",
    "else\n",
    "    <statements>\n",
    "end\n",
    "```\n",
    "\n",
    "如果 `statements` 在下一行，`then` 可以省略，`then` 也可以使用 `;` 替换。\n",
    "\n",
    "当条件1被满足时，执行 `if` 下面的语句，当条件1不满足的时候，转到 `elsif` ，看它的条件2满不满足，满足执行 `elif` 下面的语句，不满足则执行 `else` 下面的语句。\n",
    "\n",
    "对于上面的例子进行扩展：\n",
    "\n",
    "- `elsif` 的个数没有限制，可以是1个或者多个，也可以没有。\n",
    "- `else` 最多只有1个，也可以没有。\n",
    "- 可以使用 `and`，`or`，`not`，`&&`，`||`，`!`等关键词结合多个判断条件："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 10\n",
    "y = -5\n",
    "x > 0 and y < 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not x > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x < 0 or y < 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里使用这个简单的例子，假如想判断一个年份是不是闰年，按照闰年的定义，这里只需要判断这个年份是不是能被4整除，但是不能被100整除，或者正好被400整除："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is not a leap year.\n"
     ]
    }
   ],
   "source": [
    "year = 1900\n",
    "if year % 400 == 0\n",
    "    puts \"This is a leap year!\"\n",
    "elsif year % 4 == 0 and year % 100 != 0\n",
    "    puts \"This is a leap year!\"\n",
    "else\n",
    "    puts \"This is not a leap year.\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ruby** 语法非常灵活，除了 `if` 语句之外，还有 `unless` 语句。\n",
    "\n",
    "`unless` 等价于 `if not`，适合的情况下，它可以增强代码的可读性。\n",
    "\n",
    "```ruby\n",
    "wear_sweater unless summer? or wearing_sweater?\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is positive\n"
     ]
    }
   ],
   "source": [
    "x = 0.5\n",
    "unless x <= 0\n",
    "  puts \"x is positive\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意： `unless` 不能和 `elsif` 配合，一般情况下，尽量不要 `unless` 配合 `else` 或者 `not` 使用。\n",
    "\n",
    "如果判断语句的主体只有一行代码，也可以把 `if` 或者 `unless` 放到后面。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is positive\n"
     ]
    }
   ],
   "source": [
    "puts \"x is positive\" if x > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is positive\n"
     ]
    }
   ],
   "source": [
    "puts \"x is positive\" unless x <= 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 值的测试"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ruby** 不仅仅可以使用布尔型变量作为条件，它可以直接在 `if` 中使用任何表达式作为条件：\n",
    "\n",
    "所有表达式的值都会被当作 `true`，除了：\n",
    "\n",
    "- false\n",
    "- nil\n",
    "\n",
    "| 语句 | 值 |\n",
    "| :--- | --- |\n",
    "|  not nil | true |\n",
    "|  not 0   | false |\n",
    "|  !0 | false |\n",
    "|  0 == false | false |\n",
    "|  nil == false | false |\n",
    "|  y = false | false |\n",
    "|  y == false | true |\n",
    "|  x = 0 |0 |\n",
    "| \"foo\" if (x = 0) | \"foo\" |\n",
    "|  x == y | false |\n",
    "|  x != y | true |\n",
    "|  !x==y | true |\n",
    "|  not x==y | true |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val is nil\n"
     ]
    }
   ],
   "source": [
    "nil_val = nil\n",
    "puts \"val is nil\" unless nil_val"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "val is zero\n"
     ]
    }
   ],
   "source": [
    "zero_val = 0\n",
    "puts \"val is zero\" if zero_val"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `case` 语句\n",
    "\n",
    "一个完整的 `case` 结构通常如下所示：\n",
    "    \n",
    "```\n",
    "case <expression>\n",
    "    when <arg1 [,arg2, ..., argn]> [then] <statements>\n",
    "else:\n",
    "    <statements>\n",
    "end\n",
    "```\n",
    "\n",
    "先计算 `expression` 的结果，再根据 `when` 条件中的 `arg` 和结果进行匹配，如果匹配，则执行其之后的语句，否则执行 `else` 块中的语句， `arg` 和 `expression` 的结果匹配总是调用 `arg` 的 `===`。\n",
    "\n",
    "或者\n",
    "\n",
    "```\n",
    "case\n",
    "    when <expression> [then] <statements>\n",
    "else:\n",
    "    <statements>\n",
    "end\n",
    "```\n",
    "\n",
    "逐行执行 `when` 语句，`expression` 为真则执行其后的表达式。\n",
    "\n",
    "如果 `statements` 换到下一行，则 `then` 可以省略，`then` 也可以使用 `;` 替换。\n",
    "\n",
    "对于上面的例子进行扩展：\n",
    "- `when` 的个数没有限制，可以是1个或者多个。\n",
    "- `else` 最多只有1个，也可以没有。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letter\n"
     ]
    }
   ],
   "source": [
    "c = 'B'\n",
    "case c\n",
    "  when 'a'..'z', 'A'..'Z' then puts 'letter'\n",
    "  when 0..9, '0'..'9' then puts'number'\n",
    "  when \"*\" then puts \"star\"\n",
    "else\n",
    "  puts 'other'\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number\n"
     ]
    }
   ],
   "source": [
    "obj = 100\n",
    "case \n",
    "  when obj.is_a?(Array); puts 'list'\n",
    "  when obj.is_a?(Numeric); puts 'number'\n",
    "  when obj.is_a?(String); puts 'string'\n",
    "else\n",
    "  puts \"unkown\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 用作表达式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Man with age 0 is a Baby\n",
      "Man with age 8 is a Child\n",
      "Man with age 16 is a Juvenile\n",
      "Man with age 24 is a Puber\n",
      "Man with age 32 is a Puber\n",
      "Man with age 40 is a Puber\n",
      "Man with age 48 is a Wrinkly\n",
      "Man with age 56 is a Wrinkly\n",
      "Man with age 64 is a Aged\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0..70"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0..70).step(8).each do|age|\n",
    "  level = if age > 60; 'Aged'\n",
    "  elsif age > 40; 'Wrinkly'\n",
    "  elsif age > 20; 'Puber'\n",
    "  elsif age > 10; 'Juvenile'\n",
    "  elsif age > 1; 'Child'\n",
    "  else; 'Baby' end\n",
    "  \n",
    "  puts \"Man with age #{age} is a #{level}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "false\n",
      "false\n",
      "true\n",
      "Today is Sunday!\n"
     ]
    }
   ],
   "source": [
    "it_is_day_of_week = lambda{|day_of_week, date| date.wday == day_of_week}\n",
    "\n",
    "it_is_wednesday = it_is_day_of_week.curry[3]\n",
    "it_is_saturday = it_is_day_of_week.curry.call(6)\n",
    "it_is_sunday = it_is_day_of_week.curry.yield(0)\n",
    "\n",
    "puts it_is_day_of_week.===(0, Time.now)\n",
    "\n",
    "puts it_is_wednesday === Time.now\n",
    "puts it_is_saturday === Time.now\n",
    "puts it_is_sunday === Time.now\n",
    "\n",
    "day = case Time.now\n",
    "  when it_is_wednesday\n",
    "    \"Wednesday\"\n",
    "  when it_is_saturday\n",
    "    \"Saturday\"\n",
    "  when it_is_sunday\n",
    "    \"Sunday\"\n",
    "else\n",
    "    \"Not weekend\"\n",
    "end\n",
    "\n",
    "puts \"Today is #{day}!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 注意事项"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `!` vs. `not`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "not two\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "puts \"not two\" if not x == 2\n",
    "puts \"not what you think!\" if !x == 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`not x == 2` 等价于 `not (x == 2)`\n",
    "\n",
    "`!x == 2` 等价于 `(!x) == 2`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `===` 不支持交换律"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Integer === 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100 === Integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1..9) === 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 === (1..9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 运算符优先级"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " 优先级从高到低:\n",
    " \n",
    " 能否重写\t| 运算符 |\t描述 |\n",
    " :---: | :--- | --- |\n",
    " Y\t| []、[]=\t| 数组下标、数组元素赋值\n",
    " Y\t| ** | 乘幂\n",
    " Y\t| ！、~、+、- \t| 非、位非、一元加(正号)、负号\n",
    " Y\t| *、/、%\t| 乘、除、模\n",
    " Y\t| +、-\t | 加、减\n",
    " Y\t| >>、<<\t | 右移、左移\n",
    " Y\t| &\t| 位与\n",
    " Y\t| ^、&#124; |\t位异或、位或\n",
    " Y\t| <=、<、]] > 、>=\t| 小于等于、小于、大于、大于等于\n",
    " Y/N |\t<=>、==、===、=~、!=、!~\t| 各种相等判断（不能重写=~、!=、!~）\n",
    " N\t| &&\t| 短路与\n",
    " N\t| &#124;&#124;\t| 短路或\n",
    " N\t| ..、...\t| 区间的开始点到结束点\n",
    " N\t| ? :\t| 三元条件运算符\n",
    " N\t| =、%=、~=、/=、-=、+=、&#124;=、&=、>>=、<<=、*=、&&=、&#124;&#124;=、**=\t| 各种赋值\n",
    " N\t| defined? \t| 检查类型\n",
    " N\t| not | 逻辑非\n",
    " N\t| or、and\t| 逻辑或、逻辑与\n",
    " N\t| if、unless、while、until \t| 判断与循环\n",
    " N\t| begin、end\t | 定义方法，类，模块的范围\n",
    " \n",
    " 值得注意的是，ruby中没有\"++\"、\"--\"一类的运算符，但可以通过\"+=1\"、\"-=1\"实现"
   ]
  }
 ],
 "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
}