ch05.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ch05: Bash Tutorial\n",
    "___"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many different shells in our system. Let's have a look:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# /etc/shells: valid login shells\r\n",
      "/bin/sh;/bin/dash;/bin/bash;/bin/rbash;/bin/ksh93;/bin/zsh;/usr/bin/zsh;/bin/tcsh;/usr/bin/tcsh;/bin/csh;/usr/bin/screen;/usr/bin/tmux\r\n"
     ]
    }
   ],
   "source": [
    "cat /etc/shells | sed -n -e '1p;2h;2!H;${g;s/\\n/;/g;p}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Two types of bash shells（两种shells）\n",
    "\n",
    "1. Non-login shells: `~/.bashrc` as the startup file （非登录shell）\n",
    "2. Login shells: `/etc/profile`, `~/bash_profile`, `~/.bash_login`, `~/.profile` as the startup files （登录shell）\n",
    "\n",
    "Note: Here the `rc` is the acronym of __`resource configuration`__.\n",
    "\n",
    "___on login__:\n",
    "```bash\n",
    "if -e /etc/profile; then\n",
    "    source /etc/profile\n",
    "end\n",
    "if -e ~/.bash_profile; then\n",
    "    source ~/.bash_profile\n",
    "elif -e ~/.bash_login; then\n",
    "    source ~/.bash_login\n",
    "elif -e ~/.profile; then\n",
    "    source ~/.profile\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a small bash program `sysinfo.sh`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[H\u001b[2JThis is information provided by my script sysinfo.sh.\r\n",
      "=====================================================\r\n",
      "Hello, bio\r\n",
      "\r\n",
      "Today's date is 2016年 03月 03日 星期四 13:09:57 CST, this is week 09.\r\n",
      "\r\n",
      "These users are currently connected:\r\n",
      "\r\n",
      "bio\r\n",
      "\r\n",
      "This is Linux running on a x86_64 processor.\r\n",
      "\r\n",
      "This is the uptime information:\r\n",
      " 13:09:57 up 5 days, 23:31,  8 users,  load average: 2.13, 0.93, 0.64\r\n",
      "\r\n",
      "That's all folks.\r\n",
      "=====================================================\r\n"
     ]
    }
   ],
   "source": [
    "cat > sysinfo.sh <<EOF\n",
    "#!/bin/bash \n",
    "clear \n",
    "echo \"This is information provided by my script sysinfo.sh.\" \n",
    "echo \"=====================================================\"\n",
    "echo \"Hello, $USER\"\n",
    "echo \n",
    "\n",
    "echo \"Today's date is `date`, this is week `date +\"%V\"`.\" \n",
    "echo\n",
    "\n",
    "echo \"These users are currently connected:\" \n",
    "w | cut -d \" \" -f 1 | grep -v USER | sort -u \n",
    "echo \n",
    "\n",
    "echo \"This is `uname -s` running on a `uname -m` processor.\" \n",
    "echo\n",
    "\n",
    "echo \"This is the uptime information:\" \n",
    "uptime \n",
    "echo \n",
    "\n",
    "echo \"That's all folks.\"\n",
    "echo \"=====================================================\"\n",
    "EOF\n",
    "chmod u+x sysinfo.sh\n",
    "./sysinfo.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This kind of execution will create a new shell to run the script.\n",
    "> If you don’t want to start a new shell but execute the script in the current shell, you `source` it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## How to define a variable\n",
    "\n",
    "Here's the __customs for defining a variable__:\n",
    "* Use upper-case characters (大写字母) for global variable name (全局变量名), while lower-case (小写字母) for local variable (局部变量).\n",
    "* Use double quotes (双引号) to enclose the value of the variables.\n",
    "\n",
    "Here is the example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "local name=\"Jacky Wu\"\n",
    "NAME=\"Jacky Chan\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default a variable without a modifier __`local`__ is __global variable__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### No space is allowed beside the assignment `=`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No command 'name' found, did you mean:\r\n",
      " Command 'namei' from package 'util-linux' (main)\r\n",
      " Command 'lame' from package 'lame' (universe)\r\n",
      " Command 'mame' from package 'mame' (multiverse)\r\n",
      " Command 'named' from package 'bind9' (main)\r\n",
      " Command 'nam' from package 'nam' (universe)\r\n",
      " Command 'nama' from package 'nama' (universe)\r\n",
      " Command 'uname' from package 'coreutils' (main)\r\n",
      "name: command not found\r\n"
     ]
    }
   ],
   "source": [
    "name =\"John\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "or"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No command 'John' found, did you mean:\r\n",
      " Command 'john' from package 'john' (main)\r\n",
      "John: command not found\r\n"
     ]
    }
   ],
   "source": [
    "name= \"John\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n"
     ]
    }
   ],
   "source": [
    "echo $name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Unless we use `export` command, the variable will not be inherited by the child process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "unset bill\n",
    "cat > test_export.sh <<EOF\n",
    "#!/bin/zsh\n",
    "echo \"My names is \\$bill\"\n",
    "EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My names is \r\n"
     ]
    }
   ],
   "source": [
    "chmod u+x test_export.sh\n",
    "unset bill\n",
    "echo $bill\n",
    "bill=\"Clinton\"\n",
    "bash/test_export.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But if we use `export` like that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My names is Clinton\r\n"
     ]
    }
   ],
   "source": [
    "unset bill\n",
    "export bill=\"Clinton\"\n",
    "bash/test_export.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "However, the reassignment in the child process will not change the variable in the parent process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "cat > bash/test_export2.sh <<EOF\n",
    "#!/bin/zsh\n",
    "bill=\"Fraser\"\n",
    "echo \"My names is \\$bill\"\n",
    "EOF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clinton\r\n"
     ]
    }
   ],
   "source": [
    "echo $bill"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Clinton\r\n"
     ]
    }
   ],
   "source": [
    "bash/test_export2.sh\n",
    "echo $bill"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So we can say that:\n",
    "> The command `export` has only one-way effect which is downward（命令的作用方向是单向且向下的）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Positional parameters for bash script"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. `$*` and `$@`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\t#!/bin/bash\r\n",
      "     2\techo \"\\$* is $*\"\r\n",
      "     3\techo \"\\$@ is $@\"\r\n"
     ]
    }
   ],
   "source": [
    "cat -n bash/test.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "$* is Borne shell Borne-again shell C shell\r\n",
      "$@ is Borne shell Borne-again shell C shell\r\n"
     ]
    }
   ],
   "source": [
    "bash/test.sh \"Borne shell\" \"Borne-again shell\" \"C shell\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It seems that `$*` and `$@` given the same results. But wait, if we use `for` to iterate over all the parameters with or without double quotes, things will be completely different: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\t#!/bin/bash\r\n",
      "     2\techo\r\n",
      "     3\techo \"1. Here is the result for \\$*:\"\r\n",
      "     4\tfor i in $*; do\r\n",
      "     5\t\techo $i\r\n",
      "     6\tdone\r\n",
      "     7\techo\r\n",
      "     8\techo \"2. Here is the result for \\\"\\$*\\\":\"\r\n",
      "     9\tfor i in \"$*\"; do\r\n",
      "    10\t\techo $i\r\n",
      "    11\tdone\r\n",
      "    12\techo\r\n",
      "    13\techo \"3. Here is the result for \\$@:\"\r\n",
      "    14\tfor i in $@; do\r\n",
      "    15\t    echo $i\r\n",
      "    16\tdone\r\n",
      "    17\techo\r\n",
      "    18\techo \"4. Here is the result for \\\"\\$@\\\":\"\r\n",
      "    19\tfor i in \"$@\"; do\r\n",
      "    20\t    echo $i\r\n",
      "    21\tdone\r\n"
     ]
    }
   ],
   "source": [
    "cat -n bash/test2.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n",
      "1. Here is the result for $*:\r\n",
      "Borne\r\n",
      "shell\r\n",
      "Borne-again\r\n",
      "shell\r\n",
      "C\r\n",
      "shell\r\n",
      "\r\n",
      "2. Here is the result for \"$*\":\r\n",
      "Borne shell Borne-again shell C shell\r\n",
      "\r\n",
      "3. Here is the result for $@:\r\n",
      "Borne\r\n",
      "shell\r\n",
      "Borne-again\r\n",
      "shell\r\n",
      "C\r\n",
      "shell\r\n",
      "\r\n",
      "4. Here is the result for \"$@\":\r\n",
      "Borne shell\r\n",
      "Borne-again shell\r\n",
      "C shell\r\n"
     ]
    }
   ],
   "source": [
    "bash/test2.sh \"Borne shell\" \"Borne-again shell\" \"C shell\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that:\n",
    "* Without double quotes, `$*` and `$@` are the same;\n",
    "* With double quotes, `\"$*\"` will be treated as a whole single string; however, `\"$@\"` will be treated as a series of parameters, as we expect."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But is this the final answer? Here we use different `IFS` to see if this is true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\t#!/bin/bash\r\n",
      "     2\t\r\n",
      "     3\tIFS=\" \"\r\n",
      "     4\techo \"By default, IFS is \\\"$IFS\\\"\"\r\n",
      "     5\techo -e \"\\$* is $*\"\r\n",
      "     6\techo -e \"\\$@ is $@\"\r\n",
      "     7\techo -e \"\\\"\\$*\\\" is \"$*\"\"\r\n",
      "     8\techo -e \"\\\"\\$@\\\" is \"$@\"\"\r\n",
      "     9\t\r\n",
      "    10\techo\r\n",
      "    11\tIFS=\":\"\r\n",
      "    12\techo \"But when we change IFS to \\\"$IFS\\\"\"\r\n",
      "    13\techo -e \"\\$* is $*\"\r\n",
      "    14\techo -e \"\\$@ is $@\"\r\n",
      "    15\techo -e \"\\\"\\$*\\\" is \"$*\"\"\r\n",
      "    16\techo -e \"\\\"\\$@\\\" is \"$@\"\"\r\n"
     ]
    }
   ],
   "source": [
    "cat -n bash/test3.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "By default, IFS is \" \"\r\n",
      "$* is Borne shell Borne-again shell C shell\r\n",
      "$@ is Borne shell Borne-again shell C shell\r\n",
      "\"$*\" is Borne shell Borne-again shell C shell\r\n",
      "\"$@\" is Borne shell Borne-again shell C shell\r\n",
      "\r\n",
      "But when we change IFS to \":\"\r\n",
      "$* is Borne shell:Borne-again shell:C shell\r\n",
      "$@ is Borne shell Borne-again shell C shell\r\n",
      "\"$*\" is Borne shell Borne-again shell C shell\r\n",
      "\"$@\" is Borne shell Borne-again shell C shell\r\n"
     ]
    }
   ],
   "source": [
    "bash/test3.sh \"Borne shell\" \"Borne-again shell\" \"C shell\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could use a table to conclude this section:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Parameters | Definition |\n",
    "| :---: | --- |\n",
    "| `$*` | `\"$1 $2 $3...\"` |\n",
    "| `\"$*\"` | `\"$1$IFS[0]$2$IFS[0]$3...\"` |\n",
    "| `$@` | `\"$1 $2 $3...\"` |\n",
    "| `\"$@\"` | `\"$1\"\"$2\"\"$3\"...\"` |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is:\n",
    "> *  `$*` expands to the positional parameters, starting from one. When the expansion occurs within double quotes, it expands to a single word with the value of each parameter separated by the __first character of the IFS__ special varible.\n",
    "> * `$@` expands to the positional parameters, starting from one. When the expansion occurs within double quotes, each parameter expands to a separate word."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The other positional parameters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could summarize the other positional parameters as shown below:\n",
    "\n",
    "| Positional parameters | Definition |\n",
    "| :---: | --- |\n",
    "| `$#` | The number of positional parameters, starting from 1. |\n",
    "| `$0` | The name of the bash script. |\n",
    "| `$1`, `$2`, ..., `${10}`, `${11}` | The 1st, 2nd, ..., 10th, 11th positional parameter. |  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quotes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. single quotes\n",
    "\n",
    "Single quotes('') are used to preserve the literal value of each character enclosed within the quotes. A single quote may not occur between single quotes, even when preceded by a backslash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\t#!/bin/bash\r\n",
      "     2\ttoday='`date`'\r\n",
      "     3\techo -e \"When using '\\`date\\`' (single quotes):\"\r\n",
      "     4\techo -e \"today is: $today\"\r\n",
      "     5\techo -e 'today is: $today'\r\n",
      "     6\techo -e 'today is: \\$today'\r\n",
      "     7\techo\r\n",
      "     8\t\r\n",
      "     9\ttoday=\"`date`\"\r\n",
      "    10\techo -e \"When using \\\"\\`date\\`\\\" (Double quotes):\"\r\n",
      "    11\techo -e \"today is: $today\"\r\n",
      "    12\techo -e 'today is: $today'\r\n",
      "    13\techo -e 'today is: \\$today'\r\n"
     ]
    }
   ],
   "source": [
    "cat -n bash/test5.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "When using '`date`' (single quotes):\r\n",
      "today is: `date`\r\n",
      "today is: $today\r\n",
      "today is: \\$today\r\n",
      "\r\n",
      "When using \"`date`\" (Double quotes):\r\n",
      "today is: 2016年 03月 03日 星期四 14:25:07 CST\r\n",
      "today is: $today\r\n",
      "today is: \\$today\r\n"
     ]
    }
   ],
   "source": [
    "bash/test5.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. double quotes\n",
    "\n",
    "Using double quotes the literal value of all characters enclosed is preserved, except for the dollar sign (`$`), the backquotes (\\`) and the backslash (`\\`).\n",
    "\n",
    "The dollar sign and the backquotes retain their special meaning within the double quotes.\n",
    "\n",
    "The backslash retains its meaning only when followed by dollar, backquote, double quote, backslash or newline. Within double quotes, the backslashes are removed from the input stream when followed by one of these characters. Backslashes preceding characters that don’t have a special meaning are left unmodified for processing by the shell interpreter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Shell expansions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. brace expansion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "span sport spill\r\n"
     ]
    }
   ],
   "source": [
    "echo \"sp\"{an,ort,ill}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Michael Johndon Michael Smith Michael Jackson\r\n"
     ]
    }
   ],
   "source": [
    "echo \"Michael \"{Johndon,Smith,Jackson}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Michael {Johndon, Smith, Jackson}\r\n"
     ]
    }
   ],
   "source": [
    "echo \"Michael \"{Johndon, Smith, Jackson}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could see that\n",
    "> It is treated as a whole string when spaces are put before or after the colons within the brace."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. tilde expansion\n",
    "\n",
    "| Tilde parameter | Definition | Example |\n",
    "| :---: | --- | --- |\n",
    "| `~` | Home directory of the current user | `cd ~` |\n",
    "| `~USER` | Home directory of `USER` | `cd ~root` |\n",
    "| `~+` | The next working directory. | `cd ~+` |\n",
    "| `~-` | The previous working directory. | `cd ~-` |\n",
    "\n",
    "Here we could also use `pushd` to push directory into the __directory stack__, and then use __`cd ~-1`, `cd ~+1`, or `cd ~+n`, `cd ~-n`__ to leap between the directories stored in the stack."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. parameter expansion and variable expansion\n",
    "\n",
    "In parameter and variable expansion, the dollar sign (`$`), and the curly brace (`{}`) play an essential role. \n",
    "\n",
    "#### (1) parameter expansion\n",
    "\n",
    "For positional parameters, when the position is over 10, we should use the brace to avoid confusion. Here is an example to output the 10th positional parameter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#!/bin/bash\r\n",
      "echo $10\r\n"
     ]
    }
   ],
   "source": [
    "cat bash/test7a.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00\r\n"
     ]
    }
   ],
   "source": [
    "bash/test7a.sh 0 1 2 3 4 5 6 7 8 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To avoid the obscure definition, we should use brace here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#!/bin/bash\r\n",
      "echo ${10}\r\n"
     ]
    }
   ],
   "source": [
    "cat bash/test7b.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\r\n"
     ]
    }
   ],
   "source": [
    "bash/test7b.sh 0 1 2 3 4 5 6 7 8 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (2) direct variable expansion\n",
    "\n",
    "Direct variable expansion use the value of the variable to substitute the string. Here is an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\t#!/bin/bash\r\n",
      "     2\tfirstname=\"Wang\"\r\n",
      "     3\techo -e \"The poet is named ${firstname}guozhen\"\r\n"
     ]
    }
   ],
   "source": [
    "cat -n bash/test8a.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The poet is named Wangguozhen\r\n"
     ]
    }
   ],
   "source": [
    "bash/test8a.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### (3) Indirect variable expansion\n",
    "\n",
    "In indirect variable expansion, the variable name is also a variable. And then we can use `!` to expand the variable name. Here is an example. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\t#!/bin/bash\r\n",
      "     2\tfirstname=\"Wang\"\r\n",
      "     3\tfirst=\"firstname\"\r\n",
      "     4\techo -e \"The poet is named ${!first}guozhen\"\r\n"
     ]
    }
   ],
   "source": [
    "cat -n bash/test8b.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The poet is named Wangguozhen\r\n"
     ]
    }
   ],
   "source": [
    "bash/test8b.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. command substitution\n",
    "\n",
    "It is to note that we can use __`$(COMMAND)`__ to do command substitution instead of command execution. Here is an example: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#!/bin/bash\r\n",
      "# command substitution\r\n",
      "\r\n",
      "echo\r\n",
      "date\r\n",
      "\r\n",
      "echo\r\n",
      "$(date)\r\n"
     ]
    }
   ],
   "source": [
    "cat bash/test9.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ echo\r\n",
      "\r\n",
      "+ date\r\n",
      "2016年 03月 03日 星期四 15:46:25 CST\r\n",
      "+ echo\r\n",
      "\r\n",
      "++ date\r\n",
      "+ 2016年 03月 03日 星期四 15:46:25 CST\r\n",
      "bash/test9.sh: line 8: 2016年: command not found\r\n"
     ]
    }
   ],
   "source": [
    "bash -x bash/test9.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example the output for the command `date` is treated as a series of command. But unfortunately, the command does not exist.\n",
    "\n",
    "The second type of command substitution uses the backquotes (__\\`COMMAND\\`__)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. arithmetic expansion\n",
    "\n",
    "To expand the arithmetic expression, you need to use __`$((EXPRESSION))`__.\n",
    "> All tokens in the expression undergo parameter expansion, command substitution, and quote removal.\n",
    "\n",
    "Here we use an example to illustrate the usage of arithmetic expansion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#!/bin/bash\r\n",
      "echo\r\n",
      "\r\n",
      "val=3\r\n",
      "\r\n",
      "echo $(($1+val+2+`date +%d`))\r\n"
     ]
    }
   ],
   "source": [
    "cat bash/test10.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ echo\r\n",
      "\r\n",
      "+ val=3\r\n",
      "++ date +%d\r\n",
      "+ echo 24\r\n",
      "24\r\n"
     ]
    }
   ],
   "source": [
    "bash -x bash/test10.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ echo\r\n",
      "\r\n",
      "+ val=3\r\n",
      "++ date +%d\r\n",
      "+ echo 26\r\n",
      "26\r\n"
     ]
    }
   ],
   "source": [
    "bash -x bash/test10.sh 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we show another example to illustrate the conversion between binary number, octal number, hexadecimal number, and decimal number. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#!/bin/bash\r\n",
      "\r\n",
      "echo \"octal numbers\" \r\n",
      "echo \"011==$((011))\" \r\n",
      "\r\n",
      "echo \r\n",
      "echo \"hexadecimal numbers\" \r\n",
      "echo \"0x1a==$((0x1a))\" \r\n",
      "\r\n",
      "echo\r\n",
      "echo \"binary numbers\"\r\n",
      "echo \"01110==$((2#01110))\"\r\n",
      "\r\n",
      "echo \r\n",
      "echo \"arithmetic base 36\" \r\n",
      "echo \"36#z==$((36#z))\" \r\n",
      "echo \"36#Z==$((36#Z))\" \r\n",
      "\r\n",
      "echo \r\n",
      "echo \"arithmetic base 37\" \r\n",
      "echo \"37#a==$((37#a))\" \r\n",
      "echo \"37#A==$((37#A))\" \r\n",
      "\r\n",
      "echo \r\n",
      "echo \"arithmetic base 64\" \r\n",
      "echo \"64#@==$((64#@))\" \r\n",
      "echo \"64#_==$((64#_))\"\r\n"
     ]
    }
   ],
   "source": [
    "cat bash/test11.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+ echo 'octal numbers'\r\n",
      "octal numbers\r\n",
      "+ echo 011==9\r\n",
      "011==9\r\n",
      "+ echo\r\n",
      "\r\n",
      "+ echo 'hexadecimal numbers'\r\n",
      "hexadecimal numbers\r\n",
      "+ echo 0x1a==26\r\n",
      "0x1a==26\r\n",
      "+ echo\r\n",
      "\r\n",
      "+ echo 'binary numbers'\r\n",
      "binary numbers\r\n",
      "+ echo 01110==14\r\n",
      "01110==14\r\n",
      "+ echo\r\n",
      "\r\n",
      "+ echo 'arithmetic base 36'\r\n",
      "arithmetic base 36\r\n",
      "+ echo 36#z==35\r\n",
      "36#z==35\r\n",
      "+ echo 36#Z==35\r\n",
      "36#Z==35\r\n",
      "+ echo\r\n",
      "\r\n",
      "+ echo 'arithmetic base 37'\r\n",
      "arithmetic base 37\r\n",
      "+ echo 37#a==10\r\n",
      "37#a==10\r\n",
      "+ echo 37#A==36\r\n",
      "37#A==36\r\n",
      "+ echo\r\n",
      "\r\n",
      "+ echo 'arithmetic base 64'\r\n",
      "arithmetic base 64\r\n",
      "+ echo 64#@==62\r\n",
      "64#@==62\r\n",
      "+ echo 64#_==63\r\n",
      "64#_==63\r\n"
     ]
    }
   ],
   "source": [
    "bash -x bash/test11.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. process expansion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lr-x------ 1 bio bio 64  3月  3 16:11 \u001b[0m\u001b[40;31;01m/dev/fd/63\u001b[0m -> \u001b[40;31;01mpipe:[5287275]\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "ls -l <(true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The process of running the command `true` results in a pipe file named `/dev/fd/63` where `63` is the file descriptor for this file. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* If the \">(LIST)\" form is used, writing to the file will provide input for LIST.\n",
    "* If the \"<(LIST)\" form is used, the file passed as an argument should be read to obtain the output of LIST."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l-wx------ 1 bio bio 64  3月  3 16:16 \u001b[0m\u001b[40;31;01m/dev/fd/63\u001b[0m -> \u001b[40;31;01mpipe:[5290761]\u001b[0m\r\n"
     ]
    }
   ],
   "source": [
    "ls -l >(false)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. word splitting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     1\t#!/bin/bash\r\n",
      "     2\tfilename=\"path1/path2/file.ext\"\r\n",
      "     3\text=${filename#*.}\r\n",
      "     4\tbasename=${filename##*/}\r\n",
      "     5\ttoppath=${filename%%/*}\r\n",
      "     6\tcomppath=${filename%/*}\r\n",
      "     7\techo -e \"Extension: $ext\"\r\n",
      "     8\techo -e \"Basename: $basename\"\r\n",
      "     9\techo -e \"Top path: $toppath\"\r\n",
      "    10\techo -e \"Complete path: $comppath\"\r\n"
     ]
    }
   ],
   "source": [
    "cat -n bash/test12.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bash -x bash/test12.sh\r\n",
      "+ bash -x bash/test12.sh\r\n",
      "+ filename=path1/path2/file.ext\r\n",
      "+ ext=ext\r\n",
      "+ basename=file.ext\r\n",
      "+ toppath=path1\r\n",
      "+ comppath=path1/path2\r\n",
      "+ echo -e 'Extension: ext'\r\n",
      "Extension: ext\r\n",
      "+ echo -e 'Basename: file.ext'\r\n",
      "Basename: file.ext\r\n",
      "+ echo -e 'Top path: path1'\r\n",
      "Top path: path1\r\n",
      "+ echo -e 'Complete path: path1/path2'\r\n",
      "Complete path: path1/path2\r\n"
     ]
    }
   ],
   "source": [
    "bash -x bash/test12.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. default value expansion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Expression1 | Expression2 | Definition |\n",
    "| :---: | :---: | --- |\n",
    "| `echo ${var-6}` | `echo ${var:-6}` | print 6 if `var` not set; otherwise print it. |\n",
    "| `echo ${var+6}` | `echo ${var:=6}` | print 6 if `var` set; otherwise print null. |\n",
    "| `echo ${var=6}` | `echo ${var:+6}` | set `var=6` and print it if `var` not set; otherwise only print it. | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo ${undefined:-5}\r\n",
      "+ echo 5\r\n",
      "5\r\n"
     ]
    }
   ],
   "source": [
    "unset undefined\n",
    "echo ${undefined:-5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo $undefined\r\n",
      "+ echo\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "echo $undefined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo ${undefined:-10}\r\n",
      "+ echo 10\r\n",
      "10\r\n"
     ]
    }
   ],
   "source": [
    "echo ${undefined:-10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo $undefined\r\n",
      "+ echo\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "echo $undefined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo ${undefined=5}\r\n",
      "+ echo 5\r\n",
      "5\r\n"
     ]
    }
   ],
   "source": [
    "unset undefined\n",
    "echo ${undefined=5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo $undefined\r\n",
      "+ echo 5\r\n",
      "5\r\n"
     ]
    }
   ],
   "source": [
    "echo $undefined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo ${undefined+10}\r\n",
      "+ echo 10\r\n",
      "10\r\n"
     ]
    }
   ],
   "source": [
    "echo ${undefined+10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo $undefined\r\n",
      "+ echo 5\r\n",
      "5\r\n"
     ]
    }
   ],
   "source": [
    "echo $undefined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo ${undefined=10}\r\n",
      "+ echo 5\r\n",
      "5\r\n"
     ]
    }
   ],
   "source": [
    "echo ${undefined=10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\r\n"
     ]
    }
   ],
   "source": [
    "unset undefined\n",
    "echo ${undefined=10}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\r\n"
     ]
    }
   ],
   "source": [
    "echo $undefined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n"
     ]
    }
   ],
   "source": [
    "unset undefined\n",
    "echo ${undefined+6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\r\n"
     ]
    }
   ],
   "source": [
    "undefined=5\n",
    "echo ${undefined+6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n"
     ]
    }
   ],
   "source": [
    "echo ${undefined}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo $undefined\r\n",
      "+ echo\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "echo $undefined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "if test -n undefined; then echo true; else echo false; fi\r\n",
      "+ test -n undefined\r\n",
      "+ echo true\r\n",
      "true\r\n"
     ]
    }
   ],
   "source": [
    "if test -n undefined; then echo true; else echo false; fi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, when the variable is a `null` string, things can be very different:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\r\n"
     ]
    }
   ],
   "source": [
    "unset undefined\n",
    "undefined=\n",
    "echo ${undefined:-5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n"
     ]
    }
   ],
   "source": [
    "echo $undefined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\r\n"
     ]
    }
   ],
   "source": [
    "echo ${undefined:=5}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\r\n"
     ]
    }
   ],
   "source": [
    "echo $undefined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\r\n"
     ]
    }
   ],
   "source": [
    "unset undefined\n",
    "undefined=\n",
    "echo ${undefined:+5}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Conditional expressions\n",
    "* [[ __compound command__ ]]\n",
    "* [ __built-in command__ ]\n",
    "* `test` built-in command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test is a symbolic link\r\n"
     ]
    }
   ],
   "source": [
    "if [[ -s test ]]; then\n",
    "    echo \"test is a symbolic link\"\n",
    "else\n",
    "    echo \"test is not a symbolic link\"\n",
    "fi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unary operators\n",
    "| Unary operator | Description |\n",
    "| :---: | --- |\n",
    "| `[ -a FILE ]` | True if FILE is __available__. |\n",
    "| `[ -b FILE ]` | True if FILE exists and is a __block-special__ file. |\n",
    "| `[ -c FILE ]` | True if FILE exists and is a __character-special__ file.|\n",
    "| `[ -d FILE ]` | True if FILE exists and is a __directory__. |\n",
    "| `[ -e FILE ]` | True if FILE __exists__. |\n",
    "| `[ -f FILE ]` | True if FILE exists and is a __regular__ file. |\n",
    "| `[ -g FILE ]` | True if FILE exists and its __SGID__ bit is set. |\n",
    "| `[ -h FILE ]` | True if FILE exists and is a __symbolic link__. |\n",
    "| `[ -k FILE ]` | True if FILE exists and its __sticky bit__ is set. |\n",
    "| `[ -p FILE ]` | True if FILE exists and is a __named pipe (FIFO)__. |\n",
    "| `[ -r FILE ]` | True if FILE exists and is __readable__. |\n",
    "| `[ -s FILE ]` | True if FILE exists and has a __non-zero size__. |\n",
    "| `[ -t FD ]`   | True if file descriptor (FD) is open and refers to a __terminal__. |\n",
    "| `[ -u FILE ]` | True if FILE exists and its __SUID__ bit is set. |\n",
    "| `[ -w FILE ]` | True if FILE exists and is __writable__. |\n",
    "| `[ -x FILE ]` | True if FILE exists and is __executable__. |\n",
    "| `[ -O FILE ]` | True if FILE exists and is __owned by the EUID__.|\n",
    "| `[ -G FILE ]` | True if FILE exists and is __owned by the EGID__.|\n",
    "| `[ -L FILE ]` | True if FILE exists and is a __symbolic link__. |\n",
    "| `[ -N FILE ]` | True if FILE exists and has been __modified__ since it was last read. |\n",
    "| `[ -S FILE ]` | True if FILE exists and is a __socket__. |\n",
    "| `[ -o OPTIONNAME ]` | True if shell option \"OPTIONNAME\" is enabled. |\n",
    "| `[ -z STRING ]` | True if \"STRING\" is empty. |\n",
    "| `[ -n STRING ]` or `[ STRING ]` | True if \"STRING\" is non-empty. |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### binary operators\n",
    "| Binary operator | Description |\n",
    "| :---: | --- |\n",
    "| `[ FILE1 -nt FILE2 ]` | True if FILE1 is newer than FILE2, or if FILE1 exists and FILE2 does not. |\n",
    "| `[ FILE1 -ot FILE2 ]` | True if FILE1 is older than FILE2, or is FILE2 exists and FILE1 does not. |\n",
    "| `[ FILE1 -ef FILE2 ]` | True if FILE1 and FILE2 refer to the same device and inode numbers. |\n",
    "| `[ STRING1 == STRING2 ]` | True if the strings are equal. \"=\" may be used instead of \"==\" for strict POSIX compliance. |\n",
    "| `[ STRING1 != STRING2 ]` | True if the strings are not equal. |\n",
    "| `[ STRING1 < STRING2 ]` | True if \"STRING1\" sorts before \"STRING2\" lexicographically. |\n",
    "| `[ STRING1 > STRING2 ]` | True if \"STRING1\" sorts after \"STRING2\" lexicographically. |\n",
    "| `[ ARG1 OP ARG2 ]` | \"OP\" is one of -eq, -ne, -lt, -le, -gt or -ge. These arithmetic binary operators return true if \"ARG1\" is equal to, not equal to, less than, less than or equal to, greater than, or greater than or equal to \"ARG2\", respectively. \"ARG1\" and \"ARG2\" are integers. |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining expressions\n",
    "\n",
    "| Operation | Effect |\n",
    "| :---: | --- |\n",
    "| `[ ! EXPR ]` | True if EXPR is false. |\n",
    "| `[ ( EXPR ) ]` | Returns the value of EXPR. This may be used to override the normal precedence of operators. |\n",
    "| `[ EXPR1 -a EXPR2 ]` | True if both EXPR1 and EXPR2 are true. |\n",
    "| `[ EXPR1 -o EXPR2 ]` | True if either EXPR1 or EXPR2 is true. |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bio2 is not a valid user on this machine\r\n"
     ]
    }
   ],
   "source": [
    "grep \"^bio2:\" /etc/passwd 1>/dev/null 2>&1\n",
    "if [ $? -ne 0 ]; then\n",
    "    echo \"bio2 is not a valid user on this machine\"\n",
    "fi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "if grep \"^bio2:\" /etc/passwd 1>/dev/null 2>&1; then\n",
    "    echo \"bio2 is not a valid user on this machine\"\n",
    "fi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lrwxrwxrwx 1 bio bio 7  3月  2 15:41 test -> re/test\r\n"
     ]
    }
   ],
   "source": [
    "ls -l test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matching exactly\r\n"
     ]
    }
   ],
   "source": [
    "x=\"string match\"\n",
    "if [[ \"$x\" = string* ]]; then\n",
    "    echo \"matching exactly\"\n",
    "fi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__How about changing the above conditional statement as following?__\n",
    "* `[[ $x == \"string*\" ]]`\n",
    "* `[ $x == string* ]`\n",
    "* `[ \"$x\" == string* ]`\n",
    "* `test \"$x\" == string*`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `if` statement "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test is a regular file\r\n"
     ]
    }
   ],
   "source": [
    "if [[ -f test ]]; then\n",
    "    echo \"test is a regular file\"\n",
    "elif [[ -r test ]]; then\n",
    "    echo \"test is readable\"\n",
    "elif [[ -w test ]]; then\n",
    "    echo \"test is writable\"\n",
    "elif [[ -x test ]]; then\n",
    "    echo \"test is executable\"\n",
    "else\n",
    "    echo \"test is not available\"\n",
    "fi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `while` statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\r\n",
      "6\r\n",
      "7\r\n",
      "8\r\n",
      "9\r\n"
     ]
    }
   ],
   "source": [
    "i=5\n",
    "while [[ $i -lt 10 -a $i -ge 5 ]]; do\n",
    "    echo $i\n",
    "    (( i++ ))\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for` statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With respect to the `for` statement, there are two types of syntaxes:\n",
    "#### [1] `for ... in ...`\n",
    "```bash\n",
    "for i in `seq 10`; do\n",
    "    echo $i\n",
    "done\n",
    "```\n",
    "\n",
    "#### [2] C-style\n",
    "```bash\n",
    "for ((i=0; i<10; i++)); do\n",
    "    echo $i\n",
    "done\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `until` expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\r\n",
      "2\r\n",
      "3\r\n",
      "4\r\n"
     ]
    }
   ],
   "source": [
    "x=1\n",
    "until [[ x -ge 5 ]]; do\n",
    "    echo $x\n",
    "    (( x++ ))\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `select` expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) ls\r\n",
      "2) uname -r\r\n",
      "3) pwd\r\n",
      "4) ls -l\r\n",
      "#? \r\n"
     ]
    }
   ],
   "source": [
    "select item in \"ls\" \"uname -r\" \"pwd\" \"ls -l\" \"break\"; do\n",
    "    `echo $item`\n",
    "done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `case` expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) ls\\n2) uname -r\\n3) pwd\\n4) ls -l\\n5) break\r\n"
     ]
    }
   ],
   "source": [
    "echo \"Write down your option: \"\n",
    "read -p \"1) ls\\n2) uname -r\\n3) pwd\\n4) ls -l\\n5) break\" opt\n",
    "case $opt in\n",
    "1) ls ;;\n",
    "2) uname -r ;;\n",
    "3) pwd ;;\n",
    "4) ls -l ;;\n",
    "5) break ;;\n",
    "esac"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16599\r\n"
     ]
    }
   ],
   "source": [
    "echo $PPID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\r\n"
     ]
    }
   ],
   "source": [
    "echo $HISTSIZE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## `declare`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. declare a read-only variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bash: x: readonly variable\r\n"
     ]
    }
   ],
   "source": [
    "unset x\n",
    "declare -r x=3           # read only\n",
    "x=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\r\n"
     ]
    }
   ],
   "source": [
    "echo $x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 2. declare an integer variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "unset y\n",
    "declare -i y\n",
    "y=5/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\r\n"
     ]
    }
   ],
   "source": [
    "echo $y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. declare an indexed array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "unset z\n",
    "declare -a z\n",
    "z=(a b c d e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\r\n"
     ]
    }
   ],
   "source": [
    "echo ${z[1]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\r\n",
      "b\r\n",
      "c\r\n",
      "d\r\n",
      "e\r\n"
     ]
    }
   ],
   "source": [
    "for i in ${z[@]}; do echo $i; done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. declare an associated array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "unset w\n",
    "declare -A w\n",
    "w['a']=12\n",
    "w['b']=13\n",
    "for i in a b c; do let \"w[$i]-=1\"; done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\r\n",
      "12\r\n",
      "-1\r\n"
     ]
    }
   ],
   "source": [
    "for count in ${w[@]}; do echo $count; done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arithmetic computation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. (( ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\r\n"
     ]
    }
   ],
   "source": [
    "unset a\n",
    "a=1\n",
    "(( a++ ))\n",
    "echo $a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. `expr`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\r\n"
     ]
    }
   ],
   "source": [
    "expr 3 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3+5\r\n"
     ]
    }
   ],
   "source": [
    "expr 3+5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "expr: non-integer argument\r\n"
     ]
    }
   ],
   "source": [
    "expr 3.5 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "expr: syntax error\r\n"
     ]
    }
   ],
   "source": [
    "expr 3 * 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\r\n"
     ]
    }
   ],
   "source": [
    "expr 3 \\* 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\r\n"
     ]
    }
   ],
   "source": [
    "expr 13 / 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\r\n"
     ]
    }
   ],
   "source": [
    "expr 13 % 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. `let`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\r\n"
     ]
    }
   ],
   "source": [
    "let \"a = $a + 2\"\n",
    "echo $a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bash: let: a = 8 * 2.5: syntax error: invalid arithmetic operator (error token is \".5\")\r\n",
      "8\r\n"
     ]
    }
   ],
   "source": [
    "let \"a = $a * 2.5\"\n",
    "echo $a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\r\n"
     ]
    }
   ],
   "source": [
    "echo $?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. `bc`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.12\r\n"
     ]
    }
   ],
   "source": [
    "echo \"3.53*4+2\" | bc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## String operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. String substitution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "actgCTG\r\n"
     ]
    }
   ],
   "source": [
    "var=\"ACTGCTG\"\n",
    "echo ${var/ACTG/actg}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. substring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TGCTG\r\n"
     ]
    }
   ],
   "source": [
    "echo ${var:2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GC\r\n"
     ]
    }
   ],
   "source": [
    "echo ${var:3:2}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. string length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\r\n"
     ]
    }
   ],
   "source": [
    "echo ${#var}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. string truncation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original string: ACTGCTG\r\n"
     ]
    }
   ],
   "source": [
    "echo \"original string: ${var}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lazy head truncation: GCTG\r\n"
     ]
    }
   ],
   "source": [
    "echo \"Lazy head truncation: ${var#*T}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greedy head truncation: G\r\n"
     ]
    }
   ],
   "source": [
    "echo \"Greedy head truncation: ${var##*T}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lazy tail truncation: ACTGC\r\n"
     ]
    }
   ],
   "source": [
    "echo \"lazy tail truncation: ${var%T*}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greedy tail truncation: AC\r\n"
     ]
    }
   ],
   "source": [
    "echo \"Greedy tail truncation: ${var%%T*}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "26250\r\n"
     ]
    }
   ],
   "source": [
    "echo $RANDOM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "for i in {1..100}\n",
    "do\n",
    "    expr 50 + $RANDOM % 50\n",
    "done > random.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "79\r\n",
      "54\r\n",
      "97\r\n",
      "78\r\n",
      "61\r\n",
      "75\r\n",
      "64\r\n",
      "82\r\n",
      "92\r\n",
      "51\r\n"
     ]
    }
   ],
   "source": [
    "head random.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Bash",
   "language": "bash",
   "name": "bash"
  },
  "language_info": {
   "codemirror_mode": "shell",
   "file_extension": ".sh",
   "mimetype": "text/x-sh",
   "name": "bash"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}