qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-22 01:34:41 -07:00
Code Releases Activity

update tutorial text to refer to io.Reader etc.

Browse Source 
R=rsc
DELTA=15  (0 added, 5 deleted, 10 changed)
OCL=28526
CL=28532
This commit is contained in:
Rob Pike 2009-05-08 11:21:25 -07:00
parent fb24d792da
commit df46b3342c
1 changed files with 10 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
doc/go_tutorial.txt
View File

@ -632,19 +632,19 @@ be converted to an interface variable that implements the method.
Schematically, given a value "v", it does this:
type String interface {
type Stringer interface {
String() string
}
s, ok := v.(String); // Test whether v satisfies "String"
s, ok := v.(Stringer); // Test whether v implements "String()"
if ok {
result = s.String()
} else {
result = default_output(v)
}
The code uses a ``type assertion'' ("v.(String)") to test if the value stored in
"v" satisfies the "String" interface; if it does, "s"
The code uses a ``type assertion'' ("v.(Stringer)") to test if the value stored in
"v" satisfies the "Stringer" interface; if it does, "s"
will become an interface variable implementing the method and "ok" will
be "true". We then use the interface variable to call the method.
(The ''comma, ok'' pattern is a Go idiom used to test the success of
@ -652,25 +652,20 @@ operations such as type conversion, map update, communications, and so on,
although this is the only appearance in this tutorial.)
If the value does not satisfy the interface, "ok" will be false.
In this snippet "String" is used as both a type name and a method name. This does
not create any ambiguity because methods only appear in association
with a variable ("s.String()"); a method name can never appear in a context
where a type name is legal and vice versa. Another way to say this is that the
method "String" is only available within the scope bound to a variable of type
"String". We double-use the name because it makes the interface type
self-describing ("String" (the interface) implements "String" (the method)).
In this snippet the name "Stringer" follows the convention that we add "[e]r"
to interfaces describing simple method sets like this.
One last wrinkle. To complete the suite, besides "Printf" etc. and "Sprintf"
etc., there are also "Fprintf" etc. Unlike in C, "Fprintf"'s first argument is
not a file. Instead, it is a variable of type "io.Write", which is an
not a file. Instead, it is a variable of type "io.Writer", which is an
interface type defined in the "io" library:
type Write interface {
type Writer interface {
Write(p []byte) (n int, err *os.Error);
}
(This interface is another doubled name, this time for "Write"; there are also
"io.Read", "io.ReadWrite", and so on.)
(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()"
method, not just files but also network channels, buffers, rot13ers, whatever
you want.