qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-21 15:14:43 -07:00
Code Releases Activity

doc/tutorial: update for slice changes.

Browse Source 
Awaiting the lower-bound change before checkin.

Fixes #1067.

R=rsc, iant, gri
CC=golang-dev
https://golang.org/cl/2105043
This commit is contained in:
Rob Pike 2010-09-10 13:53:18 +10:00
parent 0eb0afde9a
commit 781462dc46
5 changed files with 78 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
doc/go_tutorial.html
View File

@ -286,14 +286,15 @@ In Go, since arrays are values, it's meaningful (and useful) to talk
about pointers to arrays.
<p>
The size of the array is part of its type; however, one can declare
a <i>slice</i> variable, to which one can assign a pointer to
any array
with the same element type or&mdash;much more commonly&mdash;a <i>slice
expression</i> of the form <code>a[low : high]</code>, representing
the subarray indexed by <code>low</code> through <code>high-1</code>.
Slices look a lot like arrays but have
a <i>slice</i> variable to hold a reference to any array, of any size,
with the same element type.
A <i>slice
expression</i> has the form <code>a[low : high]</code>, representing
the internal array indexed from <code>low</code> through <code>high-1</code>; the resulting
slice is indexed from <code>0</code> through <code>high-low-1</code>.
In short, slices look a lot like arrays but with
no explicit size (<code>[]</code> vs. <code>[10]</code>) and they reference a segment of
an underlying, often anonymous, regular array. Multiple slices
an underlying, usually anonymous, regular array. Multiple slices
can share data if they represent pieces of the same array;
multiple arrays can never share data.
<p>
@ -302,12 +303,23 @@ regular arrays; they're more flexible, have reference semantics,
and are efficient. What they lack is the precise control of storage
layout of a regular array; if you want to have a hundred elements
of an array stored within your structure, you should use a regular
array.
array. To create one, use a compound value <i>constructor</i>&mdash;an
expression formed
from a type followed by a brace-bounded expression like this:
<p>
<pre>
[3]int{1,2,3}
</pre>
<p>
In this case the constructor builds an array of 3 <code>ints</code>.
<p>
When passing an array to a function, you almost always want
to declare the formal parameter to be a slice. When you call
the function, take the address of the array and Go will
create (efficiently) a slice reference and pass that.
the function, slice the array to create
(efficiently) a slice reference and pass that.
By default, the lower and upper bounds of a slice match the
ends of the existing object, so the concise notation <code>[:]</code>
will slice the whole array.
<p>
Using slices one can write this function (from <code>sum.go</code>):
<p>
@ -321,32 +333,27 @@ Using slices one can write this function (from <code>sum.go</code>):
15 }
</pre>
<p>
and invoke it like this:
<p>
<pre> <!-- progs/sum.go /1,2,3/ -->
19 s := sum(&amp;[3]int{1,2,3}) // a slice of the array is passed to sum
</pre>
<p>
Note how the return type (<code>int</code>) is defined for <code>sum()</code> by stating it
after the parameter list.
The expression <code>[3]int{1,2,3}</code>&mdash;a type followed by a
brace-bounded
expression&mdash;is a constructor for a value, in this case an array
of 3 <code>ints</code>.
Putting an <code>&amp;</code>
in front gives us the address of a unique instance of the value. We pass the
pointer to <code>sum()</code> by (implicitly) promoting it to a slice.
<p>
To call the function, we slice the array. This intricate call (we'll show
a simpler way in a moment) constructs
an array and slices it:
<p>
<pre>
s := sum([3]int{1,2,3}[:])
</pre>
<p>
If you are creating a regular array but want the compiler to count the
elements for you, use <code>...</code> as the array size:
<p>
<pre>
s := sum(&amp;[...]int{1,2,3})
s := sum([...]int{1,2,3}[:])
</pre>
<p>
In practice, though, unless you're meticulous about storage layout within a
data structure, a slice itself&mdash;using empty brackets and no
<code>&amp;</code>&mdash;is all you need:
That's fussier than necessary, though.
In practice, unless you're meticulous about storage layout within a
data structure, a slice itself&mdash;using empty brackets with no size&mdash;is all you need:
<p>
<pre>
s := sum([]int{1,2,3})
@ -687,7 +694,7 @@ Building on the <code>file</code> package, here's a simple version of the Unix u
15 const NBUF = 512
16 var buf [NBUF]byte
17 for {
18 switch nr, er := f.Read(&amp;buf); true {
18 switch nr, er := f.Read(buf[:]); true {
19 case nr &lt; 0:
20 fmt.Fprintf(os.Stderr, &quot;cat: error reading from %s: %s\n&quot;, f.String(), er.String())
21 os.Exit(1)
@ -803,7 +810,7 @@ and use it from within a mostly unchanged <code>cat()</code> function:
57 r = newRotate13(r)
58 }
59 for {
60 switch nr, er := r.Read(&amp;buf); {
60 switch nr, er := r.Read(buf[:]); {
61 case nr &lt; 0:
62 fmt.Fprintf(os.Stderr, &quot;cat: error reading from %s: %s\n&quot;, r.String(), er.String())
63 os.Exit(1)

55
doc/go_tutorial.txt
View File

@ -227,14 +227,15 @@ In Go, since arrays are values, it's meaningful (and useful) to talk
about pointers to arrays.
The size of the array is part of its type; however, one can declare
a <i>slice</i> variable, to which one can assign a pointer to
any array
with the same element type or&mdash;much more commonly&mdash;a <i>slice
expression</i> of the form "a[low : high]", representing
the subarray indexed by "low" through "high-1".
Slices look a lot like arrays but have
a <i>slice</i> variable to hold a reference to any array, of any size,
with the same element type.
A <i>slice
expression</i> has the form "a[low : high]", representing
the internal array indexed from "low" through "high-1"; the resulting
slice is indexed from "0" through "high-low-1".
In short, slices look a lot like arrays but with
no explicit size ("[]" vs. "[10]") and they reference a segment of
an underlying, often anonymous, regular array. Multiple slices
an underlying, usually anonymous, regular array. Multiple slices
can share data if they represent pieces of the same array;
multiple arrays can never share data.
@ -243,39 +244,43 @@ regular arrays; they're more flexible, have reference semantics,
and are efficient. What they lack is the precise control of storage
layout of a regular array; if you want to have a hundred elements
of an array stored within your structure, you should use a regular
array.
array. To create one, use a compound value <i>constructor</i>&mdash;an
expression formed
from a type followed by a brace-bounded expression like this:
[3]int{1,2,3}
In this case the constructor builds an array of 3 "ints".
When passing an array to a function, you almost always want
to declare the formal parameter to be a slice. When you call
the function, take the address of the array and Go will
create (efficiently) a slice reference and pass that.
the function, slice the array to create
(efficiently) a slice reference and pass that.
By default, the lower and upper bounds of a slice match the
ends of the existing object, so the concise notation "[:]"
will slice the whole array.
Using slices one can write this function (from "sum.go"):
--PROG progs/sum.go /sum/ /^}/
and invoke it like this:
--PROG progs/sum.go /1,2,3/
Note how the return type ("int") is defined for "sum()" by stating it
after the parameter list.
The expression "[3]int{1,2,3}"&mdash;a type followed by a
brace-bounded
expression&mdash;is a constructor for a value, in this case an array
of 3 "ints".
Putting an "&amp;"
in front gives us the address of a unique instance of the value. We pass the
pointer to "sum()" by (implicitly) promoting it to a slice.
To call the function, we slice the array. This intricate call (we'll show
a simpler way in a moment) constructs
an array and slices it:
s := sum([3]int{1,2,3}[:])
If you are creating a regular array but want the compiler to count the
elements for you, use "..." as the array size:
s := sum(&amp;[...]int{1,2,3})
s := sum([...]int{1,2,3}[:])
In practice, though, unless you're meticulous about storage layout within a
data structure, a slice itself&mdash;using empty brackets and no
"&amp;"&mdash;is all you need:
That's fussier than necessary, though.
In practice, unless you're meticulous about storage layout within a
data structure, a slice itself&mdash;using empty brackets with no size&mdash;is all you need:
s := sum([]int{1,2,3})

2
doc/progs/cat.go
View File

@ -15,7 +15,7 @@ func cat(f *file.File) {
const NBUF = 512
var buf [NBUF]byte
for {
switch nr, er := f.Read(&buf); true {
switch nr, er := f.Read(buf[:]); true {
case nr < 0:
fmt.Fprintf(os.Stderr, "cat: error reading from %s: %s\n", f.String(), er.String())
os.Exit(1)

6
doc/progs/cat_rot13.go
View File

@ -15,10 +15,10 @@ var rot13Flag = flag.Bool("rot13", false, "rot13 the input")
func rot13(b byte) byte {
if 'a' <= b && b <= 'z' {
b = 'a' + ((b - 'a') + 13) % 26
b = 'a' + ((b-'a')+13)%26
}
if 'A' <= b && b <= 'Z' {
b = 'A' + ((b - 'A') + 13) % 26
b = 'A' + ((b-'A')+13)%26
}
return b
}
@ -57,7 +57,7 @@ func cat(r reader) {
r = newRotate13(r)
}
for {
switch nr, er := r.Read(&buf); {
switch nr, er := r.Read(buf[:]); {
case nr < 0:
fmt.Fprintf(os.Stderr, "cat: error reading from %s: %s\n", r.String(), er.String())
os.Exit(1)

2
doc/progs/sum.go
View File

@ -16,6 +16,6 @@ func sum(a []int) int { // returns an int
func main() {
s := sum(&[3]int{1,2,3}) // a slice of the array is passed to sum
s := sum([3]int{1, 2, 3}[:]) // a slice of the array is passed to sum
fmt.Print(s, "\n")
}