From 56135c623a865c501ab31cc940c0e22ece2673f4 Mon Sep 17 00:00:00 2001 From: Ondřej Surý Date: Fri, 3 Jun 2011 11:31:24 +0200 Subject: Imported Upstream version 2011.06.02 --- doc/go_tutorial.html | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) (limited to 'doc/go_tutorial.html') diff --git a/doc/go_tutorial.html b/doc/go_tutorial.html index c87254ecb..cfdd0ec6e 100644 --- a/doc/go_tutorial.html +++ b/doc/go_tutorial.html @@ -341,7 +341,7 @@ Using slices one can write this function (from sum.go): 15 }

-Note how the return type (int) is defined for sum() by stating it +Note how the return type (int) is defined for sum by stating it after the parameter list.

To call the function, we slice the array. This intricate call (we'll show @@ -373,7 +373,7 @@ There are also maps, which you can initialize like this: m := map[string]int{"one":1 , "two":2}

-The built-in function len(), which returns number of elements, +The built-in function len, which returns number of elements, makes its first appearance in sum. It works on strings, arrays, slices, maps, and channels.

@@ -401,7 +401,7 @@ for more examples of its use. Most types in Go are values. If you have an int or a struct or an array, assignment copies the contents of the object. -To allocate a new variable, use new(), which +To allocate a new variable, use the built-in function new, which returns a pointer to the allocated storage. 

@@ -418,7 +418,7 @@ or the more idiomatic
 Some types—maps, slices, and channels (see below)—have reference semantics.
 If you're holding a slice or a map and you modify its contents, other variables
 referencing the same underlying data will see the modification.  For these three
-types you want to use the built-in function make():
+types you want to use the built-in function make:
 

 
     m := make(map[string]int)
@@ -432,11 +432,11 @@ If you just declare the map, as in
 

 

 it creates a nil reference that cannot hold anything. To use the map,
-you must first initialize the reference using make() or by assignment from an
+you must first initialize the reference using make or by assignment from an
 existing map.
 

 Note that new(T) returns type *T while make(T) returns type
-T.  If you (mistakenly) allocate a reference object with new(),
+T.  If you (mistakenly) allocate a reference object with new rather than make,
 you receive a pointer to a nil reference, equivalent to
 declaring an uninitialized variable and taking its address.
 

@@ -767,7 +767,7 @@ Building on the file package, here's a simple version of the Unix u
 By now this should be easy to follow, but the switch statement introduces some
 new features.  Like a for loop, an if or switch can include an
 initialization statement.  The switch on line 18 uses one to create variables
-nr and er to hold the return values from f.Read().  (The if on line 25
+nr and er to hold the return values from the call to f.Read.  (The if on line 25
 has the same idea.)  The switch statement is general: it evaluates the cases
 from  top to bottom looking for the first case that matches the value; the
 case expressions don't need to be constants or even integers, as long as
@@ -779,14 +779,14 @@ in a for statement, a missing value means true.  In fa
 is a form of if-else chain. While we're here, it should be mentioned that in
 switch statements each case has an implicit break.
 

-Line 25 calls Write() by slicing the incoming buffer, which is itself a slice.
+Line 25 calls Write by slicing the incoming buffer, which is itself a slice.
 Slices provide the standard Go way to handle I/O buffers.
 

 Now let's make a variant of cat that optionally does rot13 on its input.
 It's easy to do by just processing the bytes, but instead we will exploit
 Go's notion of an interface.
 

-The cat() subroutine uses only two methods of f: Read() and String(),
+The cat subroutine uses only two methods of f: Read and String,
 so let's start by defining an interface that has exactly those two methods.
 Here is code from progs/cat_rot13.go:
 

@@ -838,7 +838,7 @@ To use the new feature, we define a flag:
 14    var rot13Flag = flag.Bool("rot13", false, "rot13 the input")

-and use it from within a mostly unchanged cat() function: +and use it from within a mostly unchanged cat function: 

 
 52    func cat(r reader) {
@@ -866,7 +866,7 @@ and use it from within a mostly unchanged cat() function:
 74    }

-(We could also do the wrapping in main and leave cat() mostly alone, except +(We could also do the wrapping in main and leave cat mostly alone, except for changing the type of the argument; consider that an exercise.) Lines 56 through 58 set it all up: If the rot13 flag is true, wrap the reader we received into a rotate13 and proceed. Note that the interface variables @@ -1055,7 +1055,7 @@ to that of the Printf call above.

If you have your own type you'd like Printf or Print to format, -just give it a String() method that returns a string. The print +just give it a String method that returns a string. The print routines will examine the value to inquire whether it implements the method and if so, use it rather than some other formatting. Here's a simple example. @@ -1076,14 +1076,14 @@ Here's a simple example. 21 }

-Since *testType has a String() method, the +Since *testType has a String method, the default formatter for that type will use it and produce the output 

     77 Sunset Strip

-Observe that the String() method calls Sprint (the obvious Go +Observe that the String method calls Sprint (the obvious Go variant that returns a string) to do its formatting; special formatters can use the fmt library recursively.

@@ -1096,7 +1096,7 @@ and such, but that's getting a little off the main thread so we'll leave it as an exploration exercise.

You might ask, though, how Printf can tell whether a type implements -the String() method. Actually what it does is ask if the value can +the String method. Actually what it does is ask if the value can be converted to an interface variable that implements the method. Schematically, given a value v, it does this:

@@ -1141,7 +1141,7 @@ interface type defined in the io library:

(This interface is another conventional name, this time for Write; there are also io.Reader, io.ReadWriter, and so on.) -Thus you can call Fprintf on any type that implements a standard Write() +Thus you can call Fprintf on any type that implements a standard Write method, not just files but also network channels, buffers, whatever you want.

-- cgit v1.2.3