/gobyexample

Permalink
Browse files

first pass at import

  • Loading branch information...
1 parent 8fa1292 commit 72b227694fec242e906ab0a1b1044a2d2f32a84a @mmcgrana committed Nov 17, 2012
Unified Split
Showing with 13,834 additions and 18 deletions.
  1. +2 −0 .env
  2. +1 −0 Procfile
  3. +43 −6 README.md
  4. +29 −0 public/404.html
  5. +195 −0 public/arrays
  6. +207 −0 public/atomic-counters
  7. +179 −0 public/base64-encoding
  8. +145 −0 public/channel-buffering
  9. +138 −0 public/channel-directions
  10. +170 −0 public/channel-synchronization
  11. +160 −0 public/channels
  12. +185 −0 public/closing-channels
  13. +180 −0 public/closures
  14. +348 −0 public/collection-functions
  15. +159 −0 public/command-line-arguments
  16. +303 −0 public/command-line-flags
  17. +171 −0 public/constants
  18. +183 −0 public/defer
  19. +175 −0 public/environment-variables
  20. +166 −0 public/epoch
  21. +281 −0 public/errors
  22. +190 −0 public/execing-processes
  23. +162 −0 public/exit
  24. BIN public/favicon.ico
  25. +164 −0 public/for
  26. +152 −0 public/functions
  27. +196 −0 public/goroutines
  28. +132 −0 public/hello-world
  29. +174 −0 public/if-else
  30. +174 −0 public/index.html
  31. +222 −0 public/interfaces
  32. +379 −0 public/json
  33. +207 −0 public/line-filters
  34. +217 −0 public/maps
  35. +186 −0 public/methods
  36. +157 −0 public/multiple-return-values
  37. +285 −0 public/mutexes
  38. +165 −0 public/non-blocking-channel-operations
  39. +199 −0 public/number-parsing
  40. +163 −0 public/panic
  41. +183 −0 public/pointers
  42. +206 −0 public/random-numbers
  43. +174 −0 public/range
  44. +147 −0 public/range-over-channels
  45. +246 −0 public/rate-limiting
  46. +280 −0 public/reading-files
  47. +119 −0 public/recursion
  48. +320 −0 public/regular-expressions
  49. +172 −0 public/select
  50. +190 −0 public/sha1-hashes
  51. +177 −0 public/signals
  52. +201 −0 public/site.css
  53. +291 −0 public/slices
  54. +150 −0 public/sorting
  55. +167 −0 public/sorting-by-functions
  56. +244 −0 public/spawning-processes
  57. +303 −0 public/stateful-goroutines
  58. +426 −0 public/string-formatting
  59. +191 −0 public/string-functions
  60. +209 −0 public/structs
  61. +162 −0 public/switch
  62. +144 −0 public/tickers
  63. +254 −0 public/time
  64. +207 −0 public/time-formatting-parsing
  65. +182 −0 public/timeouts
  66. +160 −0 public/timers
  67. +222 −0 public/url-parsing
  68. +144 −0 public/values
  69. +173 −0 public/variables
  70. +163 −0 public/variadic-functions
  71. +205 −0 public/worker-pools
  72. +270 −0 public/writing-files
  73. +207 −0 server.go
  74. +1 −12 tools/generate.go
View
2 .env
@@ -0,0 +1,2 @@
+CANONICAL_HOST=127.0.0.1
+FORCE_HTTPS=0
View
1 Procfile
@@ -0,0 +1 @@
+web: gobyexample
View
49 README.md
@@ -22,7 +22,7 @@ To build the site:
```console
$ tools/build
-$ open site/index.html
+$ open public/index.html
```
To build continuously in a loop:
@@ -40,15 +40,52 @@ $ export PATH="$HOME/repos/pygments:$PATH"
```
-### Serving
+### Local Deploy
-The site is served by the [gobyexample-server](https://github.com/mmcgrana/gobyexample-server)
-tool. To export to this tool:
+```bash
+$ mkdir -p $GOPATH/src/github.com/mmcgrana
+$ cd $GOPATH/src/github.com/mmcgrana
+$ git clone git@github.com:mmcgrana/gobyexaple.git
+$ cd gobyexample
+$ go get
+$ foreman start
+$ foreman open
+```
-```console
-$ SITEDIR=../gobyexample-server/public tool/build
+
+### Platform Deploy
+
+Basic setup:
+
+```bash
+$ export DEPLOY=$USER
+$ heroku create gobyexample-$DEPLOY -r $DEPLOY
+$ heroku config:add -r $DEPLOY \
+ BUILDPACK_URL=https://github.com/kr/heroku-buildpack-go.git -r $DEPLOY \
+ CANONICAL_HOST=gobyexample-$DEPLOY.herokuapp.com -r $DEPLOY \
+ FORCE_HTTPS=1 \
+ AUTH=go:byexample
+$ git push $DEPLOY master
+$ heroku open -r $DEPLOY
```
+Add a domain + SSL:
+
+```bash
+$ heroku domains:add $DOMAIN
+$ heroku addons:add ssl -r $DEPLOY
+# order ssl cert for domain
+$ cat > /tmp/server.key
+$ cat > /tmp/server.crt.orig
+$ cat /tmp/server.crt.orig /tmp/rapidssl_bundle.pem > /tmp/server.crt
+$ heroku certs:add /tmp/server.crt /tmp/server.key -r $DEPLOY
+# add ALIAS record from domain to ssl endpoint dns
+$ heroku config:add CANONICAL_HOST=$DOMAIN -r $DEPLOY
+$ heroku open -r $DEPLOY
+```
+
+
+
### License
View
29 public/404.html
@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Not Found</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div id="intro">
+ <h2><a href="./">Go by Example</a></h2>
+ <p>Sorry, we couldn't find that! Check out the <a href="./">home page</a>?</p>
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
195 public/arrays
@@ -0,0 +1,195 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Arrays</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="arrays">
+ <h2><a href="./">Go by Example</a>: Arrays</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>In Go, an <em>array</em> is a numbered sequence of elements of a
+specific length.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we create an array <code>a</code> that will hold exactly
+5 <code>int</code>s. The type of elements and length are both
+part of the array&rsquo;s type. By default an array is
+zero-valued, which for <code>int</code>s means <code>0</code>s.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">a</span> <span class="p">[</span><span class="mi">5</span><span class="p">]</span><span class="kt">int</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;emp:&quot;</span><span class="p">,</span> <span class="nx">a</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We can set a value at an index using the
+<code>array[index] = value</code> syntax, and get a value with
+<code>array[index]</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">a</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span> <span class="p">=</span> <span class="mi">100</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;set:&quot;</span><span class="p">,</span> <span class="nx">a</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;get:&quot;</span><span class="p">,</span> <span class="nx">a</span><span class="p">[</span><span class="mi">4</span><span class="p">])</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The builtin <code>len</code> returns the length of an array.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;len:&quot;</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="nx">a</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Use this syntax to declare and initalize an array
+in one line.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">b</span> <span class="o">:=</span> <span class="p">[</span><span class="mi">5</span><span class="p">]</span><span class="kt">int</span><span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;dcl:&quot;</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Array types are one-dimensional, but you can
+compose types to build multi-dimensional data
+structures.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">twoD</span> <span class="p">[</span><span class="mi">2</span><span class="p">][</span><span class="mi">3</span><span class="p">]</span><span class="kt">int</span>
+ <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">2</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">twoD</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">j</span><span class="p">]</span> <span class="p">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="nx">j</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;2d: &quot;</span><span class="p">,</span> <span class="nx">twoD</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Note that arrays appear in the form <code>[v1 v2 v3 ...]</code>
+when printed with <code>fmt.Println</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run arrays.go
+<span class="go">emp: [0 0 0 0 0]</span>
+<span class="go">set: [0 0 0 0 100]</span>
+<span class="go">get: 100</span>
+<span class="go">len: 5</span>
+<span class="go">dcl: [1 2 3 4 5]</span>
+<span class="go">2d: [[0 1 2] [1 2 3]]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You&rsquo;ll see <em>slices</em> much more often than arrays in
+typical Go. We&rsquo;ll look at slices next.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="slices">Slices</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/arrays">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
207 public/atomic-counters
@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Atomic Counters</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="atomic-counters">
+ <h2><a href="./">Go by Example</a>: Atomic Counters</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>The primary mechanism for managing state in Go is
+communication over channels. We saw this for example
+with <a href="worker-pool">worker pools</a>. There are a few other
+options for managing state though. Here we&rsquo;ll
+look at using the <code>sync/atomic</code> package for <em>atomic
+counters</em> accessed by multiple goroutines.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;sync/atomic&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll use an unsigned integer to represent our
+(always-positive) counter.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">ops</span> <span class="kt">uint64</span> <span class="p">=</span> <span class="mi">0</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To simulate concurrent updates, we&rsquo;ll start 50
+goroutines that each increment the counter about
+once a millisecond.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">50</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="p">{</span>
+ <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Millisecond</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To atomically increment the counter we
+use <code>AddUint64</code>, giving it the memory
+address of our <code>ops</code> counter with the
+<code>&amp;</code> syntax.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">atomic</span><span class="p">.</span><span class="nx">AddUint64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">ops</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}()</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Wait a second to allow some ops to accumulate.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In order to safely use the counter while it&rsquo;s still
+being updated by other goroutines, we extract a
+copy of the current value into <code>opsFinal</code> via
+<code>LoadUint64</code>. As above we need to give this
+function the memory address <code>&amp;ops</code> from which to
+fetch the value.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">opsFinal</span> <span class="o">:=</span> <span class="nx">atomic</span><span class="p">.</span><span class="nx">LoadUint64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">ops</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;ops:&quot;</span><span class="p">,</span> <span class="nx">opsFinal</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at another approach to managing state:
+mutexes.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running the program shows that we executed about
+40,000 operations.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run atomic-counters.go
+<span class="go">ops: 40200</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at mutexes, another tool for managing
+state.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="mutexes">Mutexes</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/atomic-counters">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
179 public/base64-encoding
@@ -0,0 +1,179 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Base64 Encoding</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="base64-encoding">
+ <h2><a href="./">Go by Example</a>: Base64 Encoding</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go provides built-in support for <a href="http://en.wikipedia.org/wiki/Base64">base64
+encoding/decoding</a>.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This syntax imports the <code>encoding/base64</code> package with
+the <code>b64</code> name instead of the default <code>base64</code>. It&rsquo;ll
+save us some space below.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="nx">b64</span> <span class="s">&quot;encoding/base64&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s the <code>string</code> we&rsquo;ll encode/decode.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">data</span> <span class="o">:=</span> <span class="s">&quot;abc123!?$*&amp;()&#39;-=@~&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Go supports both standard and URL-compatible
+base64. Here&rsquo;s how to encode using the standard
+encoder. The encoder requires a <code>[]byte</code> so we
+cast our <code>string</code> to that type.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">sEnc</span> <span class="o">:=</span> <span class="nx">b64</span><span class="p">.</span><span class="nx">StdEncoding</span><span class="p">.</span><span class="nx">EncodeToString</span><span class="p">([]</span><span class="nb">byte</span><span class="p">(</span><span class="nx">data</span><span class="p">))</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">sEnc</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Decoding may return an error, which you can check
+if you don&rsquo;t already know the input to be
+well-formed.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">sDec</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">b64</span><span class="p">.</span><span class="nx">StdEncoding</span><span class="p">.</span><span class="nx">DecodeString</span><span class="p">(</span><span class="nx">sEnc</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">sDec</span><span class="p">))</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This encodes/decodes using a URL-compatible base64
+format.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">uEnc</span> <span class="o">:=</span> <span class="nx">b64</span><span class="p">.</span><span class="nx">URLEncoding</span><span class="p">.</span><span class="nx">EncodeToString</span><span class="p">([]</span><span class="nb">byte</span><span class="p">(</span><span class="nx">data</span><span class="p">))</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">uEnc</span><span class="p">)</span>
+ <span class="nx">uDec</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">b64</span><span class="p">.</span><span class="nx">URLEncoding</span><span class="p">.</span><span class="nx">DecodeString</span><span class="p">(</span><span class="nx">uEnc</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">uDec</span><span class="p">))</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>The string encodes to slightly different values with the
+standard and URL base64 encoders (trailing <code>+</code> vs <code>-</code>)
+but they both decode to the original string as desired.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run base64-encoding.sh
+<span class="go">YWJjMTIzIT8kKiYoKSctPUB+</span>
+<span class="go">abc123!?$*&amp;()&#39;-=@~</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="go">YWJjMTIzIT8kKiYoKSctPUB-</span>
+<span class="go">abc123!?$*&amp;()&#39;-=@~</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="reading-files">Reading Files</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/base64-encoding">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
145 public/channel-buffering
@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Channel Buffering</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="channel-buffering">
+ <h2><a href="./">Go by Example</a>: Channel Buffering</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>By default channels are <em>unbuffered</em>, meaning that they
+will only accept sends (<code>chan &lt;-</code>) if there is a
+corresponding receive (<code>&lt;- chan</code>) ready to receive the
+sent value. <em>Buffered channels</em> accept a limited
+number of values without a corresponding receiver for
+those values.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we <code>make</code> a channel of strings buffering up to
+2 values.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">messages</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Because this channel is buffered, we can send these
+values into the channel without a corresponding
+concurrent receive.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">messages</span> <span class="o">&lt;-</span> <span class="s">&quot;buffered&quot;</span>
+ <span class="nx">messages</span> <span class="o">&lt;-</span> <span class="s">&quot;channel&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Later we can receive these two values as usual.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="o">&lt;-</span><span class="nx">messages</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="o">&lt;-</span><span class="nx">messages</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run channel-buffering.go
+<span class="go">buffered</span>
+<span class="go">channel</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="channel-synchronization">Channel Synchronization</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/channel-buffering">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
138 public/channel-directions
@@ -0,0 +1,138 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Channel Directions</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="channel-directions">
+ <h2><a href="./">Go by Example</a>: Channel Directions</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>When using channels as function parameters, you can
+specify if a channel is meant to only send or receive
+values. This specificity increases the type-safety of
+the program.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This <code>ping</code> function only accepts a channel for sending
+values. It would be a compile-time error to try to
+receive on this channel.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">ping</span><span class="p">(</span><span class="nx">pings</span> <span class="kd">chan</span><span class="o">&lt;-</span> <span class="kt">string</span><span class="p">,</span> <span class="nx">msg</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">pings</span> <span class="o">&lt;-</span> <span class="nx">msg</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>pong</code> function accepts one channel for receives
+(<code>pings</code>) and a second for sends (<code>pongs</code>).</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">pong</span><span class="p">(</span><span class="nx">pings</span> <span class="o">&lt;-</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">,</span> <span class="nx">pongs</span> <span class="kd">chan</span><span class="o">&lt;-</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">msg</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">pings</span>
+ <span class="nx">pongs</span> <span class="o">&lt;-</span> <span class="nx">msg</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">pings</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+ <span class="nx">pongs</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+ <span class="nx">ping</span><span class="p">(</span><span class="nx">pings</span><span class="p">,</span> <span class="s">&quot;passed message&quot;</span><span class="p">)</span>
+ <span class="nx">pong</span><span class="p">(</span><span class="nx">pings</span><span class="p">,</span> <span class="nx">pongs</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="o">&lt;-</span><span class="nx">pongs</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run channel-directions.go
+<span class="go">passed message</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="select">Select</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/channel-directions">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
170 public/channel-synchronization
@@ -0,0 +1,170 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Channel Synchronization</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="channel-synchronization">
+ <h2><a href="./">Go by Example</a>: Channel Synchronization</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>We can use channels to synchronize execution
+across goroutines. Here&rsquo;s an example of using a
+blocking receive to wait for a goroutine to finish.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This is the function we&rsquo;ll run in a goroutine. The
+<code>done</code> channel will be used to notify another
+goroutine that this function&rsquo;s work is done.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">worker</span><span class="p">(</span><span class="nx">done</span> <span class="kd">chan</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="s">&quot;working...&quot;</span><span class="p">)</span>
+ <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;done&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Send a value to notify that we&rsquo;re done.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">done</span> <span class="o">&lt;-</span> <span class="kc">true</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Start a worker goroutine, giving it the channel to
+notify on.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">bool</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+ <span class="k">go</span> <span class="nx">worker</span><span class="p">(</span><span class="nx">done</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Block until we receive a notification from the
+worker on the channel.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="o">&lt;-</span><span class="nx">done</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run channel-synchronization.go
+<span class="go">working...done </span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If you removed the <code>&lt;- done</code> line from this program, the
+program would exit before the <code>worker</code> even
+started.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="channel-directions">Channel Directions</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/channel-synchronization">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
160 public/channels
@@ -0,0 +1,160 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Channels</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="channels">
+ <h2><a href="./">Go by Example</a>: Channels</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>Channels</em> are the pipes that connect concurrent
+goroutines. You can send values into channels from one
+goroutine and receive those values into another
+goroutine. Channels are a powerful primitive that
+underly much of Go&rsquo;s functionality.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Create a new channel with <code>make(chan val-type)</code>.
+Channels are typed by the values they convey.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">messages</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><em>Send</em> a value into a channel using the <code>channel &lt;-</code>
+syntax. Here we send <code>&quot;ping&quot;</code> to the <code>messages</code>
+channel we made above, from a new goroutine.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span> <span class="nx">messages</span> <span class="o">&lt;-</span> <span class="s">&quot;ping&quot;</span> <span class="p">}()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>&lt;-channel</code> syntax <em>receives</em> a value from the
+channel. Here we&rsquo;ll receive the <code>&quot;ping&quot;</code> message
+we sent above and print it out.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">msg</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">messages</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">msg</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>When we run the program the <code>&quot;ping&quot;</code> message is
+succesfully passed from one goroutine to another via our
+channel.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run channels.go
+<span class="go">ping</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>By default sends and receives block until both the
+sender and receiver are ready. This property allowed
+us to wait at the end of our program for the <code>&quot;ping&quot;</code>
+message without having to use any other synchronization.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="channel-buffering">Channel Buffering</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/channels">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
185 public/closing-channels
@@ -0,0 +1,185 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Closing Channels</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="closing-channels">
+ <h2><a href="./">Go by Example</a>: Closing Channels</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>Closing</em> a channel indicates that no more values
+will be sent on it. This can be useful to communicate
+completion to the channel&rsquo;s receivers.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In this example we&rsquo;ll use a <code>jobs</code> channel to
+communicate work to be done from the <code>main()</code> goroutine
+to a worker goroutine. When we have no more jobs for
+the worker we&rsquo;ll <code>close</code> the <code>jobs</code> channel.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">jobs</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">int</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
+ <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">bool</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s the worker goroutine. It repeatedly receives
+from <code>jobs</code> with <code>j, more := &lt;-jobs</code>. In this
+special 2-value form of receive, the <code>more</code> value
+will be <code>false</code> if <code>jobs</code> has been <code>close</code>d and all
+values in the channel have already been received.
+We use this to notify on <code>done</code> when we&rsquo;ve worked
+all our jobs.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="p">{</span>
+ <span class="nx">j</span><span class="p">,</span> <span class="nx">more</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">jobs</span>
+ <span class="k">if</span> <span class="nx">more</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;received job&quot;</span><span class="p">,</span> <span class="nx">j</span><span class="p">)</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;received all jobs&quot;</span><span class="p">)</span>
+ <span class="nx">done</span> <span class="o">&lt;-</span> <span class="kc">true</span>
+ <span class="k">return</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="p">}()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This sends 3 jobs to the worker over the <code>jobs</code>
+channel, then closes it.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;=</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">jobs</span> <span class="o">&lt;-</span> <span class="nx">j</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;sent job&quot;</span><span class="p">,</span> <span class="nx">j</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="nb">close</span><span class="p">(</span><span class="nx">jobs</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;sent all jobs&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We await the worker using the
+<a href="channel-synchronization">synchronization</a> approach
+we saw earlier.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="o">&lt;-</span><span class="nx">done</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run closing-channels.go
+<span class="go">sent job 1</span>
+<span class="go">received job 1</span>
+<span class="go">sent job 2</span>
+<span class="go">received job 2</span>
+<span class="go">sent job 3</span>
+<span class="go">received job 3</span>
+<span class="go">sent all jobs</span>
+<span class="go">received all jobs</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The idea of closed channels leads naturally to our next
+example: <code>range</code> over channels.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="range-over-channels">Range over Channels</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/closing-channels">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
180 public/closures
@@ -0,0 +1,180 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Closures</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="closures">
+ <h2><a href="./">Go by Example</a>: Closures</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go supports <a href="http://en.wikipedia.org/wiki/Anonymous_function"><em>anonymous functions</em></a>,
+which can form <a href="http://en.wikipedia.org/wiki/Closure_(computer_science)"><em>closures</em></a>.
+Anonymous functions are useful when you want to define
+a function inline without having to name it.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This function <code>intSeq</code> returns another function, which
+we define anonymously in the body of <code>intSeq</code>. The
+returned function <em>closes over</em> the variable <code>i</code> to
+form a closure.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">intSeq</span><span class="p">()</span> <span class="kd">func</span><span class="p">()</span> <span class="kt">int</span> <span class="p">{</span>
+ <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span>
+ <span class="k">return</span> <span class="kd">func</span><span class="p">()</span> <span class="kt">int</span> <span class="p">{</span>
+ <span class="nx">i</span> <span class="o">+=</span> <span class="mi">1</span>
+ <span class="k">return</span> <span class="nx">i</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We call <code>intSeq</code>, assigning the result (a function)
+to <code>nextInt</code>. This function value captures its
+own <code>i</code> value, which will be updated each time
+we call <code>nextInt</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">nextInt</span> <span class="o">:=</span> <span class="nx">intSeq</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>See the effect of the closure by calling <code>nextInt</code>
+a few times.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">nextInt</span><span class="p">())</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">nextInt</span><span class="p">())</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">nextInt</span><span class="p">())</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To confirm that the state is unique to that
+particular function, create and test a new one.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">newInts</span> <span class="o">:=</span> <span class="nx">intSeq</span><span class="p">()</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">newInts</span><span class="p">())</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run closures.go
+<span class="go">1</span>
+<span class="go">2</span>
+<span class="go">3</span>
+<span class="go">1</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The last feature of functions we&rsquo;ll look at for now is
+recursion.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="recursion">Recursion</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/closures">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
348 public/collection-functions
@@ -0,0 +1,348 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Collection Functions</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="collection-functions">
+ <h2><a href="./">Go by Example</a>: Collection Functions</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>We often need our programs to perform operations on
+collections of data, like selecting all items that
+satisfy a given predicate or mapping all items to a new
+collection with a custom function.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In some languages it&rsquo;s idiomatic to use <a href="http://en.wikipedia.org/wiki/Generic_programming">generic</a>
+data structures and algorithms. Go does not support
+generics; in Go it&rsquo;s common to provide collection
+functions if and when they are specifically needed for
+your program and data types.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here are some example collection functions for slices
+of <code>strings</code>. You can use these examples to build your
+own functions. Note that in some cases it may be
+clearest to just inline the collection-manipulating
+code directly, instead of creating and calling a
+helper function.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;strings&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Returns the first index of the target string <code>t</code>, or
+-1 if no match is found.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">Index</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">t</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">int</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">v</span> <span class="o">==</span> <span class="nx">t</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nx">i</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Returns <code>true</code> if the target string t is in the
+slice.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">Include</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">t</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nx">Index</span><span class="p">(</span><span class="nx">vs</span><span class="p">,</span> <span class="nx">t</span><span class="p">)</span> <span class="o">&gt;=</span> <span class="mi">0</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Returns <code>true</code> if one of the strings in the slice
+satisfies the predicate <code>f</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">Any</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">f</span> <span class="kd">func</span><span class="p">(</span><span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">f</span><span class="p">(</span><span class="nx">v</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="kc">true</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="kc">false</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Returns <code>true</code> if all of the strings in the slice
+satisfy the predicate <code>f</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">All</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">f</span> <span class="kd">func</span><span class="p">(</span><span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="p">!</span><span class="nx">f</span><span class="p">(</span><span class="nx">v</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="kc">false</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="kc">true</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Returns a new slice containing all strings in the
+slice that satisfy the predicate <code>f</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">Filter</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">f</span> <span class="kd">func</span><span class="p">(</span><span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span><span class="p">)</span> <span class="p">[]</span><span class="kt">string</span> <span class="p">{</span>
+ <span class="nx">vsf</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">string</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">f</span><span class="p">(</span><span class="nx">v</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">vsf</span> <span class="p">=</span> <span class="nb">append</span><span class="p">(</span><span class="nx">vsf</span><span class="p">,</span> <span class="nx">v</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="nx">vsf</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Returns a new slice containing the results of applying
+the function <code>f</code> to each string in the original slice.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">Map</span><span class="p">(</span><span class="nx">vs</span> <span class="p">[]</span><span class="kt">string</span><span class="p">,</span> <span class="nx">f</span> <span class="kd">func</span><span class="p">(</span><span class="kt">string</span><span class="p">)</span> <span class="kt">string</span><span class="p">)</span> <span class="p">[]</span><span class="kt">string</span> <span class="p">{</span>
+ <span class="nx">vsm</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">string</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="nx">vs</span><span class="p">))</span>
+ <span class="k">for</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">vs</span> <span class="p">{</span>
+ <span class="nx">vsm</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="p">=</span> <span class="nx">f</span><span class="p">(</span><span class="nx">v</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="nx">vsm</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we try out our various collection functions.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">strs</span> <span class="p">=</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;peach&quot;</span><span class="p">,</span> <span class="s">&quot;apple&quot;</span><span class="p">,</span> <span class="s">&quot;pear&quot;</span><span class="p">,</span> <span class="s">&quot;plum&quot;</span><span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Index</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="s">&quot;pear&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Include</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="s">&quot;grape&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Any</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="kd">func</span><span class="p">(</span><span class="nx">v</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">HasPrefix</span><span class="p">(</span><span class="nx">v</span><span class="p">,</span> <span class="s">&quot;p&quot;</span><span class="p">)</span>
+ <span class="p">}))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">All</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="kd">func</span><span class="p">(</span><span class="nx">v</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">HasPrefix</span><span class="p">(</span><span class="nx">v</span><span class="p">,</span> <span class="s">&quot;p&quot;</span><span class="p">)</span>
+ <span class="p">}))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Filter</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="kd">func</span><span class="p">(</span><span class="nx">v</span> <span class="kt">string</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">Contains</span><span class="p">(</span><span class="nx">v</span><span class="p">,</span> <span class="s">&quot;e&quot;</span><span class="p">)</span>
+ <span class="p">}))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The above examples all used anonymous functions,
+but you can also use named functions of the correct
+type.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">Map</span><span class="p">(</span><span class="nx">strs</span><span class="p">,</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">ToUpper</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run collection-functions.go
+<span class="go">2</span>
+<span class="go">false</span>
+<span class="go">true</span>
+<span class="go">false</span>
+<span class="go">[peach apple pear]</span>
+<span class="go">[PEACH APPLE PEAR PLUM]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="string-functions">String Functions</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/collection-functions">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
159 public/command-line-arguments
@@ -0,0 +1,159 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Command-Line Arguments</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="command-line-arguments">
+ <h2><a href="./">Go by Example</a>: Command-Line Arguments</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><a href="http://en.wikipedia.org/wiki/Command-line_interface#Arguments"><em>Command-line arguments</em></a>
+are a common way to parameterize execution of programs.
+For example, <code>go run hello.go</code> uses <code>run</code> and
+<code>hello.go</code> arguments to the <code>go</code> program.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;os&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>os.Args</code> provides access to raw command-line
+arguments. Note that the first value in this slice
+is the path to the program, and <code>os.Args[1:]</code>
+holds the arguments to the program.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">argsWithProg</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Args</span>
+ <span class="nx">argsWithoutProg</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Args</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can get individual args with normal indexing.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">arg</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Args</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">argsWithProg</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">argsWithoutProg</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">arg</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>To experiment with command-line arguments it&rsquo;s best to
+build a binary with <code>go build</code> first.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go build <span class="nb">command</span>-line-arguments.go
+<span class="gp">$</span> ./command-line-arguments a b c d
+<span class="go">[./command-line-arguments a b c d] </span>
+<span class="go">[a b c d]</span>
+<span class="go">c</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at more advanced command-line processing
+with flags.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="command-line-flags">Command-Line Flags</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/command-line-arguments">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
303 public/command-line-flags
@@ -0,0 +1,303 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Command-Line Flags</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="command-line-flags">
+ <h2><a href="./">Go by Example</a>: Command-Line Flags</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><a href="http://en.wikipedia.org/wiki/Command-line_interface#Command-line_option"><em>Command-line flags</em></a>
+are a common way to specify options for command-line
+programs. For example, in <code>wc -l</code> the <code>-l</code> is a
+command-line flag.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Go provides a <code>flag</code> package supporting basic
+command-line flag parsing. We&rsquo;ll use this package to
+implement our example command-line program.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;flag&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Basic flag declarations are available for string,
+integer, and boolean options. Here we declare a
+string flag <code>word</code> with a default value <code>&quot;foo&quot;</code>
+and a short description. This <code>flag.String</code> function
+returns a string pointer (not a string value);
+we&rsquo;ll see how to use this pointer below.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">wordPtr</span> <span class="o">:=</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">String</span><span class="p">(</span><span class="s">&quot;word&quot;</span><span class="p">,</span> <span class="s">&quot;foo&quot;</span><span class="p">,</span> <span class="s">&quot;a string&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This declares <code>numb</code> and <code>fork</code> flags, using a
+similar approach to the <code>word</code> flag.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">numbPtr</span> <span class="o">:=</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">Int</span><span class="p">(</span><span class="s">&quot;numb&quot;</span><span class="p">,</span> <span class="mi">42</span><span class="p">,</span> <span class="s">&quot;an int&quot;</span><span class="p">)</span>
+ <span class="nx">boolPtr</span> <span class="o">:=</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">Bool</span><span class="p">(</span><span class="s">&quot;fork&quot;</span><span class="p">,</span> <span class="kc">false</span><span class="p">,</span> <span class="s">&quot;a bool&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>It&rsquo;s also possible to declare an option that uses an
+existing var declared elsewhere in the program.
+Note that we need to pass in a pointer to the flag
+declaration function.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">svar</span> <span class="kt">string</span>
+ <span class="nx">flag</span><span class="p">.</span><span class="nx">StringVar</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">svar</span><span class="p">,</span> <span class="s">&quot;svar&quot;</span><span class="p">,</span> <span class="s">&quot;bar&quot;</span><span class="p">,</span> <span class="s">&quot;a string var&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Once all flags are declared, call <code>flag.Parse()</code>
+to execute the command-line parsing.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">flag</span><span class="p">.</span><span class="nx">Parse</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we&rsquo;ll just dump out the parsed options and
+any trailing positional arguments. Note that we
+need to dereference the points with e.g. <code>*wordPtr</code>
+to get the actual option values.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;word:&quot;</span><span class="p">,</span> <span class="o">*</span><span class="nx">wordPtr</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;numb:&quot;</span><span class="p">,</span> <span class="o">*</span><span class="nx">numbPtr</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;fork:&quot;</span><span class="p">,</span> <span class="o">*</span><span class="nx">boolPtr</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;svar:&quot;</span><span class="p">,</span> <span class="nx">svar</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;tail:&quot;</span><span class="p">,</span> <span class="nx">flag</span><span class="p">.</span><span class="nx">Args</span><span class="p">())</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>To experiment with the command-line flags program it&rsquo;s
+best to first compile it and then run the resulting
+binary directly.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go build <span class="nb">command</span>-line-flags.go
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Try out the built program by first giving it values for
+all flags.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -word<span class="o">=</span>opt -numb<span class="o">=</span>7 -fork -svar<span class="o">=</span>flag
+<span class="go">word: opt</span>
+<span class="go">numb: 7</span>
+<span class="go">fork: true</span>
+<span class="go">svar: flag</span>
+<span class="go">tail: []</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that if you omit flags they automatically take
+their default values.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -word<span class="o">=</span>opt
+<span class="go">word: opt</span>
+<span class="go">numb: 42</span>
+<span class="go">fork: false</span>
+<span class="go">svar: bar</span>
+<span class="go">tail: []</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Trailing positional arguments can be provided after
+any flags.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -word<span class="o">=</span>opt a1 a2 a3
+<span class="go">word: opt</span>
+<span class="go">...</span>
+<span class="go">tail: [a1 a2 a3]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that the <code>flag</code> package requires all flags to
+appear before positional arguments (otherwise the flags
+will be interpreted as positional arguments).</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -word<span class="o">=</span>opt a1 a2 a3 -num<span class="o">=</span>7
+<span class="go">word: opt</span>
+<span class="go">numb: 42</span>
+<span class="go">fork: false</span>
+<span class="go">svar: bar</span>
+<span class="go">trailing: [a1 a2 a3 -num=7]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Use <code>-h</code> or <code>--help</code> flags to get automatically
+generated help text for the command-line program.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -h
+<span class="go">Usage of ./command-line-flags:</span>
+<span class="go"> -fork=false: a bool</span>
+<span class="go"> -numb=42: an int</span>
+<span class="go"> -svar=&quot;bar&quot;: a string var</span>
+<span class="go"> -word=&quot;foo&quot;: a string</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If you provide a flag that wasn&rsquo;t specified to the
+<code>flag</code> package, the program will print an error message
+an show the help text again.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> ./command-line-flags -wat
+<span class="go">flag provided but not defined: -wat</span>
+<span class="go">Usage of ./command-line-flags:</span>
+<span class="go">...</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at environment variables, another common
+way to parameterize programs.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="environment-variables">Environment Variables</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/command-line-flags">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
171 public/constants
@@ -0,0 +1,171 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Constants</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="constants">
+ <h2><a href="./">Go by Example</a>: Constants</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go supports <em>constants</em> of character, string, boolean,
+and numeric values.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;math&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>const</code> declares a constant value.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">const</span> <span class="nx">s</span> <span class="kt">string</span> <span class="p">=</span> <span class="s">&quot;constant&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A <code>const</code> statement can appear anywhere a <code>var</code>
+statement can.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">const</span> <span class="nx">n</span> <span class="p">=</span> <span class="mi">500000000</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Constant expressions perform arithmetic with
+arbitrary precision.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">const</span> <span class="nx">d</span> <span class="p">=</span> <span class="mf">3e20</span> <span class="o">/</span> <span class="nx">n</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A numeric constant has no type until it&rsquo;s given
+one, such as by an explicit cast.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">int64</span><span class="p">(</span><span class="nx">d</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A number can be given a type by using it in a
+context that requires one, such as a variable
+assignment or function call. For example, here
+<code>math.Sin</code> expects a <code>float64</code>.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">math</span><span class="p">.</span><span class="nx">Sin</span><span class="p">(</span><span class="nx">n</span><span class="p">))</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run constant.go
+<span class="go">constant</span>
+<span class="go">6e+11</span>
+<span class="go">600000000000</span>
+<span class="go">-0.28470407323754404</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="for">For</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/constants">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
183 public/defer
@@ -0,0 +1,183 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Defer</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="defer">
+ <h2><a href="./">Go by Example</a>: Defer</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>Defer</em> is used to ensure that a function call is
+performed later in a program&rsquo;s execution, usually for
+purposes of cleanup. <code>defer</code> is often used where e.g.
+<code>ensure</code> and <code>finally</code> would be used in other languages.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;os&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Suppose we wanted to create a file, write to it,
+and then close when we&rsquo;re done. Here&rsquo;s how we could
+do that with <code>defer</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Immediately after getting a file object with
+<code>createFile</code>, we defer the closing of that file
+with <code>closeFile</code>. This will be executed at the end
+of the enclosing function (<code>main</code>), after
+<code>writeFile</code> has finished.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">f</span> <span class="o">:=</span> <span class="nx">createFile</span><span class="p">(</span><span class="s">&quot;/tmp/defer.txt&quot;</span><span class="p">)</span>
+ <span class="k">defer</span> <span class="nx">closeFile</span><span class="p">(</span><span class="nx">f</span><span class="p">)</span>
+ <span class="nx">writeFile</span><span class="p">(</span><span class="nx">f</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">createFile</span><span class="p">(</span><span class="nx">p</span> <span class="kt">string</span><span class="p">)</span> <span class="o">*</span><span class="nx">os</span><span class="p">.</span><span class="nx">File</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;creating&quot;</span><span class="p">)</span>
+ <span class="nx">f</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Create</span><span class="p">(</span><span class="nx">p</span><span class="p">)</span>
+ <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="nx">f</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">writeFile</span><span class="p">(</span><span class="nx">f</span> <span class="o">*</span><span class="nx">os</span><span class="p">.</span><span class="nx">File</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;writing&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Fprintln</span><span class="p">(</span><span class="nx">f</span><span class="p">,</span> <span class="s">&quot;data&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">closeFile</span><span class="p">(</span><span class="nx">f</span> <span class="o">*</span><span class="nx">os</span><span class="p">.</span><span class="nx">File</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;closing&quot;</span><span class="p">)</span>
+ <span class="nx">f</span><span class="p">.</span><span class="nx">Close</span><span class="p">()</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running the program confirms that the file is closed
+after being written.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run defer.go
+<span class="go">creating</span>
+<span class="go">writing</span>
+<span class="go">closing</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="collection-functions">Collection Functions</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/defer">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
175 public/environment-variables
@@ -0,0 +1,175 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Environment Variables</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="environment-variables">
+ <h2><a href="./">Go by Example</a>: Environment Variables</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><a href="http://en.wikipedia.org/wiki/Environment_variable">Environment variables</a>
+are a universal mechanism for <a href="http://www.12factor.net/config">conveying configuration
+information to Unix programs</a>.
+Let&rsquo;s look at how to set, get, and list environment variables.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;os&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;strings&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To set a key/value pair, use <code>os.Setenv</code>. To get a
+value for a key, use <code>os.Getenv</code>. This will return
+an empty string if the key isn&rsquo;t present in the
+environment.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">os</span><span class="p">.</span><span class="nx">Setenv</span><span class="p">(</span><span class="s">&quot;FOO&quot;</span><span class="p">,</span> <span class="s">&quot;1&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;FOO:&quot;</span><span class="p">,</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Getenv</span><span class="p">(</span><span class="s">&quot;FOO&quot;</span><span class="p">))</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;BAR:&quot;</span><span class="p">,</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Getenv</span><span class="p">(</span><span class="s">&quot;BAR&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Use <code>os.Environ</code> to list all key/value pairs in the
+environment. This returns a slice of strings in the
+form <code>KEY=value</code>. You can <code>strings.Split</code> them to
+get the key and value. Here we print all the keys.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">()</span>
+ <span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Environ</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">pair</span> <span class="o">:=</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">Split</span><span class="p">(</span><span class="nx">e</span><span class="p">,</span> <span class="s">&quot;=&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">pair</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running the program shows that we pick up the value
+value for <code>FOO</code> that we set in the program, but that
+<code>BAR</code> is empty.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run environment-variables.go
+<span class="go">FOO: 1</span>
+<span class="go">BAR: </span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The list of keys in the environment will depend on your
+particular machine.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="go">TERM_PROGRAM</span>
+<span class="go">PATH</span>
+<span class="go">SHELL</span>
+<span class="go">...</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If we set <code>BAR</code> in the environemnt first, the running
+program picks that value up.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> <span class="nv">BAR</span><span class="o">=</span>2 go run environment-variables.go
+<span class="go">FOO: 1</span>
+<span class="go">BAR: 2</span>
+<span class="go">...</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="spawning-processes">Spawning Processes</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/environment-variables">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
166 public/epoch
@@ -0,0 +1,166 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Epoch</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="epoch">
+ <h2><a href="./">Go by Example</a>: Epoch</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>A common requirement in programs is getting the number
+of seconds, milliseconds, or nanoseconds since the
+<a href="http://en.wikipedia.org/wiki/Unix_time">Unix epoch</a>.
+Here&rsquo;s how to do it in Go.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Use <code>time.Now</code> with <code>Unix</code> or <code>UnixNano</code> to get
+elapsed time since the Unix epoch in seconds or
+nanoseconds, respectively.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">now</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Now</span><span class="p">()</span>
+ <span class="nx">secs</span> <span class="o">:=</span> <span class="nx">now</span><span class="p">.</span><span class="nx">Unix</span><span class="p">()</span>
+ <span class="nx">nanos</span> <span class="o">:=</span> <span class="nx">now</span><span class="p">.</span><span class="nx">UnixNano</span><span class="p">()</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">now</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that there is no <code>UnixMillis</code>, so to get the
+milliseconds since epoch you&rsquo;ll need to manually
+dive from nanoseconds.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">millis</span> <span class="o">:=</span> <span class="nx">nanos</span> <span class="o">/</span> <span class="mi">1000000</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">secs</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">millis</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">nanos</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can also convert integer seconds or nanoseconds
+since the epoch into the corresponding <code>time</code>.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Unix</span><span class="p">(</span><span class="nx">secs</span><span class="p">,</span> <span class="mi">0</span><span class="p">))</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Unix</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nx">nanos</span><span class="p">))</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run epoch.go
+<span class="go">2012-10-31 16:13:58.292387 +0000 UTC</span>
+<span class="go">1351700038</span>
+<span class="go">1351700038292</span>
+<span class="go">1351700038292387000</span>
+<span class="go">2012-10-31 16:13:58 +0000 UTC</span>
+<span class="go">2012-10-31 16:13:58.292387 +0000 UTC</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at another time-related task: time
+parsing and formatting.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="time-formatting-parsing">Time Formatting / Parsing</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/epoch">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
281 public/errors
@@ -0,0 +1,281 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Errors</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="errors">
+ <h2><a href="./">Go by Example</a>: Errors</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>In Go it&rsquo;s idiomatic to communicate errors via an
+explicit, separate return value. This contrasts with
+the exceptions used in languages like Java and Ruby and
+the overloaded single result / error value sometimes
+used in C. Go&rsquo;s approach makes it easy to see which
+functions return errors and to handle them using the
+same language constructs employed for any other,
+non-error tasks.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;errors&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>By convention, errors are the last return value and
+have type <code>error</code>, a built-in interface.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">f1</span><span class="p">(</span><span class="nx">arg</span> <span class="kt">int</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">arg</span> <span class="o">==</span> <span class="mi">42</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>errors.New</code> constructs a basic <code>error</code> value
+with the given error message.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="nx">errors</span><span class="p">.</span><span class="nx">New</span><span class="p">(</span><span class="s">&quot;can&#39;t work with 42&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A nil value in the error position indicates that
+there was no error.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">return</span> <span class="nx">arg</span> <span class="o">+</span> <span class="mi">3</span><span class="p">,</span> <span class="kc">nil</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>It&rsquo;s possible to use custom types as <code>error</code>s by
+implementing the <code>Error()</code> method on them. Here&rsquo;s a
+variant on the example above that uses a custom type
+to explicitly represent an argument error.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">type</span> <span class="nx">argError</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">arg</span> <span class="kt">int</span>
+ <span class="nx">prob</span> <span class="kt">string</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">e</span> <span class="o">*</span><span class="nx">argError</span><span class="p">)</span> <span class="nx">Error</span><span class="p">()</span> <span class="kt">string</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Sprintf</span><span class="p">(</span><span class="s">&quot;%d - %s&quot;</span><span class="p">,</span> <span class="nx">e</span><span class="p">.</span><span class="nx">arg</span><span class="p">,</span> <span class="nx">e</span><span class="p">.</span><span class="nx">prob</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">f2</span><span class="p">(</span><span class="nx">arg</span> <span class="kt">int</span><span class="p">)</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">arg</span> <span class="o">==</span> <span class="mi">42</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In this case we use <code>&amp;argError</code> syntax to build
+a new struct, supplying values for the two
+fields <code>arg</code> and <code>prob</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="o">&amp;</span><span class="nx">argError</span><span class="p">{</span><span class="nx">arg</span><span class="p">,</span> <span class="s">&quot;can&#39;t work with it&quot;</span><span class="p">}</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="nx">arg</span> <span class="o">+</span> <span class="mi">3</span><span class="p">,</span> <span class="kc">nil</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The two loops below test out each of our
+error-returning functions. Note that the use of an
+inline error check on the <code>if</code> line is a common
+idiom in Go code.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">i</span> <span class="o">:=</span> <span class="k">range</span> <span class="p">[]</span><span class="kt">int</span><span class="p">{</span><span class="mi">7</span><span class="p">,</span> <span class="mi">42</span><span class="p">}</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">r</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">f1</span><span class="p">(</span><span class="nx">i</span><span class="p">);</span> <span class="nx">e</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;f1 failed:&quot;</span><span class="p">,</span> <span class="nx">e</span><span class="p">)</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;f1 worked:&quot;</span><span class="p">,</span> <span class="nx">r</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">i</span> <span class="o">:=</span> <span class="k">range</span> <span class="p">[]</span><span class="kt">int</span><span class="p">{</span><span class="mi">7</span><span class="p">,</span> <span class="mi">42</span><span class="p">}</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">r</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">f2</span><span class="p">(</span><span class="nx">i</span><span class="p">);</span> <span class="nx">e</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;f2 failed:&quot;</span><span class="p">,</span> <span class="nx">e</span><span class="p">)</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;f2 worked:&quot;</span><span class="p">,</span> <span class="nx">r</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If you want to programmatically use the data in
+a custom error, you&rsquo;ll need to get the error as an
+instance of the custom error type via type
+assertion.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">_</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">f2</span><span class="p">(</span><span class="mi">42</span><span class="p">)</span>
+ <span class="k">if</span> <span class="nx">ae</span><span class="p">,</span> <span class="nx">ok</span> <span class="o">:=</span> <span class="nx">e</span><span class="p">.(</span><span class="o">*</span><span class="nx">argError</span><span class="p">);</span> <span class="nx">ok</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">ae</span><span class="p">.</span><span class="nx">arg</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">ae</span><span class="p">.</span><span class="nx">prob</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run errors.go
+<span class="go">f1 worked: 10</span>
+<span class="go">f1 failed: can&#39;t work with 42</span>
+<span class="go">f2 worked: 10</span>
+<span class="go">f2 failed: 42 - can&#39;t work with it</span>
+<span class="go">42</span>
+<span class="go">can&#39;t work with it</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>See this <a href="http://blog.golang.org/2011/07/error-handling-and-go.html">great post</a>
+on the Go blog for more on error handling.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="goroutines">Goroutines</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/errors">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
190 public/execing-processes
@@ -0,0 +1,190 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Exec'ing Processes</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="execing-processes">
+ <h2><a href="./">Go by Example</a>: Exec'ing Processes</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>In the previous example we looked at
+<a href="spawning-processes">spawning external processes</a>. We
+do this when we need an external process accessible to
+a running Go process. Sometimes we just want to
+completely replace the current Go process with another
+(perhaps non-Go) one. To do this we&rsquo;ll use Go&rsquo;s
+implementation of the classic
+<a href="http://en.wikipedia.org/wiki/Exec_(operating_system)"><code>exec</code></a>
+function.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;syscall&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;os&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;os/exec&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For our example we&rsquo;ll exec <code>ls</code>. Go requires an
+abolute path to the binary we want to execute, so
+we&rsquo;ll use <code>exec.LookPath</code> to find it (probably
+<code>/bin/ls</code>).</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">binary</span><span class="p">,</span> <span class="nx">lookErr</span> <span class="o">:=</span> <span class="nx">exec</span><span class="p">.</span><span class="nx">LookPath</span><span class="p">(</span><span class="s">&quot;ls&quot;</span><span class="p">)</span>
+ <span class="k">if</span> <span class="nx">lookErr</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">lookErr</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>Exec</code> requires arguments in slice form (as
+apposed to one big string). We&rsquo;ll give <code>ls</code> a few
+common arguments.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">args</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;-a&quot;</span><span class="p">,</span> <span class="s">&quot;-l&quot;</span><span class="p">,</span> <span class="s">&quot;-h&quot;</span><span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>Exec</code> also needs a set of <a href="environment-variables">environment variables</a>
+to use. Here we just provide our current
+environment.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">env</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Environ</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s the actual <code>os.Exec</code> call. If this call is
+succesful, the execution of our process will end
+here and be replaced by the <code>/bin/ls -a -l -h</code>
+process. If there is an error we&rsquo;ll get a return
+value.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">execErr</span> <span class="o">:=</span> <span class="nx">syscall</span><span class="p">.</span><span class="nx">Exec</span><span class="p">(</span><span class="nx">binary</span><span class="p">,</span> <span class="nx">args</span><span class="p">,</span> <span class="nx">env</span><span class="p">)</span>
+ <span class="k">if</span> <span class="nx">execErr</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">execErr</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>When we run our program it is replaced by <code>ls</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run execing-processes.go
+<span class="go">total 16</span>
+<span class="go">drwxr-xr-x 4 mark 136B Oct 3 16:29 .</span>
+<span class="go">drwxr-xr-x 91 mark 3.0K Oct 3 12:50 ..</span>
+<span class="go">-rw-r--r-- 1 mark 1.3K Oct 3 16:28 execing-processes.go</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that Go does not offer a classic Unix <code>fork</code>
+function. Usually this isn&rsquo;t an issue though, since
+starting goroutines, spawning processes, and exec&rsquo;ing
+processes covers most use cases for <code>fork</code>.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="signals">Signals</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/execing-processes">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
162 public/exit
@@ -0,0 +1,162 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Exit</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="exit">
+ <h2><a href="./">Go by Example</a>: Exit</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Use <code>os.Exit</code> to immediately exit with a given
+status.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;os&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>defer</code>s will <em>not</em> be run when using <code>os.Exit</code>, so
+this <code>fmt.Println</code> will never be called.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">defer</span> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;!&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Exit with status 3.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">os</span><span class="p">.</span><span class="nx">Exit</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that unlike e.g. C, Go does not use an integer
+return value from <code>main</code> to indicate exit status. If
+you&rsquo;d like to exit with a non-zero status you should
+use <code>os.Exit</code>.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>If you run <code>exit.go</code> using <code>go run</code>, the exit
+will be picked up by <code>go</code> and printed.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run exit.go
+<span class="go">exit status 3</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>By building and executing a binary you can see
+the status in the terminal.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go build exit.go
+<span class="gp">$</span> ./exit
+<span class="gp">$</span> <span class="nb">echo</span> <span class="nv">$?</span>
+<span class="go">3</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that the <code>!</code> from our program never got printed.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/exit">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
BIN public/favicon.ico
Binary file not shown.
View
164 public/for
@@ -0,0 +1,164 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: For</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="for">
+ <h2><a href="./">Go by Example</a>: For</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><code>for</code> is Go&rsquo;s only looping construct. Here are
+three basic types of <code>for</code> loops.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The most basic type, with a single condition.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">1</span>
+ <span class="k">for</span> <span class="nx">i</span> <span class="o">&lt;=</span> <span class="mi">3</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span>
+ <span class="nx">i</span> <span class="p">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A classic initial/condition/after <code>for</code> loop.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">7</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;=</span> <span class="mi">9</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">j</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>for</code> without a condition will loop repeatedly
+until you <code>break</code> out of the loop or <code>return</code> from
+the enclosing function.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;loop&quot;</span><span class="p">)</span>
+ <span class="k">break</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run <span class="k">for</span>.go
+<span class="go">1</span>
+<span class="go">2</span>
+<span class="go">3</span>
+<span class="go">7</span>
+<span class="go">8</span>
+<span class="go">9</span>
+<span class="go">loop</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll see some other <code>for</code> forms latter when we look at
+<code>range</code> statements, channels, and other data
+structures.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="if-else">If/Else</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/for">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
152 public/functions
@@ -0,0 +1,152 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Functions</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="functions">
+ <h2><a href="./">Go by Example</a>: Functions</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>Functions</em> are central in Go. We&rsquo;ll learn about
+functions with a few different examples.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s a function that takes two <code>int</code>s and returns
+their sum as an <code>int</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">plus</span><span class="p">(</span><span class="nx">a</span> <span class="kt">int</span><span class="p">,</span> <span class="nx">b</span> <span class="kt">int</span><span class="p">)</span> <span class="kt">int</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Go requires explicit returns, i.e. it won&rsquo;t
+automatically return the value of the last
+expression.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">return</span> <span class="nx">a</span> <span class="o">+</span> <span class="nx">b</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Call a function just as you&rsquo;d expect, with
+<code>name(args)</code>.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">res</span> <span class="o">:=</span> <span class="nx">plus</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;1+2 =&quot;</span><span class="p">,</span> <span class="nx">res</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run functions.go
+<span class="go">1+2 = 3</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>There are several other features to Go functions. One is
+multiple return values, which we&rsquo;ll look at next.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="multiple-return-values">Multiple Return Values</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/functions">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
196 public/goroutines
@@ -0,0 +1,196 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Goroutines</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="goroutines">
+ <h2><a href="./">Go by Example</a>: Goroutines</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>A <em>goroutine</em> is a lightweight thread of execution.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">f</span><span class="p">(</span><span class="nx">from</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">from</span><span class="p">,</span> <span class="s">&quot;:&quot;</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Suppose we have a function call <code>f(s)</code>. Here&rsquo;s how
+we&rsquo;d call that in the usual way, running it
+synchronously.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">f</span><span class="p">(</span><span class="s">&quot;direct&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To invoke this function in a goroutine, use
+<code>go f(s)</code>. This new goroutine will execute
+concurrently with the calling one.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">go</span> <span class="nx">f</span><span class="p">(</span><span class="s">&quot;goroutine&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can also start a goroutine for an anonymous
+function call.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">(</span><span class="nx">msg</span> <span class="kt">string</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">msg</span><span class="p">)</span>
+ <span class="p">}(</span><span class="s">&quot;going&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Our two goroutines are running asynchronously in
+separate goroutines now, so execution falls through
+to here. This <code>Scanln</code> code requires we press a key
+before the program exits.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">input</span> <span class="kt">string</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Scanln</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">input</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;done&quot;</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>When we run this program, we see the output of the
+blocking call first, then the interleaved output of the
+two gouroutines. This interleaving reflects the
+goroutines being run concurrently by the Go runtime.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run goroutines.go
+<span class="go">direct : 0</span>
+<span class="go">direct : 1</span>
+<span class="go">direct : 2</span>
+<span class="go">goroutine : 0</span>
+<span class="go">going</span>
+<span class="go">goroutine : 1</span>
+<span class="go">goroutine : 2</span>
+<span class="go">&lt;enter&gt;</span>
+<span class="go">done</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at a complement to goroutines in
+concurrent Go programs: channels.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="channels">Channels</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/goroutines">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
132 public/hello-world
@@ -0,0 +1,132 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Hello World</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="hello-world">
+ <h2><a href="./">Go by Example</a>: Hello World</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Our first program will print the classic &ldquo;hello world&rdquo;
+message. Here&rsquo;s the full source code.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;hello world&quot;</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>To run the program, put the code in <code>hello-world.go</code> and
+use <code>go run</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run hello-world.go
+<span class="go">hello world</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Sometimes we&rsquo;ll want to build our programs into
+binaries. We can do this using <code>go build</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go build hello-world.go
+<span class="gp">$</span> ls
+<span class="go">hello-world hello-world.go</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We can then execute the built binary directly.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> ./hello-world
+<span class="go">hello world</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Now that we can run and build basic Go programs, let&rsquo;s
+learn more about the language.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="values">Values</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/hello-world">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
174 public/if-else
@@ -0,0 +1,174 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: If/Else</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="if-else">
+ <h2><a href="./">Go by Example</a>: If/Else</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Branching with <code>if</code> and <code>else</code> in Go is
+straight-forward.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s a basic example.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">if</span> <span class="mi">7</span><span class="o">%</span><span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;7 is even&quot;</span><span class="p">)</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;7 is odd&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can have an <code>if</code> statement without an else.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">if</span> <span class="mi">8</span><span class="o">%</span><span class="mi">4</span> <span class="o">==</span> <span class="mi">0</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;8 is divisible by 4&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A statement can proceed conditionals; any variables
+declared in this statement are available in all
+branches.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">if</span> <span class="nx">num</span> <span class="o">:=</span> <span class="mi">9</span><span class="p">;</span> <span class="nx">num</span> <span class="p">&lt;</span> <span class="mi">0</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">num</span><span class="p">,</span> <span class="s">&quot;is negative&quot;</span><span class="p">)</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="nx">num</span> <span class="p">&lt;</span> <span class="mi">10</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">num</span><span class="p">,</span> <span class="s">&quot;has 1 digit&quot;</span><span class="p">)</span>
+ <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">num</span><span class="p">,</span> <span class="s">&quot;has multiple digits&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that you don&rsquo;t need parentheses around conditions
+in Go, but that the brackets are required.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run <span class="k">if</span>-else.go
+<span class="go">7 is odd</span>
+<span class="go">8 is divisible by 4</span>
+<span class="go">9 has 1 digit</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>There is no <a href="http://en.wikipedia.org/wiki/%3F:">ternary if</a>
+in Go, so you&rsquo;ll need to use a full <code>if</code> statement even
+for basic conditions.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="switch">Switch</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/if-else">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
174 public/index.html
@@ -0,0 +1,174 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div id="intro">
+ <h2><a href="./">Go by Example</a></h2>
+ <p>
+ <a href="http://golang.org">Go</a> is an
+ open source programming language designed for
+ building simple, fast, and reliable software.
+ </p>
+
+ <p>
+ <em>Go by Example</em> is a hands-on introduction
+ to Go using annotated example programs. Check out
+ the <a href="/hello-world">first example</a> or
+ browse the full list below.
+ </p>
+
+ <ul>
+
+ <li><a href="hello-world">Hello World</a></li>
+
+ <li><a href="values">Values</a></li>
+
+ <li><a href="variables">Variables</a></li>
+
+ <li><a href="constants">Constants</a></li>
+
+ <li><a href="for">For</a></li>
+
+ <li><a href="if-else">If/Else</a></li>
+
+ <li><a href="switch">Switch</a></li>
+
+ <li><a href="arrays">Arrays</a></li>
+
+ <li><a href="slices">Slices</a></li>
+
+ <li><a href="maps">Maps</a></li>
+
+ <li><a href="range">Range</a></li>
+
+ <li><a href="functions">Functions</a></li>
+
+ <li><a href="multiple-return-values">Multiple Return Values</a></li>
+
+ <li><a href="variadic-functions">Variadic Functions</a></li>
+
+ <li><a href="closures">Closures</a></li>
+
+ <li><a href="recursion">Recursion</a></li>
+
+ <li><a href="pointers">Pointers</a></li>
+
+ <li><a href="structs">Structs</a></li>
+
+ <li><a href="methods">Methods</a></li>
+
+ <li><a href="interfaces">Interfaces</a></li>
+
+ <li><a href="errors">Errors</a></li>
+
+ <li><a href="goroutines">Goroutines</a></li>
+
+ <li><a href="channels">Channels</a></li>
+
+ <li><a href="channel-buffering">Channel Buffering</a></li>
+
+ <li><a href="channel-synchronization">Channel Synchronization</a></li>
+
+ <li><a href="channel-directions">Channel Directions</a></li>
+
+ <li><a href="select">Select</a></li>
+
+ <li><a href="timeouts">Timeouts</a></li>
+
+ <li><a href="non-blocking-channel-operations">Non-Blocking Channel Operations</a></li>
+
+ <li><a href="closing-channels">Closing Channels</a></li>
+
+ <li><a href="range-over-channels">Range over Channels</a></li>
+
+ <li><a href="timers">Timers</a></li>
+
+ <li><a href="tickers">Tickers</a></li>
+
+ <li><a href="worker-pools">Worker Pools</a></li>
+
+ <li><a href="rate-limiting">Rate Limiting</a></li>
+
+ <li><a href="atomic-counters">Atomic Counters</a></li>
+
+ <li><a href="mutexes">Mutexes</a></li>
+
+ <li><a href="stateful-goroutines">Stateful Goroutines</a></li>
+
+ <li><a href="sorting">Sorting</a></li>
+
+ <li><a href="sorting-by-functions">Sorting by Functions</a></li>
+
+ <li><a href="panic">Panic</a></li>
+
+ <li><a href="defer">Defer</a></li>
+
+ <li><a href="collection-functions">Collection Functions</a></li>
+
+ <li><a href="string-functions">String Functions</a></li>
+
+ <li><a href="string-formatting">String Formatting</a></li>
+
+ <li><a href="regular-expressions">Regular Expressions</a></li>
+
+ <li><a href="json">JSON</a></li>
+
+ <li><a href="time">Time</a></li>
+
+ <li><a href="epoch">Epoch</a></li>
+
+ <li><a href="time-formatting-parsing">Time Formatting / Parsing</a></li>
+
+ <li><a href="random-numbers">Random Numbers</a></li>
+
+ <li><a href="number-parsing">Number Parsing</a></li>
+
+ <li><a href="url-parsing">URL Parsing</a></li>
+
+ <li><a href="sha1-hashes">SHA1 Hashes</a></li>
+
+ <li><a href="base64-encoding">Base64 Encoding</a></li>
+
+ <li><a href="reading-files">Reading Files</a></li>
+
+ <li><a href="writing-files">Writing Files</a></li>
+
+ <li><a href="line-filters">Line Filters</a></li>
+
+ <li><a href="command-line-arguments">Command-Line Arguments</a></li>
+
+ <li><a href="command-line-flags">Command-Line Flags</a></li>
+
+ <li><a href="environment-variables">Environment Variables</a></li>
+
+ <li><a href="spawning-processes">Spawning Processes</a></li>
+
+ <li><a href="execing-processes">Exec'ing Processes</a></li>
+
+ <li><a href="signals">Signals</a></li>
+
+ <li><a href="exit">Exit</a></li>
+
+ </ul>
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
222 public/interfaces
@@ -0,0 +1,222 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Interfaces</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="interfaces">
+ <h2><a href="./">Go by Example</a>: Interfaces</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>Interfaces</em> are named collections of method
+signatures.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;math&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s a basic interface for geometric shapes.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">type</span> <span class="nx">geometry</span> <span class="kd">interface</span> <span class="p">{</span>
+ <span class="nx">area</span><span class="p">()</span> <span class="kt">float64</span>
+ <span class="nx">perim</span><span class="p">()</span> <span class="kt">float64</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For our example we&rsquo;ll implement this interface on
+<code>square</code> and <code>circle</code> types.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">type</span> <span class="nx">square</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">width</span><span class="p">,</span> <span class="nx">height</span> <span class="kt">float64</span>
+<span class="p">}</span>
+<span class="kd">type</span> <span class="nx">circle</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">radius</span> <span class="kt">float64</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To implement an interface in Go, we just need to
+implement all the methods in the interface. Here we
+implement <code>geometry</code> on <code>square</code>s.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">s</span> <span class="nx">square</span><span class="p">)</span> <span class="nx">area</span><span class="p">()</span> <span class="kt">float64</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nx">s</span><span class="p">.</span><span class="nx">width</span> <span class="o">*</span> <span class="nx">s</span><span class="p">.</span><span class="nx">height</span>
+<span class="p">}</span>
+<span class="kd">func</span> <span class="p">(</span><span class="nx">s</span> <span class="nx">square</span><span class="p">)</span> <span class="nx">perim</span><span class="p">()</span> <span class="kt">float64</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">2</span><span class="o">*</span><span class="nx">s</span><span class="p">.</span><span class="nx">width</span> <span class="o">+</span> <span class="mi">2</span><span class="o">*</span><span class="nx">s</span><span class="p">.</span><span class="nx">height</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The implementation for <code>circle</code>s.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">c</span> <span class="nx">circle</span><span class="p">)</span> <span class="nx">area</span><span class="p">()</span> <span class="kt">float64</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nx">math</span><span class="p">.</span><span class="nx">Pi</span> <span class="o">*</span> <span class="nx">c</span><span class="p">.</span><span class="nx">radius</span> <span class="o">*</span> <span class="nx">c</span><span class="p">.</span><span class="nx">radius</span>
+<span class="p">}</span>
+<span class="kd">func</span> <span class="p">(</span><span class="nx">c</span> <span class="nx">circle</span><span class="p">)</span> <span class="nx">perim</span><span class="p">()</span> <span class="kt">float64</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">2</span> <span class="o">*</span> <span class="nx">math</span><span class="p">.</span><span class="nx">Pi</span> <span class="o">*</span> <span class="nx">c</span><span class="p">.</span><span class="nx">radius</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If a variable has an interface type, then we can call
+methods that are in the named interface. Here&rsquo;s a
+generic <code>measure</code> function taking advantage of this
+to work on any <code>geometry</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">measure</span><span class="p">(</span><span class="nx">g</span> <span class="nx">geometry</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">g</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">g</span><span class="p">.</span><span class="nx">area</span><span class="p">())</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">g</span><span class="p">.</span><span class="nx">perim</span><span class="p">())</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">s</span> <span class="o">:=</span> <span class="nx">square</span><span class="p">{</span><span class="nx">width</span><span class="p">:</span> <span class="mi">3</span><span class="p">,</span> <span class="nx">height</span><span class="p">:</span> <span class="mi">4</span><span class="p">}</span>
+ <span class="nx">c</span> <span class="o">:=</span> <span class="nx">circle</span><span class="p">{</span><span class="nx">radius</span><span class="p">:</span> <span class="mi">5</span><span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>circle</code> and <code>square</code> struct types both
+implement the <code>geometry</code> interface so we can use
+instances of
+these structs as arguments to measure.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">measure</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span>
+ <span class="nx">measure</span><span class="p">(</span><span class="nx">c</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run interfaces.go
+<span class="go">{3 4}</span>
+<span class="go">12</span>
+<span class="go">14</span>
+<span class="go">{5}</span>
+<span class="go">78.53981633974483</span>
+<span class="go">31.41592653589793</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To learn more about Go&rsquo;s interfaces, check out this
+<a href="http://jordanorelli.tumblr.com/post/32665860244/how-to-use-interfaces-in-go">great blog post</a>.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="errors">Errors</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/interfaces">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
379 public/json
@@ -0,0 +1,379 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: JSON</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="json">
+ <h2><a href="./">Go by Example</a>: JSON</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go offers built-in support for JSON encoding and
+decoding, including to and from built-in and custom
+data types.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;encoding/json&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;os&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll use these two structs to demonstrate encoding and
+decoding of custom types below.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">type</span> <span class="nx">Response1</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">Page</span> <span class="kt">int</span>
+ <span class="nx">Fruits</span> <span class="p">[]</span><span class="kt">string</span>
+<span class="p">}</span>
+<span class="kd">type</span> <span class="nx">Response2</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">Page</span> <span class="kt">int</span> <span class="s">`json:&quot;page&quot;`</span>
+ <span class="nx">Fruits</span> <span class="p">[]</span><span class="kt">string</span> <span class="s">`json:&quot;fruits&quot;`</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>First we&rsquo;ll look at encoding basic data types to
+JSON strings. Here are some examples for atomic
+values.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">bolB</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">Marshal</span><span class="p">(</span><span class="kc">true</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">bolB</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">intB</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">Marshal</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">intB</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fltB</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">Marshal</span><span class="p">(</span><span class="mf">2.34</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">fltB</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">strB</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">Marshal</span><span class="p">(</span><span class="s">&quot;gopher&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">strB</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>And here are some for slices and maps, which encode
+to JSON arrays and objects as you&rsquo;d expect.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">slcD</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;apple&quot;</span><span class="p">,</span> <span class="s">&quot;peach&quot;</span><span class="p">,</span> <span class="s">&quot;pear&quot;</span><span class="p">}</span>
+ <span class="nx">slcB</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">Marshal</span><span class="p">(</span><span class="nx">slcD</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">slcB</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">mapD</span> <span class="o">:=</span> <span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">int</span><span class="p">{</span><span class="s">&quot;apple&quot;</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span> <span class="s">&quot;lettuce&quot;</span><span class="p">:</span> <span class="mi">7</span><span class="p">}</span>
+ <span class="nx">mapB</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">Marshal</span><span class="p">(</span><span class="nx">mapD</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">mapB</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The JSON package can automatically encode your
+custom data types. It will only include exported
+fields in the encoded output and will by default
+use those names as the JSON keys.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">res1D</span> <span class="o">:=</span> <span class="o">&amp;</span><span class="nx">Response1</span><span class="p">{</span>
+ <span class="nx">Page</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
+ <span class="nx">Fruits</span><span class="p">:</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;apple&quot;</span><span class="p">,</span> <span class="s">&quot;peach&quot;</span><span class="p">,</span> <span class="s">&quot;pear&quot;</span><span class="p">}}</span>
+ <span class="nx">res1B</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">Marshal</span><span class="p">(</span><span class="nx">res1D</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">res1B</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can use tags on struct field declarations
+to customize the encoded JSON key names. Check the
+definition of <code>Response2</code> above to see an example
+of such tags.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">res2D</span> <span class="o">:=</span> <span class="o">&amp;</span><span class="nx">Response2</span><span class="p">{</span>
+ <span class="nx">Page</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
+ <span class="nx">Fruits</span><span class="p">:</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;apple&quot;</span><span class="p">,</span> <span class="s">&quot;peach&quot;</span><span class="p">,</span> <span class="s">&quot;pear&quot;</span><span class="p">}}</span>
+ <span class="nx">res2B</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">Marshal</span><span class="p">(</span><span class="nx">res2D</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">res2B</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Now let&rsquo;s look at decoding JSON data into Go
+values. Here&rsquo;s an example for a generic data
+structure.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">byt</span> <span class="o">:=</span> <span class="p">[]</span><span class="nb">byte</span><span class="p">(</span><span class="s">`{&quot;num&quot;:6.0,&quot;strs&quot;:[&quot;a&quot;,&quot;b&quot;]}`</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We need to provide a variable where the JSON
+package can put the decoded data. This
+<code>map[string]interface{}</code> will hold a map of strings
+to arbitrary data types.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">dat</span> <span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kd">interface</span><span class="p">{}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s the actual decoding, and a check for
+associated errors.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">if</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">Unmarshal</span><span class="p">(</span><span class="nx">byt</span><span class="p">,</span> <span class="o">&amp;</span><span class="nx">dat</span><span class="p">);</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">dat</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In order to use the values in the decoded map,
+we&rsquo;ll need to cast them to their appropriate type.
+For example here we cast the value in <code>num</code> to
+the expected <code>float64</code> type.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">num</span> <span class="o">:=</span> <span class="nx">dat</span><span class="p">[</span><span class="s">&quot;num&quot;</span><span class="p">].(</span><span class="kt">float64</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">num</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Accessing nested data requires a series of
+casts.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">strs</span> <span class="o">:=</span> <span class="nx">dat</span><span class="p">[</span><span class="s">&quot;strs&quot;</span><span class="p">].([]</span><span class="kd">interface</span><span class="p">{})</span>
+ <span class="nx">str1</span> <span class="o">:=</span> <span class="nx">strs</span><span class="p">[</span><span class="mi">0</span><span class="p">].(</span><span class="kt">string</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">str1</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We can also decode JSON into custom data types.
+This has the advantages of adding additional
+type-safety to our programs and eliminating the
+need for type assertions when accessing the decoded
+data.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">str</span> <span class="o">:=</span> <span class="s">`{&quot;page&quot;: 1, &quot;fruits&quot;: [&quot;apple&quot;, &quot;peach&quot;]}`</span>
+ <span class="nx">res</span> <span class="o">:=</span> <span class="o">&amp;</span><span class="nx">Response2</span><span class="p">{}</span>
+ <span class="nx">json</span><span class="p">.</span><span class="nx">Unmarshal</span><span class="p">([]</span><span class="nb">byte</span><span class="p">(</span><span class="nx">str</span><span class="p">),</span> <span class="o">&amp;</span><span class="nx">res</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">res</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">res</span><span class="p">.</span><span class="nx">Fruits</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In the examples above we always used bytes and
+strings as intermediates between the data and
+JSON representation on standard out. We can also
+stream JSON encodings directly to <code>os.Writer</code>s like
+<code>os.Stdout</code> or even HTTP response bodies.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">enc</span> <span class="o">:=</span> <span class="nx">json</span><span class="p">.</span><span class="nx">NewEncoder</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span><span class="p">)</span>
+ <span class="nx">d</span> <span class="o">:=</span> <span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">int</span><span class="p">{</span><span class="s">&quot;apple&quot;</span><span class="p">:</span> <span class="mi">5</span><span class="p">,</span> <span class="s">&quot;lettuce&quot;</span><span class="p">:</span> <span class="mi">7</span><span class="p">}</span>
+ <span class="nx">enc</span><span class="p">.</span><span class="nx">Encode</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run json.go
+<span class="go">true</span>
+<span class="go">1</span>
+<span class="go">2.34</span>
+<span class="go">&quot;gopher&quot;</span>
+<span class="go">[&quot;apple&quot;,&quot;peach&quot;,&quot;pear&quot;]</span>
+<span class="go">{&quot;apple&quot;:5,&quot;lettuce&quot;:7}</span>
+<span class="go">{&quot;Page&quot;:1,&quot;Fruits&quot;:[&quot;apple&quot;,&quot;peach&quot;,&quot;pear&quot;]}</span>
+<span class="go">{&quot;page&quot;:1,&quot;fruits&quot;:[&quot;apple&quot;,&quot;peach&quot;,&quot;pear&quot;]}</span>
+<span class="go">map[num:6 strs:[a b]]</span>
+<span class="go">6</span>
+<span class="go">a</span>
+<span class="go">&amp;{1 [apple peach]}</span>
+<span class="go">apple</span>
+<span class="go">{&quot;apple&quot;:5,&quot;lettuce&quot;:7}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ve covered the basic of JSON in Go here, but check
+out the <a href="http://blog.golang.org/2011/01/json-and-go.html">JSON and Go</a>
+blog post and <a href="http://golang.org/pkg/encoding/json/">JSON package docs</a>
+for more.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="time">Time</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/json">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
207 public/line-filters
@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Line Filters</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="line-filters">
+ <h2><a href="./">Go by Example</a>: Line Filters</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>A <em>line filter</em> is a common type of program that reads
+input on stdin, processes it, and then prints some
+derived result to stdout. <code>grep</code> and <code>sed</code> are common
+line filters.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s an example line filter in Go that writes a
+capitalized version of all input text. You can use this
+pattern to write your own Go line filters.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
+ <span class="s">&quot;bufio&quot;</span>
+ <span class="s">&quot;fmt&quot;</span>
+ <span class="s">&quot;io&quot;</span>
+ <span class="s">&quot;os&quot;</span>
+ <span class="s">&quot;strings&quot;</span>
+<span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Wrapping the unbuffered <code>os.Stdin</code> with a buffered
+reader gives us a convenient <code>ReadString</code> method
+that we&rsquo;ll use to read input line-by-line.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">rdr</span> <span class="o">:=</span> <span class="nx">bufio</span><span class="p">.</span><span class="nx">NewReader</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stdin</span><span class="p">)</span>
+ <span class="nx">out</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Stdout</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>ReadString</code> returns the next string from the
+input up to the given separator byte. We give the
+newline byte <code>'\n'</code> as our separator so we&rsquo;ll get
+successive input lines.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="p">{</span>
+ <span class="k">switch</span> <span class="nx">line</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">rdr</span><span class="p">.</span><span class="nx">ReadString</span><span class="p">(</span><span class="sc">&#39;\n&#39;</span><span class="p">);</span> <span class="nx">err</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If the read succeeded (the read <code>err</code> is nil),
+write out out the uppercased line. Check for an
+error on this write as we do on the read.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">case</span> <span class="kc">nil</span><span class="p">:</span>
+ <span class="nx">ucl</span> <span class="o">:=</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">ToUpper</span><span class="p">(</span><span class="nx">line</span><span class="p">)</span>
+ <span class="k">if</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">out</span><span class="p">.</span><span class="nx">WriteString</span><span class="p">(</span><span class="nx">ucl</span><span class="p">);</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Fprintln</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stderr</span><span class="p">,</span> <span class="s">&quot;error:&quot;</span><span class="p">,</span> <span class="nx">err</span><span class="p">)</span>
+ <span class="nx">os</span><span class="p">.</span><span class="nx">Exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>EOF</code> error is expected when we reach the
+end of input, so exit gracefully in that case.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">case</span> <span class="nx">io</span><span class="p">.</span><span class="nx">EOF</span><span class="p">:</span>
+ <span class="nx">os</span><span class="p">.</span><span class="nx">Exit</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Otherwise there&rsquo;s a problem; print the
+error and exit with non-zero status.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="k">default</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Fprintln</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stderr</span><span class="p">,</span> <span class="s">&quot;error:&quot;</span><span class="p">,</span> <span class="nx">err</span><span class="p">)</span>
+ <span class="nx">os</span><span class="p">.</span><span class="nx">Exit</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>To try out our line filter, first make a file with a few
+lowercase lines.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> <span class="nb">echo</span> <span class="s1">&#39;hello&#39;</span> &gt; /tmp/lines
+<span class="gp">$</span> <span class="nb">echo</span> <span class="s1">&#39;filter&#39;</span> &gt;&gt; /tmp/lines
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Then use the line filter to get uppercase lines.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> cat /tmp/lines | go run line-filters.go
+<span class="go">HELLO</span>
+<span class="go">FILTER</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="command-line-arguments">Command-Line Arguments</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/line-filters">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
217 public/maps
@@ -0,0 +1,217 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Maps</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="maps">
+ <h2><a href="./">Go by Example</a>: Maps</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>Maps</em> are Go&rsquo;s built-in <a href="http://en.wikipedia.org/wiki/Associative_array">associative data type</a>
+(sometimes called <em>hashes</em> or <em>dicts</em> in other languages).</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To create an empty map, use the builtin <code>make</code>:
+<code>make(map[key-type]val-type)</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">m</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">int</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Set key/value pairs using typical <code>name[key] = val</code>
+syntax.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">m</span><span class="p">[</span><span class="s">&quot;k1&quot;</span><span class="p">]</span> <span class="p">=</span> <span class="mi">7</span>
+ <span class="nx">m</span><span class="p">[</span><span class="s">&quot;k2&quot;</span><span class="p">]</span> <span class="p">=</span> <span class="mi">13</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Printing a map with e.g. <code>Println</code> will show all of
+its key/value pairs.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;map:&quot;</span><span class="p">,</span> <span class="nx">m</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Get a value for a key with <code>name[key]</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">v1</span> <span class="o">:=</span> <span class="nx">m</span><span class="p">[</span><span class="s">&quot;k1&quot;</span><span class="p">]</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;v1: &quot;</span><span class="p">,</span> <span class="nx">v1</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The builtin <code>len</code> returns the number of key/value
+pairs when called on a map.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;len:&quot;</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="nx">m</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The builtin <code>delete</code> removes key/value pairs from
+a map.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nb">delete</span><span class="p">(</span><span class="nx">m</span><span class="p">,</span> <span class="s">&quot;k2&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;map:&quot;</span><span class="p">,</span> <span class="nx">m</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The optional second return value when getting a
+value from a map indiciates if the key was present
+in the map. This can be used to disambiguate
+between missing keys and keys with zero values
+like <code>0</code> or <code>&quot;&quot;</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">_</span><span class="p">,</span> <span class="nx">prs</span> <span class="o">:=</span> <span class="nx">m</span><span class="p">[</span><span class="s">&quot;k2&quot;</span><span class="p">]</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;prs:&quot;</span><span class="p">,</span> <span class="nx">prs</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can also declare and initialize a new map in
+the same line with this syntax.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">n</span> <span class="o">:=</span> <span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">int</span><span class="p">{</span><span class="s">&quot;foo&quot;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s">&quot;bar&quot;</span><span class="p">:</span> <span class="mi">2</span><span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;map:&quot;</span><span class="p">,</span> <span class="nx">n</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Note that maps appear in the form <code>map[k:v k:v]</code> when
+printed with <code>fmt.Println</code>.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run maps.go
+<span class="go">map: map[k1:7 k2:13]</span>
+<span class="go">v1: 7</span>
+<span class="go">len: 2</span>
+<span class="go">map: map[k1:7]</span>
+<span class="go">prs: false</span>
+<span class="go">map: map[foo:1 bar:2]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="range">Range</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/maps">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
186 public/methods
@@ -0,0 +1,186 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Methods</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="methods">
+ <h2><a href="./">Go by Example</a>: Methods</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go supports <em>methods</em> defined on struct types.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">type</span> <span class="nx">rect</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">width</span><span class="p">,</span> <span class="nx">height</span> <span class="kt">int</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This <code>area</code> method has a <em>receiver type</em> of <code>*rect</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">r</span> <span class="o">*</span><span class="nx">rect</span><span class="p">)</span> <span class="nx">area</span><span class="p">()</span> <span class="kt">int</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nx">r</span><span class="p">.</span><span class="nx">width</span> <span class="o">*</span> <span class="nx">r</span><span class="p">.</span><span class="nx">height</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Methods can be defined for either pointer or value
+receiver types. Here&rsquo;s an example of a value receiver.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">r</span> <span class="nx">rect</span><span class="p">)</span> <span class="nx">perim</span><span class="p">()</span> <span class="kt">int</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">2</span><span class="o">*</span><span class="nx">r</span><span class="p">.</span><span class="nx">width</span> <span class="o">+</span> <span class="mi">2</span><span class="o">*</span><span class="nx">r</span><span class="p">.</span><span class="nx">height</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">r</span> <span class="o">:=</span> <span class="nx">rect</span><span class="p">{</span><span class="nx">width</span><span class="p">:</span> <span class="mi">10</span><span class="p">,</span> <span class="nx">height</span><span class="p">:</span> <span class="mi">5</span><span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we call the 2 methods defined for our struct.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;area: &quot;</span><span class="p">,</span> <span class="nx">r</span><span class="p">.</span><span class="nx">area</span><span class="p">())</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;perim:&quot;</span><span class="p">,</span> <span class="nx">r</span><span class="p">.</span><span class="nx">perim</span><span class="p">())</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Go automatically handles conversion between values
+and pointers for method calls. You may want to use
+a pointer receiver type to avoid copying on method
+calls or to allow the method to mutate the
+receiving struct.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">rp</span> <span class="o">:=</span> <span class="o">&amp;</span><span class="nx">r</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;area: &quot;</span><span class="p">,</span> <span class="nx">rp</span><span class="p">.</span><span class="nx">area</span><span class="p">())</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;perim:&quot;</span><span class="p">,</span> <span class="nx">rp</span><span class="p">.</span><span class="nx">perim</span><span class="p">())</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run methods.go
+<span class="go">area: 50</span>
+<span class="go">perim: 30</span>
+<span class="go">area: 50</span>
+<span class="go">perim: 30</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at Go&rsquo;s mechanism for grouping and
+naming related sets of methods: interfaces.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="interfaces">Interfaces</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/methods">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
157 public/multiple-return-values
@@ -0,0 +1,157 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Multiple Return Values</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="multiple-return-values">
+ <h2><a href="./">Go by Example</a>: Multiple Return Values</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go has built-in support for <em>multiple return values</em>.
+This feature is used often in idiomatic Go, for example
+to return both result and error values from a function.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>(int, int)</code> in this function signature shows that
+the function returns 2 <code>int</code>s.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">vals</span><span class="p">()</span> <span class="p">(</span><span class="kt">int</span><span class="p">,</span> <span class="kt">int</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">7</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we use the 2 different return values from the
+call with <em>multiple assignment</em>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">a</span><span class="p">,</span> <span class="nx">b</span> <span class="o">:=</span> <span class="nx">vals</span><span class="p">()</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">a</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">b</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If you only want a subset of the returned values,
+use the blank identifier <code>_</code>.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">_</span><span class="p">,</span> <span class="nx">c</span> <span class="o">:=</span> <span class="nx">vals</span><span class="p">()</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">c</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run multiple-return-values.go
+<span class="go">3</span>
+<span class="go">7</span>
+<span class="go">7</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Accepting a variable number of arguments is another nice
+feature of Go functions; we&rsquo;ll look at this next.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="variadic-functions">Variadic Functions</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/multiple-return-values">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
285 public/mutexes
@@ -0,0 +1,285 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Mutexes</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="mutexes">
+ <h2><a href="./">Go by Example</a>: Mutexes</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>In the previous example we saw how to manage simple
+counter state using atomic operations. For more complex
+state we can use a <em><a href="http://en.wikipedia.org/wiki/Mutual_exclusion">mutex</a></em>
+to safely access data across multiple goroutines.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
+ <span class="s">&quot;fmt&quot;</span>
+ <span class="s">&quot;math/rand&quot;</span>
+ <span class="s">&quot;runtime&quot;</span>
+ <span class="s">&quot;sync&quot;</span>
+ <span class="s">&quot;sync/atomic&quot;</span>
+ <span class="s">&quot;time&quot;</span>
+<span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For our example the <code>state</code> will be a map.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">state</span> <span class="p">=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">map</span><span class="p">[</span><span class="kt">int</span><span class="p">]</span><span class="kt">int</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This <code>mutex</code> will synchronize access to <code>state</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">mutex</span> <span class="p">=</span> <span class="o">&amp;</span><span class="nx">sync</span><span class="p">.</span><span class="nx">Mutex</span><span class="p">{}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To compare the mutex-based approach with another
+we&rsquo;ll see later, <code>ops</code> will count how many
+operations we perform against the state.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">ops</span> <span class="kt">int64</span> <span class="p">=</span> <span class="mi">0</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we start 100 goroutines to execute repeated
+reads against the state.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">r</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">r</span> <span class="p">&lt;</span> <span class="mi">100</span><span class="p">;</span> <span class="nx">r</span><span class="o">++</span> <span class="p">{</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">total</span> <span class="o">:=</span> <span class="mi">0</span>
+ <span class="k">for</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For each read we pick a key to access,
+<code>Lock()</code> the <code>mutex</code> to ensure
+exclusive access to the <code>state</code>, read
+the value at the chosen key,
+<code>Unlock()</code> the mutex, and increment
+the <code>ops</code> count.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">key</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
+ <span class="nx">mutex</span><span class="p">.</span><span class="nx">Lock</span><span class="p">()</span>
+ <span class="nx">total</span> <span class="o">+=</span> <span class="nx">state</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span>
+ <span class="nx">mutex</span><span class="p">.</span><span class="nx">Unlock</span><span class="p">()</span>
+ <span class="nx">atomic</span><span class="p">.</span><span class="nx">AddInt64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">ops</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In order to ensure that this goroutine
+doesn&rsquo;t starve the scheduler, we explicitly
+yield after each operation with
+<code>runtime.Gosched()</code>. This yielding is
+handled automatically with e.g. every
+channel operation and for blocking
+calls like <code>time.Sleep</code>, but in this
+case we need to do it manually.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">runtime</span><span class="p">.</span><span class="nx">Gosched</span><span class="p">()</span>
+ <span class="p">}</span>
+ <span class="p">}()</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll also start 10 goroutines to simulate writes,
+using the same pattern we did for reads.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">w</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">w</span> <span class="p">&lt;</span> <span class="mi">10</span><span class="p">;</span> <span class="nx">w</span><span class="o">++</span> <span class="p">{</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="p">{</span>
+ <span class="nx">key</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
+ <span class="nx">val</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
+ <span class="nx">mutex</span><span class="p">.</span><span class="nx">Lock</span><span class="p">()</span>
+ <span class="nx">state</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span> <span class="p">=</span> <span class="nx">val</span>
+ <span class="nx">mutex</span><span class="p">.</span><span class="nx">Unlock</span><span class="p">()</span>
+ <span class="nx">atomic</span><span class="p">.</span><span class="nx">AddInt64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">ops</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+ <span class="nx">runtime</span><span class="p">.</span><span class="nx">Gosched</span><span class="p">()</span>
+ <span class="p">}</span>
+ <span class="p">}()</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Let the 110 goroutines work on the <code>state</code> and
+<code>mutex</code> for a second.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Take and report a final operations count.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">opsFinal</span> <span class="o">:=</span> <span class="nx">atomic</span><span class="p">.</span><span class="nx">LoadInt64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">ops</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;ops:&quot;</span><span class="p">,</span> <span class="nx">opsFinal</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>With a final lock of <code>state</code>, show how it ended up.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">mutex</span><span class="p">.</span><span class="nx">Lock</span><span class="p">()</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;state:&quot;</span><span class="p">,</span> <span class="nx">state</span><span class="p">)</span>
+ <span class="nx">mutex</span><span class="p">.</span><span class="nx">Unlock</span><span class="p">()</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running the program shows that we executed about
+3,500,000 operations against our <code>mutex</code>-synchronized
+<code>state</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run mutexes.go
+<span class="go">ops: 3598302</span>
+<span class="go">state: map[1:38 4:98 2:23 3:85 0:44]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at implementing this same state
+management task using only goroutines and channels.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="stateful-goroutines">Stateful Goroutines</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/mutexes">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
165 public/non-blocking-channel-operations
@@ -0,0 +1,165 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Non-Blocking Channel Operations</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="non-blocking-channel-operations">
+ <h2><a href="./">Go by Example</a>: Non-Blocking Channel Operations</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Basic sends and receives on channels are blocking.
+However, we can use <code>select</code> with a <code>default</code> clause to
+implement <em>non-blocking</em> sends, receives, and even
+non-blocking multi-way <code>select</code>s.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">messages</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">)</span>
+ <span class="nx">signals</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">bool</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s a non-blocking receive. If a value is
+available on <code>messages</code> then <code>select</code> will take
+the <code>&lt;-messages</code> <code>case</code> with that value. If not
+it will immediately take the <code>default</code> case.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">select</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="nx">msg</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">messages</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;received message&quot;</span><span class="p">,</span> <span class="nx">msg</span><span class="p">)</span>
+ <span class="k">default</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;no message received&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A non-blocking send works similarly.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">msg</span> <span class="o">:=</span> <span class="s">&quot;hi&quot;</span>
+ <span class="k">select</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="nx">messages</span> <span class="o">&lt;-</span> <span class="nx">msg</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;sent message&quot;</span><span class="p">,</span> <span class="nx">msg</span><span class="p">)</span>
+ <span class="k">default</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;no message sent&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We can use multiple <code>case</code>s above the <code>default</code>
+clause to implement a multi-way non-blocking
+select. Here we attempt non-blocking receives
+on both <code>messages</code> and <code>signals</code>.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="k">select</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="nx">msg</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">messages</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;received message&quot;</span><span class="p">,</span> <span class="nx">msg</span><span class="p">)</span>
+ <span class="k">case</span> <span class="nx">sig</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">signals</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;received signal&quot;</span><span class="p">,</span> <span class="nx">sig</span><span class="p">)</span>
+ <span class="k">default</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;no activity&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run non-blocking-channel-operations.go
+<span class="go">no message received</span>
+<span class="go">no message sent</span>
+<span class="go">no activity</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="closing-channels">Closing Channels</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/non-blocking-channel-operations">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
199 public/number-parsing
@@ -0,0 +1,199 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Number Parsing</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="number-parsing">
+ <h2><a href="./">Go by Example</a>: Number Parsing</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Parsing numbers from strings is a basic but common task
+in many programs; here&rsquo;s how to do it in Go.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The built-in package <code>strconv</code> provides the number
+parsing.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;strconv&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>With <code>ParseFloat</code>, this <code>64</code> tells how many bits of
+precision to parse.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">f</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">strconv</span><span class="p">.</span><span class="nx">ParseFloat</span><span class="p">(</span><span class="s">&quot;1.234&quot;</span><span class="p">,</span> <span class="mi">64</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">f</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For <code>ParseInt</code>, the <code>0</code> means infer the base from
+the string. <code>64</code> requires that the result fit in 64
+bits.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">i</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">strconv</span><span class="p">.</span><span class="nx">ParseInt</span><span class="p">(</span><span class="s">&quot;123&quot;</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">64</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>ParseInt</code> will recognize hex-formatted numbers.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">d</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">strconv</span><span class="p">.</span><span class="nx">ParseInt</span><span class="p">(</span><span class="s">&quot;0x1c8&quot;</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">64</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A <code>ParseUint</code> is also available.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">u</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">strconv</span><span class="p">.</span><span class="nx">ParseUint</span><span class="p">(</span><span class="s">&quot;789&quot;</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">64</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">u</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>Atoi</code> is a convenience function for basic base-10
+<code>int</code> parsing.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">k</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">strconv</span><span class="p">.</span><span class="nx">Atoi</span><span class="p">(</span><span class="s">&quot;135&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">k</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Parse functions return an error on bad input.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">_</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">strconv</span><span class="p">.</span><span class="nx">Atoi</span><span class="p">(</span><span class="s">&quot;wat&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">e</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run number-parsing.go
+<span class="go">1.234</span>
+<span class="go">123</span>
+<span class="go">456</span>
+<span class="go">789</span>
+<span class="go">135</span>
+<span class="go">strconv.ParseInt: parsing &quot;wat&quot;: invalid syntax</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at another common parsing task: URLs.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="url-parsing">URL Parsing</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/number-parsing">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
163 public/panic
@@ -0,0 +1,163 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Panic</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="panic">
+ <h2><a href="./">Go by Example</a>: Panic</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>A <code>panic</code> typically means something went unexpectedly
+wrong. Mostly we use it to fail fast on errors that
+shouldn&rsquo;t occur during normal operation, or that we
+aren&rsquo;t prepared to handle gracefully.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;os&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll use panic throughout this site to check for
+unexpected errors. This is the only program on the
+site designed to panic.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nb">panic</span><span class="p">(</span><span class="s">&quot;a problem&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A common use of panic is to abort if a function
+returns an error value that we don&rsquo;t know how to
+(or want to) handle. Here&rsquo;s an example of
+<code>panic</code>king if we get an unexpected error when creating a new file.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">_</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Create</span><span class="p">(</span><span class="s">&quot;/tmp/file&quot;</span><span class="p">)</span>
+ <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running this program will cause it to panic, print
+an error message and goroutine traces, and exit with
+a non-zero status.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run panic.go
+<span class="go">panic: a problem</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="go">goroutine 1 [running]:</span>
+<span class="go">main.main()</span>
+<span class="go"> /.../panic.go:12 +0x47</span>
+<span class="go">...</span>
+<span class="go">exit status 2</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that unlike some languages which use exceptions
+for handling of many errors, in Go it is idiomatic
+to use error-indicating return values wherever possible.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="defer">Defer</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/panic">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
183 public/pointers
@@ -0,0 +1,183 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Pointers</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="pointers">
+ <h2><a href="./">Go by Example</a>: Pointers</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go supports <em><a href="http://en.wikipedia.org/wiki/Pointer_(computer_programming)">pointers</a></em>,
+allowing you to pass references to values and records
+within your program.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll show how pointers work in contrast to values with
+2 functions: <code>zeroval</code> and <code>zeroptr</code>. <code>zeroval</code> has an
+<code>int</code> parameter, so arguments will be passed to it by
+value. <code>zeroval</code> will get a copy of <code>ival</code> distinct
+from the one in the calling function.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">zeroval</span><span class="p">(</span><span class="nx">ival</span> <span class="kt">int</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">ival</span> <span class="p">=</span> <span class="mi">0</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>zeroptr</code> in contrast has an <code>*int</code> parameter, meaning
+that it takes an <code>int</code> pointer. The <code>*iptr</code> code in the
+function body then <em>dereferences</em> the pointer from its
+memory address to the current value at that address.
+Assigning a value to a dereferenced pointer changes the
+value at the referenced address.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">zeroptr</span><span class="p">(</span><span class="nx">iptr</span> <span class="o">*</span><span class="kt">int</span><span class="p">)</span> <span class="p">{</span>
+ <span class="o">*</span><span class="nx">iptr</span> <span class="p">=</span> <span class="mi">0</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">i</span> <span class="o">:=</span> <span class="mi">1</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;initial:&quot;</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">zeroval</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;zeroval:&quot;</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>&amp;i</code> syntax gives the memory address of <code>i</code>,
+i.e. a pointer to <code>i</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">zeroptr</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">i</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;zeroptr:&quot;</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Pointers can be printed too.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;pointer:&quot;</span><span class="p">,</span> <span class="o">&amp;</span><span class="nx">i</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><code>zeroval</code> doesn&rsquo;t change the <code>i</code> in <code>main</code>, but
+<code>zeroptr</code> does because it has a reference to
+the memory address for that variable.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run pointers.go
+<span class="go">initial: 1</span>
+<span class="go">zeroval: 1</span>
+<span class="go">zeroptr: 0</span>
+<span class="go">pointer: 0x42131100</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="structs">Structs</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/pointers">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
206 public/random-numbers
@@ -0,0 +1,206 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Random Numbers</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="random-numbers">
+ <h2><a href="./">Go by Example</a>: Random Numbers</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go&rsquo;s <code>math/rand</code> package provides
+<a href="http://en.wikipedia.org/wiki/Pseudorandom_number_generator">pseudorandom number</a>
+generation.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;math/rand&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For example, <code>rand.Intn</code> returns a random <code>int</code> n,
+<code>0 &lt;= n &lt; 100</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">100</span><span class="p">),</span> <span class="s">&quot;,&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">100</span><span class="p">))</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>rand.Float64</code> returns a <code>float64</code> <code>f</code>,
+<code>0.0 &lt;= f &lt; 1.0</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">rand</span><span class="p">.</span><span class="nx">Float64</span><span class="p">())</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This can be used to generate random floats in
+other ranges, for example <code>5.0 &lt;= f' &lt; 10.0</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">((</span><span class="nx">rand</span><span class="p">.</span><span class="nx">Float64</span><span class="p">()</span><span class="o">*</span><span class="mi">5</span><span class="p">)</span><span class="o">+</span><span class="mi">5</span><span class="p">,</span> <span class="s">&quot;,&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">((</span><span class="nx">rand</span><span class="p">.</span><span class="nx">Float64</span><span class="p">()</span> <span class="o">*</span> <span class="mi">5</span><span class="p">)</span> <span class="o">+</span> <span class="mi">5</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To make the pseudorandom generator deterministic,
+give it a well-known seed.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">s1</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">NewSource</span><span class="p">(</span><span class="mi">42</span><span class="p">)</span>
+ <span class="nx">r1</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">New</span><span class="p">(</span><span class="nx">s1</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Call the resulting <code>rand.Source</code> just like the
+functions on the <code>rand</code> package.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="nx">r1</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">100</span><span class="p">),</span> <span class="s">&quot;,&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="nx">r1</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">100</span><span class="p">))</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If you seed a source with the same number, it
+produces the same sequence of random numbers.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">s2</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">NewSource</span><span class="p">(</span><span class="mi">42</span><span class="p">)</span>
+ <span class="nx">r2</span> <span class="o">:=</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">New</span><span class="p">(</span><span class="nx">s2</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="nx">r2</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">100</span><span class="p">),</span> <span class="s">&quot;,&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="nx">r2</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">100</span><span class="p">))</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">()</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run random-numbers.go
+<span class="go">81,87</span>
+<span class="go">0.6645600532184904</span>
+<span class="go">7.123187485356329,8.434115364335547</span>
+<span class="go">5,87</span>
+<span class="go">5,87</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>See the <a href="http://golang.org/pkg/math/rand/"><code>math/rand</code></a>
+package docs for references on other random quantities
+that Go can provide.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="number-parsing">Number Parsing</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/random-numbers">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
174 public/range
@@ -0,0 +1,174 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Range</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="range">
+ <h2><a href="./">Go by Example</a>: Range</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>range</em> iterates over of elements in a variety of
+data structures. Let&rsquo;s see how to use <code>range</code> with some
+of the data structures we&rsquo;ve already learned.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we use <code>range</code> to sum the numbers in a slice.
+Arrays work like this too.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">nums</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">int</span><span class="p">{</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">}</span>
+ <span class="nx">sum</span> <span class="o">:=</span> <span class="mi">0</span>
+ <span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">num</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">nums</span> <span class="p">{</span>
+ <span class="nx">sum</span> <span class="o">+=</span> <span class="nx">num</span>
+ <span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;sum:&quot;</span><span class="p">,</span> <span class="nx">sum</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>range</code> on arrays and slices provides both the
+index and value for each entry. Above we didn&rsquo;t
+need the index, so we ignored it with the
+<em>blank identifier</em> <code>_</code>. Sometimes we actually want
+the indexes though.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">num</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">nums</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">num</span> <span class="o">==</span> <span class="mi">3</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;index:&quot;</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>range</code> on map iterates over key/value pairs.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">kvs</span> <span class="o">:=</span> <span class="kd">map</span><span class="p">[</span><span class="kt">string</span><span class="p">]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;a&quot;</span><span class="p">:</span> <span class="s">&quot;apple&quot;</span><span class="p">,</span> <span class="s">&quot;b&quot;</span><span class="p">:</span> <span class="s">&quot;bannana&quot;</span><span class="p">}</span>
+ <span class="k">for</span> <span class="nx">k</span><span class="p">,</span> <span class="nx">v</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">kvs</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%s -&gt; %s\n&quot;</span><span class="p">,</span> <span class="nx">k</span><span class="p">,</span> <span class="nx">v</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>range</code> on strings iterates over Unicode code
+points. The first value is the starting byte index
+of the <code>rune</code> and the second the <code>rune</code> itself.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">c</span> <span class="o">:=</span> <span class="k">range</span> <span class="s">&quot;go&quot;</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">c</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run range.go
+<span class="go">sum: 9</span>
+<span class="go">index: 1</span>
+<span class="go">a -&gt; apple</span>
+<span class="go">b -&gt; bannana</span>
+<span class="go">0 103</span>
+<span class="go">1 111</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="functions">Functions</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/range">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
147 public/range-over-channels
@@ -0,0 +1,147 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Range over Channels</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="range-over-channels">
+ <h2><a href="./">Go by Example</a>: Range over Channels</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>In a <a href="range">previous</a> example we saw how <code>for</code> and
+<code>range</code> provide iteration over basic data structures.
+We can also use this syntax to iterate over
+values received from a channel.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll iterate over 2 values in the <code>queue</code> channel.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">queue</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
+ <span class="nx">queue</span> <span class="o">&lt;-</span> <span class="s">&quot;one&quot;</span>
+ <span class="nx">queue</span> <span class="o">&lt;-</span> <span class="s">&quot;two&quot;</span>
+ <span class="nb">close</span><span class="p">(</span><span class="nx">queue</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This <code>range</code> iterates over each element as it&rsquo;s
+received from <code>queue</code>. Because we <code>close</code>d the
+channel above, the iteration terminates after
+receiving the 2 elements. If we didn&rsquo;t <code>close</code> it
+we&rsquo;d block on a 3rd receive in the loop.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">elem</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">queue</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">elem</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run range-over-channels.go
+<span class="go">one</span>
+<span class="go">two</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This example also showed that it&rsquo;s possible to close
+a non-empty channel but still have the remaining
+values be received.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="timers">Timers</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/range-over-channels">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
246 public/rate-limiting
@@ -0,0 +1,246 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Rate Limiting</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="rate-limiting">
+ <h2><a href="./">Go by Example</a>: Rate Limiting</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em><a href="http://en.wikipedia.org/wiki/Rate_limiting">Rate limiting</a></em>
+is an important mechanism for controlling resource
+utilization and maintaining quality of service. Go
+elegantly supports rate limiting with goroutines,
+channels, and <a href="tickers">tickers</a>.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>First we&rsquo;ll look at basic rate limiting. Suppose
+we want to limit our handling of incoming requests.
+We&rsquo;ll serve these requests off a channel of the
+same name.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">requests</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">int</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
+ <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;=</span> <span class="mi">5</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">requests</span> <span class="o">&lt;-</span> <span class="nx">i</span>
+ <span class="p">}</span>
+ <span class="nb">close</span><span class="p">(</span><span class="nx">requests</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This <code>limiter</code> channel will receive a value
+every 200 milliseconds. This is the regulator in
+our rate limiting scheme.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">limiter</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Tick</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Millisecond</span> <span class="o">*</span> <span class="mi">200</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>By blocking on a receive from the <code>limiter</code> channel
+before serving each request, we limit ourselves to
+1 request every 200 milliseconds.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">req</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">requests</span> <span class="p">{</span>
+ <span class="o">&lt;-</span><span class="nx">limiter</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;request&quot;</span><span class="p">,</span> <span class="nx">req</span><span class="p">,</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Now</span><span class="p">())</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We may want to allow short bursts of requests in
+our rate limiting scheme while preserving the
+overall rate limit. We can accomplish this by
+buffering our limiter channel. This <code>burstyLimiter</code>
+channel will allow bursts of up to 3 events.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">burstyLimiter</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Time</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Fill up the channel to represent allowed bursting.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">burstyLimiter</span> <span class="o">&lt;-</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Now</span><span class="p">()</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Every 200 milliseconds we&rsquo;ll try to add a new
+value to <code>burstyLimiter</code>, up to its limit of 3.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="nx">t</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Tick</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Millisecond</span> <span class="o">*</span> <span class="mi">200</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">burstyLimiter</span> <span class="o">&lt;-</span> <span class="nx">t</span>
+ <span class="p">}</span>
+ <span class="p">}()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Now simulate 5 more incoming requests. The first
+3 of these will benefit from the burst capability
+of <code>burstyLimiter</code>.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">burstyRequests</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">int</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
+ <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;=</span> <span class="mi">5</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">burstyRequests</span> <span class="o">&lt;-</span> <span class="nx">i</span>
+ <span class="p">}</span>
+ <span class="nb">close</span><span class="p">(</span><span class="nx">burstyRequests</span><span class="p">)</span>
+ <span class="k">for</span> <span class="nx">req</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">burstyRequests</span> <span class="p">{</span>
+ <span class="o">&lt;-</span><span class="nx">burstyLimiter</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;request&quot;</span><span class="p">,</span> <span class="nx">req</span><span class="p">,</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Now</span><span class="p">())</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running our program we see the first batch of requests
+handled once every ~200 milliseconds as desired.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run rate-limiting.go
+<span class="go">request 1 2012-10-19 00:38:18.687438 +0000 UTC</span>
+<span class="go">request 2 2012-10-19 00:38:18.887471 +0000 UTC</span>
+<span class="go">request 3 2012-10-19 00:38:19.087238 +0000 UTC</span>
+<span class="go">request 4 2012-10-19 00:38:19.287338 +0000 UTC</span>
+<span class="go">request 5 2012-10-19 00:38:19.487331 +0000 UTC</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For the second batch of requests we serve the first
+3 immediately because of the burstable rate limiting,
+then serve the remaining 2 with ~200ms delays each.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="go">request 1 2012-10-19 00:38:20.487578 +0000 UTC</span>
+<span class="go">request 2 2012-10-19 00:38:20.487645 +0000 UTC</span>
+<span class="go">request 3 2012-10-19 00:38:20.487676 +0000 UTC</span>
+<span class="go">request 4 2012-10-19 00:38:20.687483 +0000 UTC</span>
+<span class="go">request 5 2012-10-19 00:38:20.887542 +0000 UTC</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="atomic-counters">Atomic Counters</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/rate-limiting">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
280 public/reading-files
@@ -0,0 +1,280 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Reading Files</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="reading-files">
+ <h2><a href="./">Go by Example</a>: Reading Files</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Reading and writing files are basic tasks needed for
+many Go programs. First we&rsquo;ll look at some examples of
+reading files.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
+ <span class="s">&quot;bufio&quot;</span>
+ <span class="s">&quot;fmt&quot;</span>
+ <span class="s">&quot;io&quot;</span>
+ <span class="s">&quot;io/ioutil&quot;</span>
+ <span class="s">&quot;os&quot;</span>
+<span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Reading files requires checking most calls for errors.
+This helper will streamline our error checks below.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">check</span><span class="p">(</span><span class="nx">e</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">e</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">e</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Perhaps the most basic file reading task is
+slurping a file&rsquo;s entire contents into memory.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">dat</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">ioutil</span><span class="p">.</span><span class="nx">ReadFile</span><span class="p">(</span><span class="s">&quot;/tmp/dat&quot;</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">dat</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You&rsquo;ll often want more control over how and what
+parts of a file are read. For these tasks, start
+by <code>Open</code>ing a file to obtain an <code>os.File</code> value.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">f</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Open</span><span class="p">(</span><span class="s">&quot;/tmp/dat&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Read some bytes from the beginning of the file.
+Allow up to 5 to be read but also not how many
+actually were read.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">b1</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">byte</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
+ <span class="nx">n1</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">f</span><span class="p">.</span><span class="nx">Read</span><span class="p">(</span><span class="nx">b1</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%d bytes: %s\n&quot;</span><span class="p">,</span> <span class="nx">n1</span><span class="p">,</span> <span class="nb">string</span><span class="p">(</span><span class="nx">b1</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can also <code>Seek</code> to a known location in the file
+and <code>Read</code> from there.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">o2</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">f</span><span class="p">.</span><span class="nx">Seek</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="nx">b2</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">byte</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
+ <span class="nx">n2</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">f</span><span class="p">.</span><span class="nx">Read</span><span class="p">(</span><span class="nx">b2</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%d bytes @ %d: %s\n&quot;</span><span class="p">,</span> <span class="nx">n2</span><span class="p">,</span> <span class="nx">o2</span><span class="p">,</span> <span class="nb">string</span><span class="p">(</span><span class="nx">b2</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>io</code> package provides some functions that may
+be helpful for file reading. For example, reads
+like the ones above can be more robustly
+implemented with <code>ReadAtLeast</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">o3</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">f</span><span class="p">.</span><span class="nx">Seek</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="nx">b3</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">byte</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
+ <span class="nx">n3</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">io</span><span class="p">.</span><span class="nx">ReadAtLeast</span><span class="p">(</span><span class="nx">f</span><span class="p">,</span> <span class="nx">b3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%d bytes @ %d: %s\n&quot;</span><span class="p">,</span> <span class="nx">n3</span><span class="p">,</span> <span class="nx">o3</span><span class="p">,</span> <span class="nb">string</span><span class="p">(</span><span class="nx">b3</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>There is no built-in rewind, but <code>Seek(0, 0)</code>
+accomplishes this.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">_</span><span class="p">,</span> <span class="nx">err</span> <span class="p">=</span> <span class="nx">f</span><span class="p">.</span><span class="nx">Seek</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>bufio</code> package implements a buffered
+reader that may be useful both for it&rsquo;s efficiency
+with many small reads and because of the additional
+reading methods it provides.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">r4</span> <span class="o">:=</span> <span class="nx">bufio</span><span class="p">.</span><span class="nx">NewReader</span><span class="p">(</span><span class="nx">f</span><span class="p">)</span>
+ <span class="nx">b4</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">r4</span><span class="p">.</span><span class="nx">Peek</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;5 bytes: %s\n&quot;</span><span class="p">,</span> <span class="nb">string</span><span class="p">(</span><span class="nx">b4</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Close the file when you&rsquo;re done (usually this would
+be scheduled immediately after <code>Open</code>ing with
+<code>defer</code>).</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">f</span><span class="p">.</span><span class="nx">Close</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> <span class="nb">echo</span> <span class="s2">&quot;hello&quot;</span> &gt; /tmp/dat
+<span class="gp">$</span> <span class="nb">echo</span> <span class="s2">&quot;go&quot;</span> &gt;&gt; /tmp/dat
+<span class="gp">$</span> go run reading-files.go
+<span class="go">hello</span>
+<span class="go">go</span>
+<span class="go">5 bytes: hello</span>
+<span class="go">2 bytes @ 6: go</span>
+<span class="go">2 bytes @ 6: go</span>
+<span class="go">5 bytes: hello</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at writing files.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="writing-files">Writing Files</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/reading-files">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
119 public/recursion
@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Recursion</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="recursion">
+ <h2><a href="./">Go by Example</a>: Recursion</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go supports
+<a href="http://en.wikipedia.org/wiki/Recursion_(computer_science)"><em>recursive functions</em></a>.
+Here&rsquo;s a classic factorial example.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This <code>fact</code> function calls itself until it reaches the
+base case of <code>fact(0)</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">fact</span><span class="p">(</span><span class="nx">n</span> <span class="kt">int</span><span class="p">)</span> <span class="kt">int</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">n</span> <span class="o">==</span> <span class="mi">0</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="mi">1</span>
+ <span class="p">}</span>
+ <span class="k">return</span> <span class="nx">n</span> <span class="o">*</span> <span class="nx">fact</span><span class="p">(</span><span class="nx">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">fact</span><span class="p">(</span><span class="mi">7</span><span class="p">))</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run recursion.go
+<span class="go">5040</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="pointers">Pointers</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/recursion">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
320 public/regular-expressions
@@ -0,0 +1,320 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Regular Expressions</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="regular-expressions">
+ <h2><a href="./">Go by Example</a>: Regular Expressions</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go offers built-in support for <a href="http://en.wikipedia.org/wiki/Regular_expression">regular expressions</a>.
+Here are some examples of common regexp-related tasks
+in Go.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;bytes&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;regexp&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This tests whether a pattern matches a string.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">match</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">regexp</span><span class="p">.</span><span class="nx">MatchString</span><span class="p">(</span><span class="s">&quot;p([a-z]+)ch&quot;</span><span class="p">,</span> <span class="s">&quot;peach&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">match</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Above we used a string pattern directly, but for
+other regexp tasks you&rsquo;ll need to <code>Compile</code> an
+optimized <code>Regexp</code> struct.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">r</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">regexp</span><span class="p">.</span><span class="nx">Compile</span><span class="p">(</span><span class="s">&quot;p([a-z]+)ch&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Many methods are available on these structs. Here&rsquo;s
+a match test like we saw earlier.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">MatchString</span><span class="p">(</span><span class="s">&quot;peach&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This finds the match for the regexp.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">FindString</span><span class="p">(</span><span class="s">&quot;peach punch&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The also finds the first match but returns the
+start and end indexes for the match instead of the
+matching text.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">FindStringIndex</span><span class="p">(</span><span class="s">&quot;peach punch&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>Submatch</code> variants include information about
+both the whole-pattern matches and the submatches
+within those matches. For example this will return
+information for both <code>p([a-z]+)ch</code> and <code>([a-z]+)</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">FindStringSubmatch</span><span class="p">(</span><span class="s">&quot;peach punch&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Similarly this will return information about the
+indexes of matches and submatches.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">FindStringSubmatchIndex</span><span class="p">(</span><span class="s">&quot;peach punch&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>All</code> variants of these functions apply to all
+matches in the input, not just the first. For
+example to find all matches for a regexp.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">FindAllString</span><span class="p">(</span><span class="s">&quot;peach punch pinch&quot;</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>These <code>All</code> variants are available for the other
+functions we saw above as well.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">FindAllStringSubmatchIndex</span><span class="p">(</span>
+ <span class="s">&quot;peach punch pinch&quot;</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Providing a non-negative integer as the second
+argument to these functions will limit the number
+of matches.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">FindAllString</span><span class="p">(</span><span class="s">&quot;peach punch pinch&quot;</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Our examples above had string arguments and used
+names like <code>MatchString</code>. We can also provide
+<code>[]byte</code> arguments and drop <code>String</code> from the
+function name.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">Match</span><span class="p">([]</span><span class="nb">byte</span><span class="p">(</span><span class="s">&quot;peach&quot;</span><span class="p">)))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>When creating constants with regular expressions
+you can use the <code>MustCompile</code> variation of
+<code>Compile</code>. A plain <code>Compile</code> won&rsquo;t work for
+constants because it has 2 return values.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">r</span> <span class="p">=</span> <span class="nx">regexp</span><span class="p">.</span><span class="nx">MustCompile</span><span class="p">(</span><span class="s">&quot;p([a-z]+)ch&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>regexp</code> package can also be used to replace
+subsets of strings with other values.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">r</span><span class="p">.</span><span class="nx">ReplaceAllString</span><span class="p">(</span><span class="s">&quot;a peach&quot;</span><span class="p">,</span> <span class="s">&quot;&lt;fruit&gt;&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>Func</code> variant allows you to transform matched
+text with a given function.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">in</span> <span class="o">:=</span> <span class="p">[]</span><span class="nb">byte</span><span class="p">(</span><span class="s">&quot;a peach&quot;</span><span class="p">)</span>
+ <span class="nx">out</span> <span class="o">:=</span> <span class="nx">r</span><span class="p">.</span><span class="nx">ReplaceAllFunc</span><span class="p">(</span><span class="nx">in</span><span class="p">,</span> <span class="nx">bytes</span><span class="p">.</span><span class="nx">ToUpper</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">out</span><span class="p">))</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run regular-expressions.go
+<span class="go">true</span>
+<span class="go">true</span>
+<span class="go">peach</span>
+<span class="go">[0 5]</span>
+<span class="go">[peach ea]</span>
+<span class="go">[0 5 1 3]</span>
+<span class="go">[peach punch pinch]</span>
+<span class="go">[[0 5 1 3] [6 11 7 9] [12 17 13 15]]</span>
+<span class="go">[peach punch]</span>
+<span class="go">true</span>
+<span class="go">p([a-z]+)ch</span>
+<span class="go">a &lt;fruit&gt;</span>
+<span class="go">a PEACH</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For a complete reference on Go regular expressions check
+the <a href="http://golang.org/pkg/regexp/"><code>regexp</code></a> package docs.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="json">JSON</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/regular-expressions">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
172 public/select
@@ -0,0 +1,172 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Select</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="select">
+ <h2><a href="./">Go by Example</a>: Select</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go&rsquo;s <em>select</em> lets you wait on multiple channel
+operations. Combining goroutines and channels with
+select is powerful feature of Go.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For our example we&rsquo;ll select across two channels.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">c1</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">)</span>
+ <span class="nx">c2</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Each channel will receive a value after some amount
+of time, to simulate e.g. blocking RPC operations
+executing in concurrent goroutines.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span> <span class="o">*</span> <span class="mi">1</span><span class="p">)</span>
+ <span class="nx">c1</span> <span class="o">&lt;-</span> <span class="s">&quot;one&quot;</span>
+ <span class="p">}()</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
+ <span class="nx">c2</span> <span class="o">&lt;-</span> <span class="s">&quot;two&quot;</span>
+ <span class="p">}()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll use <code>select</code> to await both of these values
+simultaneously, printing each one as it arrives.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">2</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+ <span class="k">select</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="nx">msg1</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">c1</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;received&quot;</span><span class="p">,</span> <span class="nx">msg1</span><span class="p">)</span>
+ <span class="k">case</span> <span class="nx">msg2</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">c2</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;received&quot;</span><span class="p">,</span> <span class="nx">msg2</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>We receive the values <code>&quot;one&quot;</code> and then <code>&quot;two&quot;</code> as
+expected.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> <span class="nb">time </span>go run <span class="k">select</span>.go
+<span class="go">received one</span>
+<span class="go">received two</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that the total execution time is only ~2 seconds
+since both the 1 and 2 second <code>Sleeps</code> execute
+concurrently.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="go">real 0m2.245s</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="timeouts">Timeouts</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/select">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
190 public/sha1-hashes
@@ -0,0 +1,190 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: SHA1 Hashes</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="sha1-hashes">
+ <h2><a href="./">Go by Example</a>: SHA1 Hashes</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><a href="http://en.wikipedia.org/wiki/SHA-1"><em>SHA1 hashes</em></a> are
+frequently used to compute short identities for binary
+or text blobs. For example, the <a href="http://git-scm.com/">git revision control
+system</a> uses SHA1s extensively to
+identify versioned files and directories. Here&rsquo;s how to
+compute SHA1 hashes in Go.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Go implements several hash functions in various
+<code>crypto/*</code> packages.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;crypto/sha1&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">s</span> <span class="o">:=</span> <span class="s">&quot;sha1 this string&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The pattern for generating a hash is <code>sha1.New()</code>,
+<code>sha1.Write(bytes)</code>, then <code>sha1.Sum([]byte{})</code>.
+Here we start with a new hash.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">h</span> <span class="o">:=</span> <span class="nx">sha1</span><span class="p">.</span><span class="nx">New</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>Write</code> expects bytes. If you have a string <code>s</code>,
+use <code>[]byte(s)</code> to coerce it to bytes.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">h</span><span class="p">.</span><span class="nx">Write</span><span class="p">([]</span><span class="nb">byte</span><span class="p">(</span><span class="nx">s</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This gets the finalized hash result as a byte
+slice. The argument to <code>Sum</code> can be used to append
+to an existing byte slice: it usually isn&rsquo;t needed.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">bs</span> <span class="o">:=</span> <span class="nx">h</span><span class="p">.</span><span class="nx">Sum</span><span class="p">(</span><span class="kc">nil</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>SHA1 values are often printed in hex, for example
+in git commits. Use the <code>%x</code> format verb to convert
+a hash results to a hex string.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%x\n&quot;</span><span class="p">,</span> <span class="nx">bs</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running the program computes the hash and prints it in
+a human-readable hex format.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run sha1-hashes.go
+<span class="go">sha1 this string</span>
+<span class="go">cf23df2207d99a74fbe169e3eba035e633b65d94</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can compute other hashes using a similar pattern to
+the one shown above. For example, to compute MD5 hashes
+import <code>crypto/md5</code> and use <code>md5.New()</code>.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that if you need cryptographically secure hashes,
+you should carefully research
+<a href="http://en.wikipedia.org/wiki/Cryptographic_hash_function">hash strength</a>!</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="base64-encoding">Base64 Encoding</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/sha1-hashes">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
177 public/signals
@@ -0,0 +1,177 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Signals</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="signals">
+ <h2><a href="./">Go by Example</a>: Signals</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Sometines we&rsquo;d like our Go programs to intelligently
+handle <a href="http://en.wikipedia.org/wiki/Unix_signal">Unix signals</a>.
+For example, we might want a server to gracefully
+shutdown when it receives a <code>SIGTERM</code>, or a command-line
+tool to stop processing input if it receives a <code>SIGINT</code>.
+Here&rsquo;s how to handle signals in Go with channels.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;os&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;os/signal&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;syscall&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Go signal notification works by sending <code>os.Signal</code>
+values on a channel. We&rsquo;ll create a channel to
+receive these notifications (we&rsquo;ll also make one to
+notify us when the program can exit.)</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">sigs</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Signal</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+ <span class="nx">done</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">bool</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>signal.Notify</code> registers the given channel to
+receive notifications of the specified signals.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">signal</span><span class="p">.</span><span class="nx">Notify</span><span class="p">(</span><span class="nx">sigs</span><span class="p">,</span> <span class="nx">syscall</span><span class="p">.</span><span class="nx">SIGINT</span><span class="p">,</span> <span class="nx">syscall</span><span class="p">.</span><span class="nx">SIGTERM</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This goroutine executes a blocking receive for
+signals. When it gets one it&rsquo;ll print it out
+and then notify the program that it can finish.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">sig</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">sigs</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">()</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">sig</span><span class="p">)</span>
+ <span class="nx">done</span> <span class="o">&lt;-</span> <span class="kc">true</span>
+ <span class="p">}()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The program will wait here until it gets the
+expected signal (as indicated by the goroutine
+above sending a value on <code>done</code>) and then exit.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;awaiting signal&quot;</span><span class="p">)</span>
+ <span class="o">&lt;-</span><span class="nx">done</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;exiting&quot;</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>When we run this program it will block waiting for a
+signal. By typing <code>ctrl-C</code> (which the
+terminal shows as <code>^C</code>) we can send a <code>SIGINT</code> signal,
+causing the program to print <code>interrupt</code> and then exit.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run signals.go
+<span class="go">awaiting signal</span>
+<span class="go">^C</span>
+<span class="go">interrupt</span>
+<span class="go">exiting</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="exit">Exit</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/signals">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
201 public/site.css
@@ -0,0 +1,201 @@
+/* CSS reset: http://meyerweb.com/eric/tools/css/reset/ */
+html, body, div, span, applet, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+a, abbr, acronym, address, big, cite, code,
+del, dfn, em, img, ins, kbd, q, s, samp,
+small, strike, strong, sub, sup, tt, var,
+b, u, i, center,
+dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, canvas, details, embed,
+figure, figcaption, footer, header, hgroup,
+menu, nav, output, ruby, section, summary,
+time, mark, audio, video {
+ margin: 0;
+ padding: 0;
+ border: 0;
+ font-size: 100%;
+ font: inherit;
+ vertical-align: baseline;
+}
+article, aside, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section {
+ display: block;
+}
+body {
+ line-height: 1;
+}
+ol, ul {
+ list-style: none;
+}
+blockquote, q {
+ quotes: none;
+}
+blockquote:before, blockquote:after,
+q:before, q:after {
+ content: '';
+ content: none;
+}
+table {
+ border-collapse: collapse;
+ border-spacing: 0;
+}
+
+/* Layout and typography */
+body {
+ font-family: 'Georgia', serif;
+ font-size: 16px;
+ line-height: 20px;
+ color: #252519;
+}
+em {
+ font-style: italic;
+}
+a, a:visited {
+ color: #261a3b;
+}
+h2 {
+ font-size: 32px;
+ line-height: 40px;
+ margin-top: 40px;
+}
+h2 a {
+ text-decoration: none;
+}
+div.example {
+ width: 900px;
+ min-width: 900px;
+ max-width: 900px;
+ margin-left: auto;
+ margin-right: auto;
+ margin-bottom: 120px;
+}
+div.example table {
+ margin-top: 15px;
+ margin-bottom: 20px;
+}
+p.next {
+ margin-bottom: 20px;
+}
+p.footer {
+ color: grey;
+}
+p.footer a, p.footer a:visited {
+ color: grey;
+}
+div#intro {
+ width: 420px;
+ min-width: 420px;
+ max-width: 420px;
+ margin-left: auto;
+ margin-right: auto;
+ margin-bottom: 120px;
+}
+div#intro p {
+ padding-top: 20px;
+}
+div#intro ul {
+ padding-top: 20px;
+}
+table td {
+ border: 0;
+ outline: 0;
+}
+td.docs {
+ width: 420px;
+ max-width: 420px;
+ min-width: 420px;
+ min-height: 5px;
+ vertical-align: top;
+ text-align: left;
+}
+td.docs p {
+ padding-right: 5px;
+ padding-top: 5px;
+ padding-bottom: 15px;
+}
+td.code {
+ width: 480px;
+ max-width: 480px;
+ min-width: 480px;
+ padding-top: 5px;
+ padding-right: 5px;
+ padding-left: 5px;
+ padding-bottom: 5px;
+ vertical-align: top;
+ background: #f0f0f0;
+}
+td.code.leading {
+ padding-bottom: 11px;
+}
+td.code.empty {
+ background: #ffffff;
+}
+pre, code {
+ font-size: 14px; line-height: 18px;
+ font-family: 'Menlo', 'Monaco', 'Consolas', 'Lucida Console', monospace;
+}
+
+/* Syntax highlighting */
+body .hll { background-color: #ffffcc }
+body .err { border: 1px solid #FF0000 } /* Error */
+body .c { color: #408080; font-style: italic } /* Comment */
+body .k { color: #954121 } /* Keyword */
+body .o { color: #666666 } /* Operator */
+body .cm { color: #408080; font-style: italic } /* Comment.Multiline */
+body .cp { color: #BC7A00 } /* Comment.Preproc */
+body .c1 { color: #408080; font-style: italic } /* Comment.Single */
+body .cs { color: #408080; font-style: italic } /* Comment.Special */
+body .gd { color: #A00000 } /* Generic.Deleted */
+body .ge { font-style: italic } /* Generic.Emph */
+body .gr { color: #FF0000 } /* Generic.Error */
+body .gh { color: #000080; font-weight: bold } /* Generic.Heading */
+body .gi { color: #00A000 } /* Generic.Inserted */
+body .go { color: #808080 } /* Generic.Output */
+body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */
+body .gs { font-weight: bold } /* Generic.Strong */
+body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+body .gt { color: #0040D0 } /* Generic.Traceback */
+body .kc { color: #954121 } /* Keyword.Constant */
+body .kd { color: #954121 } /* Keyword.Declaration */
+body .kn { color: #954121 } /* Keyword.Namespace */
+body .kp { color: #954121 } /* Keyword.Pseudo */
+body .kr { color: #954121; font-weight: bold } /* Keyword.Reserved */
+body .kt { color: #B00040 } /* Keyword.Type */
+body .m { color: #666666 } /* Literal.Number */
+body .s { color: #219161 } /* Literal.String */
+body .na { color: #7D9029 } /* Name.Attribute */
+body .nb { color: #954121 } /* Name.Builtin */
+body .nc { color: #0000FF; font-weight: bold } /* Name.Class */
+body .no { color: #880000 } /* Name.Constant */
+body .nd { color: #AA22FF } /* Name.Decorator */
+body .ni { color: #999999; font-weight: bold } /* Name.Entity */
+body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */
+body .nf { color: #0000FF } /* Name.Function */
+body .nl { color: #A0A000 } /* Name.Label */
+body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
+body .nt { color: #954121; font-weight: bold } /* Name.Tag */
+body .nv { color: #19469D } /* Name.Variable */
+body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
+body .w { color: #bbbbbb } /* Text.Whitespace */
+body .mf { color: #666666 } /* Literal.Number.Float */
+body .mh { color: #666666 } /* Literal.Number.Hex */
+body .mi { color: #666666 } /* Literal.Number.Integer */
+body .mo { color: #666666 } /* Literal.Number.Oct */
+body .sb { color: #219161 } /* Literal.String.Backtick */
+body .sc { color: #219161 } /* Literal.String.Char */
+body .sd { color: #219161; font-style: italic } /* Literal.String.Doc */
+body .s2 { color: #219161 } /* Literal.String.Double */
+body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
+body .sh { color: #219161 } /* Literal.String.Heredoc */
+body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
+body .sx { color: #954121 } /* Literal.String.Other */
+body .sr { color: #BB6688 } /* Literal.String.Regex */
+body .s1 { color: #219161 } /* Literal.String.Single */
+body .ss { color: #19469D } /* Literal.String.Symbol */
+body .bp { color: #954121 } /* Name.Builtin.Pseudo */
+body .vc { color: #19469D } /* Name.Variable.Class */
+body .vg { color: #19469D } /* Name.Variable.Global */
+body .vi { color: #19469D } /* Name.Variable.Instance */
+body .il { color: #666666 } /* Literal.Number.Integer.Long */
View
291 public/slices
@@ -0,0 +1,291 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Slices</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="slices">
+ <h2><a href="./">Go by Example</a>: Slices</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>Slices</em> are a key data type in Go, giving a more
+powerful interface to sequences than arrays.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Unlike arrays, slices are typed only by the
+elements they contain (not the number of elements).
+To create an empty slice with non-zero length, use
+the builtin <code>make</code>. Here we make a slice of
+<code>string</code>s of length <code>3</code> (initially zero-valued).</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">s</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">string</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;emp:&quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We can set and get just like with arrays.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">s</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="p">=</span> <span class="s">&quot;a&quot;</span>
+ <span class="nx">s</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="p">=</span> <span class="s">&quot;b&quot;</span>
+ <span class="nx">s</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="p">=</span> <span class="s">&quot;c&quot;</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;set:&quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;get:&quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>len</code> returns the length of the slice as expected.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;len:&quot;</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In addition to these basic operations, slices
+support several more that make them richer than
+arrays. One is the builtin <code>append</code>, which
+returns a slice containing one or more new values.
+Note that we need to accept a return value from
+append as we may get a new slice value.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">s</span> <span class="p">=</span> <span class="nb">append</span><span class="p">(</span><span class="nx">s</span><span class="p">,</span> <span class="s">&quot;d&quot;</span><span class="p">)</span>
+ <span class="nx">s</span> <span class="p">=</span> <span class="nb">append</span><span class="p">(</span><span class="nx">s</span><span class="p">,</span> <span class="s">&quot;e&quot;</span><span class="p">,</span> <span class="s">&quot;f&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;apd:&quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Slices can also be <code>copy</code>&rsquo;d. Here we create an
+empty slice <code>c</code> of the same length as <code>s</code> and copy
+into <code>c</code> from <code>s</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">c</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">string</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">))</span>
+ <span class="nb">copy</span><span class="p">(</span><span class="nx">c</span><span class="p">,</span> <span class="nx">s</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;cpy:&quot;</span><span class="p">,</span> <span class="nx">c</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Slices support a &ldquo;slice&rdquo; operator with the syntax
+<code>slice[low:high]</code>. For example, this gets a slice
+of the elements <code>s[2]</code>, <code>s[3]</code>, and <code>s[4]</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">l</span> <span class="o">:=</span> <span class="nx">s</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">5</span><span class="p">]</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;sl1:&quot;</span><span class="p">,</span> <span class="nx">l</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This slices up to (but excluding) <code>s[5]</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">l</span> <span class="p">=</span> <span class="nx">s</span><span class="p">[:</span><span class="mi">5</span><span class="p">]</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;sl2:&quot;</span><span class="p">,</span> <span class="nx">l</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>And this slices up from (and including) <code>s[2]</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">l</span> <span class="p">=</span> <span class="nx">s</span><span class="p">[</span><span class="mi">2</span><span class="p">:]</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;sl3:&quot;</span><span class="p">,</span> <span class="nx">l</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We can declare and initialize a variable for slice
+in a single line as well.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">t</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;g&quot;</span><span class="p">,</span> <span class="s">&quot;h&quot;</span><span class="p">,</span> <span class="s">&quot;i&quot;</span><span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;dcl:&quot;</span><span class="p">,</span> <span class="nx">t</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Slices can be composed into multi-dimensional data
+structures. The length of the inner slices can
+vary, unlike with multi-dimensional arrays.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">twoD</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([][]</span><span class="kt">int</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
+ <span class="k">for</span> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="p">&lt;</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">innerLen</span> <span class="o">:=</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
+ <span class="nx">twoD</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="p">=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">int</span><span class="p">,</span> <span class="nx">innerLen</span><span class="p">)</span>
+ <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="p">&lt;</span> <span class="nx">innerLen</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">twoD</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">j</span><span class="p">]</span> <span class="p">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="nx">j</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;2d: &quot;</span><span class="p">,</span> <span class="nx">twoD</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Note that while slices are different types than arrays,
+they are rendered similarly by <code>fmt.Println</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run slices.go
+<span class="go">emp: [ ]</span>
+<span class="go">set: [a b c]</span>
+<span class="go">get: c</span>
+<span class="go">len: 3</span>
+<span class="go">apd: [a b c d e f]</span>
+<span class="go">cpy: [a b c d e f]</span>
+<span class="go">sl1: [c d e]</span>
+<span class="go">sl2: [a b c d e]</span>
+<span class="go">sl3: [c d e f]</span>
+<span class="go">dcl: [g h i]</span>
+<span class="go">2d: [[0] [1 2] [2 3 4]]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Check out this <a href="http://blog.golang.org/2011/01/go-slices-usage-and-internals.html">great blog post</a>
+by the Go team for more details on the design and
+implementation of slices in Go.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Now that we&rsquo;ve seen arrays and slices we&rsquo;ll look at
+Go&rsquo;s other key builtin data structure: maps.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="maps">Maps</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/slices">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
150 public/sorting
@@ -0,0 +1,150 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Sorting</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="sorting">
+ <h2><a href="./">Go by Example</a>: Sorting</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go&rsquo;s <code>sort</code> package implements sorting for builtins
+and user-defined types. We&rsquo;ll look at sorting for
+builtins first.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;sort&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Sort methods are specific to the builtin type;
+here&rsquo;s an example for strings. Note that sorting is
+in-place, so it changes the given slice and doesn&rsquo;t
+return a new one.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">strs</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;c&quot;</span><span class="p">,</span> <span class="s">&quot;a&quot;</span><span class="p">,</span> <span class="s">&quot;b&quot;</span><span class="p">}</span>
+ <span class="nx">sort</span><span class="p">.</span><span class="nx">Strings</span><span class="p">(</span><span class="nx">strs</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Strings:&quot;</span><span class="p">,</span> <span class="nx">strs</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>An example of sorting <code>int</code>s.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">ints</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">int</span><span class="p">{</span><span class="mi">7</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">}</span>
+ <span class="nx">sort</span><span class="p">.</span><span class="nx">Ints</span><span class="p">(</span><span class="nx">ints</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Ints: &quot;</span><span class="p">,</span> <span class="nx">ints</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We can also use <code>sort</code> to check if a slice is
+already in sorted order.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">s</span> <span class="o">:=</span> <span class="nx">sort</span><span class="p">.</span><span class="nx">IntsAreSorted</span><span class="p">(</span><span class="nx">ints</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Sorted: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running our program prints the sorted string and int
+slices and <code>true</code> as the result of our <code>AreSorted</code> test.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run sorting.go
+<span class="go">Strings: [a b c]</span>
+<span class="go">Ints: [2 4 7]</span>
+<span class="go">Sorted: true</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="sorting-by-functions">Sorting by Functions</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/sorting">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
167 public/sorting-by-functions
@@ -0,0 +1,167 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Sorting by Functions</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="sorting-by-functions">
+ <h2><a href="./">Go by Example</a>: Sorting by Functions</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Sometimes we&rsquo;ll want to sort a collection by something
+other than its natural order. For example, suppose we
+wanted to sort strings by their length instead of
+alphabetically. Here&rsquo;s an example of custom sorts sorts
+in Go.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;sort&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In order to sort by a custom function in Go, we need a
+corresponding type. Here we&rsquo;ve created a <code>ByLength</code>
+type that is just an alias for the builtin <code>[]string</code>
+type.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">type</span> <span class="nx">ByLength</span> <span class="p">[]</span><span class="kt">string</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We implement <code>sort.Interface</code> - <code>Len</code>, <code>Less</code>, and
+<code>Swap</code> - on our type so we can use the <code>sort</code> package&rsquo;s
+generic <code>Sort</code> function. <code>Len</code> and <code>Swap</code>
+will usually be similar accross types and <code>Less</code> will
+hold the actual custom sorting logic. In our case we
+want to sort in order of increasing string length, so
+we use <code>len(s[i])</code> and <code>len(s[j])</code> here.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="p">(</span><span class="nx">s</span> <span class="nx">ByLength</span><span class="p">)</span> <span class="nx">Len</span><span class="p">()</span> <span class="kt">int</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span>
+<span class="p">}</span>
+<span class="kd">func</span> <span class="p">(</span><span class="nx">s</span> <span class="nx">ByLength</span><span class="p">)</span> <span class="nx">Swap</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">j</span> <span class="kt">int</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">],</span> <span class="nx">s</span><span class="p">[</span><span class="nx">j</span><span class="p">]</span> <span class="p">=</span> <span class="nx">s</span><span class="p">[</span><span class="nx">j</span><span class="p">],</span> <span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span>
+<span class="p">}</span>
+<span class="kd">func</span> <span class="p">(</span><span class="nx">s</span> <span class="nx">ByLength</span><span class="p">)</span> <span class="nx">Less</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">j</span> <span class="kt">int</span><span class="p">)</span> <span class="kt">bool</span> <span class="p">{</span>
+ <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">&lt;</span> <span class="nb">len</span><span class="p">(</span><span class="nx">s</span><span class="p">[</span><span class="nx">j</span><span class="p">])</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>With all of this in place, we can now implement our
+custom sort by casting the original <code>fruits</code> slice to
+<code>ByLength</code>, and then use <code>sort.Sort</code> on that typed
+slice.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">fruits</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;peach&quot;</span><span class="p">,</span> <span class="s">&quot;banana&quot;</span><span class="p">,</span> <span class="s">&quot;kiwi&quot;</span><span class="p">}</span>
+ <span class="nx">sort</span><span class="p">.</span><span class="nx">Sort</span><span class="p">(</span><span class="nx">ByLength</span><span class="p">(</span><span class="nx">fruits</span><span class="p">))</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">fruits</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running our program shows a list sorted by string
+length, as desired.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run sorting-by-functions.go
+<span class="go">[kiwi peach banana]</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>By following this same pattern of creating a custom
+type, implementing the three <code>Interface</code> methods on that
+type, and then calling sort.Sort on a collection of that
+custom type, we can sort Go slices by arbitrary
+functions.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="panic">Panic</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/sorting-by-functions">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
244 public/spawning-processes
@@ -0,0 +1,244 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Spawning Processes</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="spawning-processes">
+ <h2><a href="./">Go by Example</a>: Spawning Processes</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Sometimes our Go programs need to spawn other, non-Go
+processes. For example, the syntax highlighting on this
+site is <a href="https://github.com/mmcgrana/gobyexample/blob/master/tools/generate.go">implemented</a>
+by spawning a <a href="http://pygments.org/"><code>pygmentize</code></a>
+process from a Go program. Let&rsquo;s look at a few examples
+of spawning processes from Go.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;io/ioutil&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;os/exec&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll start with a simple command that takes no
+arguments or input and just prints something to
+stdout. The <code>exec.Command</code> helper creates an object
+to represent this external process.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">dateCmd</span> <span class="o">:=</span> <span class="nx">exec</span><span class="p">.</span><span class="nx">Command</span><span class="p">(</span><span class="s">&quot;date&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>.Output</code> is another helper than handles the common
+case of running a command, waiting for it to finish,
+and collecting its output. If there were no errors,
+<code>dateOut</code> will hold bytes with the date info.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">dateOut</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">dateCmd</span><span class="p">.</span><span class="nx">Output</span><span class="p">()</span>
+ <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;&gt; date&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">dateOut</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at a slightly more involved case
+where we pipe data to the external process on its
+<code>stdin</code> and collect the results from its <code>stdout</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">grepCmd</span> <span class="o">:=</span> <span class="nx">exec</span><span class="p">.</span><span class="nx">Command</span><span class="p">(</span><span class="s">&quot;grep&quot;</span><span class="p">,</span> <span class="s">&quot;hello&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we explicitly grab input/output pipes, start
+the process, write some input to it, read the
+resulting output, and finally wait for the process
+to exit.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">grepIn</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">grepCmd</span><span class="p">.</span><span class="nx">StdinPipe</span><span class="p">()</span>
+ <span class="nx">grepOut</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">grepCmd</span><span class="p">.</span><span class="nx">StdoutPipe</span><span class="p">()</span>
+ <span class="nx">grepCmd</span><span class="p">.</span><span class="nx">Start</span><span class="p">()</span>
+ <span class="nx">grepIn</span><span class="p">.</span><span class="nx">Write</span><span class="p">([]</span><span class="nb">byte</span><span class="p">(</span><span class="s">&quot;hello grep\ngoodbye grep&quot;</span><span class="p">))</span>
+ <span class="nx">grepIn</span><span class="p">.</span><span class="nx">Close</span><span class="p">()</span>
+ <span class="nx">grepBytes</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">ioutil</span><span class="p">.</span><span class="nx">ReadAll</span><span class="p">(</span><span class="nx">grepOut</span><span class="p">)</span>
+ <span class="nx">grepCmd</span><span class="p">.</span><span class="nx">Wait</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We ommited error checks in the above example, but
+you could use the usual <code>if err != nil</code> pattern for
+all of them. We also only collect the <code>StdoutPipe</code>
+results, but you could collect the <code>StderrPipe</code> in
+exactly the same way.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;&gt; grep hello&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">grepBytes</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Note that when spawning commands we need to
+provide an explicitly delineated command and
+argument array, vs. being able to just pass in one
+command-line string. If you want to spawn a full
+command with a string, you can use <code>bash</code>&rsquo;s <code>-c</code>
+option:</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">lsCmd</span> <span class="o">:=</span> <span class="nx">exec</span><span class="p">.</span><span class="nx">Command</span><span class="p">(</span><span class="s">&quot;bash&quot;</span><span class="p">,</span> <span class="s">&quot;-c&quot;</span><span class="p">,</span> <span class="s">&quot;ls -a -l -h&quot;</span><span class="p">)</span>
+ <span class="nx">lsOut</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">lsCmd</span><span class="p">.</span><span class="nx">Output</span><span class="p">()</span>
+ <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;&gt; ls -a -l -h&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nb">string</span><span class="p">(</span><span class="nx">lsOut</span><span class="p">))</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>The spawned programs return output that is the same
+as if we had run them directly from the command-line.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run spawning-processes.go
+<span class="gp">&gt;</span> date
+<span class="go">Wed Oct 10 09:53:11 PDT 2012</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">&gt;</span> grep hello
+<span class="go">hello grep</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">&gt;</span> ls -a -l -h
+<span class="go">drwxr-xr-x 4 mark 136B Oct 3 16:29 .</span>
+<span class="go">drwxr-xr-x 91 mark 3.0K Oct 3 12:50 ..</span>
+<span class="go">-rw-r--r-- 1 mark 1.3K Oct 3 16:28 spawning-processes.go</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="execing-processes">Exec'ing Processes</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/spawning-processes">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
303 public/stateful-goroutines
@@ -0,0 +1,303 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Stateful Goroutines</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="stateful-goroutines">
+ <h2><a href="./">Go by Example</a>: Stateful Goroutines</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>In the previous example we used explicit locking with
+mutexes to synchronize access to shared state across
+multiple goroutines. Another option is to use the
+built-in synchronization features of goroutines and
+channels to achieve the same result. This channel-based
+approach aligns with Go&rsquo;s ideas of sharing memory by
+communicating and having each piece of data owned
+by exactly 1 goroutine.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
+ <span class="s">&quot;fmt&quot;</span>
+ <span class="s">&quot;math/rand&quot;</span>
+ <span class="s">&quot;sync/atomic&quot;</span>
+ <span class="s">&quot;time&quot;</span>
+<span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In this example our state will be owned by a single
+goroutine. This will guarantee that the data is never
+corrupted with concurrent access. In order to read or
+write that state, other goroutines will send messages
+to the owning goroutine and receive corresponding
+replies. These <code>readOp</code> and <code>writeOp</code> <code>struct</code>s
+encapsulate those requests and a way for the owning
+goroutine to respond.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">type</span> <span class="nx">readOp</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">key</span> <span class="kt">int</span>
+ <span class="nx">resp</span> <span class="kd">chan</span> <span class="kt">int</span>
+<span class="p">}</span>
+<span class="kd">type</span> <span class="nx">writeOp</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">key</span> <span class="kt">int</span>
+ <span class="nx">val</span> <span class="kt">int</span>
+ <span class="nx">resp</span> <span class="kd">chan</span> <span class="kt">bool</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>state</code> will be a map as in the previous
+example.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">state</span> <span class="p">=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">map</span><span class="p">[</span><span class="kt">int</span><span class="p">]</span><span class="kt">int</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Also as before we&rsquo;ll count how many operations we
+perform.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">ops</span> <span class="kt">int64</span> <span class="p">=</span> <span class="mi">0</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>reads</code> and <code>writes</code> channels will be used by
+other goroutines to issue read and write requests,
+respectively.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">reads</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="o">*</span><span class="nx">readOp</span><span class="p">)</span>
+ <span class="nx">writes</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="o">*</span><span class="nx">writeOp</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here is the goroutine that owns the <code>state</code>. This
+goroutine repeatedly selects on the <code>reads</code> and
+<code>writes</code> channels, responding to requests as they
+arrive. A response is executed by first performing
+the requested operation and then sending a value
+on the response channel <code>resp</code> to indicate success
+(and the desired value in the case of <code>reads</code>).</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="p">{</span>
+ <span class="k">select</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="nx">read</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">reads</span><span class="p">:</span>
+ <span class="nx">read</span><span class="p">.</span><span class="nx">resp</span> <span class="o">&lt;-</span> <span class="nx">state</span><span class="p">[</span><span class="nx">read</span><span class="p">.</span><span class="nx">key</span><span class="p">]</span>
+ <span class="k">case</span> <span class="nx">write</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">writes</span><span class="p">:</span>
+ <span class="nx">state</span><span class="p">[</span><span class="nx">write</span><span class="p">.</span><span class="nx">key</span><span class="p">]</span> <span class="p">=</span> <span class="nx">write</span><span class="p">.</span><span class="nx">val</span>
+ <span class="nx">write</span><span class="p">.</span><span class="nx">resp</span> <span class="o">&lt;-</span> <span class="kc">true</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="p">}()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This starts 100 goroutines to issue reads to the
+state-owning goroutine via the <code>reads</code> channel.
+Each read requires constructing a <code>readOp</code>, sending
+it over the <code>reads</code> channel, and the receiving the
+result over the provided <code>resp</code> channel.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">r</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">r</span> <span class="p">&lt;</span> <span class="mi">100</span><span class="p">;</span> <span class="nx">r</span><span class="o">++</span> <span class="p">{</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="p">{</span>
+ <span class="nx">read</span> <span class="o">:=</span> <span class="o">&amp;</span><span class="nx">readOp</span><span class="p">{</span>
+ <span class="nx">key</span><span class="p">:</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">5</span><span class="p">),</span>
+ <span class="nx">resp</span><span class="p">:</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">int</span><span class="p">)}</span>
+ <span class="nx">reads</span> <span class="o">&lt;-</span> <span class="nx">read</span>
+ <span class="o">&lt;-</span><span class="nx">read</span><span class="p">.</span><span class="nx">resp</span>
+ <span class="nx">atomic</span><span class="p">.</span><span class="nx">AddInt64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">ops</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}()</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We start 10 writes as well, using a similar
+approach.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">w</span> <span class="o">:=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">w</span> <span class="p">&lt;</span> <span class="mi">10</span><span class="p">;</span> <span class="nx">w</span><span class="o">++</span> <span class="p">{</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="p">{</span>
+ <span class="nx">write</span> <span class="o">:=</span> <span class="o">&amp;</span><span class="nx">writeOp</span><span class="p">{</span>
+ <span class="nx">key</span><span class="p">:</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">5</span><span class="p">),</span>
+ <span class="nx">val</span><span class="p">:</span> <span class="nx">rand</span><span class="p">.</span><span class="nx">Intn</span><span class="p">(</span><span class="mi">100</span><span class="p">),</span>
+ <span class="nx">resp</span><span class="p">:</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">bool</span><span class="p">)}</span>
+ <span class="nx">writes</span> <span class="o">&lt;-</span> <span class="nx">write</span>
+ <span class="o">&lt;-</span><span class="nx">write</span><span class="p">.</span><span class="nx">resp</span>
+ <span class="nx">atomic</span><span class="p">.</span><span class="nx">AddInt64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">ops</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}()</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Let the goroutines work for a second.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Finally, capture and report the <code>ops</code> count.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">opsFinal</span> <span class="o">:=</span> <span class="nx">atomic</span><span class="p">.</span><span class="nx">LoadInt64</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">ops</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;ops:&quot;</span><span class="p">,</span> <span class="nx">opsFinal</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running our program shows that the goroutine-based
+state management example achieves about 800,000
+operations per second.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run stateful-goroutines.go
+<span class="go">ops: 807434</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For this particular case the goroutine-based approach
+was a bit more involved than the mutex-based one. It
+might be useful in certain cases though, for example
+where you have other channels involved or when managing
+multiple such mutexes would be error-prone. You should
+use whichever approach feels most natural, especially
+with respect to understanding the correctness of your
+program.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="sorting">Sorting</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/stateful-goroutines">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
426 public/string-formatting
@@ -0,0 +1,426 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: String Formatting</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="string-formatting">
+ <h2><a href="./">Go by Example</a>: String Formatting</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go offers excellent support for string formatting in
+the <code>printf</code> tradition. Here are some examples of
+common string formatting tasks.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;os&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">type</span> <span class="nx">point</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">x</span><span class="p">,</span> <span class="nx">y</span> <span class="kt">int</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Go offers several printing &ldquo;verbs&rdquo; designed to
+format general Go values. For example, this prints
+an instance of our <code>point</code> struct.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">p</span> <span class="o">:=</span> <span class="nx">point</span><span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%v\n&quot;</span><span class="p">,</span> <span class="nx">p</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If the value is a struct, the <code>%+v</code> variant will
+include the struct&rsquo;s field names.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%+v\n&quot;</span><span class="p">,</span> <span class="nx">p</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>%#v</code> variant prints a Go syntax representation
+of the value, i.e. the source code snippet that
+would produce that value.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%#v\n&quot;</span><span class="p">,</span> <span class="nx">p</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To print the type of a value, use <code>%T</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%T\n&quot;</span><span class="p">,</span> <span class="nx">p</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Formatting booleans is straight-forward.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%t\n&quot;</span><span class="p">,</span> <span class="kc">true</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>There are many options for formatting integers.
+Use <code>%d</code> for standard, base-10 formatting.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%d\n&quot;</span><span class="p">,</span> <span class="mi">123</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This prints a binary representation.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%b\n&quot;</span><span class="p">,</span> <span class="mi">14</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This prints the character corresponding to the
+given integer.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%c\n&quot;</span><span class="p">,</span> <span class="mi">33</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>%x</code> provides hex encoding.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%x\n&quot;</span><span class="p">,</span> <span class="mi">456</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>There are also several formatting options for
+floats. For basic decimal formatting use <code>%f</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%f&quot;</span><span class="p">,</span> <span class="mf">78.9</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>%e</code> and <code>%E</code> format the float in (slightly
+different versions of) scientific notation.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%e\n&quot;</span><span class="p">,</span> <span class="mf">123400000.0</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%E\n&quot;</span><span class="p">,</span> <span class="mf">123400000.0</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For basic string printing use <code>%s</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%s\n&quot;</span><span class="p">,</span> <span class="s">&quot;\&quot;string\&quot;&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To double-quote strings as in Go source, use <code>%q</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%q\n&quot;</span><span class="p">,</span> <span class="s">&quot;\&quot;string\&quot;&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>As with integers as seen earlier, <code>%x</code> renders
+the string in base-16, with two output characters
+per byte of input.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%x\n&quot;</span><span class="p">,</span> <span class="s">&quot;hex this&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To print a representation of a pointer, use <code>%p</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%p\n&quot;</span><span class="p">,</span> <span class="o">&amp;</span><span class="nx">p</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>When formatting numbers you will often want to
+control the width and precision of the resulting
+figure. To specify the width of an integer, use a
+number after the <code>%</code> in the verb. By default the
+result will be right-justified and padded with
+spaces.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;|%6d|%6d|\n&quot;</span><span class="p">,</span> <span class="mi">12</span><span class="p">,</span> <span class="mi">345</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can also specify the width of printed floats,
+though usually you&rsquo;ll also want to restrict the
+decimal precision at the same time with the
+width.precision syntax.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;|%6.2f|%6.2f|\n&quot;</span><span class="p">,</span> <span class="mf">1.2</span><span class="p">,</span> <span class="mf">3.45</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To left-justify, use the <code>-</code> flag.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;|%-6.2f|%-6.2f|\n&quot;</span><span class="p">,</span> <span class="mf">1.2</span><span class="p">,</span> <span class="mf">3.45</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You may also want to control width when formatting
+strings, especially to ensure that they align in
+table-like output. For basic right-justified width.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;|%6s|%6s|\n&quot;</span><span class="p">,</span> <span class="s">&quot;foo&quot;</span><span class="p">,</span> <span class="s">&quot;b&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To left-justify use the <code>-</code> flag as with numbers.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;|%-6s|%-6s|\n&quot;</span><span class="p">,</span> <span class="s">&quot;foo&quot;</span><span class="p">,</span> <span class="s">&quot;b&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>So far we&rsquo;ve seen <code>Printf</code>, which prints the
+formatted string to <code>os.Stdout</code>. <code>Sprintf</code> formats
+and returns a string without printing it anywhere.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">s</span> <span class="o">:=</span> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Sprintf</span><span class="p">(</span><span class="s">&quot;a %s &quot;</span><span class="p">,</span> <span class="s">&quot;string&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can format+print to <code>io.Writers</code> other than
+<code>os.Stdout</code> using <code>Fprintf</code>.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Fprintf</span><span class="p">(</span><span class="nx">os</span><span class="p">.</span><span class="nx">Stderr</span><span class="p">,</span> <span class="s">&quot;an %s\n&quot;</span><span class="p">,</span> <span class="s">&quot;error&quot;</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run string-formatting.go
+<span class="go">{1 2} </span>
+<span class="go">{x:1 y:2} </span>
+<span class="go">main.point{x:1, y:2} </span>
+<span class="go">main.point </span>
+<span class="go">true </span>
+<span class="go">123 </span>
+<span class="go">1110 </span>
+<span class="go">! </span>
+<span class="go">1c8 </span>
+<span class="go">78.9000001.234000e+08 </span>
+<span class="go">1.234000E+08 </span>
+<span class="go">&quot;string&quot; </span>
+<span class="go">&quot;\&quot;string\&quot;&quot; </span>
+<span class="go">6865782074686973 </span>
+<span class="go">0x42134100 </span>
+<span class="go">| 12| 345| </span>
+<span class="go">| 1.20| 3.45| </span>
+<span class="go">|1.20 |3.45 | </span>
+<span class="go">| foo| b|</span>
+<span class="go">|foo |b |</span>
+<span class="go">a string </span>
+<span class="go">an error </span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="regular-expressions">Regular Expressions</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/string-formatting">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
191 public/string-functions
@@ -0,0 +1,191 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: String Functions</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="string-functions">
+ <h2><a href="./">Go by Example</a>: String Functions</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>The standard library&rsquo;s <code>strings</code> package provides many
+useful string-related functions. Here are some examples
+to give you a sense of the package.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="nx">s</span> <span class="s">&quot;strings&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We alias <code>fmt.Println</code> to a shorter name as we&rsquo;ll use
+it a lot below.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">var</span> <span class="nx">p</span> <span class="p">=</span> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s a sample of the functions available in
+<code>strings</code>. Note that these are all functions from
+package, not methods on the string object itself.
+This means that we need pass the string in question
+as the first argument to the function.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Contains: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">Contains</span><span class="p">(</span><span class="s">&quot;test&quot;</span><span class="p">,</span> <span class="s">&quot;es&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Count: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">Count</span><span class="p">(</span><span class="s">&quot;test&quot;</span><span class="p">,</span> <span class="s">&quot;t&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;HasPrefix: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">HasPrefix</span><span class="p">(</span><span class="s">&quot;test&quot;</span><span class="p">,</span> <span class="s">&quot;te&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;HasSuffix: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">HasSuffix</span><span class="p">(</span><span class="s">&quot;test&quot;</span><span class="p">,</span> <span class="s">&quot;st&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Index: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">Index</span><span class="p">(</span><span class="s">&quot;test&quot;</span><span class="p">,</span> <span class="s">&quot;e&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Join: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">Join</span><span class="p">([]</span><span class="kt">string</span><span class="p">{</span><span class="s">&quot;a&quot;</span><span class="p">,</span> <span class="s">&quot;b&quot;</span><span class="p">},</span> <span class="s">&quot;-&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Repeat: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">Repeat</span><span class="p">(</span><span class="s">&quot;a&quot;</span><span class="p">,</span> <span class="mi">5</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Replace: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">Replace</span><span class="p">(</span><span class="s">&quot;foo&quot;</span><span class="p">,</span> <span class="s">&quot;o&quot;</span><span class="p">,</span> <span class="s">&quot;0&quot;</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Replace: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">Replace</span><span class="p">(</span><span class="s">&quot;foo&quot;</span><span class="p">,</span> <span class="s">&quot;o&quot;</span><span class="p">,</span> <span class="s">&quot;0&quot;</span><span class="p">,</span> <span class="mi">1</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Split: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">Split</span><span class="p">(</span><span class="s">&quot;a-b-c-d-e&quot;</span><span class="p">,</span> <span class="s">&quot;-&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;toLower: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">ToLower</span><span class="p">(</span><span class="s">&quot;TEST&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;ToUpper: &quot;</span><span class="p">,</span> <span class="nx">s</span><span class="p">.</span><span class="nx">ToUpper</span><span class="p">(</span><span class="s">&quot;test&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can find more functions in the <a href="http://golang.org/pkg/strings/"><code>strings</code></a>
+package docs.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Not part of <code>strings</code> but worth mentioning here are
+the mechanisms for getting the length of a string
+and getting a character by index.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Len: &quot;</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="s">&quot;hello&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="s">&quot;Char:&quot;</span><span class="p">,</span> <span class="s">&quot;hello&quot;</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run string-functions.go
+<span class="go">Contains: true</span>
+<span class="go">Count: 2</span>
+<span class="go">HasPrefix: true</span>
+<span class="go">HasSuffix: true</span>
+<span class="go">Index: 1</span>
+<span class="go">Join: a-b</span>
+<span class="go">Repeat: aaaaa</span>
+<span class="go">Replace: f00</span>
+<span class="go">Replace: f0o</span>
+<span class="go">Split: [a b c d e]</span>
+<span class="go">toLower: test</span>
+<span class="go">ToUpper: TEST</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="go">Len: 5</span>
+<span class="go">Char: 101</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="string-formatting">String Formatting</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/string-functions">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
209 public/structs
@@ -0,0 +1,209 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Structs</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="structs">
+ <h2><a href="./">Go by Example</a>: Structs</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go&rsquo;s <em>structs</em> are typed collections of fields.
+They&rsquo;re useful for grouping data together to form
+records.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This <code>person</code> struct type has <code>name</code> and <code>age</code> fields.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">type</span> <span class="nx">person</span> <span class="kd">struct</span> <span class="p">{</span>
+ <span class="nx">name</span> <span class="kt">string</span>
+ <span class="nx">age</span> <span class="kt">int</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This syntax creates a new struct.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">person</span><span class="p">{</span><span class="s">&quot;Bob&quot;</span><span class="p">,</span> <span class="mi">20</span><span class="p">})</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can name the fields when initializing a struct.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">person</span><span class="p">{</span><span class="nx">name</span><span class="p">:</span> <span class="s">&quot;Alice&quot;</span><span class="p">,</span> <span class="nx">age</span><span class="p">:</span> <span class="mi">30</span><span class="p">})</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Omitted fields will be zero-valued.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">person</span><span class="p">{</span><span class="nx">name</span><span class="p">:</span> <span class="s">&quot;Fred&quot;</span><span class="p">})</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>An <code>&amp;</code> prefix yields a pointer to the struct.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="o">&amp;</span><span class="nx">person</span><span class="p">{</span><span class="nx">name</span><span class="p">:</span> <span class="s">&quot;Ann&quot;</span><span class="p">,</span> <span class="nx">age</span><span class="p">:</span> <span class="mi">40</span><span class="p">})</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Access struct fields with a dot.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">s</span> <span class="o">:=</span> <span class="nx">person</span><span class="p">{</span><span class="nx">name</span><span class="p">:</span> <span class="s">&quot;Sean&quot;</span><span class="p">,</span> <span class="nx">age</span><span class="p">:</span> <span class="mi">50</span><span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">s</span><span class="p">.</span><span class="nx">name</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can also use dots with struct pointers - the
+pointers are automatically dereferenced.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">sp</span> <span class="o">:=</span> <span class="o">&amp;</span><span class="nx">s</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">sp</span><span class="p">.</span><span class="nx">age</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Structs are mutable.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">sp</span><span class="p">.</span><span class="nx">age</span> <span class="p">=</span> <span class="mi">51</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">sp</span><span class="p">.</span><span class="nx">age</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run structs.go
+<span class="go">{Bob 20}</span>
+<span class="go">{Alice 30}</span>
+<span class="go">{Fred 0}</span>
+<span class="go">&amp;{Ann 40}</span>
+<span class="go">Sean</span>
+<span class="go">50</span>
+<span class="go">51</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="methods">Methods</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/structs">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
162 public/switch
@@ -0,0 +1,162 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Switch</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="switch">
+ <h2><a href="./">Go by Example</a>: Switch</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>Switch statements</em> express conditionals across many
+branches.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s a basic <code>switch</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">i</span> <span class="o">:=</span> <span class="mi">2</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="s">&quot;write &quot;</span><span class="p">,</span> <span class="nx">i</span><span class="p">,</span> <span class="s">&quot; as &quot;</span><span class="p">)</span>
+ <span class="k">switch</span> <span class="nx">i</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="mi">1</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;one&quot;</span><span class="p">)</span>
+ <span class="k">case</span> <span class="mi">2</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;two&quot;</span><span class="p">)</span>
+ <span class="k">case</span> <span class="mi">3</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;three&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can use commas to separate multiple expressions
+in the same <code>case</code> statement. We use the optional
+<code>default</code> case in this example as well.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">switch</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Now</span><span class="p">().</span><span class="nx">Weekday</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Saturday</span><span class="p">,</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Sunday</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;it&#39;s the weekend&quot;</span><span class="p">)</span>
+ <span class="k">default</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;it&#39;s a weekday&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>switch</code> without an expression is an alternate way
+to express if/else logic. Here we also show how the
+<code>case</code> expressions can be non-constants.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">t</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Now</span><span class="p">()</span>
+ <span class="k">switch</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="nx">t</span><span class="p">.</span><span class="nx">Hour</span><span class="p">()</span> <span class="p">&lt;</span> <span class="mi">12</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;it&#39;s before noon&quot;</span><span class="p">)</span>
+ <span class="k">default</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;it&#39;s after noon&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run switch.go
+<span class="go">write 2 as two</span>
+<span class="go">it&#39;s the weekend</span>
+<span class="go">it&#39;s before noon</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="arrays">Arrays</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/switch">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
144 public/tickers
@@ -0,0 +1,144 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Tickers</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="tickers">
+ <h2><a href="./">Go by Example</a>: Tickers</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><a href="timers">Timers</a> are for when you want to do
+something once in the future - <em>tickers</em> are for when
+you want to do something repeatedly at regular
+intervals. Here&rsquo;s an example of a ticker that ticks
+periodically until we stop it.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Tickers use a similar mechanism to timers: a
+channel that is sent values. Here we&rsquo;ll use the
+<code>range</code> builtin on the channel to iterate over
+the values as they arrive every 500ms.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">ticker</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">NewTicker</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Millisecond</span> <span class="o">*</span> <span class="mi">500</span><span class="p">)</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="nx">t</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">ticker</span><span class="p">.</span><span class="nx">C</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Tick at&quot;</span><span class="p">,</span> <span class="nx">t</span><span class="p">)</span>
+ <span class="p">}</span>
+ <span class="p">}()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Tickers can be stopped like timers. Once a ticker
+is stopped it won&rsquo;t receive any more values on its
+channel. We&rsquo;ll stop ours after 1500ms.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Millisecond</span> <span class="o">*</span> <span class="mi">1500</span><span class="p">)</span>
+ <span class="nx">ticker</span><span class="p">.</span><span class="nx">Stop</span><span class="p">()</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Ticker stopped&quot;</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>When we run this program the ticker should tick 3 times
+befor we stop it.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run tickers.go
+<span class="go">Tick at 2012-09-23 11:29:56.487625 -0700 PDT</span>
+<span class="go">Tick at 2012-09-23 11:29:56.988063 -0700 PDT</span>
+<span class="go">Tick at 2012-09-23 11:29:57.488076 -0700 PDT</span>
+<span class="go">Ticker stopped</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="worker-pools">Worker Pools</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/tickers">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
254 public/time
@@ -0,0 +1,254 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Time</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="time">
+ <h2><a href="./">Go by Example</a>: Time</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go&rsquo;s offers extensive support for times and durations;
+here are some examples.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">p</span> <span class="o">:=</span> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll start by getting the current time.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">now</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Now</span><span class="p">()</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">now</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can build a <code>time</code> struct by providing the
+year, month, day, etc. Times are always associated
+with a <code>Location</code>, i.e. time zone.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">then</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Date</span><span class="p">(</span>
+ <span class="mi">2009</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">17</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">34</span><span class="p">,</span> <span class="mi">58</span><span class="p">,</span> <span class="mi">651387237</span><span class="p">,</span> <span class="nx">time</span><span class="p">.</span><span class="nx">UTC</span><span class="p">)</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can extract the various components of the time
+value as expected.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Year</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Month</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Day</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Hour</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Minute</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Second</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Nanosecond</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Location</span><span class="p">())</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The Monday-Sunday <code>Weekday</code> is also available.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Weekday</span><span class="p">())</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>These methods compare two times, testing if the
+first occurs before, after, or at the same time
+as the second, respectively.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Before</span><span class="p">(</span><span class="nx">now</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">After</span><span class="p">(</span><span class="nx">now</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Equal</span><span class="p">(</span><span class="nx">now</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>Sub</code> methods returns a <code>Duration</code> representing
+the interval between two times.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">diff</span> <span class="o">:=</span> <span class="nx">now</span><span class="p">.</span><span class="nx">Sub</span><span class="p">(</span><span class="nx">then</span><span class="p">)</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">diff</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We can compute the length of the duration in
+various units.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">p</span><span class="p">(</span><span class="nx">diff</span><span class="p">.</span><span class="nx">Hours</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">diff</span><span class="p">.</span><span class="nx">Minutes</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">diff</span><span class="p">.</span><span class="nx">Seconds</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">diff</span><span class="p">.</span><span class="nx">Nanoseconds</span><span class="p">())</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can use <code>Add</code> to advance a time by a given
+duration, or with a <code>-</code> to move backwards by a
+duration.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Add</span><span class="p">(</span><span class="nx">diff</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">then</span><span class="p">.</span><span class="nx">Add</span><span class="p">(</span><span class="o">-</span><span class="nx">diff</span><span class="p">))</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run time.go
+<span class="go">2012-10-31 15:50:13.793654 +0000 UTC</span>
+<span class="go">2009-11-17 20:34:58.651387237 +0000 UTC</span>
+<span class="go">2009</span>
+<span class="go">November</span>
+<span class="go">17</span>
+<span class="go">20</span>
+<span class="go">34</span>
+<span class="go">58</span>
+<span class="go">651387237</span>
+<span class="go">UTC</span>
+<span class="go">Tuesday</span>
+<span class="go">true</span>
+<span class="go">false</span>
+<span class="go">false</span>
+<span class="go">25891h15m15.142266763s</span>
+<span class="go">25891.25420618521</span>
+<span class="go">1.5534752523711128e+06</span>
+<span class="go">9.320851514226677e+07</span>
+<span class="go">93208515142266763</span>
+<span class="go">2012-10-31 15:50:13.793654 +0000 UTC</span>
+<span class="go">2006-12-05 01:19:43.509120474 +0000 UTC</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at the related idea of time relative to
+the Unix epoch.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="epoch">Epoch</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/time">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
207 public/time-formatting-parsing
@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Time Formatting / Parsing</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="time-formatting-parsing">
+ <h2><a href="./">Go by Example</a>: Time Formatting / Parsing</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go supports time formatting and parsing via
+pattern-based layouts.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">p</span> <span class="o">:=</span> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s a basic example of formatting a time
+according to RFC3339.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">t</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Now</span><span class="p">()</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">t</span><span class="p">.</span><span class="nx">Format</span><span class="p">(</span><span class="s">&quot;2006-01-02T15:04:05Z07:00&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>Format</code> uses an example-based layout approach; it
+takes a formatted version of the reference time
+<code>Mon Jan 2 15:04:05 MST 2006</code> to determine the
+general pattern with which to format the given
+time. Here are a few more examples of time
+formatting.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">p</span><span class="p">(</span><span class="nx">t</span><span class="p">.</span><span class="nx">Format</span><span class="p">(</span><span class="s">&quot;3:04PM&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">t</span><span class="p">.</span><span class="nx">Format</span><span class="p">(</span><span class="s">&quot;Mon Jan _2 15:04:05 2006&quot;</span><span class="p">))</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">t</span><span class="p">.</span><span class="nx">Format</span><span class="p">(</span><span class="s">&quot;2006-01-02T15:04:05.999999-07:00&quot;</span><span class="p">))</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For purely numeric representations you can also
+use standard string formatting with the extracted
+components of the time value.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;%d-%02d-%02dT%02d:%02d:%02d-00:00\n&quot;</span><span class="p">,</span>
+ <span class="nx">t</span><span class="p">.</span><span class="nx">Year</span><span class="p">(),</span> <span class="nx">t</span><span class="p">.</span><span class="nx">Month</span><span class="p">(),</span> <span class="nx">t</span><span class="p">.</span><span class="nx">Day</span><span class="p">(),</span>
+ <span class="nx">t</span><span class="p">.</span><span class="nx">Hour</span><span class="p">(),</span> <span class="nx">t</span><span class="p">.</span><span class="nx">Minute</span><span class="p">(),</span> <span class="nx">t</span><span class="p">.</span><span class="nx">Second</span><span class="p">())</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Time parsing uses the same example-based approach
+as <code>Format</code>ing. These examples parse times rendered
+with some of the layouts used above.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">withNanos</span> <span class="o">:=</span> <span class="s">&quot;2006-01-02T15:04:05.999999999-07:00&quot;</span>
+ <span class="nx">t1</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Parse</span><span class="p">(</span>
+ <span class="nx">withNanos</span><span class="p">,</span>
+ <span class="s">&quot;2012-11-01T22:08:41.117442+00:00&quot;</span><span class="p">)</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">t1</span><span class="p">)</span>
+ <span class="nx">kitchen</span> <span class="o">:=</span> <span class="s">&quot;3:04PM&quot;</span>
+ <span class="nx">t2</span><span class="p">,</span> <span class="nx">e</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Parse</span><span class="p">(</span><span class="nx">kitchen</span><span class="p">,</span> <span class="s">&quot;8:41PM&quot;</span><span class="p">)</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">t2</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>Parse</code> will return an error on malformed input
+explaining the parsing problem.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">ansic</span> <span class="o">:=</span> <span class="s">&quot;Mon Jan _2 15:04:05 2006&quot;</span>
+ <span class="nx">_</span><span class="p">,</span> <span class="nx">e</span> <span class="p">=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">Parse</span><span class="p">(</span><span class="nx">ansic</span><span class="p">,</span> <span class="s">&quot;8:41PM&quot;</span><span class="p">)</span>
+ <span class="nx">p</span><span class="p">(</span><span class="nx">e</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>There are several predefined formats that you can
+use for both formatting and parsing.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">p</span><span class="p">(</span><span class="nx">t</span><span class="p">.</span><span class="nx">Format</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Kitchen</span><span class="p">))</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run <span class="nb">time</span>-formatting-parsing.go
+<span class="go">2012-11-02T09:35:03-07:00</span>
+<span class="go">9:35AM</span>
+<span class="go">Fri Nov 2 09:35:03 2012</span>
+<span class="go">2012-11-02T09:35:03.982519-07:00</span>
+<span class="go">2012-11-02T09:35:03-00:00</span>
+<span class="go">0001-01-01 00:00:00 +0000 UTC</span>
+<span class="go">0000-01-01 20:41:00 +0000 UTC</span>
+<span class="go">parsing time &quot;8:41PM&quot; as &quot;Mon Jan _2 15:04:05 2006&quot;: ...</span>
+<span class="go">9:35AM</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="random-numbers">Random Numbers</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/time-formatting-parsing">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
182 public/timeouts
@@ -0,0 +1,182 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Timeouts</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="timeouts">
+ <h2><a href="./">Go by Example</a>: Timeouts</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><em>Timeouts</em> are important for programs that connect to
+external resources or that otherwise need to bound
+execution time. Implementing timeouts in Go is easy and
+elegant thanks to channels and <code>select</code>.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For our example, suppose we&rsquo;re executing an external
+call that returns its result on a channel <code>c1</code>
+after 2s.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">c1</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">)</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
+ <span class="nx">c1</span> <span class="o">&lt;-</span> <span class="s">&quot;result 1&quot;</span>
+ <span class="p">}()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s the <code>select</code> implementing a timeout.
+<code>res := &lt;-c1</code> awaits the result and <code>&lt;-Time.After</code>
+awaits a value to be sent after the timeout of
+1s. Since <code>select</code> proceeds with the first
+receive that&rsquo;s ready, we&rsquo;ll take the timeout case
+if the operation takes more than the allowed 1s.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">select</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="nx">res</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">c1</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">res</span><span class="p">)</span>
+ <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">time</span><span class="p">.</span><span class="nx">After</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span> <span class="o">*</span> <span class="mi">1</span><span class="p">):</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;timeout 1&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If we allow a longer timeout of 3s, then the receive
+from <code>c2</code> will succeed and we&rsquo;ll print the result.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">c2</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">string</span><span class="p">)</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
+ <span class="nx">c2</span> <span class="o">&lt;-</span> <span class="s">&quot;result 2&quot;</span>
+ <span class="p">}()</span>
+ <span class="k">select</span> <span class="p">{</span>
+ <span class="k">case</span> <span class="nx">res</span> <span class="o">:=</span> <span class="o">&lt;-</span><span class="nx">c2</span><span class="p">:</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">res</span><span class="p">)</span>
+ <span class="k">case</span> <span class="o">&lt;-</span><span class="nx">time</span><span class="p">.</span><span class="nx">After</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span> <span class="o">*</span> <span class="mi">3</span><span class="p">):</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;timeout 2&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running this program shows the first operation timing
+out and the second succeeding.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run timeouts.go
+<span class="go">timeout 1</span>
+<span class="go">result 2</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Using this <code>select</code> timeout pattern requires
+communicating results over channels. This is a good
+idea in general because other important Go features are
+based on channels and <code>select</code>. We&rsquo;ll look at two
+examples of this next: timers and tickers.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="non-blocking-channel-operations">Non-Blocking Channel Operations</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/timeouts">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
160 public/timers
@@ -0,0 +1,160 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Timers</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="timers">
+ <h2><a href="./">Go by Example</a>: Timers</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>We often want to execute Go code at some point in the
+future, or repeatedly at some interval. Go&rsquo;s built-in
+<em>timer</em> and <em>ticker</em> features make both of these tasks
+easy. We&rsquo;ll look first at timers and then
+at <a href="tickers">tickers</a>.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Timers represent a single event in the future. You
+tell the timer how long you want to wait, and it
+provides a channel that will be notified at that
+time. This timer will wait 2 seconds.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">timer1</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">NewTimer</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>&lt;-timer1.C</code> blocks on the timer&rsquo;s channel <code>C</code>
+until it sends a value indicating that the timer
+expired.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="o">&lt;-</span><span class="nx">timer1</span><span class="p">.</span><span class="nx">C</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Timer 1 expired&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If you just wanted to wait, you could have used
+<code>time.Sleep</code>. One reason a timer may be useful is
+that you can cancel the timer before it expires.
+Here&rsquo;s an example of that.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">timer2</span> <span class="o">:=</span> <span class="nx">time</span><span class="p">.</span><span class="nx">NewTimer</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span><span class="p">)</span>
+ <span class="k">go</span> <span class="kd">func</span><span class="p">()</span> <span class="p">{</span>
+ <span class="o">&lt;-</span><span class="nx">timer2</span><span class="p">.</span><span class="nx">C</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Timer 2 expired&quot;</span><span class="p">)</span>
+ <span class="p">}()</span>
+ <span class="nx">stop2</span> <span class="o">:=</span> <span class="nx">timer2</span><span class="p">.</span><span class="nx">Stop</span><span class="p">()</span>
+ <span class="k">if</span> <span class="nx">stop2</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;Timer 2 stopped&quot;</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>The first timer will expire ~2s after we start the
+program, but the second should be stopped before it has
+a chance to expire.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run timers.go
+<span class="go">Timer 1 expired</span>
+<span class="go">Timer 2 stopped</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="tickers">Tickers</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/timers">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
222 public/url-parsing
@@ -0,0 +1,222 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: URL Parsing</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="url-parsing">
+ <h2><a href="./">Go by Example</a>: URL Parsing</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>URLs provide a <a href="http://adam.heroku.com/past/2010/3/30/urls_are_the_uniform_way_to_locate_resources/">uniform way to locate resources</a>.
+Here&rsquo;s how to parse URLs in Go.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;net/url&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;strings&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>We&rsquo;ll parse this example URL, which includes a
+scheme, authentication info, host, port, path,
+query params, and query fragment.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">s</span> <span class="o">:=</span> <span class="s">&quot;postgres://user:pass@host.com:5432/path?k=v#f&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Parse the URL and ensure there are no errors.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">u</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">url</span><span class="p">.</span><span class="nx">Parse</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span>
+ <span class="k">if</span> <span class="nx">err</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Accessing the scheme is straightforward.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">u</span><span class="p">.</span><span class="nx">Scheme</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>User</code> contains all authentication info; call
+<code>Username</code> and <code>Password</code> on this for individual
+values.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">u</span><span class="p">.</span><span class="nx">User</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">u</span><span class="p">.</span><span class="nx">User</span><span class="p">.</span><span class="nx">Username</span><span class="p">())</span>
+ <span class="nx">p</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">u</span><span class="p">.</span><span class="nx">User</span><span class="p">.</span><span class="nx">Password</span><span class="p">()</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">p</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>Host</code> contains both the hostname and the port,
+if present. <code>Split</code> the <code>Host</code> manually to extract
+the port.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">u</span><span class="p">.</span><span class="nx">Host</span><span class="p">)</span>
+ <span class="nx">h</span> <span class="o">:=</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">Split</span><span class="p">(</span><span class="nx">u</span><span class="p">.</span><span class="nx">Host</span><span class="p">,</span> <span class="s">&quot;:&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">h</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">h</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we extract the <code>path</code> and the fragment after
+the <code>#</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">u</span><span class="p">.</span><span class="nx">Path</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">u</span><span class="p">.</span><span class="nx">Fragment</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To get query params in a string of <code>k=v</code> format,
+use <code>RawQuery</code>. You can also parse query params
+into a map. The parsed query param maps are from
+strings to slices of strings, so index into <code>[0]</code>
+if you only want the first value.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">u</span><span class="p">.</span><span class="nx">RawQuery</span><span class="p">)</span>
+ <span class="nx">m</span><span class="p">,</span> <span class="nx">_</span> <span class="o">:=</span> <span class="nx">url</span><span class="p">.</span><span class="nx">ParseQuery</span><span class="p">(</span><span class="nx">u</span><span class="p">.</span><span class="nx">RawQuery</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">m</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">m</span><span class="p">[</span><span class="s">&quot;k&quot;</span><span class="p">][</span><span class="mi">0</span><span class="p">])</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Running our URL parsing program shows all the different
+pieces that we extracted.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run url-parsing.go
+<span class="go">postgres</span>
+<span class="go">user:pass</span>
+<span class="go">user</span>
+<span class="go">pass</span>
+<span class="go">host.com:5432</span>
+<span class="go">host.com</span>
+<span class="go">5432</span>
+<span class="go">/path</span>
+<span class="go">f</span>
+<span class="go">k=v</span>
+<span class="go">map[k:[v]]</span>
+<span class="go">v</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="sha1-hashes">SHA1 Hashes</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/url-parsing">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
144 public/values
@@ -0,0 +1,144 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Values</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="values">
+ <h2><a href="./">Go by Example</a>: Values</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Go has various value types including strings,
+integers, floats, booleans, etc. Here are a few
+basic examples.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Strings, which can be added together with <code>+</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;go&quot;</span> <span class="o">+</span> <span class="s">&quot;lang&quot;</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Integers and floats.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;1+1 =&quot;</span><span class="p">,</span> <span class="mi">1</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;7.0/3.0 =&quot;</span><span class="p">,</span> <span class="mf">7.0</span><span class="o">/</span><span class="mf">3.0</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Booleans, with boolean operators as you&rsquo;d expect.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="kc">true</span> <span class="o">&amp;&amp;</span> <span class="kc">false</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="kc">true</span> <span class="o">||</span> <span class="kc">false</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(!</span><span class="kc">true</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run values.go
+<span class="go">golang</span>
+<span class="go">1+1 = 2</span>
+<span class="go">7.0/3.0 = 2.3333333333333335</span>
+<span class="go">false</span>
+<span class="go">true</span>
+<span class="go">false</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="variables">Variables</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/values">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
173 public/variables
@@ -0,0 +1,173 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Variables</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="variables">
+ <h2><a href="./">Go by Example</a>: Variables</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>In Go, <em>variables</em> are explicitly declared and used by
+the compiler to e.g. check type-correctness of function
+calls.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>var</code> declares 1 or more variables.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">a</span> <span class="kt">string</span> <span class="p">=</span> <span class="s">&quot;initial&quot;</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">a</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can declare multiple variables at once.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">b</span><span class="p">,</span> <span class="nx">c</span> <span class="kt">int</span> <span class="p">=</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">b</span><span class="p">,</span> <span class="nx">c</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Go will infer the type of initialized variables.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">d</span> <span class="p">=</span> <span class="kc">true</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">d</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Variables declared without a corresponding
+initialization are <em>zero-valued</em>. For example, the
+zero value for an <code>int</code> is <code>0</code>.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="kd">var</span> <span class="nx">e</span> <span class="kt">int</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">e</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>The <code>:=</code> syntax is shorthand for declaring and
+initializing a variable, e.g. for
+<code>var f string = &quot;short&quot;</code> in this case.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">f</span> <span class="o">:=</span> <span class="s">&quot;short&quot;</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">f</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="gp">$</span> go run variables.go
+<span class="go">initial</span>
+<span class="go">1 2</span>
+<span class="go">true</span>
+<span class="go">0</span>
+<span class="go">short</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="constants">Constants</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/variables">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
163 public/variadic-functions
@@ -0,0 +1,163 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Variadic Functions</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="variadic-functions">
+ <h2><a href="./">Go by Example</a>: Variadic Functions</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p><a href="http://en.wikipedia.org/wiki/Variadic_function"><em>Variadic functions</em></a>
+can be called with any number of trailing arguments.
+For example, <code>fmt.Println</code> is a common variadic
+function.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s a function that will take an arbitrary number
+of <code>ints</code> as arguments.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">sum</span><span class="p">(</span><span class="nx">nums</span> <span class="o">...</span><span class="kt">int</span><span class="p">)</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Print</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="s">&quot; &quot;</span><span class="p">)</span>
+ <span class="nx">total</span> <span class="o">:=</span> <span class="mi">0</span>
+ <span class="k">for</span> <span class="nx">_</span><span class="p">,</span> <span class="nx">num</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">nums</span> <span class="p">{</span>
+ <span class="nx">total</span> <span class="o">+=</span> <span class="nx">num</span>
+ <span class="p">}</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="nx">total</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Variadic functions can be called in the usual way
+with individual arguments.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">sum</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
+ <span class="nx">sum</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>If you already have multiple args in a slice,
+apply them to a variadic function using
+<code>func(slice...)</code> like this.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="nx">nums</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">int</span><span class="p">{</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">}</span>
+ <span class="nx">sum</span><span class="p">(</span><span class="nx">nums</span><span class="o">...</span><span class="p">)</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run variadic-functions.go
+<span class="go">[1 2] 3</span>
+<span class="go">[1 2 3] 6</span>
+<span class="go">[1 2 3 4] 10</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Another key aspect of functions in Go is their ability
+to form closures, which we&rsquo;ll look at next.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="closures">Closures</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/variadic-functions">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
205 public/worker-pools
@@ -0,0 +1,205 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Worker Pools</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="worker-pools">
+ <h2><a href="./">Go by Example</a>: Worker Pools</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>In this example we&rsquo;ll look at how to implement
+a <em>worker pool</em> using goroutines and channels.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="s">&quot;fmt&quot;</span>
+<span class="kn">import</span> <span class="s">&quot;time&quot;</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here&rsquo;s the worker, of which we&rsquo;ll run several
+concurrent instances. These workers will receive
+work on the <code>jobs</code> channel and send the corresponding
+results on <code>results</code>. We&rsquo;ll sleep a second per job to
+simulate an expensive task.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">worker</span><span class="p">(</span><span class="nx">id</span> <span class="kt">int</span><span class="p">,</span> <span class="nx">jobs</span> <span class="o">&lt;-</span><span class="kd">chan</span> <span class="kt">int</span><span class="p">,</span> <span class="nx">results</span> <span class="kd">chan</span><span class="o">&lt;-</span> <span class="kt">int</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="k">range</span> <span class="nx">jobs</span> <span class="p">{</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Println</span><span class="p">(</span><span class="s">&quot;worker&quot;</span><span class="p">,</span> <span class="nx">id</span><span class="p">,</span> <span class="s">&quot;processing job&quot;</span><span class="p">,</span> <span class="nx">j</span><span class="p">)</span>
+ <span class="nx">time</span><span class="p">.</span><span class="nx">Sleep</span><span class="p">(</span><span class="nx">time</span><span class="p">.</span><span class="nx">Second</span><span class="p">)</span>
+ <span class="nx">results</span> <span class="o">&lt;-</span> <span class="nx">j</span> <span class="o">*</span> <span class="mi">2</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>In order to use our pool of workers we need to send
+them work and collect their results. We make 2
+channels for this.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">jobs</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">int</span><span class="p">,</span> <span class="mi">100</span><span class="p">)</span>
+ <span class="nx">results</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">(</span><span class="kd">chan</span> <span class="kt">int</span><span class="p">,</span> <span class="mi">100</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>This starts up 3 workers, initially blocked
+because there are no jobs yet.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">w</span> <span class="o">:=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">w</span> <span class="o">&lt;=</span> <span class="mi">3</span><span class="p">;</span> <span class="nx">w</span><span class="o">++</span> <span class="p">{</span>
+ <span class="k">go</span> <span class="nx">worker</span><span class="p">(</span><span class="nx">w</span><span class="p">,</span> <span class="nx">jobs</span><span class="p">,</span> <span class="nx">results</span><span class="p">)</span>
+ <span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Here we send 9 <code>jobs</code> and then <code>close</code> that
+channel to indicate that&rsquo;s all the work we have.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">j</span> <span class="o">:=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;=</span> <span class="mi">9</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span> <span class="p">{</span>
+ <span class="nx">jobs</span> <span class="o">&lt;-</span> <span class="nx">j</span>
+ <span class="p">}</span>
+ <span class="nb">close</span><span class="p">(</span><span class="nx">jobs</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Finally we collect all the results of the work.</p>
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre> <span class="k">for</span> <span class="nx">a</span> <span class="o">:=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">a</span> <span class="o">&lt;=</span> <span class="mi">9</span><span class="p">;</span> <span class="nx">a</span><span class="o">++</span> <span class="p">{</span>
+ <span class="o">&lt;-</span><span class="nx">results</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Our running program shows the 9 jobs being executed by
+various workers. The program only takes about 3 seconds
+despite doing about 9 seconds of total work because
+there are 3 workers operating concurrently.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> <span class="nb">time </span>go run worker-pools.go
+<span class="go">worker 1 processing job 1</span>
+<span class="go">worker 2 processing job 2</span>
+<span class="go">worker 3 processing job 3</span>
+<span class="go">worker 1 processing job 4</span>
+<span class="go">worker 2 processing job 5</span>
+<span class="go">worker 3 processing job 6</span>
+<span class="go">worker 1 processing job 7</span>
+<span class="go">worker 2 processing job 8</span>
+<span class="go">worker 3 processing job 9</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="go">real 0m3.149s</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="rate-limiting">Rate Limiting</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/worker-pools">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
270 public/writing-files
@@ -0,0 +1,270 @@
+<!DOCTYPE html>
+<html>
+ <head>
+ <meta http-eqiv="content-type" content="text/html;charset=utf-8">
+ <title>Go by Example: Writing Files</title>
+ <link rel=stylesheet href="site.css">
+ </head>
+ <script type="text/javascript">
+ if (window.location.host == "gobyexample.com") {
+ var _gaq = _gaq || [];
+ _gaq.push(['_setAccount', 'UA-34996217-1']);
+ _gaq.push(['_trackPageview']);
+ (function() {
+ var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
+ ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
+ var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
+ })();
+ }
+ </script>
+ <body>
+ <div class="example" id="writing-files">
+ <h2><a href="./">Go by Example</a>: Writing Files</h2>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Writing files in Go follows similar patterns to the
+ones we saw earlier for reading.</p>
+
+ </td>
+ <td class="code empty leading">
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">package</span> <span class="nx">main</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kn">import</span> <span class="p">(</span>
+ <span class="s">&quot;bufio&quot;</span>
+ <span class="s">&quot;fmt&quot;</span>
+ <span class="s">&quot;io/ioutil&quot;</span>
+ <span class="s">&quot;os&quot;</span>
+<span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">check</span><span class="p">(</span><span class="nx">e</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
+ <span class="k">if</span> <span class="nx">e</span> <span class="o">!=</span> <span class="kc">nil</span> <span class="p">{</span>
+ <span class="nb">panic</span><span class="p">(</span><span class="nx">e</span><span class="p">)</span>
+ <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="kd">func</span> <span class="nx">main</span><span class="p">()</span> <span class="p">{</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>To start, here&rsquo;s how to dump a string (or just
+bytes) into a file.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">d1</span> <span class="o">:=</span> <span class="p">[]</span><span class="nb">byte</span><span class="p">(</span><span class="s">&quot;hello\ngo\n&quot;</span><span class="p">)</span>
+ <span class="nx">err</span> <span class="o">:=</span> <span class="nx">ioutil</span><span class="p">.</span><span class="nx">WriteFile</span><span class="p">(</span><span class="s">&quot;/tmp/dat1&quot;</span><span class="p">,</span> <span class="nx">d1</span><span class="p">,</span> <span class="mo">0644</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>For more granular writes, open a file for writing.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">f</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">os</span><span class="p">.</span><span class="nx">Create</span><span class="p">(</span><span class="s">&quot;/tmp/dat2&quot;</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>It&rsquo;s idiomatic to defer a <code>Close</code> immediately
+after opening a file.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="k">defer</span> <span class="nx">f</span><span class="p">.</span><span class="nx">Close</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>You can <code>Write</code> byte slices as you&rsquo;d expect.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">d2</span> <span class="o">:=</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">{</span><span class="mi">115</span><span class="p">,</span> <span class="mi">111</span><span class="p">,</span> <span class="mi">109</span><span class="p">,</span> <span class="mi">101</span><span class="p">,</span> <span class="mi">10</span><span class="p">}</span>
+ <span class="nx">n2</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">f</span><span class="p">.</span><span class="nx">Write</span><span class="p">(</span><span class="nx">d2</span><span class="p">)</span>
+ <span class="nx">check</span><span class="p">(</span><span class="nx">err</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;wrote %d bytes\n&quot;</span><span class="p">,</span> <span class="nx">n2</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>A <code>WriteString</code> is also available.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">n3</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">f</span><span class="p">.</span><span class="nx">WriteString</span><span class="p">(</span><span class="s">&quot;writes\n&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;wrote %d bytes\n&quot;</span><span class="p">,</span> <span class="nx">n3</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Issue a <code>Sync</code> to flush writes to stable storage.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">f</span><span class="p">.</span><span class="nx">Sync</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p><code>bufio</code> provides buffered writers in addition
+to the buffered readers we saw earlier.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">w</span> <span class="o">:=</span> <span class="nx">bufio</span><span class="p">.</span><span class="nx">NewWriter</span><span class="p">(</span><span class="nx">f</span><span class="p">)</span>
+ <span class="nx">n4</span><span class="p">,</span> <span class="nx">err</span> <span class="o">:=</span> <span class="nx">w</span><span class="p">.</span><span class="nx">WriteString</span><span class="p">(</span><span class="s">&quot;buffered\n&quot;</span><span class="p">)</span>
+ <span class="nx">fmt</span><span class="p">.</span><span class="nx">Printf</span><span class="p">(</span><span class="s">&quot;wrote %d bytes\n&quot;</span><span class="p">,</span> <span class="nx">n4</span><span class="p">)</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Use <code>Flush</code> to ensure all buffered operations have
+been applied to the underlying writer.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre> <span class="nx">w</span><span class="p">.</span><span class="nx">Flush</span><span class="p">()</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+
+ </td>
+ <td class="code">
+ <div class="highlight"><pre><span class="p">}</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ </table>
+
+ <table>
+
+ <tr>
+ <td class="docs">
+ <p>Try running the file-writing code.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> go run writing-files.go
+<span class="go">wrote 5 bytes</span>
+<span class="go">wrote 7 bytes</span>
+<span class="go">wrote 9 bytes</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Then check the contents of the written files.</p>
+
+ </td>
+ <td class="code leading">
+ <div class="highlight"><pre><span class="gp">$</span> cat /tmp/dat1
+<span class="go">hello</span>
+<span class="go">go</span>
+<span class="gp">$</span> cat /tmp/dat2
+<span class="go">some</span>
+<span class="go">writes</span>
+<span class="go">buffered</span>
+</pre></div>
+
+ </td>
+ </tr>
+
+ <tr>
+ <td class="docs">
+ <p>Next we&rsquo;ll look at applying some of the file I/O ideas
+we&rsquo;ve just seen to the <code>stdin</code> and <code>stdout</code> streams.</p>
+
+ </td>
+ <td class="code empty">
+
+ </td>
+ </tr>
+
+ </table>
+
+
+ <p class="next">
+ Next example: <a href="line-filters">Line Filters</a>.
+ </p>
+
+ <p class="footer">
+ <a href="https://twitter.com/gobyexample">@gobyexample</a> | <a href="mailto:mmcgrana@gmail.com">feedback</a> | <a href="https://github.com/mmcgrana/gobyexample/blob/master/examples/writing-files">source</a> | <a href="https://github.com/mmcgrana/gobyexample#license">license</a>
+ </p>
+ </div>
+ </body>
+</html>
View
207 server.go
@@ -0,0 +1,207 @@
+package main
+
+import (
+ "code.google.com/p/gorilla/mux"
+ "encoding/base64"
+ "fmt"
+ "io/ioutil"
+ "net"
+ "net/http"
+ "os"
+ "os/signal"
+ "strings"
+ "sync/atomic"
+ "syscall"
+ "time"
+)
+
+func check(err error) {
+ if err != nil {
+ panic(err)
+ }
+}
+
+func config(k string) string {
+ v := os.Getenv(k)
+ if v == "" {
+ panic("missing " + k)
+ }
+ return v
+}
+
+func runLogging(logs chan string) {
+ for log := range logs {
+ fmt.Println(log)
+ }
+}
+
+func wrapLogging(f http.HandlerFunc, logs chan string) http.HandlerFunc {
+ return func(res http.ResponseWriter, req *http.Request) {
+ start := time.Now()
+ f(res, req)
+ method := req.Method
+ path := req.URL.Path
+ elapsed := float64(time.Since(start)) / 1000000.0
+ logs <- fmt.Sprintf("request at=finish method=%s path=%s elapsed=%f", method, path, elapsed)
+ }
+}
+
+func wrapCanonicalHost(f http.HandlerFunc, canonicalHost string, forceHttps bool) http.HandlerFunc {
+ return func(res http.ResponseWriter, req *http.Request) {
+ scheme := "http"
+ if h, ok := req.Header["X-Forwarded-Proto"]; ok {
+ if h[0] == "https" {
+ scheme = "https"
+ }
+ }
+
+ hostPort := strings.Split(req.Host, ":")
+ host := hostPort[0]
+
+ if (forceHttps && (scheme != "https")) || host != canonicalHost {
+ if forceHttps {
+ scheme = "https"
+ }
+ hostPort[0] = canonicalHost
+ url := scheme + "://" + strings.Join(hostPort, ":") + req.URL.String()
+ http.Redirect(res, req, url, 301)
+ return
+ }
+
+ f(res, req)
+ }
+}
+
+type Authenticator func(string, string) bool
+
+func testAuth(r *http.Request, auth Authenticator) bool {
+ s := strings.SplitN(r.Header.Get("Authorization"), " ", 2)
+ if len(s) != 2 || s[0] != "Basic" {
+ return false
+ }
+ b, err := base64.StdEncoding.DecodeString(s[1])
+ if err != nil {
+ return false
+ }
+ pair := strings.SplitN(string(b), ":", 2)
+ if len(pair) != 2 {
+ return false
+ }
+ return auth(pair[0], pair[1])
+}
+
+func requireAuth(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("WWW-Authenticate", `Basic realm="private"`)
+ w.WriteHeader(401)
+ w.Write([]byte("401 Unauthorized\n"))
+}
+
+func wrapAuth(h http.HandlerFunc, a Authenticator) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ if testAuth(r, a) {
+ h(w, r)
+ } else {
+ requireAuth(w, r)
+ }
+ }
+}
+
+var reqCount int64 = 0
+
+func wrapReqCount(h http.HandlerFunc, reqCountPtr *int64) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ atomic.AddInt64(reqCountPtr, 1)
+ h(w, r)
+ atomic.AddInt64(reqCountPtr, -1)
+ }
+}
+
+func static(res http.ResponseWriter, req *http.Request) {
+ http.ServeFile(res, req, "public"+req.URL.Path)
+}
+
+func notFound(res http.ResponseWriter, req *http.Request) {
+ http.ServeFile(res, req, "public/404.html")
+}
+
+func checkAuth(user, pass string) bool {
+ auth := os.Getenv("AUTH")
+ if auth == "" {
+ return true
+ }
+ return auth == strings.Join([]string{user, pass}, ":")
+}
+
+func routerHandlerFunc(router *mux.Router) http.HandlerFunc {
+ return func(res http.ResponseWriter, req *http.Request) {
+ router.ServeHTTP(res, req)
+ }
+}
+
+func router() *mux.Router {
+ router := mux.NewRouter()
+ router.HandleFunc("/", static).Methods("GET")
+ router.HandleFunc("/favicon.ico", static).Methods("GET")
+ router.HandleFunc("/site.css", static).Methods("GET")
+ entries, err := ioutil.ReadDir("public")
+ check(err)
+ for _, f := range entries {
+ if !strings.Contains(f.Name(), ".") {
+ router.HandleFunc("/" + f.Name(), static).Methods("GET")
+ }
+ }
+ router.NotFoundHandler = http.HandlerFunc(notFound)
+ return router
+}
+
+func main() {
+ logs := make(chan string, 10000)
+ go runLogging(logs)
+
+ handler := routerHandlerFunc(router())
+ if os.Getenv("AUTH") != "" {
+ handler = wrapAuth(handler, checkAuth)
+ }
+ handler = wrapCanonicalHost(handler, config("CANONICAL_HOST"), config("FORCE_HTTPS") == "1")
+ handler = wrapLogging(handler, logs)
+ handler = wrapReqCount(handler, &reqCount)
+
+ server := &http.Server{Handler: handler}
+ listener, listenErr := net.Listen("tcp", ":"+config("PORT"))
+ if listenErr != nil {
+ panic(listenErr)
+ }
+
+ stop := make(chan bool, 1)
+ sig := make(chan os.Signal, 1)
+ go func() {
+ signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
+ logs <- "trap at=start"
+ <-sig
+ for {
+ reqCountCurrent := atomic.LoadInt64(&reqCount)
+ if reqCountCurrent > 0 {
+ logs <- fmt.Sprintf("trap at=draining remaining=%d", reqCountCurrent)
+ time.Sleep(time.Second)
+ } else {
+ logs <- fmt.Sprintf("trap at=finish")
+ stop <- true
+ return
+ }
+ }
+ }()
+
+ go func() {
+ logs <- "serve at=start"
+ server.Serve(listener)
+ logs <- "serve at=finish"
+ }()
+
+ <-stop
+ logs <- "close at=start"
+ closeErr := listener.Close()
+ if closeErr != nil {
+ panic(closeErr)
+ }
+ logs <- "close at=finish"
+}
View
13 tools/generate.go
@@ -14,7 +14,7 @@ import (
)
var cacheDir = "/tmp/gobyexample-cache"
-var siteDir = ""
+var siteDir = "./public"
var pygmentizeBin = ""
func check(err error) {
@@ -106,15 +106,6 @@ func whichLexer(path string) string {
return ""
}
-func whichSiteDir() {
- dir := os.Getenv("SITEDIR")
- if dir != "" {
- siteDir = dir
- } else {
- siteDir = "site"
- }
-}
-
func whichPygmentize() {
bin, err := exec.LookPath("pygmentize")
check(err)
@@ -254,9 +245,7 @@ func renderExamples(examples []*Example) {
}
func main() {
- whichSiteDir()
whichPygmentize()
- ensureDir(siteDir)
copyFile("templates/site.css", siteDir+"/site.css")
copyFile("templates/favicon.ico", siteDir+"/favicon.ico")
copyFile("templates/404.html", siteDir+"/404.html")

0 comments on commit 72b2276

Please sign in to comment.