key features of the language. All the programs work (at time of writing) and are
checked into the repository in the directory <a href='/doc/progs'><code>/doc/progs/</code></a>.
<p>
-Program snippets are annotated with the line number in the original file; for
-cleanliness, blank lines remain blank.
-<p>
<h2>Hello, World</h2>
<p>
Let's start in the usual way:
<pre><!-- progs/helloworld.go /package/ $
-->package main
-import fmt "fmt" // Package implementing formatted I/O.
+import fmt "fmt" // Package implementing formatted I/O.
func main() {
fmt.Printf("Hello, world; or Καλημέρα κόσμε; or こんにちは 世界\n")
import (
"os"
- "flag" // command line option parser
+ "flag" // command line option parser
)
var omitNewline = flag.Bool("n", false, "don't print final newline")
const (
- Space = " "
+ Space = " "
Newline = "\n"
)
func main() {
- flag.Parse() // Scans the arg list and sets up flags
+ flag.Parse() // Scans the arg list and sets up flags
var s string = ""
for i := 0; i < flag.NArg(); i++ {
if i > 0 {
<p>
Given <code>os.Stdout</code> we can use its <code>WriteString</code> method to print the string.
<p>
-Having imported the <code>flag</code> package, line 12 creates a global variable to hold
-the value of echo's <code>-n</code> flag. The variable <code>omitNewline</code> has type <code>*bool</code>, pointer
-to <code>bool</code>.
+After importing the <code>flag</code> package, we use a <code>var</code> declaration
+to create and initialize a global variable, called <code>omitNewline</code>,
+to hold the value of echo's <code>-n</code> flag.
+The variable has type <code>*bool</code>, pointer to <code>bool</code>.
<p>
-In <code>main.main</code>, we parse the arguments (line 20) and then create a local
-string variable we will use to build the output.
+In <code>main.main</code>, we parse the arguments (the call to <code>flag.Parse</code>) and then create a local
+string variable with which to build the output.
<p>
The declaration statement has the form
<p>
<p>
<pre><!-- progs/strings.go /hello/ /ciao/
--> s := "hello"
- if s[1] != 'e' { os.Exit(1) }
+ if s[1] != 'e' {
+ os.Exit(1)
+ }
s = "good bye"
var p *string = &s
*p = "ciao"
</pre>
<p>
but for simple structures like <code>File</code> it's easier to return the address of a
-composite literal, as is done here on line 21.
+composite literal, as is done here in the <code>return</code> statement from <code>newFile</code>.
<p>
We can use the factory to construct some familiar, exported variables of type <code>*File</code>:
<p>
they look just like a second parameter list. The function
<code>syscall.Open</code>
also has a multi-value return, which we can grab with the multi-variable
-declaration on line 31; it declares <code>r</code> and <code>e</code> to hold the two values,
+declaration on the first line; it declares <code>r</code> and <code>e</code> to hold the two values,
both of type <code>int</code> (although you'd have to look at the <code>syscall</code> package
-to see that). Finally, line 35 returns two values: a pointer to the new <code>File</code>
+to see that). Finally, <code>OpenFile</code> returns two values: a pointer to the new <code>File</code>
and the error. If <code>syscall.Open</code> fails, the file descriptor <code>r</code> will
be negative and <code>newFile</code> will return <code>nil</code>.
<p>
file.Stdout.Write(hello)
f, err := file.Open("/does/not/exist")
if f == nil {
- fmt.Printf("can't open file; err=%s\n", err.String())
+ fmt.Printf("can't open file; err=%s\n", err.String())
os.Exit(1)
}
}
<pre><!-- progs/sort.go /type.*IntSlice/ /Swap/
-->type IntSlice []int
-func (p IntSlice) Len() int { return len(p) }
-func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
-func (p IntSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p IntSlice) Len() int { return len(p) }
+func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
+func (p IntSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
</pre>
<p>
Here we see methods defined for non-<code>struct</code> types. You can define methods
<p>
<pre><!-- progs/sortmain.go /type.day/ /Swap/
-->type day struct {
- num int
- shortName string
- longName string
+ num int
+ shortName string
+ longName string
}
type dayArray struct {
data []*day
}
-func (p *dayArray) Len() int { return len(p.data) }
-func (p *dayArray) Less(i, j int) bool { return p.data[i].num < p.data[j].num }
-func (p *dayArray) Swap(i, j int) { p.data[i], p.data[j] = p.data[j], p.data[i] }
+func (p *dayArray) Len() int { return len(p.data) }
+func (p *dayArray) Less(i, j int) bool { return p.data[i].num < p.data[j].num }
+func (p *dayArray) Swap(i, j int) { p.data[i], p.data[j] = p.data[j], p.data[i] }
</pre>
<p>
<p>
integer and can do the right thing for you. The snippet
<p>
<pre><!-- progs/print.go 10 11
---> var u64 uint64 = 1<<64-1
+--> var u64 uint64 = 1<<64 - 1
fmt.Printf("%d %d\n", u64, int64(u64))
</pre>
<p>
-->// Send the sequence 2, 3, 4, ... to channel 'ch'.
func generate(ch chan int) {
for i := 2; ; i++ {
- ch <- i // Send 'i' to channel 'ch'.
+ ch <- i // Send 'i' to channel 'ch'.
}
}
</pre>
// removing those divisible by 'prime'.
func filter(in, out chan int, prime int) {
for {
- i := <-in // Receive value of new variable 'i' from 'in'.
- if i % prime != 0 {
- out <- i // Send 'i' to channel 'out'.
+ i := <-in // Receive value of new variable 'i' from 'in'.
+ if i%prime != 0 {
+ out <- i // Send 'i' to channel 'out'.
}
}
}
<p>
<pre><!-- progs/sieve.go /func.main/ /^}/
-->func main() {
- ch := make(chan int) // Create a new channel.
- go generate(ch) // Start generate() as a goroutine.
+ ch := make(chan int) // Create a new channel.
+ go generate(ch) // Start generate() as a goroutine.
for i := 0; i < 100; i++ { // Print the first hundred primes.
prime := <-ch
fmt.Println(prime)
<pre><!-- progs/sieve1.go /func.generate/ /^}/
-->func generate() chan int {
ch := make(chan int)
- go func(){
+ go func() {
for i := 2; ; i++ {
ch <- i
}
out := make(chan int)
go func() {
for {
- if i := <-in; i % prime != 0 {
+ if i := <-in; i%prime != 0 {
out <- i
}
}
<p>
<pre><!-- progs/server.go /type.request/ /^}/
-->type request struct {
- a, b int
- replyc chan int
+ a, b int
+ replyc chan int
}
</pre>
<p>
-->func server(op binOp, service chan *request) {
for {
req := <-service
- go run(op, req) // don't wait for it
+ go run(op, req) // don't wait for it
}
}
</pre>
req.replyc = make(chan int)
adder <- req
}
- for i := N-1; i >= 0; i-- { // doesn't matter what order
- if <-reqs[i].replyc != N + 2*i {
+ for i := N - 1; i >= 0; i-- { // doesn't matter what order
+ if <-reqs[i].replyc != N+2*i {
fmt.Println("fail at", i)
}
}
for {
select {
case req := <-service:
- go run(op, req) // don't wait for it
+ go run(op, req) // don't wait for it
case <-quit:
return
}
key features of the language. All the programs work (at time of writing) and are
checked into the repository in the directory <a href='/doc/progs'>"/doc/progs/"</a>.
-Program snippets are annotated with the line number in the original file; for
-cleanliness, blank lines remain blank.
-
Hello, World
----
Given "os.Stdout" we can use its "WriteString" method to print the string.
-Having imported the "flag" package, line 12 creates a global variable to hold
-the value of echo's "-n" flag. The variable "omitNewline" has type "*bool", pointer
-to "bool".
+After importing the "flag" package, we use a "var" declaration
+to create and initialize a global variable, called "omitNewline",
+to hold the value of echo's "-n" flag.
+The variable has type "*bool", pointer to "bool".
-In "main.main", we parse the arguments (line 20) and then create a local
-string variable we will use to build the output.
+In "main.main", we parse the arguments (the call to "flag.Parse") and then create a local
+string variable with which to build the output.
The declaration statement has the form
return n
but for simple structures like "File" it's easier to return the address of a
-composite literal, as is done here on line 21.
+composite literal, as is done here in the "return" statement from "newFile".
We can use the factory to construct some familiar, exported variables of type "*File":
they look just like a second parameter list. The function
"syscall.Open"
also has a multi-value return, which we can grab with the multi-variable
-declaration on line 31; it declares "r" and "e" to hold the two values,
+declaration on the first line; it declares "r" and "e" to hold the two values,
both of type "int" (although you'd have to look at the "syscall" package
-to see that). Finally, line 35 returns two values: a pointer to the new "File"
+to see that). Finally, "OpenFile" returns two values: a pointer to the new "File"
and the error. If "syscall.Open" fails, the file descriptor "r" will
be negative and "newFile" will return "nil".