ch1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 1. Tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hello, World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "//gopl.io/ch1/helloworld\n",
    "import \"fmt\"\n",
    "\n",
    "func main(){\n",
    "    fmt.Println(\"Hello, World\")\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World\n"
     ]
    }
   ],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Command-Line Arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "//gopl.io/ch1/echo1\n",
    "import (\n",
    "        \"fmt\"\n",
    "        \"os\"\n",
    ")\n",
    "\n",
    "func main(){\n",
    "    var s, sep string\n",
    "    for i := 0; i < len(os.Args); i++ {\n",
    "        s += sep  + os.Args[i]\n",
    "        sep = \" \"\n",
    "     }\n",
    "    fmt.Println(s)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo2 type -l\n",
      "3"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1 <nil>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.Args = []string{\"echo2\",\"type\",\"-l\"}\n",
    "main()\n",
    "fmt.Printf(\"%x\",len(os.Args))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    for initializaion; condition; post {\n",
    "       // zero or more statements\n",
    "    }\n",
    "    // a traditional \"while\" loop\n",
    "    for condition {\n",
    "    }\n",
    "    // a traditional infinite loop\n",
    "    for {\n",
    "    }\n",
    "* os.Args is a slice of strings\n",
    "* a slice as a s\n",
    " - s[i]  the ith element\n",
    " - s[m:n] subsequence of s, 0 &le; m &le; n &le; len(s), containing n-m elements\n",
    " - len(s) is the number of elements \n",
    " \n",
    " \n",
    "* os.Args[0] the first element, the name of the command\n",
    "  - the other elements are the arguments passed to the program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "//gopl.io/ch1/echo2\n",
    "import (\"fmt\";\"os\")\n",
    "\n",
    "func main(){\n",
    "    s, sep := \"\", \"\"\n",
    "    for _, arg := range os.Args[0:] {\n",
    "        s += sep + arg\n",
    "        sep = \" \"\n",
    "    }\n",
    "    fmt.Println(s)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[echo2 ls]\n"
     ]
    }
   ],
   "source": [
    "os.Args = []string{\"echo2\",\"ls\",\"-l\"}\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "//gopl.io/ch1/echo3\n",
    "import (\"fmt\"; \"os\" ; \"strings\")\n",
    "func main(){\n",
    "    fmt.Println(strings.Join(os.Args[1:],\" \"))\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "echo2 ls -l\n"
     ]
    }
   ],
   "source": [
    "os.Args = []string{\"echo2\",\"ls\",\"-l\"}\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "// print the slice of an array\n",
    "import (\"fmt\"; \"os\")\n",
    "func main(){\n",
    "    fmt.Println(os.Args[0:])\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[echo3 ls -l]\n"
     ]
    }
   ],
   "source": [
    "os.Args = []string{\"echo3\",\"ls\",\"-l\"}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding Duplicate Lines\n",
    "\n",
    "dup.txt\n",
    "<pre>\n",
    "design\n",
    "design\n",
    "base\n",
    "key\n",
    "design\n",
    "zero\n",
    "first\n",
    "time\n",
    "key\n",
    "first\n",
    "second\n",
    "base\n",
    "design\n",
    "first\n",
    "</pre>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "//gopl.io/ch1/dup1        \n",
    "import (\"bufio\";\"fmt\";\"os\";\"log\")\n",
    "func main(){\n",
    "    file, err := os.Open(\"dup.txt\")\n",
    "    if err != nil {\n",
    "        //log.Fatal(err)\n",
    "        fmt.Fprintf(os.Stderr, \"%v\\n\", err)\n",
    "    }\n",
    "    counts := make(map[string]int)\n",
    "//input := bufio.NewScanner(os.Stdin)\n",
    "    input := bufio.NewScanner(file)\n",
    "    for input.Scan() {\n",
    "        counts[input.Text()]++\n",
    "    }\n",
    "        // NOTE: ignoring potential errors from input.Err()\n",
    "    for line, n := range counts {\n",
    "        if n > 1 {\n",
    "             fmt.Printf(\"%d\\t%s\\n\", n, line)\n",
    "         }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\tkey\n",
      "3\tfirst\n",
      "4\tdesign\n",
      "2\tbase\n"
     ]
    }
   ],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "//gopl.io/ch1/dup2\n",
    "import (\"bufio\";\"fmt\";\"os\";\"strings\")\n",
    "//func countLines(*os.File, map[string]int, map[string]string)\n",
    "func main() {\n",
    "        counts := make(map[string]int)\n",
    "        fcounts:= make(map[string]string)\n",
    "        os.Args[1] = \"dup.txt\"\n",
    "        files := os.Args[1:]\n",
    "        if len(files) == 0 {\n",
    "                countLines(os.Stdin, counts, fcounts)\n",
    "        } else {\n",
    "                for _, arg := range files {\n",
    "                        f, err := os.Open(arg)\n",
    "                        if err != nil {\n",
    "                                fmt.Fprintf(os.Stderr, \"dup2: %v\\n\", err)\n",
    "                                continue\n",
    "                        }\n",
    "                        countLines(f, counts, fcounts)\n",
    "                        f.Close()\n",
    "                }\n",
    "        }\n",
    "        for line, n := range counts {\n",
    "                            if n > 1 {\n",
    "                                fmt.Printf(\"%s: %d\\t%s\\n\", fcounts[line], n, line)\n",
    "                }\n",
    "        }\n",
    "}\n",
    "\n",
    "func countLines(f *os.File, counts map[string]int, fcounts map[string]string) {\n",
    "        input := bufio.NewScanner(f)\n",
    "        for input.Scan() {\n",
    "                counts[input.Text()]++\n",
    "                fcounts[input.Text()] = f.Name()\n",
    "        }\n",
    "        // NOTE: ignoring potential errors from input.Err()\n",
    "}\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dup2.txt: 2\tzero\n",
      "dup2.txt: 6\tfirst\n",
      "dup2.txt: 2\ttime\n",
      "dup2.txt: 2\tsecond\n",
      "dup2.txt: 7\tdesign\n",
      "dup2.txt: 5\tbase\n",
      "dup2.txt: 6\tkey\n"
     ]
    }
   ],
   "source": [
    "os.Args = []string{\"dup2\",\"dup.txt\", \"dup2.txt\"}\n",
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "//gopl.io/ch1/dup3\n",
    "import (\"fmt\";\"io/ioutil\";\"os\";\"strings\")\n",
    "\n",
    "func main() {\n",
    "        counts := make(map[string]int)\n",
    "        for _, filename := range os.Args[1:] {\n",
    "                data, err := ioutil.ReadFile(filename)\n",
    "                if err != nil {\n",
    "                        fmt.Fprintf(os.Stderr, \"dup3: %v\\n\", err)\n",
    "                        continue\n",
    "                }\n",
    "                for _, line := range strings.Split(string(data), \"\\n\") {\n",
    "                        counts[line]++\n",
    "                }\n",
    "        }\n",
    "        for line, n := range counts {\n",
    "                if n > 1 {\n",
    "                        fmt.Printf(\"%d\\t%s\\n\", n, line)\n",
    "                }\n",
    "        }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\tdesign\n",
      "2\tbase\n",
      "2\tkey\n",
      "3\tfirst\n"
     ]
    }
   ],
   "source": [
    "os.Args = []string{\"dup3\",\"dup.txt\"}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Animated GIFs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "//gopl.io/ch1/lissajous\n",
    "import (\n",
    "        \"image\"\n",
    "        \"image/color\"\n",
    "        \"image/gif\"\n",
    "        \"io\"\n",
    "        \"math\"\n",
    "        \"math/rand\"\n",
    "        \"os\"\n",
    ")\n",
    "//func lissajous(out io.Writer) \n",
    "//!-main\n",
    "// Packages not needed by version in book.\n",
    "import (\n",
    "        \"log\"\n",
    "        \"net/http\"\n",
    "        \"time\"\n",
    ")\n",
    "\n",
    "//!+main\n",
    "\n",
    "var palette = []color.Color{color.White, color.RGBA{0x00,0xff,0x00,0xff}}\n",
    "\n",
    "const (\n",
    "        whiteIndex = 0 // first color in palette\n",
    "        blackIndex = 1 // next color in palette\n",
    "        //blackIndex = 2\n",
    ")\n",
    "//func lissajous(out io.Writer)\n",
    "\n",
    "func main() {\n",
    "        //!-main\n",
    "        // The sequence of images is deterministic unless we seed\n",
    "        // the pseudo-random number generator using the current time.\n",
    "        // Thanks to Randall McPherson for pointing out the omission.\n",
    "        rand.Seed(time.Now().UTC().UnixNano())\n",
    "\n",
    "        if len(os.Args) > 1 && os.Args[1] == \"web\" {\n",
    "                //!+http\n",
    "                handler := func(w http.ResponseWriter, r *http.Request) {\n",
    "                        lissajous(w)\n",
    "                }\n",
    "                http.HandleFunc(\"/\", handler)\n",
    "                //!-http\n",
    "                log.Fatal(http.ListenAndServe(\"localhost:8000\", nil))\n",
    "                //return\n",
    "        }\n",
    "        //!+main\n",
    "        //lissajous(os.Stdout)\n",
    "        outfile, err := os.Create(\"out4.gif\")\n",
    "        if err != nil {\n",
    "            log.Fatal(err)\n",
    "        }\n",
    "        lissajous(outfile)\n",
    "}\n",
    "\n",
    "func lissajous(out io.Writer) {\n",
    "        const (\n",
    "                cycles  = 5     // number of complete x oscillator revolutions\n",
    "                res     = 0.001 // angular resolution\n",
    "                size    = 100   // image canvas covers [-size..+size]\n",
    "                nframes = 64    // number of animation frames\n",
    "                delay   = 8     // delay between frames in 10ms units\n",
    "        )\n",
    "        freq := rand.Float64() * 3.0 // relative frequency of y oscillator\n",
    "        anim := gif.GIF{LoopCount: nframes}\n",
    "        phase := 0.0 // phase difference\n",
    "        for i := 0; i < nframes; i++ {\n",
    "                rect := image.Rect(0, 0, 2*size+1, 2*size+1)\n",
    "                img := image.NewPaletted(rect, palette)\n",
    "                for t := 0.0; t < cycles*2*math.Pi; t += res {\n",
    "                        x := math.Sin(t)\n",
    "                        y := math.Sin(t*freq + phase)\n",
    "                        img.SetColorIndex(size+int(x*size+0.5), size+int(y*size+0.5),\n",
    "                                blackIndex)\n",
    "                }\n",
    "                phase += 0.1\n",
    "                anim.Delay = append(anim.Delay, delay)\n",
    "                anim.Image = append(anim.Image, img)\n",
    "            }\n",
    "        gif.EncodeAll(out, &anim) // NOTE: ignoring encoding errors\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.Args = []string{\"lissajous\"}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![SegmentLocal](https://github.com/skhuang/go2019/raw/master/out4.gif \"segment\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fetching a URL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "//gopl.io/ch1/fetch\n",
    "import (\n",
    "        \"fmt\"\n",
    "        \"io/ioutil\"\n",
    "        \"net/http\"\n",
    "        \"os\"\n",
    ")\n",
    "\n",
    "func main() {\n",
    "        for _, url := range os.Args[1:] {\n",
    "                resp, err := http.Get(url)\n",
    "                if err != nil {\n",
    "                        fmt.Fprintf(os.Stderr, \"fetch: %v\\n\", err)\n",
    "                        os.Exit(1)\n",
    "                }\n",
    "                b, err := ioutil.ReadAll(resp.Body)\n",
    "                resp.Body.Close()\n",
    "                if err != nil {\n",
    "                        fmt.Fprintf(os.Stderr, \"fetch: reading %s: %v\\n\", url, err)\n",
    "                        os.Exit(1)\n",
    "                }\n",
    "                fmt.Printf(\"%s\", b)\n",
    "        }\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\"\n",
      "\t  \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n",
      "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n",
      "<head>\n",
      "  <meta name=\"go-import\" content=\"gopl.io git https://github.com/adonovan/gopl.io\"></meta>\n",
      "  <title>The Go Programming Language</title>\n",
      "  <script>\n",
      "  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){\n",
      "  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),\n",
      "  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)\n",
      "  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');\n",
      "\n",
      "  ga('create', 'UA-68781809-1', 'auto');\n",
      "  ga('send', 'pageview');\n",
      "  </script>\n",
      "  <link rel=\"stylesheet\" type=\"text/css\" href=\"style.css\" />\n",
      "  <style>\n",
      ".bio {\n",
      "\tfont-size:\t95%;\n",
      "\ttext-align:\tjustify;\n",
      "}\n",
      ".biblio {\n",
      "\tmargin:\t\t0.5em;\n",
      "\tfont-size:\t110%;\n",
      "\tline-height:\t130%;\n",
      "}\n",
      ".center {\n",
      "\ttext-align:\tcenter;\n",
      "}\n",
      "td {\n",
      "\tpadding:\t0.5em 1em 0.5em 1em;\n",
      "\tvertical-align: top;\n",
      "}\n",
      "#toc h1 {\n",
      "\tfont-size:\t95%;\n",
      "\tfont-weight:    normal;\n",
      "}\n",
      "hr {\n",
      "\tborder:\t\t0;\n",
      "\tborder-top:\tthin solid #ccc\n",
      "}\n",
      "  </style>\n",
      "</head>\n",
      "<body>\n",
      "<table><tr>\n",
      "<td>\n",
      "  <a href='http://www.informit.com/store/go-programming-language-9780134190440'><img border='1' src=\"cover.png\" height='600'/></a>\n",
      "  <br/>\n",
      "  <div style='text-align: center'>\n",
      "  <a href='http://www.amazon.com/dp/0134190440'><img border='0' width='150' src=\"buyfromamazon.png\"/></a>\n",
      "  &nbsp;&nbsp;&nbsp;\n",
      "  <a href='http://www.informit.com/store/go-programming-language-9780134190440'/><img border='0' height='26' src=\"informit.png\"/></a>\n",
      "  &nbsp;&nbsp;&nbsp;\n",
      "  <a href='http://www.barnesandnoble.com/w/1121601944'><img border='0' width='150' src=\"barnesnoble.png\"/></a>\n",
      "  </div>\n",
      "</br>\n",
      "</td>\n",
      "<td width='500'>\n",
      "<h1 class='center'>The Go Programming Language</h1>\n",
      "<p class='biblio center'>\n",
      "Alan A. A. Donovan &middot; Brian W. Kernighan<br/>\n",
      "Published Oct 26, 2015 in paperback and Nov 20 in e-book<br/>\n",
      "Addison-Wesley; 380pp; ISBN:&nbsp;978-0134190440<br/>\n",
      "<tt>authors</tt><tt>&#0064;</tt><tt>gopl.io</tt>\n",
      "</p>\n",
      "\n",
      "<!-- Table of Contents -->\n",
      "<div id='toc'>\n",
      "<table><tr>\n",
      "<td>\n",
      "<h1>Contents [<a href='ch1.pdf'/>PDF</a>]</h1>\n",
      "<h1>Preface  [<a href='ch1.pdf'/>PDF</a>]</h1>\n",
      "<h1>1. Tutorial [<a href='ch1.pdf'/>PDF</a>]</h1>\n",
      "<h1>2. Program Structure</h1>\n",
      "<h1>3. Basic Data Types</h1>\n",
      "<h1>4. Composite Types</h1>\n",
      "<h1>5. Functions</h1>\n",
      "<h1>6. Methods</h1>\n",
      "</td>\n",
      "<td>\n",
      "<h1>7. Interfaces</h1>\n",
      "<h1>8. Goroutines and Channels</h1>\n",
      "<h1>9. Concurrency with Shared Variables</h1>\n",
      "<h1>10. Packages and the Go Tool</h1>\n",
      "<h1>11. Testing</h1>\n",
      "<h1>12. Reflection</h1>\n",
      "<h1>13. Low-Level Programming</h1>\n",
      "<h1>Index  [<a href='ch1.pdf'/>PDF</a>]</h1>\n",
      "</td>\n",
      "</tr>\n",
      "<tr>\n",
      "<td colspan='2'>\n",
      "<h1>\n",
      "  <a href='https://github.com/adonovan/gopl.io/'>Source code</a>&nbsp;&nbsp;|&nbsp;&nbsp;\n",
      "  <a href='reviews.html'>Reviews</a>&nbsp;&nbsp;|&nbsp;&nbsp;\n",
      "  <a href='translations.html'>Translations</a>&nbsp;&nbsp;|&nbsp;&nbsp;\n",
      "  <a href='errata.html'>Errata</a>\n",
      "</h1>\n",
      "</td>\n",
      "</tr>\n",
      "</table>\n",
      "</div>\n",
      "\n",
      "<p class=\"bio\">\n",
      "Alan Donovan is a Staff Engineer in Google's infrastructure division,\n",
      "specializing in software development tools.  Since 2012, he has been\n",
      "working on the Go team, designing libraries and tools for static\n",
      "analysis.  He is the author of the\n",
      "<a href='http://golang.org/s/oracle-user-manual'><code>oracle</code></a>,\n",
      "<a href='http://golang.org/lib/godoc/analysis/help.html'><code>godoc -analysis</code></a>,\n",
      "<a href='https://github.com/golang/tools/blob/master/refactor/eg/eg.go'><code>eg</code></a>,\n",
      "and <a href='https://github.com/golang/tools/blob/master/refactor/rename/rename.go'><code>gorename</code></a> tools.\n",
      "</p> \n",
      "\n",
      "<p class=\"bio\">\n",
      "Brian Kernighan was in the Computing Science Research center at Bell\n",
      "Labs until 2000, where he worked on languages and tools for Unix.  He\n",
      "is now a professor in the Computer Science Department at Princeton.\n",
      "He is the co-author of several books, including\n",
      "<a href='http://www.amazon.com/dp/0131103628?tracking_id=disfordig-20'>The C Programming Language</a> and\n",
      "<a href='http://www.amazon.com/dp/020161586X?tracking_id=disfordig-20'>The Practice of Programming</a>.\n",
      "\n",
      "</td>\n",
      "</tr></table>\n",
      "</body>\n",
      "</html>\n"
     ]
    }
   ],
   "source": [
    "os.Args = []string{\"fetch\",\"http://gopl.io/\"}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fetching URLs Concurrently"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "//gopl.io/ch1/fetchall\n",
    "import (\"fmt\";\"io\";\"io/ioutil\";\"net/http\";\"os\";\"time\")\n",
    "\n",
    "func main() {\n",
    "        start := time.Now()\n",
    "        ch := make(chan string)\n",
    "        for _, url := range os.Args[1:] {\n",
    "                go fetch(url, ch) // start a goroutine\n",
    "        }\n",
    "        for range os.Args[1:] {\n",
    "                fmt.Println(<-ch) // receive from channel ch\n",
    "        }\n",
    "        fmt.Printf(\"%.2fs elapsed\\n\", time.Since(start).Seconds())\n",
    "}\n",
    "\n",
    "func fetch(url string, ch chan<- string) {\n",
    "        start := time.Now()\n",
    "        resp, err := http.Get(url)\n",
    "         if err != nil {\n",
    "                ch <- fmt.Sprint(err) // send to channel ch\n",
    "                return\n",
    "        }\n",
    "\n",
    "        nbytes, err := io.Copy(ioutil.Discard, resp.Body)\n",
    "        resp.Body.Close() // don't leak resources\n",
    "        if err != nil {\n",
    "                ch <- fmt.Sprintf(\"while reading %s: %v\", url, err)\n",
    "                return\n",
    "        }\n",
    "        secs := time.Since(start).Seconds()\n",
    "        ch <- fmt.Sprintf(\"%.2fs  %7d  %s\", secs, nbytes, url)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.17s     6841  https://godoc.org true\n",
      "0.17s    11060  https://golang.org true\n",
      "0.23s     4154  http://gopl.io/ true\n",
      "0.40s    27066  https://www.nctu.edu.tw/ true\n",
      "0.40s elapsed\n"
     ]
    }
   ],
   "source": [
    "os.Args = []string{\"fetchall\",\"https://golang.org\", \"http://gopl.io/\", \"https://godoc.org\", \"https://www.nctu.edu.tw/\"}\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A Web Server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import (\n",
    "        \"fmt\"\n",
    "        \"log\"\n",
    "        \"net/http\"\n",
    ")\n",
    "\n",
    "func main() {\n",
    "        http.HandleFunc(\"/\", handler) // each request calls handler\n",
    "        log.Fatal(http.ListenAndServe(\"localhost:9000\", nil))\n",
    "}\n",
    "\n",
    "// handler echoes the Path component of the requested URL.\n",
    "func handler(w http.ResponseWriter, r *http.Request) {\n",
    "        fmt.Fprintf(w, \"URL.Path = %q\\n\", r.URL.Path)\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [http://localhost:9000](http://localhost:9000)\n",
    "* [http://localhost:9000/help](http://localhost:9000/help)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//gopl.io/ch1/server2\n",
    "import (\n",
    "        \"fmt\"\n",
    "        \"log\"\n",
    "        \"net/http\"\n",
    "        \"sync\"\n",
    ")\n",
    "\n",
    "var mu sync.Mutex\n",
    "var count int\n",
    "\n",
    "func main() {\n",
    "        http.HandleFunc(\"/\", handler)\n",
    "        http.HandleFunc(\"/count\", counter)\n",
    "        log.Fatal(http.ListenAndServe(\"localhost:9100\", nil))\n",
    "}\n",
    "\n",
    "// handler echoes the Path component of the requested URL.\n",
    "func handler(w http.ResponseWriter, r *http.Request) {\n",
    "        mu.Lock()\n",
    "        count++\n",
    "        mu.Unlock()\n",
    "        fmt.Fprintf(w, \"URL.Path = %q\\n\", r.URL.Path)\n",
    "}\n",
    "// counter echoes the number of calls so far.\n",
    "func counter(w http.ResponseWriter, r *http.Request) {\n",
    "        mu.Lock()\n",
    "        fmt.Fprintf(w, \"Count %d\\n\", count)\n",
    "        mu.Unlock()\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [http://localhost:9100/](http://localhost:9100)\n",
    "* [http://localhost:9100/count](http://localhost:9100/count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//gopl.io/ch1/server3\n",
    "import (\n",
    "        \"fmt\"\n",
    "        \"log\"\n",
    "        \"net/http\"\n",
    ")\n",
    "\n",
    "func main() {\n",
    "        http.HandleFunc(\"/\", handler)\n",
    "        log.Fatal(http.ListenAndServe(\"localhost:9200\", nil))\n",
    "}\n",
    "\n",
    "//!+handler\n",
    "// handler echoes the HTTP request.\n",
    "func handler(w http.ResponseWriter, r *http.Request) {\n",
    "        fmt.Fprintf(w, \"%s %s %s\\n\", r.Method, r.URL, r.Proto)\n",
    "        for k, v := range r.Header {\n",
    "                fmt.Fprintf(w, \"Header[%q] = %q\\n\", k, v)\n",
    "        }\n",
    "        fmt.Fprintf(w, \"Host = %q\\n\", r.Host)\n",
    "        fmt.Fprintf(w, \"RemoteAddr = %q\\n\", r.RemoteAddr)\n",
    "        if err := r.ParseForm(); err != nil {\n",
    "                log.Print(err)\n",
    "        }\n",
    "        for k, v := range r.Form {\n",
    "             fmt.Fprintf(w, \"Form[%q] = %q\\n\", k, v)\n",
    "        }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [http://localhost:9200](http://localhost:9200)\n",
    "* [http://localhost:9200/?q=query](http://localhost:9200/?q=query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "landed on edge!\n"
     ]
    }
   ],
   "source": [
    "import (\"fmt\";\"math\";\"math/rand\")\n",
    "\n",
    "func coinflip() string {\n",
    "    choice := rand.Intn(3)\n",
    "    return []string{\"heads\",\"tails\",\"edge\"}[choice]\n",
    "}\n",
    "var heads, tails int\n",
    "switch coinflip() {\n",
    "    case \"heads\":\n",
    "        heads++\n",
    "    case \"tails\":\n",
    "        tails++\n",
    "    default:\n",
    "        fmt.Println(\"landed on edge!\")\n",
    "}\n",
    "\n"
   ]
  }
 ],
 "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
}