ch3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Basic Data Types\n",
    "\n",
    "## 3.1. Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "255 0 1\n",
      "11111111, 0000000100000000, 1111111000000001\n",
      "127 -128 1\n",
      "01111111, 0000000010000000, 0011111100000001\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "45 <nil>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import \"fmt\"\n",
    "var u uint8 = 255\n",
    "fmt.Println(u, u+1, u*u) // \"255 0 1\"\n",
    "fmt.Printf(\"%08b, %016b, %016b\\n\", u, uint16(u)+1, uint16(u)*uint16(u))\n",
    "\n",
    "var i int8 = 127\n",
    "fmt.Println(i, i+1, i*i) // \"127 -128 1\"\n",
    "fmt.Printf(\"%08b, %016b, %016b\\n\", i, int16(i)+1, int16(i)*int16(i))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>\n",
    "&   bitwise AND\n",
    "|   bitwise OR\n",
    "^   bitwise XOR\n",
    "&^  bit clear (AND NOT)\n",
    "<<  left shift\n",
    ">>  right shift\n",
    "</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "00100010\n",
      "00000110\n",
      "00000010\n",
      "00100110\n",
      "00100100\n",
      "00100000\n",
      "1\n",
      "5\n",
      "01000100\n",
      "00010001\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "9 <nil>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var x uint8 = 1<<1 | 1<<5\n",
    "var y uint8 = 1<<1 | 1<<2\n",
    "\n",
    "fmt.Printf(\"%08b\\n\", x)\n",
    "fmt.Printf(\"%08b\\n\", y)\n",
    "fmt.Printf(\"%08b\\n\", x&y)\n",
    "fmt.Printf(\"%08b\\n\", x|y)\n",
    "fmt.Printf(\"%08b\\n\", x^y)\n",
    "fmt.Printf(\"%08b\\n\", x&^y)\n",
    "\n",
    "for i:= uint(0); i<8; i++ {\n",
    "    if int(x)&(1<<i) != 0 {\n",
    "        fmt.Println(i)\n",
    "    }\n",
    "}\n",
    "\n",
    "fmt.Printf(\"%08b\\n\", x<<1)\n",
    "fmt.Printf(\"%08b\\n\", x>>1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "brone\n",
      "silver\n",
      "gold\n"
     ]
    }
   ],
   "source": [
    "medals := []string{\"gold\",\"silver\",\"brone\"}\n",
    "for i := len(medals) - 1; i >= 0; i-- {      //i must be signed, or i will be greator than 0\n",
    "    fmt.Println(medals[i])\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "repl.go:3:28: mismatched types in binary operation + between <int32> and <int16>: apples + oranges",
     "output_type": "error",
     "traceback": [
      "repl.go:3:28: mismatched types in binary operation + between <int32> and <int16>: apples + oranges"
     ]
    }
   ],
   "source": [
    "var apples int32 = 1\n",
    "var oranges int16 = 2\n",
    "var compote int = apples + oranges // compile error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "var apples int32 = 1\n",
    "var oranges int16 = 2\n",
    "var compote int = int(apples) + int(oranges) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 Floating-Point Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 0  ex =    1.000\n",
      "x = 1  ex =    2.718\n",
      "x = 2  ex =    7.389\n",
      "x = 3  ex =   20.086\n",
      "x = 4  ex =   54.598\n",
      "x = 5  ex =  148.413\n",
      "x = 6  ex =  403.429\n",
      "x = 7  ex = 1096.633\n"
     ]
    }
   ],
   "source": [
    "import \"math\"\n",
    "for x:=0; x <8; x++ {\n",
    "    fmt.Printf(\"x = %d  ex = %8.3f\\n\",x, math.Exp(float64(x)))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Copyright © 2016 Alan A. A. Donovan & Brian W. Kernighan.\n",
    "// License: https://creativecommons.org/licenses/by-nc-sa/4.0/\n",
    "\n",
    "// See page 58.\n",
    "//!+\n",
    "\n",
    "// Surface computes an SVG rendering of a 3-D surface function.\n",
    "//package main\n",
    "\n",
    "import (\n",
    "\t\"fmt\"\n",
    "\t\"math\"\n",
    ")\n",
    "\n",
    "const (\n",
    "\twidth, height = 600, 320            // canvas size in pixels\n",
    "\tcells         = 100                 // number of grid cells\n",
    "\txyrange       = 30.0                // axis ranges (-xyrange..+xyrange)\n",
    "\txyscale       = width / 2 / xyrange // pixels per x or y unit\n",
    "\tzscale        = height * 0.4        // pixels per z unit\n",
    "\tangle         = math.Pi / 6         // angle of x, y axes (=30°)\n",
    ")\n",
    "\n",
    "var sin30, cos30 = math.Sin(angle), math.Cos(angle) // sin(30°), cos(30°)\n",
    "\n",
    "func main() {\n",
    "\tfmt.Printf(\"<svg xmlns='http://www.w3.org/2000/svg' \"+\n",
    "\t\t\"style='stroke: grey; fill: white; stroke-width: 0.7' \"+\n",
    "\t\t\"width='%d' height='%d'>\", width, height)\n",
    "\tfor i := 0; i < cells; i++ {\n",
    "\t\tfor j := 0; j < cells; j++ {\n",
    "\t\t\tax, ay := corner(i+1, j)\n",
    "\t\t\tbx, by := corner(i, j)\n",
    "\t\t\tcx, cy := corner(i, j+1)\n",
    "\t\t\tdx, dy := corner(i+1, j+1)\n",
    "\t\t\tfmt.Printf(\"<polygon points='%g,%g %g,%g %g,%g %g,%g'/>\\n\",\n",
    "\t\t\t\tax, ay, bx, by, cx, cy, dx, dy)\n",
    "\t\t}\n",
    "\t}\n",
    "\tfmt.Println(\"</svg>\")\n",
    "}\n",
    "\n",
    "func corner(i, j int) (float64, float64) {\n",
    "\t// Find point (x,y) at corner of cell (i,j).\n",
    "\tx := xyrange * (float64(i)/cells - 0.5)\n",
    "\ty := xyrange * (float64(j)/cells - 0.5)\n",
    "\n",
    "\t// Compute surface height z.\n",
    "\tz := f(x, y)\n",
    "\n",
    "\t// Project (x,y,z) isometrically onto 2-D SVG canvas (sx,sy).\n",
    "\tsx := width/2 + (x-y)*cos30*xyscale\n",
    "\tsy := height/2 + (x+y)*sin30*xyscale - z*zscale\n",
    "\treturn sx, sy\n",
    "}\n",
    "\n",
    "func f(x, y float64) float64 {\n",
    "\tr := math.Hypot(x, y) // distance from (0,0)\n",
    "\treturn math.Sin(r) / r\n",
    "}\n",
    "\n",
    "//!-"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "file:///C:/Users/skhuang/vm-data/course/go2019/src/gopl.io/ch3/surface/sinr.svg\n",
    "![SegmentLocal](https://raw.githubusercontent.com/skhuang/go2019/master/sinr.svg?sanitize=true \"segment\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "//main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3. Complex Numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-5+10i)\n",
      "10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3 <nil>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import \"fmt\"\n",
    "var x complex128 = complex(1, 2) // 1+2i\n",
    "var y complex128 = complex(3, 4) // 3+4i\n",
    "fmt.Println(x*y)     // -5+10i\n",
    "fmt.Println(imag(x*y))// 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-1+0i)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8 <nil>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x := 1 + 2i\n",
    "y := 3 + 4i\n",
    "z := 3.141592i // imaginary literal with zero real component\n",
    "fmt.Println(1i * 1i) // i * i = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "// Copyright © 2016 Alan A. A. Donovan & Brian W. Kernighan.\n",
    "// License: https://creativecommons.org/licenses/by-nc-sa/4.0/\n",
    "\n",
    "// See page 61.\n",
    "//!+\n",
    "\n",
    "// Mandelbrot emits a PNG image of the Mandelbrot fractal.\n",
    "//package main\n",
    "//gopl.go/ch3/mandelbrot\n",
    "\n",
    "import (\n",
    "\t\"image\"\n",
    "\t\"image/color\"\n",
    "\t\"image/png\"\n",
    "\t\"math/cmplx\"\n",
    "\t\"os\"\n",
    "    \"log\"\n",
    ")\n",
    "\n",
    "func main() {\n",
    "\tconst (\n",
    "\t\txmin, ymin, xmax, ymax = -2, -2, +2, +2\n",
    "\t\twidth, height          = 1024, 1024\n",
    "\t)\n",
    "\n",
    "\timg := image.NewRGBA(image.Rect(0, 0, width, height))\n",
    "\tfor py := 0; py < height; py++ {\n",
    "\t\ty := float64(py)/height*(ymax-ymin) + ymin\n",
    "\t\tfor px := 0; px < width; px++ {\n",
    "\t\t\tx := float64(px)/width*(xmax-xmin) + xmin\n",
    "\t\t\tz := complex(x, y)\n",
    "\t\t\t// Image point (px, py) represents complex value z.\n",
    "\t\t\timg.Set(px, py, mandelbrot(z))\n",
    "\t\t}\n",
    "\t}\n",
    "    outfile, err := os.Create(\"ch3mb.png\")\n",
    "    if err != nil {\n",
    "            log.Fatal(err)\n",
    "    }\n",
    "\t//png.Encode(os.Stdout, img) // NOTE: ignoring errors\n",
    "    png.Encode(outfile, img)\n",
    "}\n",
    "\n",
    "func mandelbrot(z complex128) color.Color {\n",
    "\tconst iterations = 200\n",
    "\tconst contrast = 15\n",
    "\n",
    "\tvar v complex128\n",
    "\tfor n := uint8(0); n < iterations; n++ {\n",
    "\t\tv = v*v + z\n",
    "\t\tif cmplx.Abs(v) > 2 {\n",
    "\t\t\treturn color.Gray{255 - contrast*n}\n",
    "\t\t}\n",
    "\t}\n",
    "\treturn color.Black\n",
    "}\n",
    "\n",
    "//!-\n",
    "\n",
    "// Some other interesting functions:\n",
    "\n",
    "func acos(z complex128) color.Color {\n",
    "\tv := cmplx.Acos(z)\n",
    "\tblue := uint8(real(v)*128) + 127\n",
    "\tred := uint8(imag(v)*128) + 127\n",
    "\treturn color.YCbCr{192, blue, red}\n",
    "}\n",
    "\n",
    "func sqrt(z complex128) color.Color {\n",
    "\tv := cmplx.Sqrt(z)\n",
    "\tblue := uint8(real(v)*128) + 127\n",
    "\tred := uint8(imag(v)*128) + 127\n",
    "\treturn color.YCbCr{128, blue, red}\n",
    "}\n",
    "\n",
    "// f(x) = x^4 - 1\n",
    "//\n",
    "// z' = z - f(z)/f'(z)\n",
    "//    = z - (z^4 - 1) / (4 * z^3)\n",
    "//    = z - (z - 1/z^3) / 4\n",
    "func newton(z complex128) color.Color {\n",
    "\tconst iterations = 37\n",
    "\tconst contrast = 7\n",
    "\tfor i := uint8(0); i < iterations; i++ {\n",
    "\t\tz -= (z - 1/(z*z*z)) / 4\n",
    "\t\tif cmplx.Abs(z*z*z*z-1) < 1e-6 {\n",
    "\t\t\treturn color.Gray{255 - contrast*i}\n",
    "\t\t}\n",
    "\t}\n",
    "\treturn color.Black\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![SegmentLocal](https://github.com/skhuang/go2019/raw/master/ch3mb.png \"segment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4. Booleans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A value of type bool, or boolean: true and false\n",
    "<code>\n",
    "   !  : NOT\n",
    "   && : AND\n",
    "   || : OR\n",
    "</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "//s := \"\" \n",
    "s := \"x\"\n",
    "s != \"\" && s[0] == 'x'   // short circuit behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A"
     ]
    }
   ],
   "source": [
    "c := 'A'\n",
    "if 'a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9' {\n",
    "    fmt.Printf(\"%c\",c)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "i := 0\n",
    "b := true\n",
    "if b {        // no implicit conversion from a boolean value to a numeric value like 0 or 1\n",
    "    i = 1\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4 <nil>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// btoi returns 1 if b is true and 0 if false\n",
    "func btoi(b bool) int {\n",
    "    if b {\n",
    "        return 1\n",
    "    }\n",
    "    return 0\n",
    "}\n",
    "fmt.Println(btoi(true),btoi(false))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true false\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "11 <nil>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// itob reports whether i is non-zero.\n",
    "func itob(i int) bool { return i != 0}\n",
    "fmt.Println(itob(2), itob(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5. Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A string is an immutable sequence of bytes\n",
    "* UTF-8 encoded sequences of Unicode code points (runes)\n",
    "* built-in len function returns the number of bytes (not runes) in a string\n",
    "* s[i] retrieves the i-th byte of string s, where 0 &le; i &le;  len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "104 119\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8 <nil>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s := \"hello, world\"\n",
    "fmt.Println(len(s))    // \"12\"\n",
    "fmt.Println(s[0], s[7])// 104 119, h and w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "runtime error: index out of range [12] with length 12",
     "output_type": "error",
     "traceback": [
      "runtime error: index out of range [12] with length 12"
     ]
    }
   ],
   "source": [
    "c := s[len(s)]  // index out of range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* the i-th byte of a string is not necessarily the i-th character of a string, for the UTF8 encoding of a non-ASCIIcode point requires two or more bytes\n",
    "* substring s[i:j] yields a new string starting at index i and continuing up to (not including) the byte at index j, with j - i bytes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hello\n",
      "world\n",
      "hello, world\n",
      "goodbyte, world\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "16 <nil>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fmt.Println(s[0:5]) // \"hello\"\n",
    "fmt.Println(s[:5])\n",
    "fmt.Println(s[7:])\n",
    "fmt.Println(s[:])\n",
    "fmt.Println(\"goodbyte\" + s[5:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left foot, right foot\n",
      "left foot\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10 <nil>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s := \"left foot\"\n",
    "t := s\n",
    "s += \", right foot\"\n",
    "fmt.Println(s)\n",
    "fmt.Println(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* strings are immutable and modifying a string's data is not allowed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "ERROR",
     "evalue": "repl.go:1:3: cannot assign to a byte in a string: s[0]",
     "output_type": "error",
     "traceback": [
      "repl.go:1:3: cannot assign to a byte in a string: s[0]"
     ]
    }
   ],
   "source": [
    "s[0] = 'L'    // cannot assign to s[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5.1. String Literals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<code>\n",
    "    \\a   \"alert\" or bell\n",
    "    \\b   backspace\n",
    "    \\f   form feed\n",
    "    \\n   newline\n",
    "    \\r   carriage return\n",
    "    \\t   tab\n",
    "    \\v   vertical tab\n",
    "    \\'   single quote (only in the rune literal '\\'')\n",
    "    \\\"   double quote (only within \"...\" literals)\n",
    "    \\\\   backslash\n",
    "</code>\n",
    "\n",
    "* hexadecimal escape \\xhh\n",
    "* octal esccape \\ooo (0 through 7)\n",
    "* raw string literal is written <code>\\`...\\`</code>, to write reqular expressions, HTML templates, JSONliterals, command usage messages, and the like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Go is a tool for managing Go source coe.\n",
      "Usage:\n",
      "     go command [arguments]\n",
      "...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "80 <nil>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const GoUsage = `Go is a tool for managing Go source coe.\n",
    "Usage:\n",
    "     go command [arguments]\n",
    "...`\n",
    "fmt.Println(GoUsage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5.2. Unicode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ASCII: American Standard  Code for Informaion Interchange\n",
    "* Use 7 bits to represent 128 characters\n",
    "* To hold other languages, Unicode (unicode.org) collects all of the characters in all of the world's writing systems\n",
    "* Each assigns a standard number called a Unicode code point or , a rune\n",
    "* Unicde version 8 defines code points for over 120,000 characters, over 100 languages and scripts\n",
    "* hold a single rune in int32, called UTF-32 or UCS-4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5.3. UTF-8\n",
    "\n",
    "* UTF-8 is a variable-length encoding of Unicode code points as bytes\n",
    "* UTF-8 is invented y Ken Thompson and Rob Pike, two of the creators of Go\n",
    "* Use between 1 and 4 bytes to represent each rune\n",
    "\n",
    "<code>\n",
    "0xxxxxxx                               runes 0-127     (ASCII)\n",
    "110xxxxx 10xxxxxx                      128-2047        (values < 128 unused)\n",
    "1110xxxx 10xxxxxx 10xxxxxx             2048-65535      (values < 2048 unused)\n",
    "11110xxx 10xxxxxx 10xxxxxx 10xxxxxx    65536-0x10ffff  (other values unused)\n",
    "</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. 世界\n",
      "2. 世界\n",
      "3. 世界\n",
      "4. 世界\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10 <nil>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fmt.Println(\"1. 世界\")\n",
    "fmt.Println(\"2. \\xe4\\xb8\\x96\\xe7\\x95\\x8c\")\n",
    "fmt.Println(\"3. \\u4e16\\u754c\")\n",
    "fmt.Println(\"4. \\U00004e16\\U0000754c\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "世世世"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3 <nil>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fmt.Printf(\"%c\",'世')\n",
    "fmt.Printf(\"%c\",'\\u4e16')\n",
    "fmt.Printf(\"%c\",'\\U00004e16')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "true\n",
      "true\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5 <nil>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func HasPrefix(s, prefix string) bool {\n",
    "    return len(s) >= len(prefix) && s[:len(prefix)] == prefix\n",
    "}\n",
    "\n",
    "func HasSuffix(s, suffix string) bool {\n",
    "    return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix\n",
    "}\n",
    "\n",
    "func Contains(s, substr string) bool {\n",
    "    for i:= 0; i < len(s); i++ {\n",
    "        if HasPrefix(s[i:], substr) {\n",
    "            return true\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "fmt.Println(HasPrefix(\"世界\", \"世\"))\n",
    "fmt.Println(HasSuffix(\"世界\", \"界\"))\n",
    "fmt.Println(Contains(\"花花世界\",\"花世\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "9\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2 <nil>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import \"unicode/utf8\"\n",
    "s:=\"Hello, 世界\"\n",
    "fmt.Println(len(s))                    // 13\n",
    "fmt.Println(utf8.RuneCountInString(s)) // 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "9\n",
      "9\n",
      "9\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2 <nil>"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// count the number of runes\n",
    "\n",
    "func runeLen1(s string) int {\n",
    "    n := 0\n",
    "    for i:=0; i< len(s); {\n",
    "        r, size := utf8.DecodeRuneInString(s[i:])\n",
    "        //fmt.Printf(\"%d\\t%c\\n\", i, r)\n",
    "        i += size\n",
    "        n++\n",
    "    }\n",
    "    return n\n",
    "}\n",
    "\n",
    "func runeLen2(s string) (n int) {\n",
    "    n := 0\n",
    "    for i, r := range s {\n",
    "        n++\n",
    "    }\n",
    "}\n",
    "\n",
    "func runeLen3(s string) (n int) {\n",
    "    for _, _ := range s {\n",
    "        n++\n",
    "    }\n",
    "}\n",
    "\n",
    "func runeLen4(s string) (n int) {\n",
    "    for range s {\n",
    "        n++\n",
    "    }\n",
    "}\n",
    "\n",
    "fmt.Println(runeLen1(\"Hello, 世界\"))\n",
    "fmt.Println(runeLen2(\"Hello, 世界\"))\n",
    "fmt.Println(runeLen3(\"Hello, 世界\"))\n",
    "fmt.Println(runeLen4(\"Hello, 世界\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* []rune for a UTF-8 string returns the sequence of Unicode code points "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e3 83 97 e3 83 ad e3 82 b0 e3 83 a9 e3 83 a0\n",
      "[30d7 30ed 30b0 30e9 30e0]\n",
      "プログラム\n",
      "A\n",
      "京\n",
      "�\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4 <nil>"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s := \"プログラム\"  // \"program\" in Japanese katakana 片假名\n",
    "fmt.Printf(\"% x\\n\", s) // insert a space between each pair of hex digits\n",
    "r := []rune(s)\n",
    "fmt.Printf(\"%x\\n\", r)\n",
    "\n",
    "fmt.Println(string(r)) // runes converted back to string\n",
    "\n",
    "fmt.Println(string(65))\n",
    "fmt.Println(string(0x4eac))\n",
    "fmt.Println(string(1234567))  // replacement character"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.5.4. Strings and Byte Slices\n",
    "* packages for strings: bytes, strings, strconv, and unicode\n",
    "* bytes package: slices of bytes, type []byte\n",
    "* strconv package: converting boolean, integer, and floating-point to string\n",
    "* unicode package: IsDigit, IsLetter, IsUpper, and IsLower "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c\n",
      "c.d\n",
      "abc\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4 <nil>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// basename removes directory components and a .suffix.\n",
    "// e.g., a => a, a.go => a, a/b/c.go => c, a/b.c.go => b.c\n",
    "func basename1(s string) string {\n",
    "\t// Discard last '/' and everything before.\n",
    "\tfor i := len(s) - 1; i >= 0; i-- {\n",
    "\t\tif s[i] == '/' {\n",
    "\t\t\ts = s[i+1:]\n",
    "\t\t\tbreak\n",
    "\t\t}\n",
    "\t}\n",
    "\t// Preserve everything before last '.'.\n",
    "\tfor i := len(s) - 1; i >= 0; i-- {\n",
    "\t\tif s[i] == '.' {\n",
    "\t\t\ts = s[:i]\n",
    "\t\t\tbreak\n",
    "\t\t}\n",
    "\t}\n",
    "\treturn s\n",
    "}\n",
    "\n",
    "fmt.Println(basename1(\"a/b/c.go\"))\n",
    "fmt.Println(basename1(\"c.d.go\"))\n",
    "fmt.Println(basename1(\"abc\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c\n",
      "c.d\n",
      "abc\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4 <nil>"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// basename removes directory components and a trailing .suffix.\n",
    "// e.g., a => a, a.go => a, a/b/c.go => c, a/b.c.go => b.c\n",
    "//!+\n",
    "import \"strings\"\n",
    "func basename2(s string) string {\n",
    "\tslash := strings.LastIndex(s, \"/\") // -1 if \"/\" not found\n",
    "\ts = s[slash+1:]\n",
    "\tif dot := strings.LastIndex(s, \".\"); dot >= 0 {\n",
    "\t\ts = s[:dot]\n",
    "\t}\n",
    "\treturn s\n",
    "}\n",
    "fmt.Println(basename2(\"a/b/c.go\"))\n",
    "fmt.Println(basename2(\"c.d.go\"))\n",
    "fmt.Println(basename2(\"abc\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.6. Constants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Constants are expressions whose value is known to the compiler and whose evaluation is quaranteed to occur at compile time, not run time\n",
    "* basic type: boolean, string, or number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1 2 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "8 <nil>"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "const pi = 3.14159  // math.Pi\n",
    "const (\n",
    "    e = 2.7182818284\n",
    "    pi = 314159265358\n",
    ")\n",
    "\n",
    "const (\n",
    "    a = 1\n",
    "    b\n",
    "    c = 2\n",
    "    d\n",
    ")\n",
    "\n",
    "fmt.Println(a,b,c,d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6.1. The Constant Generator iota"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* the value of iota begains at zero and increments by one for each item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "14 <nil>"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type Weekday int\n",
    "const (\n",
    "   Sunday Weekday = iota\n",
    "   Monday\n",
    "   Tuesday\n",
    "   Wednesday\n",
    "   Thursday\n",
    "   Friday\n",
    "   Saturday\n",
    ")\n",
    "\n",
    "fmt.Println(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 8 16\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "9 <nil>"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type Flags uint\n",
    "const (\n",
    "  FlagUp  Flags = 1 << iota \n",
    "  FlagBroadcast\n",
    "  FlagLoopback\n",
    "  FlagPointToPoint\n",
    "  FlagMulticast\n",
    ")\n",
    "\n",
    "fmt.Println(FlagUp, FlagBroadcast, FlagPointToPoint, FlagMulticast)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Go",
   "language": "go",
   "name": "gophernotes"
  },
  "language_info": {
   "codemirror_mode": "",
   "file_extension": ".go",
   "mimetype": "",
   "name": "go",
   "nbconvert_exporter": "",
   "pygments_lexer": "",
   "version": "go1.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}