mirror of
https://github.com/golang/go
synced 2024-11-11 23:50:22 -07:00
doc/tutorial: update for slice changes.
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:
parent
0eb0afde9a
commit
781462dc46
@ -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—much more commonly—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,17 +303,28 @@ 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>—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>
|
||||
<pre> <!-- progs/sum.go /sum/ /^}/ -->
|
||||
09 func sum(a []int) int { // returns an int
|
||||
09 func sum(a []int) int { // returns an int
|
||||
10 s := 0
|
||||
11 for i := 0; i < len(a); i++ {
|
||||
12 s += a[i]
|
||||
@ -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(&[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>—a type followed by a
|
||||
brace-bounded
|
||||
expression—is a constructor for a value, in this case an array
|
||||
of 3 <code>ints</code>.
|
||||
Putting an <code>&</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(&[...]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—using empty brackets and no
|
||||
<code>&</code>—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—using empty brackets with no size—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(&buf); true {
|
||||
18 switch nr, er := f.Read(buf[:]); true {
|
||||
19 case nr < 0:
|
||||
20 fmt.Fprintf(os.Stderr, "cat: error reading from %s: %s\n", 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(&buf); {
|
||||
60 switch nr, er := r.Read(buf[:]); {
|
||||
61 case nr < 0:
|
||||
62 fmt.Fprintf(os.Stderr, "cat: error reading from %s: %s\n", r.String(), er.String())
|
||||
63 os.Exit(1)
|
||||
|
@ -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—much more commonly—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>—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}"—a type followed by a
|
||||
brace-bounded
|
||||
expression—is a constructor for a value, in this case an array
|
||||
of 3 "ints".
|
||||
Putting an "&"
|
||||
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(&[...]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—using empty brackets and no
|
||||
"&"—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—using empty brackets with no size—is all you need:
|
||||
|
||||
s := sum([]int{1,2,3})
|
||||
|
||||
|
@ -15,11 +15,11 @@ 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)
|
||||
case nr == 0: // EOF
|
||||
case nr == 0: // EOF
|
||||
return
|
||||
case nr > 0:
|
||||
if nw, ew := file.Stdout.Write(buf[0:nr]); nw != nr {
|
||||
@ -30,7 +30,7 @@ func cat(f *file.File) {
|
||||
}
|
||||
|
||||
func main() {
|
||||
flag.Parse() // Scans the arg list and sets up flags
|
||||
flag.Parse() // Scans the arg list and sets up flags
|
||||
if flag.NArg() == 0 {
|
||||
cat(file.Stdin)
|
||||
}
|
||||
|
@ -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
|
||||
}
|
||||
@ -29,7 +29,7 @@ type reader interface {
|
||||
}
|
||||
|
||||
type rotate13 struct {
|
||||
source reader
|
||||
source reader
|
||||
}
|
||||
|
||||
func newRotate13(source reader) *rotate13 {
|
||||
@ -57,11 +57,11 @@ 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)
|
||||
case nr == 0: // EOF
|
||||
case nr == 0: // EOF
|
||||
return
|
||||
case nr > 0:
|
||||
nw, ew := file.Stdout.Write(buf[0:nr])
|
||||
@ -73,7 +73,7 @@ func cat(r reader) {
|
||||
}
|
||||
|
||||
func main() {
|
||||
flag.Parse() // Scans the arg list and sets up flags
|
||||
flag.Parse() // Scans the arg list and sets up flags
|
||||
if flag.NArg() == 0 {
|
||||
cat(file.Stdin)
|
||||
}
|
||||
|
@ -6,7 +6,7 @@ package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func sum(a []int) int { // returns an int
|
||||
func sum(a []int) int { // returns an int
|
||||
s := 0
|
||||
for i := 0; i < len(a); i++ {
|
||||
s += a[i]
|
||||
@ -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")
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user