{% include_relative test_{{ include.example }}.go.escaped %}$ go run test_{{include.example}}.go\n{% include_relative test_{{ include.example }}.expected.escaped %}\n {{ page.question }}\n
\n\n{{ content }}\n\n" }, { "path": "bin/server", "content": "#!/usr/bin/env bash\n\nset -eou pipefail\n\nbundle exec jekyll serve -H 0.0.0.0 -wDP \"$PORT\" -l --livereload-port \"$LRPORT\" -t\n" }, { "path": "bin/tests", "content": "#!/usr/bin/env bash\n\nTEST_OUTPUT=/tmp/test_output.$$\n\nprint_success() { echo -n .; }\nprint_failure() { echo -n x; }\nprint_pending() { echo -n p; }\nprint_output() { echo; cat $TEST_OUTPUT/*; }\nrun_test() { diff <( go run \"$1\" 2>&1) \"$2\" > /dev/null; }\n\nrecord_failure() {\n {\n echo \"Failed: $1\"\n echo \" To reset, run:\"\n echo \" rm $2\"\n diff -yW200 <( go run \"$1\" 2>&1) \"$2\"\n echo \"------------------------\"\n echo\n } >> \"$TEST_OUTPUT/${1//\\//_}.out\"\n}\n\ngenerate_expected() {\n echo\n echo \"$2 not found - generating it...\"\n go run \"$1\" > \"$2\"\n}\n\ngenerate_escaped() {\n sed 's/&(?!amp;)/\\&/g; s//\\>/g; s/\"/\\"/g; s/'\"'\"'/\\'/g' < \"$1\" > \"$1.escaped\"\n}\n\nprocess_file() {\n file=$1\n expected=${file/.go/.expected}\n\n if [ -s \"$file\" ]; then\n if [ -f \"$expected\" ]; then\n if run_test \"$file\" \"$expected\"; then\n print_success\n else\n record_failure \"$file\" \"$expected\"\n print_failure\n fi\n else\n generate_expected \"$file\" \"$expected\"\n fi\n else\n print_pending\n fi\n generate_escaped \"$expected\"\n generate_escaped \"$file\"\n}\n\nmain() {\n mkdir $TEST_OUTPUT\n touch $TEST_OUTPUT/cat_on_empty_dir_hangs\n\n if [[ \"$#\" -gt 0 ]]; then\n shopt -s nullglob\n files=( \"$@\" )\n else\n readarray -t files < <(find chapters -name \"test*.go\")\n fi\n\n echo \"Running tests for ${files[*]}\"\n\n for file in \"${files[@]}\"; do\n process_file \"$file\" &\n done\n\n wait\n\n print_output\n\n rm -rf $TEST_OUTPUT\n}\n\nmain \"$@\"\n" }, { "path": "chapters/arrays/reverse/index.md", "content": "---\ntitle: Reversing an Array\nquestion: How do I reverse an array?\n---\n\nReversing an array is fairly straightforward in Go, due to multiple return\nvalues. Simply loop through the first half of the array, swapping each element\nin turn with its mirror counterpart:\n\n{%include example.html example=\"simple\"%}\n\nThere's an even more terse implementation which makes use of the `,` operator\ninside the Go for loop:\n\n{%include example.html example=\"terse\"%}\n\nNote that both of these `reverse` functions take slices, which are passed by\nvalue. This is good for performance, but means we're actually modifying the\npassed in array, leading to unexpected results. In other words, the `reverse`\nmethod could be written like such:\n\n{%include example.html example=\"alternate\"%}\n\nNow `reverse` doesn't return another reference to the slice, which makes it\nmuch more clear that it's modifying the slice in-place. If we want to return a\nmodified copy of the slice, we must do so manually:\n\n{%include example.html example=\"copy\"%}\n\nAs you can see in the output above, the original array is untouched.\n\nSince we're not modifying the array in-place, we can also simplify our\nalgorithm buy doing a more straight-forward element copy:\n\n{%include example.html example=\"copy_simple\"%}\n\n" }, { "path": "chapters/arrays/reverse/test_alternate.expected", "content": "[5 4 3 2 1]\n" }, { "path": "chapters/arrays/reverse/test_alternate.expected.escaped", "content": "[5 4 3 2 1]\n" }, { "path": "chapters/arrays/reverse/test_alternate.go", "content": "package main\n\nimport \"fmt\"\n\nfunc reverse(numbers []int) {\n\tfor i, j := 0, len(numbers)-1; i < j; i, j = i+1, j-1 {\n\t\tnumbers[i], numbers[j] = numbers[j], numbers[i]\n\t}\n}\n\nfunc main() {\n\tarray := []int{1, 2, 3, 4, 5}\n\treverse(array)\n\n\tfmt.Printf(\"%v\\n\", array)\n}\n" }, { "path": "chapters/arrays/reverse/test_alternate.go.escaped", "content": "package main\n\nimport "fmt"\n\nfunc reverse(numbers []int) {\n\tfor i, j := 0, len(numbers)-1; i < j; i, j = i+1, j-1 {\n\t\tnumbers[i], numbers[j] = numbers[j], numbers[i]\n\t}\n}\n\nfunc main() {\n\tarray := []int{1, 2, 3, 4, 5}\n\treverse(array)\n\n\tfmt.Printf("%v\\n", array)\n}\n" }, { "path": "chapters/arrays/reverse/test_copy.expected", "content": "[5 4 3 2 1]\n[1 2 3 4 5]\n" }, { "path": "chapters/arrays/reverse/test_copy.expected.escaped", "content": "[5 4 3 2 1]\n[1 2 3 4 5]\n" }, { "path": "chapters/arrays/reverse/test_copy.go", "content": "package main\n\nimport \"fmt\"\n\nfunc reverse(numbers []int) []int {\n\tnewNumbers := make([]int, len(numbers))\n\tfor i, j := 0, len(numbers)-1; i <= j; i, j = i+1, j-1 {\n\t\tnewNumbers[i], newNumbers[j] = numbers[j], numbers[i]\n\t}\n\treturn newNumbers\n}\n\nfunc main() {\n\tarray := []int{1, 2, 3, 4, 5}\n\n\tfmt.Printf(\"%v\\n\", reverse(array))\n\tfmt.Printf(\"%v\\n\", array)\n}\n" }, { "path": "chapters/arrays/reverse/test_copy.go.escaped", "content": "package main\n\nimport "fmt"\n\nfunc reverse(numbers []int) []int {\n\tnewNumbers := make([]int, len(numbers))\n\tfor i, j := 0, len(numbers)-1; i <= j; i, j = i+1, j-1 {\n\t\tnewNumbers[i], newNumbers[j] = numbers[j], numbers[i]\n\t}\n\treturn newNumbers\n}\n\nfunc main() {\n\tarray := []int{1, 2, 3, 4, 5}\n\n\tfmt.Printf("%v\\n", reverse(array))\n\tfmt.Printf("%v\\n", array)\n}\n" }, { "path": "chapters/arrays/reverse/test_copy_simple.expected", "content": "[5 4 3 2 1]\n[1 2 3 4 5]\n" }, { "path": "chapters/arrays/reverse/test_copy_simple.expected.escaped", "content": "[5 4 3 2 1]\n[1 2 3 4 5]\n" }, { "path": "chapters/arrays/reverse/test_copy_simple.go", "content": "package main\n\nimport \"fmt\"\n\nfunc reverse(numbers []int) []int {\n\tnewNumbers := make([]int, 0, len(numbers))\n\tfor i := len(numbers)-1; i >= 0; i-- {\n\t\tnewNumbers = append(newNumbers, numbers[i])\n\t}\n\treturn newNumbers\n}\n\nfunc main() {\n\tarray := []int{1, 2, 3, 4, 5}\n\n\tfmt.Printf(\"%v\\n\", reverse(array))\n\tfmt.Printf(\"%v\\n\", array)\n}\n" }, { "path": "chapters/arrays/reverse/test_copy_simple.go.escaped", "content": "package main\n\nimport "fmt"\n\nfunc reverse(numbers []int) []int {\n\tnewNumbers := make([]int, 0, len(numbers))\n\tfor i := len(numbers)-1; i >= 0; i-- {\n\t\tnewNumbers = append(newNumbers, numbers[i])\n\t}\n\treturn newNumbers\n}\n\nfunc main() {\n\tarray := []int{1, 2, 3, 4, 5}\n\n\tfmt.Printf("%v\\n", reverse(array))\n\tfmt.Printf("%v\\n", array)\n}\n" }, { "path": "chapters/arrays/reverse/test_simple.expected", "content": "[5 4 3 2 1]\n[4 3 2 1]\n" }, { "path": "chapters/arrays/reverse/test_simple.expected.escaped", "content": "[5 4 3 2 1]\n[4 3 2 1]\n" }, { "path": "chapters/arrays/reverse/test_simple.go", "content": "package main\n\nimport \"fmt\"\n\nfunc reverse(numbers []int) []int {\n\tfor i := 0; i < len(numbers)/2; i++ {\n\t\tj := len(numbers) - i - 1\n\t\tnumbers[i], numbers[j] = numbers[j], numbers[i]\n\t}\n\treturn numbers\n}\n\nfunc main() {\n\tfmt.Printf(\"%v\\n\", reverse([]int{1, 2, 3, 4, 5}))\n\tfmt.Printf(\"%v\\n\", reverse([]int{1, 2, 3, 4}))\n}\n" }, { "path": "chapters/arrays/reverse/test_simple.go.escaped", "content": "package main\n\nimport "fmt"\n\nfunc reverse(numbers []int) []int {\n\tfor i := 0; i < len(numbers)/2; i++ {\n\t\tj := len(numbers) - i - 1\n\t\tnumbers[i], numbers[j] = numbers[j], numbers[i]\n\t}\n\treturn numbers\n}\n\nfunc main() {\n\tfmt.Printf("%v\\n", reverse([]int{1, 2, 3, 4, 5}))\n\tfmt.Printf("%v\\n", reverse([]int{1, 2, 3, 4}))\n}\n" }, { "path": "chapters/arrays/reverse/test_terse.expected", "content": "[5 4 3 2 1]\n[4 3 2 1]\n" }, { "path": "chapters/arrays/reverse/test_terse.expected.escaped", "content": "[5 4 3 2 1]\n[4 3 2 1]\n" }, { "path": "chapters/arrays/reverse/test_terse.go", "content": "package main\n\nimport \"fmt\"\n\nfunc reverse(numbers []int) []int {\n\tfor i, j := 0, len(numbers)-1; i < j; i, j = i+1, j-1 {\n\t\tnumbers[i], numbers[j] = numbers[j], numbers[i]\n\t}\n\treturn numbers\n}\n\nfunc main() {\n\tfmt.Printf(\"%v\\n\", reverse([]int{1, 2, 3, 4, 5}))\n\tfmt.Printf(\"%v\\n\", reverse([]int{1, 2, 3, 4}))\n}\n" }, { "path": "chapters/arrays/reverse/test_terse.go.escaped", "content": "package main\n\nimport "fmt"\n\nfunc reverse(numbers []int) []int {\n\tfor i, j := 0, len(numbers)-1; i < j; i, j = i+1, j-1 {\n\t\tnumbers[i], numbers[j] = numbers[j], numbers[i]\n\t}\n\treturn numbers\n}\n\nfunc main() {\n\tfmt.Printf("%v\\n", reverse([]int{1, 2, 3, 4, 5}))\n\tfmt.Printf("%v\\n", reverse([]int{1, 2, 3, 4}))\n}\n" }, { "path": "chapters/files/read-write/index.md", "content": "---\ntitle: Reading and Writing to Files \nquestion: How do I read from and write to a file?\n---\n\nhttp://stackoverflow.com/questions/1821811/how-to-read-write-from-to-file\n\nhttp://stackoverflow.com/a/16615559/2620448\n" }, { "path": "chapters/maps/presence/index.md", "content": "---\ntitle: Testing for the Presence of a Key in a Map\nquestion: How do I determine if a map contains a given key?\n---\n\nhttp://stackoverflow.com/questions/2050391/how-to-check-if-a-map-contains-a-key-in-go\n" }, { "path": "chapters/numbers/enums/index.md", "content": "---\ntitle: Representing Enums\nquestion: How do I represent enumerated constants in Go?\n---\n\nhttp://stackoverflow.com/questions/14426366/what-is-an-idiomatic-way-of-representing-enums-in-golang\n\nhttp://stackoverflow.com/a/1721367\n" }, { "path": "chapters/numbers/string_to_num/index.md", "content": "---\ntitle: Converting a string to number\nquestion: How do I convert a string to number if possible in Go?\n---\n\nGo comes with a core package called `strconv` which makes this task very\neasy. You can convert a string to an integer and specify a base as well. You\nalso have the flexibility to define the size of bits into which the number\nshould fit into.\n\n{% include example.html example=\"string_to_int\" %}\n\nThe `strconv` package also contains functions such as `ParseUint` and\n`ParseFloat` which convert a string to unsigned integer and floating point\nnumbers respectively.\n\n{% include example.html example=\"string_to_float\" %}\n" }, { "path": "chapters/numbers/string_to_num/test_string_to_float.expected", "content": "float64 123.123000\n" }, { "path": "chapters/numbers/string_to_num/test_string_to_float.expected.escaped", "content": "float64 123.123000\n" }, { "path": "chapters/numbers/string_to_num/test_string_to_float.go", "content": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"strconv\"\n)\n\nfunc main() {\n\tstr := \"123.123\"\n\t/*\n\t\tThe first argument to ParseInt is the string to be converted.\n\t\tThe second argument is the number of bits to which the number should fit.\n\t*/\n\ti, err := strconv.ParseFloat(str, 64)\n\tif err != nil {\n\t\tfmt.Println(err)\n\t\tos.Exit(1)\n\t}\n\tfmt.Printf(\"%T %f\\n\", i, i)\n}\n" }, { "path": "chapters/numbers/string_to_num/test_string_to_float.go.escaped", "content": "package main\n\nimport (\n\t"fmt"\n\t"os"\n\t"strconv"\n)\n\nfunc main() {\n\tstr := "123.123"\n\t/*\n\t\tThe first argument to ParseInt is the string to be converted.\n\t\tThe second argument is the number of bits to which the number should fit.\n\t*/\n\ti, err := strconv.ParseFloat(str, 64)\n\tif err != nil {\n\t\tfmt.Println(err)\n\t\tos.Exit(1)\n\t}\n\tfmt.Printf("%T %f\\n", i, i)\n}\n" }, { "path": "chapters/numbers/string_to_num/test_string_to_int.expected", "content": "int64 123\nstrconv.ParseInt: parsing \"invalidString123\": invalid syntax\n" }, { "path": "chapters/numbers/string_to_num/test_string_to_int.expected.escaped", "content": "int64 123\nstrconv.ParseInt: parsing "invalidString123": invalid syntax\n" }, { "path": "chapters/numbers/string_to_num/test_string_to_int.go", "content": "package main\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n)\n\nfunc handleError(err error) {\n\tif err != nil {\n\t\tfmt.Println(err)\n\t}\n}\n\nfunc main() {\n\tstr := \"123\"\n\t/*\n\t\tThe first argument to ParseInt is the string to be converted.\n\t\tThe second argument is the base to which the number is to be converted.\n\t\tThe third argument is the number of bits to which the number should fit.\n\t*/\n\ti, err := strconv.ParseInt(str, 10, 64)\n\thandleError(err)\n\tfmt.Printf(\"%T %d\\n\", i, i)\n\tstr = \"invalidString123\"\n\t_, err = strconv.ParseInt(str, 10, 64)\n\thandleError(err)\n}\n" }, { "path": "chapters/numbers/string_to_num/test_string_to_int.go.escaped", "content": "package main\n\nimport (\n\t"fmt"\n\t"strconv"\n)\n\nfunc handleError(err error) {\n\tif err != nil {\n\t\tfmt.Println(err)\n\t}\n}\n\nfunc main() {\n\tstr := "123"\n\t/*\n\t\tThe first argument to ParseInt is the string to be converted.\n\t\tThe second argument is the base to which the number is to be converted.\n\t\tThe third argument is the number of bits to which the number should fit.\n\t*/\n\ti, err := strconv.ParseInt(str, 10, 64)\n\thandleError(err)\n\tfmt.Printf("%T %d\\n", i, i)\n\tstr = "invalidString123"\n\t_, err = strconv.ParseInt(str, 10, 64)\n\thandleError(err)\n}\n" }, { "path": "chapters/running/cross-compiling/index.md", "content": "---\ntitle: Cross Compiling\nquestion: How do I compile a binary designed to run on a different platform than my local host?\n---\n\nSince Go is a statically compiled language, it's well designed for producing tiny, pre-compiled tools. This is great for Unix administrators or DevOps engineers, as they can send their tools with them when they work on remote systems. However, many developers use OS X or Windows on their local machine, and another OS like Linux on others. How do you use one system to compile binaries that will work on the other? This is called cross-compiling, and it's pretty simple with Go.\n\n### Pre 1.5\n\nBefore 1.5, cross compilation was an arduous process, requiring [massive scripts](http://dave.cheney.net/2013/07/09/an-introduction-to-cross-compilation-with-go-1-1) to build separate go compilers for each supported platform.\n\n### Post 1.5\n\nThings have been much better since v1.5 of Go was released. Go now [comes with support for all architectures built in](http://dave.cheney.net/2015/03/03/cross-compilation-just-got-a-whole-lot-better-in-go-1-5). That means cross compiling is as simple as setting the right `$GOOS` and `$GOARCH` environment variables before building.\n\nConsider the below example program, which simply prints the OS and Architecture it's compiled for. While the output will always be the same as the platform it's being executed on, it's really a compile-time value - not something determined at runtime.\n\n```\npackage main\n\nimport \"fmt\"\nimport \"runtime\"\n\nfunc main() {\n fmt.Printf(\"OS: %s\\nArchitecture: %s\\n\", runtime.GOOS, runtime.GOARCH)\n}\n```\n\nNow, let's compile this program for an Apple MacBook. To do so, we simply set two environment variables: `$GOOS`, which is the target operating system, and `$GOARCH`, which is the target processor. Then we run `go build` as normal:\n\n```\n$ GOOS=darwin GOARCH=386 go build test.go\n```\n\nNote that the `test` executable that comes out the other end only runs on OS X, and cannot be run on Linux or Windows. On the other hand, if we wanted to compile for Microsoft Windows, we'd simply set `GOOS=windows` and `GOARCH=386`.\n\nWhen we run the resulting binary on the right platform, we see:\n\n```\n$ ./test\nOS: windows\nArchitecture: 386\n```\n\nThis is another example of Go's strengths as a language for building easily distributed tools. It's almost trivial to modify your build process to produce binaries for every major platform your users may run. This is used, for example, to enable the Cloud Foundry team to distribute [Linux, Windows, and OS X CLI tools](https://github.com/cloudfoundry/cli).\n" }, { "path": "chapters/running/one-off/index.md", "content": "---\ntitle: Running a one-off File\nquestion: What's the easiest way to run a single Go file?\n---\n\nFirst steps are often both fundamental and overlooked.\n\nGo's unusual packaging and compilation process can be daunting and confusing to a new developer. Unlike most compiled languages, Go actually comes with a very easy way of running a single file. Simply execute the program with `go run filename.go`:\n\n{% include example.html example=\"hello_world\" %}\n\nThis allows Go to act as though it were a more dynamic language, and is useful for development and exploration. However, Go's compiler is so incredibly fast, that it's possible to use this technique in a production setting:\n\n```\n$ time go run empty.go\n\nreal\t0m0.103s\nuser\t0m0.058s\nsys\t0m0.033s\n```\n\nThroughout this book, you'll see many Go programs. Each one is available as a separate file in this book, and each example includes the `go run` command required to run the file along side the full output.\n" }, { "path": "chapters/running/one-off/test_empty.expected", "content": "" }, { "path": "chapters/running/one-off/test_empty.expected.escaped", "content": "" }, { "path": "chapters/running/one-off/test_empty.go", "content": "package main\n\nfunc main() {\n\n}\n" }, { "path": "chapters/running/one-off/test_empty.go.escaped", "content": "package main\n\nfunc main() {\n\n}\n" }, { "path": "chapters/running/one-off/test_hello_world.expected", "content": "Hello World!\n" }, { "path": "chapters/running/one-off/test_hello_world.expected.escaped", "content": "Hello World!\n" }, { "path": "chapters/running/one-off/test_hello_world.go", "content": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"Hello World!\")\n}\n" }, { "path": "chapters/running/one-off/test_hello_world.go.escaped", "content": "package main\n\nimport "fmt"\n\nfunc main() {\n\tfmt.Println("Hello World!")\n}\n" }, { "path": "chapters/running/shebang/bash.go", "content": "//usr/bin/env go run $0 $@; exit\n\npackage main\n\nfunc main() {\n\tprintln(\"hello\")\n}\n" }, { "path": "chapters/running/shebang/fail.go", "content": "#!/usr/bin/env go run\n\npackage main\n\nfunc main() {\n\tprintln(\"hello\")\n}\n" }, { "path": "chapters/running/shebang/gorun.go", "content": "#!/usr/bin/env gorun\n\npackage main\n\nfunc main() {\n\tprintln(\"hello\")\n}\n" }, { "path": "chapters/running/shebang/index.md", "content": "---\ntitle: Running a file via a shebang line\nquestion: How can I add a shebang line to the top of my Go file in order to run it directly, as though it were an interpreted script?\n---\n\n### \"Shebang??\"\n\nIn order to make it possible to execute scripts as though they were first class executables, UNIX systems will looks for what we refer to as a shebang line at the top of the file. The origin of the name is murky. Some think it came from sharp-bang or hash-bang -- contractions of `#` (\"sharp\") and `!` (\"bang\"). Others think the \"SH\" is in reference to the first UNIX shell, named \"sh\".\n\nIn any case, if a UNIX system sees that the first line of an executable begins with `#!`, then it will execute the file using whatever command is specified in the rest of the line. For example, if there's a file named `/path/to/bar` that looks like:\n\n```\n#!/bin/foo\n...\n```\n\nThen, when run, the kernel will execute `/bin/foo /path/to/bar`. \n\nThis is great for interpreted languages like Ruby and Python which allow `#` as an innocuous comment. A clever gopher might attempt to create a file named `/path/to/example` that looks like such:\n\n``` golang\n#!/usr/local/bin/go run\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n fmt.Println(\"Hello!\")\n}\n```\n\nAnd expect to run it and see \"hello\" in their terminal. However, Go does not allow `#` as a comment, which causes this to fail with a syntax error:\n\n```\n$ ./fail.go\nfail.go:1:1: illegal character U+0023 '#'\n```\n\nIn order for this to work, the Go spec would have to be modified to accept `#` as a comment on the first line of the file. However, the Go authors are highly opinionated. When (repeatedly) asked for this feature, [Rob Pike has said](https://groups.google.com/d/msg/golang-nuts/iGHWoUQFHjg/_dbLKomrPmUJ):\n\n> I have never said it cannot be done. I have always said it should not be done, and I have explained why.\n> \n> \"Useful\" is not an argument for a feature. All features are useful; otherwise they would not be features. The issue is whether the feature justifies its cost. That is a judgement call, and my judgement is, no. Running compilers and linkers, doing megabytes of I/O, and creating temporary binary files is not a justifiable expense for running a small program. For large programs, the amortization is even more in favor of not doing this.\n> \n> I am firmly against adding a feature to Go that encourages abuse of resources.\n> \n> If you want the feature, use gorun or an equivalent wrapper program. That's what it's for. I think believe [sic] gorun is a mistake, but I'm not stopping you from installing it and using it as you see fit.\n\n### gorun\n\nWhat's this gorun that has Rob up in arms? The Ubuntu Linux distribution produced the [gorun utility](https://wiki.ubuntu.com/gorun) to solve the shebang issue. As listed in the homepage, gorun will:\n\n* write files under a safe directory in `$TMPDIR` (or `/tmp`), so that the actual script location isn't touched (may be read-only)\n* avoid races between parallel executions of the same file\n* automatically clean up old compiled files that remain unused for some time (without races)\n* replace the process rather than using a child\n* pass arguments to the compiled application properly\n* handle well `GOROOT`, `GOROOT_FINAL` and the location of the toolchain\n\nImportantly, gorun will also strip the shebang line from the executed file before running it via `go run`.\n\nBecause gorun is a separate tool, and not included in the Go distribution, it must first be installed via `go get launchpad.net/gorun`. Once it's installed, you can make use of it quite simply:\n\n```\n#!/usr/bin/gorun\n\npackage main\n\nfunc main() {\n println(\"Hello world!\")\n}\n```\n\nThis file is now executable on the command line (after setting the execution bit via `chmod +x`, of course). However, it's also technically invalid Go. This means you can't compile the same code via `go build` that you would run with gorun.\n\nAs we said earlier, this solution also requires that your users install gorun, making it less portable than ideal.\n\nAs of March 1st, 2015, [gorun does not compile on OS X](https://bugs.launchpad.net/gorun/+bug/1176275), but it looks like this will be resolved, soon.\n{:.warning}\n\n### Mimic the shebang via Bash\n\nIn UNIX systems, the shebang line is handled by the family of `exec` functions inside the fundamental libc. The `exec` functions use what's referred to as magic numbers in the first bits of a file to determine what kind of executable it is. The characters `#!` are simply hard coded as a magic number that corresponds to being run as a script.\n\nBut we can make clever use of the fact that `//` is both a comment in Go, *and* interpreted as a valid part of a file path in Bash, in order to trick Bash into running the file for us instead of `exec`. This isn't technically a shebang line, but serves the same purpose quite nicely. The resulting file looks like such:\n\n```\n//usr/bin/go run $0 $@; exit $?\npackage main\n\nfunc main() {\n println(\"Hello world!\")\n}\n```\n\nThis file is *both* a valid Bash script and valid Go source code. When Bash runs this file, it executes `/usr/bin/go run $0 $@`, and then immediately exits. If the file were named \"/path/to/foo.go\", and we ran it like `./foo.go bar baz`, then Bash would execute `/usr/bin/go run ./foo.go \"bar\" \"baz\"`.\n\nAt this point, the file is parsed by `go run`, which ignores the first line as a comment, and dutifully compiles and executes the rest of the file.\n\nThis trick doesn't require a separately installed command, and is relatively portable. However, all is not roses: \n\n* The file must end in `.go`, since `go run` will happily ignore it otherwise.\n* This only works when executed via a shell. It won't work if executed directly by other programs.\n\n### Trade-offs\n\nSadly, unless Rob changes his mind and modifies the Go spec, there is no one-size-fits-all solution in sight. Both of the recipes above have their drawbacks, and choosing which one to use is entirely about your specific needs and tastes.\n\n" }, { "path": "chapters/strings/accessing/index.md", "content": "---\ntitle: Accessing Substrings\nquestion: How do I access parts of a given string?\n---\n\nGo allows you to access parts of a string via the normal indexing primitives you're accustomed to using with arrays and slices. In particular, it allows you to access `mystring[n:m]`. Either `n` or `m` can be omitted, which implies from the beginning or to the end, respectively. There's also the primitive `len(s)`, which gives you the number of characters in the string.\n\nHere are some examples:\n\n{% include example.html example=\"index\" %}\n\nAccessing strings by character, word or token are covered in the [Processing a String One Word or Character at a Time](/chapters/strings/processing) recipe.\n\n" }, { "path": "chapters/strings/accessing/test_index.expected", "content": "Hello\nHello\nello World\nWorld\nello Worl\n" }, { "path": "chapters/strings/accessing/test_index.expected.escaped", "content": "Hello\nHello\nello World\nWorld\nello Worl\n" }, { "path": "chapters/strings/accessing/test_index.go", "content": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ts := \"Hello World\"\n\tfmt.Println(s[:5]) // the first 5 characters\n\tfmt.Println(s[:len(s)-6]) // the same, but counting back from the end\n\tfmt.Println(s[1:]) // all except the first character\n\tfmt.Println(s[len(s)-5:]) // the last 5 characters\n\tfmt.Println(s[1 : len(s)-1]) // all except the first and last\n}\n" }, { "path": "chapters/strings/accessing/test_index.go.escaped", "content": "package main\n\nimport "fmt"\n\nfunc main() {\n\ts := "Hello World"\n\tfmt.Println(s[:5]) // the first 5 characters\n\tfmt.Println(s[:len(s)-6]) // the same, but counting back from the end\n\tfmt.Println(s[1:]) // all except the first character\n\tfmt.Println(s[len(s)-5:]) // the last 5 characters\n\tfmt.Println(s[1 : len(s)-1]) // all except the first and last\n}\n" }, { "path": "chapters/strings/concatenation/index.md", "content": "---\ntitle: Concatenating Strings\nquestion: How do I combine strings?\n---\n\nhttp://stackoverflow.com/questions/1760757/how-to-efficiently-concatenate-strings-in-go\n\nhttp://srcode.org/2014/08/23/string-concatenation-in-golang/\n" }, { "path": "chapters/strings/detecting/index.md", "content": "---\ntitle: Detecting a Substring\nquestion: How do I determine if a string contains another string or pattern?\n---\n\nGo prides itself on being a low level language with a rich set of functionality included by default via the standard packages. The `strings` package is a great example of this.\n\n### Detecting Substrings\n\n* `strings.Contains`\n* `strings.ContainsAny`\n* `strings.HasPrefix`\n* `strings.HasSuffix`\n\n{% include example.html example=\"substrings\" %}\n\n### Detecting Patterns\n\n{% include example.html example=\"regexp\" %}\n\n### Finding Matched Strings\n\n{% include example.html example=\"returned_regexp\" %}\n\n### Detecting Patterns that Include Special Characters\n\n{% include example.html example=\"safe_regexp\" %}\n\n### Precompiling Regular Expressions\n\n* `regexp.Compile`\n* `regexp.MustCompile`\n\n{% include example.html example=\"precompiled_regexp\" %}\n\n" }, { "path": "chapters/strings/detecting/test_precompiled_regexp.expected", "content": "" }, { "path": "chapters/strings/detecting/test_precompiled_regexp.expected.escaped", "content": "" }, { "path": "chapters/strings/detecting/test_precompiled_regexp.go", "content": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"unimplemented\")\n}\n" }, { "path": "chapters/strings/detecting/test_precompiled_regexp.go.escaped", "content": "package main\n\nimport "fmt"\n\nfunc main() {\n\tfmt.Println("unimplemented")\n}\n" }, { "path": "chapters/strings/detecting/test_regexp.expected", "content": "Matched: true Error: