7x31/the-way-to-go_ZH_CN
1
0
Fork 0
mirror of https://github.com/unknwon/the-way-to-go_ZH_CN.git synced 2025-08-12 06:23:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #322 from appleboy/patch-8

Browse Source 
fix: coding style and file format for chapter 11, 12, 13, 14 and 15.
This commit is contained in:
无闻
2017-02-10 23:34:01 -05:00
committed by GitHub
parent f215102638 4abbfabb52
commit da57568722
63 changed files with 2662 additions and 2622 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
eBook/exercises/chapter_11/float_sort.go
View File

@@ -1,66 +1,66 @@
package float64
import (
"fmt"
"math/rand"
"time"
)
type Sorter interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}
func Sort(data Sorter) {
for pass := 1; pass < data.Len(); pass++ {
for i := 0; i < data.Len()-pass; i++ {
if data.Less(i+1, i) {
data.Swap(i, i+1)
}
}
}
}
func IsSorted(data Sorter) bool {
n := data.Len()
for i := n - 1; i > 0; i-- {
if data.Less(i, i-1) {
return false
}
}
return true
}
type Float64Array []float64
func (p Float64Array) Len() int { return len(p) }
func (p Float64Array) Less(i, j int) bool { return p[i] < p[j] }
func (p Float64Array) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func NewFloat64Array() Float64Array {
return make([]float64, 25)
}
func (p Float64Array) Fill(n int) {
rand.Seed(int64(time.Now().Nanosecond()))
for i := 0; i < n; i++ {
p[i] = 100 * (rand.Float64())
}
}
func (p Float64Array) List() string {
s := "{ "
for i := 0; i < p.Len(); i++ {
if p[i] == 0 {
continue
}
s += fmt.Sprintf("%3.1f ", p[i])
}
s += " }"
return s
}
func (p Float64Array) String() string {
return p.List()
}
package float64
import (
"fmt"
"math/rand"
"time"
)
type Sorter interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}
func Sort(data Sorter) {
for pass := 1; pass < data.Len(); pass++ {
for i := 0; i < data.Len()-pass; i++ {
if data.Less(i+1, i) {
data.Swap(i, i+1)
}
}
}
}
func IsSorted(data Sorter) bool {
n := data.Len()
for i := n - 1; i > 0; i-- {
if data.Less(i, i-1) {
return false
}
}
return true
}
type Float64Array []float64
func (p Float64Array) Len() int { return len(p) }
func (p Float64Array) Less(i, j int) bool { return p[i] < p[j] }
func (p Float64Array) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func NewFloat64Array() Float64Array {
return make([]float64, 25)
}
func (p Float64Array) Fill(n int) {
rand.Seed(int64(time.Now().Nanosecond()))
for i := 0; i < n; i++ {
p[i] = 100 * (rand.Float64())
}
}
func (p Float64Array) List() string {
s := "{ "
for i := 0; i < p.Len(); i++ {
if p[i] == 0 {
continue
}
s += fmt.Sprintf("%3.1f ", p[i])
}
s += " }"
return s
}
func (p Float64Array) String() string {
return p.List()
}

50
eBook/exercises/chapter_11/float_sortmain.go
View File

@@ -1,25 +1,25 @@
package main
import (
"fmt"
"./float64"
)
func main() {
f1 := float64.NewFloat64Array()
f1.Fill(10)
fmt.Printf("Before sorting %s\n", f1)
float64.Sort(f1)
fmt.Printf("After sorting %s\n", f1)
if float64.IsSorted(f1) {
fmt.Println("The float64 array is sorted!")
} else {
fmt.Println("The float64 array is NOT sorted!")
}
}
/* Output:
Before sorting { 55.0 82.3 36.4 66.6 25.3 82.7 47.4 21.5 4.6 81.6 }
After sorting { 4.6 21.5 25.3 36.4 47.4 55.0 66.6 81.6 82.3 82.7 }
The float64 array is sorted!
*/
package main
import (
"./float64"
"fmt"
)
func main() {
f1 := float64.NewFloat64Array()
f1.Fill(10)
fmt.Printf("Before sorting %s\n", f1)
float64.Sort(f1)
fmt.Printf("After sorting %s\n", f1)
if float64.IsSorted(f1) {
fmt.Println("The float64 array is sorted!")
} else {
fmt.Println("The float64 array is NOT sorted!")
}
}
/* Output:
Before sorting { 55.0 82.3 36.4 66.6 25.3 82.7 47.4 21.5 4.6 81.6 }
After sorting { 4.6 21.5 25.3 36.4 47.4 55.0 66.6 81.6 82.3 82.7 }
The float64 array is sorted!
*/

92
eBook/exercises/chapter_11/interface_nil.go
View File

@@ -1,46 +1,46 @@
// interface_nil.go
package main
import "fmt"
type Any interface {}
type Anything struct {}
func main() {
any := getAny()
if any == nil {
fmt.Println("any is nil")
} else {
fmt.Println("any is not nil")
}
/*
// to get the inner value:
anything := any.(*Anything)
if anything == nil {
fmt.Println("anything is nil")
} else {
fmt.Println("anything is not nil")
}
*/
}
func getAny() Any {
return getAnything()
}
func getAnything() *Anything {
return nil
}
/* Output:
any is not nil
WHY?
you would perhaps expect: any is nil,because getAnything() returns that
BUT:
the interface value any is storing a value, so it is not nil.
It just so happens that the particular value it is storing is a nil pointer.
The any variable has a type, so it's not a nil interface,
rather an interface variable with type Any and concrete value (*Anything)(nil).
To get the inner value of any, use: anything := any.(*Anything)
now anything contains nil !
*/
// interface_nil.go
package main
import "fmt"
type Any interface{}
type Anything struct{}
func main() {
any := getAny()
if any == nil {
fmt.Println("any is nil")
} else {
fmt.Println("any is not nil")
}
/*
// to get the inner value:
anything := any.(*Anything)
if anything == nil {
fmt.Println("anything is nil")
} else {
fmt.Println("anything is not nil")
}
*/
}
func getAny() Any {
return getAnything()
}
func getAnything() *Anything {
return nil
}
/* Output:
any is not nil
WHY?
you would perhaps expect: any is nil,because getAnything() returns that
BUT:
the interface value any is storing a value, so it is not nil.
It just so happens that the particular value it is storing is a nil pointer.
The any variable has a type, so it's not a nil interface,
rather an interface variable with type Any and concrete value (*Anything)(nil).
To get the inner value of any, use: anything := any.(*Anything)
now anything contains nil !
*/

137
eBook/exercises/chapter_11/interface_poly3.go
View File

@@ -1,68 +1,69 @@
// interface_poly3.go
package main
import (
"fmt"
"math"
)
type Shaper interface {
Area() float32
}
type Shape struct {}
func (sh Shape) Area() float32 {
return -1 // the shape is indetermined, so we return something impossible
}
type Square struct {
side float32
Shape
}
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
type Rectangle struct {
length, width float32
Shape
}
func (r *Rectangle) Area() float32 {
return r.length * r.width
}
type Circle struct {
radius float32
Shape
}
func (c *Circle) Area() float32 {
return math.Pi * c.radius * c.radius
}
func main() {
s := Shape{}
r := &Rectangle{5, 3, s} // Area() of Rectangle needs a value
q := &Square{5, s} // Area() of Square needs a pointer
c := &Circle{2.5, s}
shapes := []Shaper{r, q, c, s}
fmt.Println("Looping through shapes for area ...")
for n, _ := range shapes {
fmt.Println("Shape details: ", shapes[n])
fmt.Println("Area of this shape is: ", shapes[n].Area())
}
}
/* Output:
Looping through shapes for area ...
Shape details: {5 3}
Area of this shape is: 15
Shape details: &{5}
Area of this shape is: 25
Shape details: &{2.5}
Area of this shape is: 19.634954
Shape details: {}
Area of this shape is: -1
*/
// interface_poly3.go
package main
import (
"fmt"
"math"
)
type Shaper interface {
Area() float32
}
type Shape struct{}
func (sh Shape) Area() float32 {
return -1 // the shape is indetermined, so we return something impossible
}
type Square struct {
side float32
Shape
}
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
type Rectangle struct {
length, width float32
Shape
}
func (r *Rectangle) Area() float32 {
return r.length * r.width
}
type Circle struct {
radius float32
Shape
}
func (c *Circle) Area() float32 {
return math.Pi * c.radius * c.radius
}
func main() {
s := Shape{}
r := &Rectangle{5, 3, s} // Area() of Rectangle needs a value
q := &Square{5, s} // Area() of Square needs a pointer
c := &Circle{2.5, s}
shapes := []Shaper{r, q, c, s}
fmt.Println("Looping through shapes for area ...")
for n := range shapes {
fmt.Println("Shape details: ", shapes[n])
fmt.Println("Area of this shape is: ", shapes[n].Area())
}
}
/* Output:
Looping through shapes for area ...
Shape details: {5 3}
Area of this shape is: 15
Shape details: &{5}
Area of this shape is: 25
Shape details: &{2.5}
Area of this shape is: 19.634954
Shape details: {}
Area of this shape is: -1
*/

103
eBook/exercises/chapter_11/interfaces_ext.go
View File

@@ -1,51 +1,52 @@
package main
import "fmt"
type Square struct {
side float32
}
type Triangle struct {
base float32
height float32
}
type AreaInterface interface {
Area() float32
}
type PeriInterface interface {
Perimeter() float32
}
func main() {
var areaIntf AreaInterface
var periIntf PeriInterface
sq1 := new(Square)
sq1.side = 5
tr1 := new(Triangle)
tr1.base = 3
tr1.height = 5
areaIntf = sq1
fmt.Printf("The square has area: %f\n", areaIntf.Area())
periIntf = sq1
fmt.Printf("The square has perimeter: %f\n", periIntf.Perimeter())
areaIntf = tr1
fmt.Printf("The triangle has area: %f\n", areaIntf.Area())
}
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
func (sq *Square) Perimeter() float32 {
return 4 * sq.side
}
func (tr *Triangle) Area() float32 {
return 0.5 * tr.base*tr.height
}
package main
import "fmt"
type Square struct {
side float32
}
type Triangle struct {
base float32
height float32
}
type AreaInterface interface {
Area() float32
}
type PeriInterface interface {
Perimeter() float32
}
func main() {
var areaIntf AreaInterface
var periIntf PeriInterface
sq1 := new(Square)
sq1.side = 5
tr1 := new(Triangle)
tr1.base = 3
tr1.height = 5
areaIntf = sq1
fmt.Printf("The square has area: %f\n", areaIntf.Area())
periIntf = sq1
fmt.Printf("The square has perimeter: %f\n", periIntf.Perimeter())
areaIntf = tr1
fmt.Printf("The triangle has area: %f\n", areaIntf.Area())
}
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
func (sq *Square) Perimeter() float32 {
return 4 * sq.side
}
func (tr *Triangle) Area() float32 {
return 0.5 * tr.base * tr.height
}

115
eBook/exercises/chapter_11/interfaces_poly2.go
View File

@@ -1,57 +1,58 @@
// interfaces_poly2.go
package main
import (
"fmt"
"math"
)
type Shaper interface {
Area() float32
}
type Square struct {
side float32
}
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
type Rectangle struct {
length, width float32
}
func (r Rectangle) Area() float32 {
return r.length * r.width
}
type Circle struct {
radius float32
}
func (c *Circle) Area() float32 {
return math.Pi * c.radius * c.radius
}
func main() {
r := Rectangle{5, 3} // Area() of Rectangle needs a value
q := &Square{5} // Area() of Square needs a pointer
c := &Circle{2.5}
fmt.Println("Looping through shapes for area ...")
// shapes := []Shaper{Shaper(r), Shaper(q), Shaper(c)}
shapes := []Shaper{r, q, c}
for n, _ := range shapes {
fmt.Println("Shape details: ", shapes[n])
fmt.Println("Area of this shape is: ", shapes[n].Area())
}
}
/* Output:
Looping through shapes for area ...
Shape details: {5 3}
Area of this shape is: 15
Shape details: &{5}
Area of this shape is: 25
Shape details: &{2.5}
Area of this shape is: 19.634954
*/
// interfaces_poly2.go
package main
import (
"fmt"
"math"
)
type Shaper interface {
Area() float32
}
type Square struct {
side float32
}
func (sq *Square) Area() float32 {
return sq.side * sq.side
}
type Rectangle struct {
length, width float32
}
func (r Rectangle) Area() float32 {
return r.length * r.width
}
type Circle struct {
radius float32
}
func (c *Circle) Area() float32 {
return math.Pi * c.radius * c.radius
}
func main() {
r := Rectangle{5, 3} // Area() of Rectangle needs a value
q := &Square{5} // Area() of Square needs a pointer
c := &Circle{2.5}
fmt.Println("Looping through shapes for area ...")
// shapes := []Shaper{Shaper(r), Shaper(q), Shaper(c)}
shapes := []Shaper{r, q, c}
for n := range shapes {
fmt.Println("Shape details: ", shapes[n])
fmt.Println("Area of this shape is: ", shapes[n].Area())
}
}
/* Output:
Looping through shapes for area ...
Shape details: {5 3}
Area of this shape is: 15
Shape details: &{5}
Area of this shape is: 25
Shape details: &{2.5}
Area of this shape is: 19.634954
*/

59
eBook/exercises/chapter_11/main_stack.go
View File

@@ -1,29 +1,30 @@
// main_stack.go
package main
import (
"fmt"
"./stack/stack"
)
var st1 stack.Stack
func main() {
st1.Push("Brown")
st1.Push(3.14)
st1.Push(100)
st1.Push([]string{"Java", "C++", "Python", "C#", "Ruby"})
for {
item, err := st1.Pop()
if err != nil {
break
}
fmt.Println(item)
}
}
/* Output:
[Java C++ Python C# Ruby]
100
3.14
Brown
*/
// main_stack.go
package main
import (
"./stack/stack"
"fmt"
)
var st1 stack.Stack
func main() {
st1.Push("Brown")
st1.Push(3.14)
st1.Push(100)
st1.Push([]string{"Java", "C++", "Python", "C#", "Ruby"})
for {
item, err := st1.Pop()
if err != nil {
break
}
fmt.Println(item)
}
}
/* Output:
[Java C++ Python C# Ruby]
100
3.14
Brown
*/

34
eBook/exercises/chapter_11/main_stack_v2.go
View File

@@ -1,17 +1,17 @@
// main_stack_v2.go
package main
import (
"./stack/collection"
"fmt"
)
func main() {
var s collection.Stack
s.Push("world")
s.Push("hello, ")
for s.Size() > 0 {
fmt.Print(s.Pop())
}
fmt.Println()
}
// main_stack_v2.go
package main
import (
"./stack/collection"
"fmt"
)
func main() {
var s collection.Stack
s.Push("world")
s.Push("hello, ")
for s.Size() > 0 {
fmt.Print(s.Pop())
}
fmt.Println()
}

125
eBook/exercises/chapter_11/map_function_interface.go
View File

@@ -1,62 +1,63 @@
package main
import "fmt"
type obj interface{}
func main() {
// define a generic lambda function mf:
mf := func(i obj) obj {
switch i.(type) {
case int:
return i.(int) * 2
case string:
return i.(string) + i.(string)
}
return i
}
isl := []obj{0, 1, 2, 3, 4, 5}
res1 := mapFunc(mf, isl)
for _, v := range res1 {
fmt.Println(v)
}
println()
ssl := []obj{"0", "1", "2", "3", "4", "5"}
res2 := mapFunc(mf, ssl)
for _, v := range res2 {
fmt.Println(v)
}
}
func mapFunc(mf func(obj) obj, list []obj) ([]obj) {
result := make([]obj, len(list))
for ix, v := range list {
result[ix] = mf(v)
}
// Equivalent:
/*
for ix := 0; ix<len(list); ix++ {
result[ix] = mf(list[ix])
}
*/
return result
}
/* Output:
0
2
4
6
8
10
00
11
22
33
44
55
*/
package main
import "fmt"
type obj interface{}
func main() {
// define a generic lambda function mf:
mf := func(i obj) obj {
switch i.(type) {
case int:
return i.(int) * 2
case string:
return i.(string) + i.(string)
}
return i
}
isl := []obj{0, 1, 2, 3, 4, 5}
res1 := mapFunc(mf, isl)
for _, v := range res1 {
fmt.Println(v)
}
println()
ssl := []obj{"0", "1", "2", "3", "4", "5"}
res2 := mapFunc(mf, ssl)
for _, v := range res2 {
fmt.Println(v)
}
}
func mapFunc(mf func(obj) obj, list []obj) []obj {
result := make([]obj, len(list))
for ix, v := range list {
result[ix] = mf(v)
}
// Equivalent:
/*
for ix := 0; ix<len(list); ix++ {
result[ix] = mf(list[ix])
}
*/
return result
}
/* Output:
0
2
4
6
8
10
00
11
22
33
44
55
*/

119
eBook/exercises/chapter_11/map_function_interface_var.go
View File

@@ -1,59 +1,60 @@
package main
import "fmt"
type obj interface{}
func main() {
// define a generic lambda function mf:
mf := func(i obj) obj {
switch i.(type) {
case int:
return i.(int) * 2
case string:
return i.(string) + i.(string)
}
return i
}
res1 := mapFunc(mf, 0, 1, 2, 3, 4, 5)
for _, v := range res1 {
fmt.Println(v)
}
println()
res2 := mapFunc(mf, "0", "1", "2", "3", "4", "5")
for _, v := range res2 {
fmt.Println(v)
}
}
func mapFunc(mf func(obj) obj, list ...obj) ([]obj) {
result := make([]obj, len(list))
for ix, v := range list {
result[ix] = mf(v)
}
// Equivalent:
/*
for ix := 0; ix<len(list); ix++ {
result[ix] = mf(list[ix])
}
*/
return result
}
/* Output:
0
2
4
6
8
10
00
11
22
33
44
55
*/
package main
import "fmt"
type obj interface{}
func main() {
// define a generic lambda function mf:
mf := func(i obj) obj {
switch i.(type) {
case int:
return i.(int) * 2
case string:
return i.(string) + i.(string)
}
return i
}
res1 := mapFunc(mf, 0, 1, 2, 3, 4, 5)
for _, v := range res1 {
fmt.Println(v)
}
println()
res2 := mapFunc(mf, "0", "1", "2", "3", "4", "5")
for _, v := range res2 {
fmt.Println(v)
}
}
func mapFunc(mf func(obj) obj, list ...obj) []obj {
result := make([]obj, len(list))
for ix, v := range list {
result[ix] = mf(v)
}
// Equivalent:
/*
for ix := 0; ix<len(list); ix++ {
result[ix] = mf(list[ix])
}
*/
return result
}
/* Output:
0
2
4
6
8
10
00
11
22
33
44
55
*/

58
eBook/exercises/chapter_11/min_interface.go
View File

@@ -1,28 +1,30 @@
// min_interface.go
package min
type Miner interface {
Len() int
ElemIx(ix int) interface{}
Less(i, j int) bool
}
func Min(data Miner) interface{} {
min := data.ElemIx(0)
for i:=1; i < data.Len(); i++ {
if data.Less(i, i-1) {
min = data.ElemIx(i)
}
}
return min
}
type IntArray []int
func (p IntArray) Len() int { return len(p) }
func (p IntArray) ElemIx(ix int) interface{} { return p[ix] }
func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }
type StringArray []string
func (p StringArray) Len() int { return len(p) }
func (p StringArray) ElemIx(ix int) interface{} { return p[ix] }
func (p StringArray) Less(i, j int) bool { return p[i] < p[j] }
// min_interface.go
package min
type Miner interface {
Len() int
ElemIx(ix int) interface{}
Less(i, j int) bool
}
func Min(data Miner) interface{} {
min := data.ElemIx(0)
for i := 1; i < data.Len(); i++ {
if data.Less(i, i-1) {
min = data.ElemIx(i)
}
}
return min
}
type IntArray []int
func (p IntArray) Len() int { return len(p) }
func (p IntArray) ElemIx(ix int) interface{} { return p[ix] }
func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }
type StringArray []string
func (p StringArray) Len() int { return len(p) }
func (p StringArray) ElemIx(ix int) interface{} { return p[ix] }
func (p StringArray) Less(i, j int) bool { return p[i] < p[j] }

62
eBook/exercises/chapter_11/minmain.go
View File

@@ -1,31 +1,31 @@
// minmain.go
package main
import (
"fmt"
"./min"
)
func ints() {
data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
a := min.IntArray(data) //conversion to type IntArray
m := min.Min(a)
fmt.Printf("The minimum of the array is: %v\n", m)
}
func strings() {
data := []string{"ddd", "eee", "bbb", "ccc", "aaa"}
a := min.StringArray(data)
m := min.Min(a)
fmt.Printf("The minimum of the array is: %v\n", m)
}
func main() {
ints()
strings()
}
/* Output:
The minimum of the array is: -5467984
The minimum of the array is: aaa
*/
// minmain.go
package main
import (
"./min"
"fmt"
)
func ints() {
data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
a := min.IntArray(data) //conversion to type IntArray
m := min.Min(a)
fmt.Printf("The minimum of the array is: %v\n", m)
}
func strings() {
data := []string{"ddd", "eee", "bbb", "ccc", "aaa"}
a := min.StringArray(data)
m := min.Min(a)
fmt.Printf("The minimum of the array is: %v\n", m)
}
func main() {
ints()
strings()
}
/* Output:
The minimum of the array is: -5467984
The minimum of the array is: aaa
*/

179
eBook/exercises/chapter_11/point_interfaces.go
View File

@@ -1,89 +1,90 @@
// float64 is necessary as input to math.Sqrt()
package main
import (
"fmt"
"math"
)
type Magnitude interface {
Abs() float64
}
var m Magnitude
type Point struct {
X, Y float64
}
func (p *Point) Scale(s float64) {
p.X *= s
p.Y *= s
}
func (p *Point) Abs() float64 {
return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}
type Point3 struct {
X, Y, Z float64
}
func (p *Point3) Abs() float64 {
return math.Sqrt(float64(p.X*p.X + p.Y*p.Y + p.Z*p.Z))
}
type Polar struct {
R, Theta float64
}
func (p Polar) Abs() float64 { return p.R }
func main() {
p1 := new(Point)
p1.X = 3
p1.Y = 4
m = p1 // p1 is type *Point, has method Abs()
fmt.Printf("The length of the vector p1 is: %f\n", m.Abs())
p2:= &Point{4, 5}
m = p2
fmt.Printf("The length of the vector p2 is: %f\n", m.Abs() )
p1.Scale(5)
m = p1
fmt.Printf("The length of the vector p1 after scaling is: %f\n", m.Abs() )
fmt.Printf("Point p1 after scaling has the following coordinates: X %f - Y %f\n", p1.X, p1.Y)
mag := m.Abs()
m = &Point3{3, 4, 5}
mag += m.Abs()
m = Polar{2.0, math.Pi / 2}
mag += m.Abs()
fmt.Printf("The float64 mag is now: %f", mag )
}
/* Output:
The length of the vector p1 is: 5.000000
The length of the vector p2 is: 6.403124
The length of the vector p1 after scaling is: 25.000000
Point p1 after scaling has the following coordinates: X 15.000000 - Y 20.000000
The float64 mag is now: 34.071068
-- instead of:
func (p *Point) Abs() float64 {
return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}
m = p1
we can write:
func (p Point) Abs() float64 {
return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}
m = p1
and instead of:
func (p Polar) Abs() float64 { return p.R }
m = Polar{2.0, math.Pi / 2}
we can write:
func (p *Polar) Abs() float64 { return p.R }
m = &Polar{2.0, math.Pi / 2}
with the same output
*/
// float64 is necessary as input to math.Sqrt()
package main
import (
"fmt"
"math"
)
type Magnitude interface {
Abs() float64
}
var m Magnitude
type Point struct {
X, Y float64
}
func (p *Point) Scale(s float64) {
p.X *= s
p.Y *= s
}
func (p *Point) Abs() float64 {
return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}
type Point3 struct {
X, Y, Z float64
}
func (p *Point3) Abs() float64 {
return math.Sqrt(float64(p.X*p.X + p.Y*p.Y + p.Z*p.Z))
}
type Polar struct {
R, Theta float64
}
func (p Polar) Abs() float64 { return p.R }
func main() {
p1 := new(Point)
p1.X = 3
p1.Y = 4
m = p1 // p1 is type *Point, has method Abs()
fmt.Printf("The length of the vector p1 is: %f\n", m.Abs())
p2 := &Point{4, 5}
m = p2
fmt.Printf("The length of the vector p2 is: %f\n", m.Abs())
p1.Scale(5)
m = p1
fmt.Printf("The length of the vector p1 after scaling is: %f\n", m.Abs())
fmt.Printf("Point p1 after scaling has the following coordinates: X %f - Y %f\n", p1.X, p1.Y)
mag := m.Abs()
m = &Point3{3, 4, 5}
mag += m.Abs()
m = Polar{2.0, math.Pi / 2}
mag += m.Abs()
fmt.Printf("The float64 mag is now: %f", mag)
}
/* Output:
The length of the vector p1 is: 5.000000
The length of the vector p2 is: 6.403124
The length of the vector p1 after scaling is: 25.000000
Point p1 after scaling has the following coordinates: X 15.000000 - Y 20.000000
The float64 mag is now: 34.071068
-- instead of:
func (p *Point) Abs() float64 {
return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}
m = p1
we can write:
func (p Point) Abs() float64 {
return math.Sqrt(float64(p.X*p.X + p.Y*p.Y))
}
m = p1
and instead of:
func (p Polar) Abs() float64 { return p.R }
m = Polar{2.0, math.Pi / 2}
we can write:
func (p *Polar) Abs() float64 { return p.R }
m = &Polar{2.0, math.Pi / 2}
with the same output
*/

93
eBook/exercises/chapter_11/print.go
View File

@@ -1,43 +1,50 @@
// print.go
package main
import (
"os"
"strconv"
)
type Stringer interface {
String() string
}
type Celsius float64
func (c Celsius) String() string {
return strconv.FormatFloat(float64(c),'f', 1, 64) + " °C"
}
type Day int
var dayName = []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
func (day Day) String() string {
return dayName[day]
}
func print(args ...interface{}) {
for i, arg := range args {
if i > 0 {os.Stdout.WriteString(" ")}
switch a := arg.(type) { // type switch
case Stringer: os.Stdout.WriteString(a.String())
case int: os.Stdout.WriteString(strconv.Itoa(a))
case string: os.Stdout.WriteString(a)
// more types
default: os.Stdout.WriteString("???")
}
}
}
func main() {
print(Day(1), "was", Celsius(18.36)) // Tuesday was 18.4 °C
}
// Tuesday was 18.4 °C
// print.go
package main
import (
"os"
"strconv"
)
type Stringer interface {
String() string
}
type Celsius float64
func (c Celsius) String() string {
return strconv.FormatFloat(float64(c), 'f', 1, 64) + " °C"
}
type Day int
var dayName = []string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}
func (day Day) String() string {
return dayName[day]
}
func print(args ...interface{}) {
for i, arg := range args {
if i > 0 {
os.Stdout.WriteString(" ")
}
switch a := arg.(type) { // type switch
case Stringer:
os.Stdout.WriteString(a.String())
case int:
os.Stdout.WriteString(strconv.Itoa(a))
case string:
os.Stdout.WriteString(a)
// more types
default:
os.Stdout.WriteString("???")
}
}
}
func main() {
print(Day(1), "was", Celsius(18.36)) // Tuesday was 18.4 °C
}
// Tuesday was 18.4 °C

69
eBook/exercises/chapter_11/simple_interface.go
View File

@@ -1,34 +1,35 @@
// simple_interface.go
package main
import (
"fmt"
)
type Simpler interface {
Get() int
Put(int)
}
type Simple struct {
i int
}
func (p *Simple) Get() int {
return p.i
}
func (p *Simple) Put(u int) {
p.i = u
}
func fI(it Simpler) int {
it.Put(5)
return it.Get()
}
func main() {
var s Simple
fmt.Println(fI(&s)) // &s is required because Get() is defined with a receiver type pointer
}
// Output: 5
// simple_interface.go
package main
import (
"fmt"
)
type Simpler interface {
Get() int
Put(int)
}
type Simple struct {
i int
}
func (p *Simple) Get() int {
return p.i
}
func (p *Simple) Put(u int) {
p.i = u
}
func fI(it Simpler) int {
it.Put(5)
return it.Get()
}
func main() {
var s Simple
fmt.Println(fI(&s)) // &s is required because Get() is defined with a receiver type pointer
}
// Output: 5

123
eBook/exercises/chapter_11/simple_interface2.go
View File

@@ -1,61 +1,62 @@
// simple_interface2.go
package main
import (
"fmt"
)
type Simpler interface {
Get() int
Set(int)
}
type Simple struct {
i int
}
func (p *Simple) Get() int {
return p.i
}
func (p *Simple) Set(u int) {
p.i = u
}
type RSimple struct {
i int
j int
}
func (p *RSimple) Get() int {
return p.j
}
func (p *RSimple) Set(u int) {
p.j = u
}
func fI(it Simpler) int {
switch it.(type) {
case *Simple:
it.Set(5)
return it.Get()
case *RSimple:
it.Set(50)
return it.Get()
default:
return 99
}
return 0
}
func main() {
var s Simple
fmt.Println(fI(&s)) // &s is required because Get() is defined with a receiver type pointer
var r RSimple
fmt.Println(fI(&r))
}
/* Output:
5
50
*/
// simple_interface2.go
package main
import (
"fmt"
)
type Simpler interface {
Get() int
Set(int)
}
type Simple struct {
i int
}
func (p *Simple) Get() int {
return p.i
}
func (p *Simple) Set(u int) {
p.i = u
}
type RSimple struct {
i int
j int
}
func (p *RSimple) Get() int {
return p.j
}
func (p *RSimple) Set(u int) {
p.j = u
}
func fI(it Simpler) int {
switch it.(type) {
case *Simple:
it.Set(5)
return it.Get()
case *RSimple:
it.Set(50)
return it.Get()
default:
return 99
}
return 0
}
func main() {
var s Simple
fmt.Println(fI(&s)) // &s is required because Get() is defined with a receiver type pointer
var r RSimple
fmt.Println(fI(&r))
}
/* Output:
5
50
*/

149
eBook/exercises/chapter_11/simple_interface3.go
View File

@@ -1,74 +1,75 @@
// simple_interface2.go
package main
import (
"fmt"
)
type Simpler interface {
Get() int
Set(int)
}
type Simple struct {
i int
}
func (p *Simple) Get() int {
return p.i
}
func (p *Simple) Set(u int) {
p.i = u
}
type RSimple struct {
i int
j int
}
func (p *RSimple) Get() int {
return p.j
}
func (p *RSimple) Set(u int) {
p.j = u
}
func fI(it Simpler) int {
switch it.(type) {
case *Simple:
it.Set(5)
return it.Get()
case *RSimple:
it.Set(50)
return it.Get()
default:
return 99
}
return 0
}
func gI(any interface{}) int {
// return any.(Simpler).Get() // unsafe, runtime panic possible
if v, ok := any.(Simpler); ok {
return v.Get()
}
return 0 // default value
}
/* Output:
6
60
*/
func main() {
var s Simple = Simple{6}
fmt.Println(gI(&s)) // &s is required because Get() is defined with a receiver type pointer
var r RSimple = RSimple{60,60}
fmt.Println(gI(&r))
}
/* Output:
6
60
*/
// simple_interface2.go
package main
import (
"fmt"
)
type Simpler interface {
Get() int
Set(int)
}
type Simple struct {
i int
}
func (p *Simple) Get() int {
return p.i
}
func (p *Simple) Set(u int) {
p.i = u
}
type RSimple struct {
i int
j int
}
func (p *RSimple) Get() int {
return p.j
}
func (p *RSimple) Set(u int) {
p.j = u
}
func fI(it Simpler) int {
switch it.(type) {
case *Simple:
it.Set(5)
return it.Get()
case *RSimple:
it.Set(50)
return it.Get()
default:
return 99
}
return 0
}
func gI(any interface{}) int {
// return any.(Simpler).Get() // unsafe, runtime panic possible
if v, ok := any.(Simpler); ok {
return v.Get()
}
return 0 // default value
}
/* Output:
6
60
*/
func main() {
var s Simple = Simple{6}
fmt.Println(gI(&s)) // &s is required because Get() is defined with a receiver type pointer
var r RSimple = RSimple{60, 60}
fmt.Println(gI(&r))
}
/* Output:
6
60
*/

120
eBook/exercises/chapter_11/sort/sort.go
View File

@@ -1,60 +1,60 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package sort
type Sorter interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}
/*
func Sort(Sorter Interface) {
for i := 1; i < data.Len(); i++ {
for j := i; j > 0 && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
}
*/
func Sort(data Sorter) {
for pass:=1; pass < data.Len(); pass++ {
for i:=0; i < data.Len() - pass; i++ {
if data.Less(i+1, i) {
data.Swap(i, i+1)
}
}
}
}
func IsSorted(data Sorter) bool {
n := data.Len()
for i := n - 1; i > 0; i-- {
if data.Less(i, i-1) {
return false
}
}
return true
}
// Convenience types for common cases
type IntArray []int
func (p IntArray) Len() int { return len(p) }
func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }
func (p IntArray) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
type StringArray []string
func (p StringArray) Len() int { return len(p) }
func (p StringArray) Less(i, j int) bool { return p[i] < p[j] }
func (p StringArray) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
// Convenience wrappers for common cases
func SortInts(a []int) { Sort(IntArray(a)) }
func SortStrings(a []string) { Sort(StringArray(a)) }
func IntsAreSorted(a []int) bool { return IsSorted(IntArray(a)) }
func StringsAreSorted(a []string) bool { return IsSorted(StringArray(a)) }
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package sort
type Sorter interface {
Len() int
Less(i, j int) bool
Swap(i, j int)
}
/*
func Sort(Sorter Interface) {
for i := 1; i < data.Len(); i++ {
for j := i; j > 0 && data.Less(j, j-1); j-- {
data.Swap(j, j-1)
}
}
}
*/
func Sort(data Sorter) {
for pass := 1; pass < data.Len(); pass++ {
for i := 0; i < data.Len()-pass; i++ {
if data.Less(i+1, i) {
data.Swap(i, i+1)
}
}
}
}
func IsSorted(data Sorter) bool {
n := data.Len()
for i := n - 1; i > 0; i-- {
if data.Less(i, i-1) {
return false
}
}
return true
}
// Convenience types for common cases
type IntArray []int
func (p IntArray) Len() int { return len(p) }
func (p IntArray) Less(i, j int) bool { return p[i] < p[j] }
func (p IntArray) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
type StringArray []string
func (p StringArray) Len() int { return len(p) }
func (p StringArray) Less(i, j int) bool { return p[i] < p[j] }
func (p StringArray) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
// Convenience wrappers for common cases
func SortInts(a []int) { Sort(IntArray(a)) }
func SortStrings(a []string) { Sort(StringArray(a)) }
func IntsAreSorted(a []int) bool { return IsSorted(IntArray(a)) }
func StringsAreSorted(a []string) bool { return IsSorted(StringArray(a)) }

72
eBook/exercises/chapter_11/sort_persons.go
View File

@@ -1,36 +1,36 @@
// sort_persons.go
package main
import (
"fmt"
"./sort"
)
type Person struct {
firstName string
lastName string
}
type Persons []Person
func (p Persons) Len() int { return len(p) }
func (p Persons) Less(i, j int) bool {
in := p[i].lastName + " " + p[i].firstName
jn := p[j].lastName + " " + p[j].firstName
return in < jn
}
func (p Persons) Swap(i, j int) {
p[i], p[j] = p[j], p[i]
}
func main() {
p1 := Person{"Xavier","Papadopoulos"}
p2 := Person{"Chris","Naegels"}
p3 := Person{"John","Doe"}
arrP := Persons{p1,p2,p3}
fmt.Printf("Before sorting: %v\n", arrP)
sort.Sort(arrP)
fmt.Printf("After sorting: %v\n", arrP)
}
// sort_persons.go
package main
import (
"./sort"
"fmt"
)
type Person struct {
firstName string
lastName string
}
type Persons []Person
func (p Persons) Len() int { return len(p) }
func (p Persons) Less(i, j int) bool {
in := p[i].lastName + " " + p[i].firstName
jn := p[j].lastName + " " + p[j].firstName
return in < jn
}
func (p Persons) Swap(i, j int) {
p[i], p[j] = p[j], p[i]
}
func main() {
p1 := Person{"Xavier", "Papadopoulos"}
p2 := Person{"Chris", "Naegels"}
p3 := Person{"John", "Doe"}
arrP := Persons{p1, p2, p3}
fmt.Printf("Before sorting: %v\n", arrP)
sort.Sort(arrP)
fmt.Printf("After sorting: %v\n", arrP)
}

78
eBook/exercises/chapter_11/stack/stack_general.go
View File

@@ -1,39 +1,39 @@
// stack.go
package stack
import "errors"
type Stack []interface{}
func (stack Stack) Len() int {
return len(stack)
}
func (stack Stack) Cap() int {
return cap(stack)
}
func (stack Stack) IsEmpty() bool {
return len(stack) == 0
}
func (stack *Stack) Push(e interface{}) {
*stack = append(*stack, e)
}
func (stack Stack) Top() (interface{}, error) {
if len(stack) == 0 {
return nil, errors.New("stack is empty")
}
return stack[len(stack)-1], nil
}
func (stack *Stack) Pop() (interface{}, error) {
stk := *stack // dereference to a local variable stk
if len(stk) == 0 {
return nil, errors.New("stack is empty")
}
top := stk[len(stk)-1]
*stack = stk[:len(stk)-1] // shrink the stack
return top, nil
}
// stack.go
package stack
import "errors"
type Stack []interface{}
func (stack Stack) Len() int {
return len(stack)
}
func (stack Stack) Cap() int {
return cap(stack)
}
func (stack Stack) IsEmpty() bool {
return len(stack) == 0
}
func (stack *Stack) Push(e interface{}) {
*stack = append(*stack, e)
}
func (stack Stack) Top() (interface{}, error) {
if len(stack) == 0 {
return nil, errors.New("stack is empty")
}
return stack[len(stack)-1], nil
}
func (stack *Stack) Pop() (interface{}, error) {
stk := *stack // dereference to a local variable stk
if len(stk) == 0 {
return nil, errors.New("stack is empty")
}
top := stk[len(stk)-1]
*stack = stk[:len(stk)-1] // shrink the stack
return top, nil
}

56
eBook/exercises/chapter_11/stack/stack_general_v2.go
View File

@@ -1,28 +1,28 @@
// stack_general_v2.go
// Package collection implements a generic stack.
package collection
// The zero value for Stack is an empty stack ready to use.
type Stack struct {
data []interface{}
}
// Push adds x to the top of the stack.
func (s *Stack) Push(x interface{}) {
s.data = append(s.data, x)
}
// Pop removes and returns the top element of the stack.
// It's a run-time error to call Pop on an empty stack.
func (s *Stack) Pop() interface{} {
i := len(s.data) - 1
res := s.data[i]
s.data[i] = nil // to avoid memory leak
s.data = s.data[:i]
return res
}
// Size returns the number of elements in the stack.
func (s *Stack) Size() int {
return len(s.data)
}
// stack_general_v2.go
// Package collection implements a generic stack.
package collection
// The zero value for Stack is an empty stack ready to use.
type Stack struct {
data []interface{}
}
// Push adds x to the top of the stack.
func (s *Stack) Push(x interface{}) {
s.data = append(s.data, x)
}
// Pop removes and returns the top element of the stack.
// It's a run-time error to call Pop on an empty stack.
func (s *Stack) Pop() interface{} {
i := len(s.data) - 1
res := s.data[i]
s.data[i] = nil // to avoid memory leak
s.data = s.data[:i]
return res
}
// Size returns the number of elements in the stack.
func (s *Stack) Size() int {
return len(s.data)
}

110
eBook/exercises/chapter_12/calculator.go
View File

@@ -1,55 +1,55 @@
// calculator.go
// example: calculate 3 + 4 = 7 as input: 3 ENTER 4 ENTER + ENTER --> result = 7,
package main
import (
"fmt"
"strconv"
"bufio"
"os"
"./stack/stack"
)
func main() {
buf := bufio.NewReader(os.Stdin)
calc1 := new(stack.Stack)
fmt.Println("Give a number, an operator (+, -, *, /), or q to stop:")
for {
token, err := buf.ReadString('\n')
if err != nil {
fmt.Println("Input error !")
os.Exit(1)
}
token = token[0:len(token)-2] // remove "\r\n"
// fmt.Printf("--%s--\n",token) // debug statement
switch {
case token == "q": // stop als invoer = "q"
fmt.Println("Calculator stopped")
return
case token >= "0" && token <= "999999":
i, _ := strconv.Atoi(token)
calc1.Push(i)
case token == "+":
q, _ := calc1.Pop()
p, _ := calc1.Pop()
fmt.Printf("The result of %d %s %d = %d\n", p, token, q, p.(int) + q.(int))
case token == "-":
q, _ := calc1.Pop()
p, _ := calc1.Pop()
fmt.Printf("The result of %d %s %d = %d\n", p, token, q, p.(int) - q.(int))
case token == "*":
q, _ := calc1.Pop()
p, _ := calc1.Pop()
fmt.Printf("The result of %d %s %d = %d\n", p, token, q, p.(int) * q.(int))
case token == "/":
q, _ := calc1.Pop()
p, _ := calc1.Pop()
fmt.Printf("The result of %d %s %d = %d\n", p, token, q, p.(int) / q.(int))
default:
fmt.Println("No valid input")
}
}
}
// calculator.go
// example: calculate 3 + 4 = 7 as input: 3 ENTER 4 ENTER + ENTER --> result = 7,
package main
import (
"./stack/stack"
"bufio"
"fmt"
"os"
"strconv"
)
func main() {
buf := bufio.NewReader(os.Stdin)
calc1 := new(stack.Stack)
fmt.Println("Give a number, an operator (+, -, *, /), or q to stop:")
for {
token, err := buf.ReadString('\n')
if err != nil {
fmt.Println("Input error !")
os.Exit(1)
}
token = token[0 : len(token)-2] // remove "\r\n"
// fmt.Printf("--%s--\n",token) // debug statement
switch {
case token == "q": // stop als invoer = "q"
fmt.Println("Calculator stopped")
return
case token >= "0" && token <= "999999":
i, _ := strconv.Atoi(token)
calc1.Push(i)
case token == "+":
q, _ := calc1.Pop()
p, _ := calc1.Pop()
fmt.Printf("The result of %d %s %d = %d\n", p, token, q, p.(int)+q.(int))
case token == "-":
q, _ := calc1.Pop()
p, _ := calc1.Pop()
fmt.Printf("The result of %d %s %d = %d\n", p, token, q, p.(int)-q.(int))
case token == "*":
q, _ := calc1.Pop()
p, _ := calc1.Pop()
fmt.Printf("The result of %d %s %d = %d\n", p, token, q, p.(int)*q.(int))
case token == "/":
q, _ := calc1.Pop()
p, _ := calc1.Pop()
fmt.Printf("The result of %d %s %d = %d\n", p, token, q, p.(int)/q.(int))
default:
fmt.Println("No valid input")
}
}
}

86
eBook/exercises/chapter_12/cat_numbered.go
View File

@@ -1,43 +1,43 @@
package main
import (
"os"
"io"
"fmt"
"bufio"
"flag"
)
var numberFlag = flag.Bool("n", false, "number each line")
func cat(r *bufio.Reader) {
i := 1
for {
buf, err := r.ReadBytes('\n')
if err == io.EOF {
break
}
if *numberFlag {
fmt.Fprintf(os.Stdout, "%5d %s", i, buf)
i++
} else {
fmt.Fprintf(os.Stdout, "%s", buf)
}
}
return
}
func main() {
flag.Parse()
if flag.NArg() == 0 {
cat(bufio.NewReader(os.Stdin))
}
for i := 0; i < flag.NArg(); i++ {
f, err := os.Open(flag.Arg(i))
if err != nil {
fmt.Fprintf(os.Stderr, "%s:error reading from %s: %s\n", os.Args[0], flag.Arg(i), err.Error())
continue
}
cat(bufio.NewReader(f))
}
}
package main
import (
"bufio"
"flag"
"fmt"
"io"
"os"
)
var numberFlag = flag.Bool("n", false, "number each line")
func cat(r *bufio.Reader) {
i := 1
for {
buf, err := r.ReadBytes('\n')
if err == io.EOF {
break
}
if *numberFlag {
fmt.Fprintf(os.Stdout, "%5d %s", i, buf)
i++
} else {
fmt.Fprintf(os.Stdout, "%s", buf)
}
}
return
}
func main() {
flag.Parse()
if flag.NArg() == 0 {
cat(bufio.NewReader(os.Stdin))
}
for i := 0; i < flag.NArg(); i++ {
f, err := os.Open(flag.Arg(i))
if err != nil {
fmt.Fprintf(os.Stderr, "%s:error reading from %s: %s\n", os.Args[0], flag.Arg(i), err.Error())
continue
}
cat(bufio.NewReader(f))
}
}

83
eBook/exercises/chapter_12/degob.go
View File

@@ -1,41 +1,42 @@
// degob.go
package main
import (
"bufio"
"fmt"
"encoding/gob"
"log"
"os"
)
type Address struct {
Type string
City string
Country string
}
type VCard struct {
FirstName string
LastName string
Addresses []*Address
Remark string
}
var content string
var vc VCard
func main() {
// using a decoder:
file, _ := os.Open("vcard.gob")
defer file.Close()
inReader := bufio.NewReader(file)
dec := gob.NewDecoder(inReader)
err := dec.Decode(&vc)
if err != nil {
log.Println("Error in decoding gob")
}
fmt.Println(vc)
}
// Output:
// {Jan Kersschot [0x12642e60 0x12642e80] none}
// degob.go
package main
import (
"bufio"
"encoding/gob"
"fmt"
"log"
"os"
)
type Address struct {
Type string
City string
Country string
}
type VCard struct {
FirstName string
LastName string
Addresses []*Address
Remark string
}
var content string
var vc VCard
func main() {
// using a decoder:
file, _ := os.Open("vcard.gob")
defer file.Close()
inReader := bufio.NewReader(file)
dec := gob.NewDecoder(inReader)
err := dec.Decode(&vc)
if err != nil {
log.Println("Error in decoding gob")
}
fmt.Println(vc)
}
// Output:
// {Jan Kersschot [0x12642e60 0x12642e80] none}

41
eBook/exercises/chapter_12/hash_md5.go
View File

@@ -1,20 +1,21 @@
// hash_md5.go
package main
import (
"fmt";
"crypto/md5"
"io"
)
func main() {
hasher := md5.New()
b := []byte{}
io.WriteString(hasher, "test")
fmt.Printf("Result: %x\n", hasher.Sum(b))
fmt.Printf("Result: %d\n", hasher.Sum(b))
}
/* Output:
Result: 098f6bcd4621d373cade4e832627b4f6
Result: [9 143 107 205 70 33 211 115 202 222 78 131 38 39 180 246]
*/
// hash_md5.go
package main
import (
"crypto/md5"
"fmt"
"io"
)
func main() {
hasher := md5.New()
b := []byte{}
io.WriteString(hasher, "test")
fmt.Printf("Result: %x\n", hasher.Sum(b))
fmt.Printf("Result: %d\n", hasher.Sum(b))
}
/* Output:
Result: 098f6bcd4621d373cade4e832627b4f6
Result: [9 143 107 205 70 33 211 115 202 222 78 131 38 39 180 246]
*/

32
eBook/exercises/chapter_12/hello_who.go
View File

@@ -1,16 +1,16 @@
// hello_who.go
package main
import (
"fmt"
"os"
"strings"
)
func main() {
who := "World"
if len(os.Args) > 1 { // os.Args[0] == hello_who
who = strings.Join(os.Args[1:], " ")
}
fmt.Println("Hello", who, "!")
}
// hello_who.go
package main
import (
"fmt"
"os"
"strings"
)
func main() {
who := "World"
if len(os.Args) > 1 { // os.Args[0] == hello_who
who = strings.Join(os.Args[1:], " ")
}
fmt.Println("Hello", who, "!")
}

135
eBook/exercises/chapter_12/read_csv.go
View File

@@ -1,67 +1,68 @@
// read_csv.go
package main
import (
"bufio"
"fmt"
"log"
"io"
"os"
"strconv"
"strings"
)
type Book struct {
title string
price float64
quantity int
}
func main() {
bks := make([]Book, 1)
file, err := os.Open("products.txt")
if err != nil {
log.Fatalf("Error %s opening file products.txt: ", err)
}
defer file.Close()
reader := bufio.NewReader(file)
for {
// read one line from the file:
line, err := reader.ReadString('\n')
if err == io.EOF {
break
}
// remove \r and \n so 2(in Windows, in Linux only \n, so 1):
line = string(line[:len(line)-2])
//fmt.Printf("The input was: -%s-", line)
strSl := strings.Split(line, ";")
book := new(Book)
book.title = strSl[0]
book.price, err = strconv.ParseFloat(strSl[1], 32)
if err!=nil {
fmt.Printf("Error in file: %v", err)
}
//fmt.Printf("The quan was:-%s-", strSl[2])
book.quantity, err = strconv.Atoi(strSl[2])
if err!=nil {
fmt.Printf("Error in file: %v", err)
}
if bks[0].title == "" {
bks[0] = *book
} else {
bks = append(bks, *book)
}
}
fmt.Println("We have read the following books from the file: ")
for _, bk := range bks {
fmt.Println(bk)
}
}
/* Output:
We have read the following books from the file:
{"The ABC of Go" 25.5 1500}
{"Functional Programming with Go" 56 280}
{"Go for It" 45.900001525878906 356}
*/
// read_csv.go
package main
import (
"bufio"
"fmt"
"io"
"log"
"os"
"strconv"
"strings"
)
type Book struct {
title string
price float64
quantity int
}
func main() {
bks := make([]Book, 1)
file, err := os.Open("products.txt")
if err != nil {
log.Fatalf("Error %s opening file products.txt: ", err)
}
defer file.Close()
reader := bufio.NewReader(file)
for {
// read one line from the file:
line, err := reader.ReadString('\n')
if err == io.EOF {
break
}
// remove \r and \n so 2(in Windows, in Linux only \n, so 1):
line = string(line[:len(line)-2])
//fmt.Printf("The input was: -%s-", line)
strSl := strings.Split(line, ";")
book := new(Book)
book.title = strSl[0]
book.price, err = strconv.ParseFloat(strSl[1], 32)
if err != nil {
fmt.Printf("Error in file: %v", err)
}
//fmt.Printf("The quan was:-%s-", strSl[2])
book.quantity, err = strconv.Atoi(strSl[2])
if err != nil {
fmt.Printf("Error in file: %v", err)
}
if bks[0].title == "" {
bks[0] = *book
} else {
bks = append(bks, *book)
}
}
fmt.Println("We have read the following books from the file: ")
for _, bk := range bks {
fmt.Println(bk)
}
}
/* Output:
We have read the following books from the file:
{"The ABC of Go" 25.5 1500}
{"Functional Programming with Go" 56 280}
{"Go for It" 45.900001525878906 356}
*/

74
eBook/exercises/chapter_12/remove_3till5char.go
View File

@@ -1,37 +1,37 @@
// remove_first6char.go
package main
import (
"fmt"
"io"
"bufio"
"os"
)
func main() {
inputFile, _ := os.Open("goprogram")
outputFile, _ := os.OpenFile("goprogramT", os.O_WRONLY|os.O_CREATE, 0666)
defer inputFile.Close()
defer outputFile.Close()
inputReader := bufio.NewReader(inputFile)
outputWriter := bufio.NewWriter(outputFile)
for {
// inputString, readerError := inputReader.ReadString('\n')
inputString, _, readerError := inputReader.ReadLine()
if readerError == io.EOF {
fmt.Println("EOF")
break
}
//fmt.Printf("The input was: --%s--", inputString)
outputString := string([]byte(inputString)[2:5]) + "\r\n"
//fmt.Printf("The output was: --%s--", outputString)
_, err := outputWriter.WriteString(outputString)
//fmt.Printf("Number of bytes written %d\n", n)
if (err != nil) {
fmt.Println(err)
return
}
}
outputWriter.Flush()
fmt.Println("Conversion done")
}
// remove_first6char.go
package main
import (
"bufio"
"fmt"
"io"
"os"
)
func main() {
inputFile, _ := os.Open("goprogram")
outputFile, _ := os.OpenFile("goprogramT", os.O_WRONLY|os.O_CREATE, 0666)
defer inputFile.Close()
defer outputFile.Close()
inputReader := bufio.NewReader(inputFile)
outputWriter := bufio.NewWriter(outputFile)
for {
// inputString, readerError := inputReader.ReadString('\n')
inputString, _, readerError := inputReader.ReadLine()
if readerError == io.EOF {
fmt.Println("EOF")
break
}
//fmt.Printf("The input was: --%s--", inputString)
outputString := string([]byte(inputString)[2:5]) + "\r\n"
//fmt.Printf("The output was: --%s--", outputString)
_, err := outputWriter.WriteString(outputString)
//fmt.Printf("Number of bytes written %d\n", n)
if err != nil {
fmt.Println(err)
return
}
}
outputWriter.Flush()
fmt.Println("Conversion done")
}

64
eBook/exercises/chapter_12/stack/stack_struct.go
View File

@@ -1,32 +1,32 @@
// stack_struct.go
package stack
import "strconv"
const LIMIT = 10
type Stack struct {
ix int // first free position, so data[ix] == 0
data [LIMIT]int
}
func (st *Stack) Push(n int) {
if (st.ix + 1 > LIMIT) {
return // stack is full!
}
st.data[st.ix] = n
st.ix++
}
func (st *Stack) Pop() int {
st.ix--
return st.data[st.ix]
}
func (st Stack) String() string {
str := ""
for ix:=0; ix<st.ix; ix++ {
str += "[" + strconv.Itoa(ix) + ":" + strconv.Itoa(st.data[ix]) + "] "
}
return str
}
// stack_struct.go
package stack
import "strconv"
const LIMIT = 10
type Stack struct {
ix int // first free position, so data[ix] == 0
data [LIMIT]int
}
func (st *Stack) Push(n int) {
if st.ix+1 > LIMIT {
return // stack is full!
}
st.data[st.ix] = n
st.ix++
}
func (st *Stack) Pop() int {
st.ix--
return st.data[st.ix]
}
func (st Stack) String() string {
str := ""
for ix := 0; ix < st.ix; ix++ {
str += "[" + strconv.Itoa(ix) + ":" + strconv.Itoa(st.data[ix]) + "] "
}
return str
}

1
eBook/exercises/chapter_12/wiki_part1.go
View File

@@ -33,6 +33,7 @@ func main() {
new_page.load("Page.md")
fmt.Println(string(new_page.Body))
}
/* Output:
* # Page
* ## Section1

73
eBook/exercises/chapter_12/word_letter_count.go
View File

@@ -1,36 +1,37 @@
// Q28_word_letter_count.go
package main
import (
"fmt"
"bufio"
"os"
"strings"
)
var nrchars, nrwords, nrlines int
func main() {
nrchars, nrwords, nrlines = 0, 0, 0
inputReader := bufio.NewReader(os.Stdin)
fmt.Println("Please enter some input, type S to stop: ")
for {
input, err := inputReader.ReadString('\n')
if err != nil {
fmt.Printf("An error occurred: %s\n", err)
}
if input == "S\r\n" { // Windows, on Linux it is "S\n"
fmt.Println("Here are the counts:")
fmt.Printf("Number of characters: %d\n", nrchars)
fmt.Printf("Number of words: %d\n", nrwords)
fmt.Printf("Number of lines: %d\n", nrlines)
os.Exit(0)
}
Counters(input)
}
}
func Counters(input string) {
nrchars += len(input) - 2 // -2 for \r\n
nrwords += len(strings.Fields(input))
nrlines++
}
// Q28_word_letter_count.go
package main
import (
"bufio"
"fmt"
"os"
"strings"
)
var nrchars, nrwords, nrlines int
func main() {
nrchars, nrwords, nrlines = 0, 0, 0
inputReader := bufio.NewReader(os.Stdin)
fmt.Println("Please enter some input, type S to stop: ")
for {
input, err := inputReader.ReadString('\n')
if err != nil {
fmt.Printf("An error occurred: %s\n", err)
}
if input == "S\r\n" { // Windows, on Linux it is "S\n"
fmt.Println("Here are the counts:")
fmt.Printf("Number of characters: %d\n", nrchars)
fmt.Printf("Number of words: %d\n", nrwords)
fmt.Printf("Number of lines: %d\n", nrlines)
os.Exit(0)
}
Counters(input)
}
}
func Counters(input string) {
nrchars += len(input) - 2 // -2 for \r\n
nrwords += len(strings.Fields(input))
nrlines++
}

89
eBook/exercises/chapter_13/panic_defer.go
View File

@@ -1,44 +1,45 @@
// panic_defer.go
package main
import "fmt"
func main() {
f()
fmt.Println("Returned normally from f.")
}
func f() {
defer func() {
if r := recover(); r != nil {
fmt.Println("Recovered in f", r)
}
}()
fmt.Println("Calling g.")
g(0)
fmt.Println("Returned normally from g.")
}
func g(i int) {
if i > 3 {
fmt.Println("Panicking!")
panic(fmt.Sprintf("%v", i))
}
defer fmt.Println("Defer in g", i)
fmt.Println("Printing in g", i)
g(i + 1)
}
/* Output:
Calling g.
Printing in g 0
Printing in g 1
Printing in g 2
Printing in g 3
Panicking!
Defer in g 3
Defer in g 2
Defer in g 1
Defer in g 0
Recovered in f 4
Returned normally from f.
*/
// panic_defer.go
package main
import "fmt"
func main() {
f()
fmt.Println("Returned normally from f.")
}
func f() {
defer func() {
if r := recover(); r != nil {
fmt.Println("Recovered in f", r)
}
}()
fmt.Println("Calling g.")
g(0)
fmt.Println("Returned normally from g.")
}
func g(i int) {
if i > 3 {
fmt.Println("Panicking!")
panic(fmt.Sprintf("%v", i))
}
defer fmt.Println("Defer in g", i)
fmt.Println("Printing in g", i)
g(i + 1)
}
/* Output:
Calling g.
Printing in g 0
Printing in g 1
Printing in g 2
Printing in g 3
Panicking!
Defer in g 3
Defer in g 2
Defer in g 1
Defer in g 0
Recovered in f 4
Returned normally from f.
*/

89
eBook/exercises/chapter_13/panic_defer_convint.go
View File

@@ -1,44 +1,45 @@
// panic_defer_convint.go
package main
import (
"fmt"
"math"
)
func main() {
l := int64(15000)
if i, err := IntFromInt64(l); err!= nil {
fmt.Printf("The conversion of %d to an int32 resulted in an error: %s", l, err.Error())
} else {
fmt.Printf("%d converted to an int32 is %d", l, i)
}
fmt.Println()
l = int64(math.MaxInt32 + 15000)
if i, err := IntFromInt64(l); err!= nil {
fmt.Printf("The conversion of %d to an int32 resulted in an error: %s", l, err.Error())
} else {
fmt.Printf("%d converted to an int32 is %d", l, i)
}
}
func ConvertInt64ToInt(l int64) int {
if math.MinInt32 <= l && l <= math.MaxInt32 {
return int(l)
}
panic(fmt.Sprintf("%d is out of the int32 range", l))
}
func IntFromInt64(l int64) (i int, err error) {
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("%v", e)
}
}()
i = ConvertInt64ToInt(l)
return i, nil
}
/* Output:
15000 converted to an int32 is 15000
The conversion of 2147498647 to an int32 resulted in an error: 2147498647 is out of the int32 range
*/
// panic_defer_convint.go
package main
import (
"fmt"
"math"
)
func main() {
l := int64(15000)
if i, err := IntFromInt64(l); err != nil {
fmt.Printf("The conversion of %d to an int32 resulted in an error: %s", l, err.Error())
} else {
fmt.Printf("%d converted to an int32 is %d", l, i)
}
fmt.Println()
l = int64(math.MaxInt32 + 15000)
if i, err := IntFromInt64(l); err != nil {
fmt.Printf("The conversion of %d to an int32 resulted in an error: %s", l, err.Error())
} else {
fmt.Printf("%d converted to an int32 is %d", l, i)
}
}
func ConvertInt64ToInt(l int64) int {
if math.MinInt32 <= l && l <= math.MaxInt32 {
return int(l)
}
panic(fmt.Sprintf("%d is out of the int32 range", l))
}
func IntFromInt64(l int64) (i int, err error) {
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("%v", e)
}
}()
i = ConvertInt64ToInt(l)
return i, nil
}
/* Output:
15000 converted to an int32 is 15000
The conversion of 2147498647 to an int32 resulted in an error: 2147498647 is out of the int32 range
*/

69
eBook/exercises/chapter_13/recover_divbyzero.go
View File

@@ -1,34 +1,35 @@
// recover_divbyzero.go
package main
import (
"fmt"
)
func badCall() {
a, b := 10, 0
n := a / b
fmt.Println(n)
}
func test() {
defer func() {
if e := recover(); e != nil {
fmt.Printf("Panicing %s\r\n", e);
}
}()
badCall()
fmt.Printf("After bad call\r\n");
}
func main() {
fmt.Printf("Calling test\r\n");
test()
fmt.Printf("Test completed\r\n");
}
/* Output:
Calling test
Panicing runtime error: integer divide by zero
Test completed
*/
// recover_divbyzero.go
package main
import (
"fmt"
)
func badCall() {
a, b := 10, 0
n := a / b
fmt.Println(n)
}
func test() {
defer func() {
if e := recover(); e != nil {
fmt.Printf("Panicing %s\r\n", e)
}
}()
badCall()
fmt.Printf("After bad call\r\n")
}
func main() {
fmt.Printf("Calling test\r\n")
test()
fmt.Printf("Test completed\r\n")
}
/* Output:
Calling test
Panicing runtime error: integer divide by zero
Test completed
*/

36
eBook/exercises/chapter_13/string_reverse.go
View File

@@ -1,18 +1,18 @@
// string_reverse.go
package strev
func Reverse(s string) string {
runes := []rune(s)
n, h := len(runes), len(runes)/2
for i := 0; i < h; i++ {
runes[i], runes[n-1-i] = runes[n-1-i], runes[i]
}
return string(runes)
}
/*
func main() {
s := "My Test String!"
fmt.Println(s, " --> ", Reverse(s))
}
*/
// string_reverse.go
package strev
func Reverse(s string) string {
runes := []rune(s)
n, h := len(runes), len(runes)/2
for i := 0; i < h; i++ {
runes[i], runes[n-1-i] = runes[n-1-i], runes[i]
}
return string(runes)
}
/*
func main() {
s := "My Test String!"
fmt.Println(s, " --> ", Reverse(s))
}
*/

80
eBook/exercises/chapter_13/string_reverse_test.go
View File

@@ -1,40 +1,40 @@
// string_reverse_test.go
package strev
import "testing"
import "./strev"
type ReverseTest struct {
in, out string
}
var ReverseTests = []ReverseTest {
ReverseTest{"ABCD", "DCBA"},
ReverseTest{"CVO-AZ", "ZA-OVC"},
ReverseTest{"Hello 世界", "界世 olleH"},
}
func TestReverse(t *testing.T) {
/*
in := "CVO-AZ"
out := Reverse(in)
exp := "ZA-OVC"
if out != exp {
t.Errorf("Reverse of %s expects %s, but got %s", in, exp, out)
}
*/
// testing with a battery of testdata:
for _, r := range ReverseTests {
exp := strev.Reverse(r.in)
if r.out != exp {
t.Errorf("Reverse of %s expects %s, but got %s", r.in, exp, r.out)
}
}
}
func BenchmarkReverse(b *testing.B) {
s := "ABCD"
for i:=0; i < b.N; i++ {
strev.Reverse(s)
}
}
// string_reverse_test.go
package strev
import "testing"
import "./strev"
type ReverseTest struct {
in, out string
}
var ReverseTests = []ReverseTest{
{"ABCD", "DCBA"},
{"CVO-AZ", "ZA-OVC"},
{"Hello 世界", "界世 olleH"},
}
func TestReverse(t *testing.T) {
/*
in := "CVO-AZ"
out := Reverse(in)
exp := "ZA-OVC"
if out != exp {
t.Errorf("Reverse of %s expects %s, but got %s", in, exp, out)
}
*/
// testing with a battery of testdata:
for _, r := range ReverseTests {
exp := strev.Reverse(r.in)
if r.out != exp {
t.Errorf("Reverse of %s expects %s, but got %s", r.in, exp, r.out)
}
}
}
func BenchmarkReverse(b *testing.B) {
s := "ABCD"
for i := 0; i < b.N; i++ {
strev.Reverse(s)
}
}

38
eBook/exercises/chapter_14/blocking.go
View File

@@ -1,19 +1,19 @@
// blocking.go
// throw: all goroutines are asleep - deadlock!
package main
import (
"fmt"
)
func f1(in chan int) {
fmt.Println(<-in)
}
func main() {
out := make(chan int)
//out := make(chan int, 1) // solution 2
// go f1(out) // solution 1
out <- 2
go f1(out)
}
// blocking.go
// throw: all goroutines are asleep - deadlock!
package main
import (
"fmt"
)
func f1(in chan int) {
fmt.Println(<-in)
}
func main() {
out := make(chan int)
//out := make(chan int, 1) // solution 2
// go f1(out) // solution 1
out <- 2
go f1(out)
}

45
eBook/exercises/chapter_14/channel_block3.go
View File

@@ -1,22 +1,23 @@
package main
import "fmt"
import "time"
func main() {
c := make(chan int)
go func() {
time.Sleep(15 * 1e9)
x := <-c
fmt.Println("received", x)
}()
fmt.Println("sending", 10)
c <- 10
fmt.Println("sent", 10)
}
/* Output:
sending 10
(15 s later):
received 10
sent 10
*/
package main
import "fmt"
import "time"
func main() {
c := make(chan int)
go func() {
time.Sleep(15 * 1e9)
x := <-c
fmt.Println("received", x)
}()
fmt.Println("sending", 10)
c <- 10
fmt.Println("sent", 10)
}
/* Output:
sending 10
(15 s later):
received 10
sent 10
*/

43
eBook/exercises/chapter_14/channel_buffer.go
View File

@@ -1,21 +1,22 @@
package main
import "fmt"
import "time"
func main() {
c := make(chan int, 50)
go func() {
time.Sleep(15 * 1e9)
x := <-c
fmt.Println("received", x)
}()
fmt.Println("sending", 10)
c <- 10
fmt.Println("sent", 10)
}
/* Output:
sending 10
sent 10 // prints immediately
no further output, because main() then stops
*/
package main
import "fmt"
import "time"
func main() {
c := make(chan int, 50)
go func() {
time.Sleep(15 * 1e9)
x := <-c
fmt.Println("received", x)
}()
fmt.Println("sending", 10)
c <- 10
fmt.Println("sent", 10)
}
/* Output:
sending 10
sent 10 // prints immediately
no further output, because main() then stops
*/

91
eBook/exercises/chapter_14/concurrent_pi.go
View File

@@ -1,45 +1,46 @@
// Concurrent computation of pi.
// See http://goo.gl/ZuTZM. - Comparison with Scala!
//
// This demonstrates Go's ability to handle
// large numbers of concurrent processes.
// It is an unreasonable way to calculate pi.
package main
import (
"fmt"
"math"
"time"
)
func main() {
start := time.Now()
fmt.Println(CalculatePi(5000))
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)
}
// CalculatePi launches n goroutines to compute an
// series-approximation of pi.
func CalculatePi(n int) float64 {
ch := make(chan float64)
for k := 0; k <= n; k++ {
// calculate k-th term in the series
go term(ch, float64(k))
}
f := 0.0
//wait for all goroutines to complete, get and sum up their results:
for k := 0; k <= n; k++ {
f += <-ch
}
return f
}
func term(ch chan float64, k float64) {
ch <- 4 * math.Pow(-1, k) / (2*k + 1)
}
/* Output:
3.14179261359579
The calculation took this amount of time: 0.028002
*/
// Concurrent computation of pi.
// See http://goo.gl/ZuTZM. - Comparison with Scala!
//
// This demonstrates Go's ability to handle
// large numbers of concurrent processes.
// It is an unreasonable way to calculate pi.
package main
import (
"fmt"
"math"
"time"
)
func main() {
start := time.Now()
fmt.Println(CalculatePi(5000))
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)
}
// CalculatePi launches n goroutines to compute an
// series-approximation of pi.
func CalculatePi(n int) float64 {
ch := make(chan float64)
for k := 0; k <= n; k++ {
// calculate k-th term in the series
go term(ch, float64(k))
}
f := 0.0
//wait for all goroutines to complete, get and sum up their results:
for k := 0; k <= n; k++ {
f += <-ch
}
return f
}
func term(ch chan float64, k float64) {
ch <- 4 * math.Pow(-1, k) / (2*k + 1)
}
/* Output:
3.14179261359579
The calculation took this amount of time: 0.028002
*/

91
eBook/exercises/chapter_14/concurrent_pi2.go
View File

@@ -1,45 +1,46 @@
// concurrent_pi2.go
package main
import (
"fmt"
"math"
"runtime"
"time"
)
const NCPU = 2
func main() {
start := time.Now()
runtime.GOMAXPROCS(2)
fmt.Println(CalculatePi(5000))
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)
}
func CalculatePi(end int) float64 {
ch := make(chan float64)
for i := 0; i < NCPU; i++ {
go term(ch, i*end/NCPU, (i+1)*end/NCPU)
}
result := 0.0
for i := 0; i < NCPU; i++ {
result += <-ch
}
return result
}
func term(ch chan float64, start, end int) {
result := 0.0
for i := start; i < end; i++ {
x := float64(i)
result += 4 * (math.Pow(-1, x) / (2.0*x + 1.0))
}
ch <- result
}
/* Output:
3.1413926535917938
The calculation took this amount of time: 0.002000
*/
// concurrent_pi2.go
package main
import (
"fmt"
"math"
"runtime"
"time"
)
const NCPU = 2
func main() {
start := time.Now()
runtime.GOMAXPROCS(2)
fmt.Println(CalculatePi(5000))
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)
}
func CalculatePi(end int) float64 {
ch := make(chan float64)
for i := 0; i < NCPU; i++ {
go term(ch, i*end/NCPU, (i+1)*end/NCPU)
}
result := 0.0
for i := 0; i < NCPU; i++ {
result += <-ch
}
return result
}
func term(ch chan float64, start, end int) {
result := 0.0
for i := start; i < end; i++ {
x := float64(i)
result += 4 * (math.Pow(-1, x) / (2.0*x + 1.0))
}
ch <- result
}
/* Output:
3.1413926535917938
The calculation took this amount of time: 0.002000
*/

119
eBook/exercises/chapter_14/general_lazy_evalution2.go
View File

@@ -1,59 +1,60 @@
package main
import (
"fmt"
)
type Any interface{}
type EvalFunc func(Any) (Any, Any)
func main() {
fibFunc := func(state Any) (Any, Any) {
os := state.([]uint64)
v1 := os[0]
v2 := os[1]
ns := []uint64{v2, v1 + v2}
return v1, ns
}
fib := BuildLazyUInt64Evaluator(fibFunc, []uint64{0, 1})
for i := 0; i < 10; i++ {
fmt.Printf("Fib nr %v: %v\n", i, fib())
}
}
func BuildLazyEvaluator(evalFunc EvalFunc, initState Any) func() Any {
retValChan := make(chan Any)
loopFunc := func() {
var actState Any = initState
var retVal Any
for {
retVal, actState = evalFunc(actState)
retValChan <- retVal
}
}
retFunc := func() Any {
return <-retValChan
}
go loopFunc()
return retFunc
}
func BuildLazyUInt64Evaluator(evalFunc EvalFunc, initState Any) func() uint64 {
ef := BuildLazyEvaluator(evalFunc, initState)
return func() uint64 {
return ef().(uint64)
}
}
/* Output:
Fib nr 0: 0
Fib nr 1: 1
Fib nr 2: 1
Fib nr 3: 2
Fib nr 4: 3
Fib nr 5: 5
Fib nr 6: 8
Fib nr 7: 13
Fib nr 8: 21
Fib nr 9: 34
*/
package main
import (
"fmt"
)
type Any interface{}
type EvalFunc func(Any) (Any, Any)
func main() {
fibFunc := func(state Any) (Any, Any) {
os := state.([]uint64)
v1 := os[0]
v2 := os[1]
ns := []uint64{v2, v1 + v2}
return v1, ns
}
fib := BuildLazyUInt64Evaluator(fibFunc, []uint64{0, 1})
for i := 0; i < 10; i++ {
fmt.Printf("Fib nr %v: %v\n", i, fib())
}
}
func BuildLazyEvaluator(evalFunc EvalFunc, initState Any) func() Any {
retValChan := make(chan Any)
loopFunc := func() {
var actState Any = initState
var retVal Any
for {
retVal, actState = evalFunc(actState)
retValChan <- retVal
}
}
retFunc := func() Any {
return <-retValChan
}
go loopFunc()
return retFunc
}
func BuildLazyUInt64Evaluator(evalFunc EvalFunc, initState Any) func() uint64 {
ef := BuildLazyEvaluator(evalFunc, initState)
return func() uint64 {
return ef().(uint64)
}
}
/* Output:
Fib nr 0: 0
Fib nr 1: 1
Fib nr 2: 1
Fib nr 3: 2
Fib nr 4: 3
Fib nr 5: 5
Fib nr 6: 8
Fib nr 7: 13
Fib nr 8: 21
Fib nr 9: 34
*/

88
eBook/exercises/chapter_14/gofibonacci.go
View File

@@ -1,44 +1,44 @@
// Q26_fibonacci_go.go
package main
import (
"fmt"
"time"
"os"
)
func main() {
term := 25
i := 0
c := make(chan int)
start := time.Now()
go fibnterms(term, c)
for {
if result, ok := <-c; ok {
fmt.Printf("fibonacci(%d) is: %d\n", i, result)
i++
} else {
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)
os.Exit(0)
}
}
}
func fibnterms(term int, c chan int) {
for i := 0; i <= term; i++ {
c <- fibonacci(i)
}
close(c)
}
func fibonacci(n int) (res int) {
if n <= 1 {
res = 1
} else {
res = fibonacci(n-1) + fibonacci(n-2)
}
return
}
// Q26_fibonacci_go.go
package main
import (
"fmt"
"os"
"time"
)
func main() {
term := 25
i := 0
c := make(chan int)
start := time.Now()
go fibnterms(term, c)
for {
if result, ok := <-c; ok {
fmt.Printf("fibonacci(%d) is: %d\n", i, result)
i++
} else {
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)
os.Exit(0)
}
}
}
func fibnterms(term int, c chan int) {
for i := 0; i <= term; i++ {
c <- fibonacci(i)
}
close(c)
}
func fibonacci(n int) (res int) {
if n <= 1 {
res = 1
} else {
res = fibonacci(n-1) + fibonacci(n-2)
}
return
}

71
eBook/exercises/chapter_14/gofibonacci2.go
View File

@@ -1,35 +1,36 @@
// gofibonacci2.go
package main
import (
"fmt"
)
func fibonacci(n int, c chan int) {
x, y := 1, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x+y
}
close(c)
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
for i := range c {
fmt.Println(i)
}
}
/* Output:
1
1
2
3
5
8
13
21
34
55
*/
// gofibonacci2.go
package main
import (
"fmt"
)
func fibonacci(n int, c chan int) {
x, y := 1, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x+y
}
close(c)
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
for i := range c {
fmt.Println(i)
}
}
/* Output:
1
1
2
3
5
8
13
21
34
55
*/

90
eBook/exercises/chapter_14/gofibonacci3.go
View File

@@ -1,45 +1,45 @@
// courtesy of: http://sdh33b.blogspot.com/2009/12/fibonacci-in-go.html
package main
import (
"fmt"
"time"
)
func dup3(in <-chan int) (<-chan int, <-chan int, <-chan int) {
a, b, c := make(chan int, 2), make(chan int, 2), make(chan int, 2)
go func() {
for {
x := <-in
a <- x
b <- x
c <- x
}
}()
return a, b, c
}
func fib() <-chan int {
x := make(chan int, 2)
a, b, out := dup3(x)
go func() {
x <- 0
x <- 1
<-a
for {
x <- <-a + <-b
}
}()
return out
}
func main() {
start := time.Now()
x := fib()
for i := 0; i < 10; i++ {
fmt.Println(<-x)
}
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)
}
// courtesy of: http://sdh33b.blogspot.com/2009/12/fibonacci-in-go.html
package main
import (
"fmt"
"time"
)
func dup3(in <-chan int) (<-chan int, <-chan int, <-chan int) {
a, b, c := make(chan int, 2), make(chan int, 2), make(chan int, 2)
go func() {
for {
x := <-in
a <- x
b <- x
c <- x
}
}()
return a, b, c
}
func fib() <-chan int {
x := make(chan int, 2)
a, b, out := dup3(x)
go func() {
x <- 0
x <- 1
<-a
for {
x <- <-a + <-b
}
}()
return out
}
func main() {
start := time.Now()
x := fib()
for i := 0; i < 10; i++ {
fmt.Println(<-x)
}
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s\n", delta)
}

85
eBook/exercises/chapter_14/gofibonacci_select.go
View File

@@ -1,42 +1,43 @@
// gofibonacci_select.go
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 1, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
/* Output:
1
1
2
3
5
8
13
21
34
55
quit
*/
// gofibonacci_select.go
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 1, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
/* Output:
1
1
2
3
5
8
13
21
34
55
quit
*/

52
eBook/exercises/chapter_14/goroutine_close.go
View File

@@ -1,26 +1,26 @@
// Q20_goroutine.go
package main
import (
"fmt"
)
func tel(ch chan int) {
for i:=0; i < 15; i++ {
ch <- i
}
close(ch) // if this is ommitted: panic: all goroutines are asleep - deadlock!
}
func main() {
var ok = true
var i int
ch := make(chan int)
go tel(ch)
for ok {
if i, ok= <-ch; ok {
fmt.Printf("ok is %t and the counter is at %d\n", ok, i)
}
}
}
// Q20_goroutine.go
package main
import (
"fmt"
)
func tel(ch chan int) {
for i := 0; i < 15; i++ {
ch <- i
}
close(ch) // if this is ommitted: panic: all goroutines are asleep - deadlock!
}
func main() {
var ok = true
var i int
ch := make(chan int)
go tel(ch)
for ok {
if i, ok = <-ch; ok {
fmt.Printf("ok is %t and the counter is at %d\n", ok, i)
}
}
}

44
eBook/exercises/chapter_14/goroutine_panic.go
View File

@@ -1,22 +1,22 @@
package main
import (
"fmt"
)
func tel(ch chan int) {
for i := 0; i < 15; i++ {
ch <- i
}
}
func main() {
var ok = true
ch := make(chan int)
go tel(ch)
for ok {
i := <-ch
fmt.Printf("ok is %t and the counter is at %d\n", ok, i)
}
}
package main
import (
"fmt"
)
func tel(ch chan int) {
for i := 0; i < 15; i++ {
ch <- i
}
}
func main() {
var ok = true
ch := make(chan int)
go tel(ch)
for ok {
i := <-ch
fmt.Printf("ok is %t and the counter is at %d\n", ok, i)
}
}

61
eBook/exercises/chapter_14/goroutine_select.go
View File

@@ -1,31 +1,30 @@
// Q20b_goroutine.go
package main
import (
"fmt"
"os"
)
func tel(ch chan int, quit chan bool) {
for i:=0; i < 15; i++ {
ch <- i
}
quit <- true
}
func main() {
var ok = true
ch := make(chan int)
quit := make(chan bool)
go tel(ch, quit)
for ok {
select {
case i:= <-ch:
fmt.Printf("The counter is at %d\n", i)
case <-quit:
os.Exit(0)
}
}
}
// Q20b_goroutine.go
package main
import (
"fmt"
"os"
)
func tel(ch chan int, quit chan bool) {
for i := 0; i < 15; i++ {
ch <- i
}
quit <- true
}
func main() {
var ok = true
ch := make(chan int)
quit := make(chan bool)
go tel(ch, quit)
for ok {
select {
case i := <-ch:
fmt.Printf("The counter is at %d\n", i)
case <-quit:
os.Exit(0)
}
}
}

32
eBook/exercises/chapter_14/gosum.go
View File

@@ -1,16 +1,16 @@
// gosum.go
package main
import (
"fmt"
)
func sum(x, y int, c chan int) {
c <- x + y
}
func main() {
c := make(chan int)
go sum(12, 13, c)
fmt.Println(<-c) // 25
}
// gosum.go
package main
import (
"fmt"
)
func sum(x, y int, c chan int) {
c <- x + y
}
func main() {
c := make(chan int)
go sum(12, 13, c)
fmt.Println(<-c) // 25
}

117
eBook/exercises/chapter_14/multiplex_server3.go
View File

@@ -1,58 +1,59 @@
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import "fmt"
type Request struct {
a, b int
replyc chan int // reply channel inside the Request
}
type binOp func(a, b int) int
func run(op binOp, req *Request) {
req.replyc <- op(req.a, req.b)
}
func (r *Request) String() string {
return fmt.Sprintf("%d+%d=%d", r.a, r.b, <-r.replyc)
}
func server(op binOp, service chan *Request, quit chan bool) {
for {
select {
case req := <-service:
go run(op, req)
case <-quit:
return // stop infinite loop
}
}
}
func startServer(op binOp) (service chan *Request, quit chan bool) {
service = make(chan *Request)
quit = make(chan bool)
go server(op, service, quit)
return service, quit
}
func main() {
adder, quit := startServer(func(a, b int) int { return a + b })
// make requests:
req1 := &Request{3, 4, make(chan int)}
req2 := &Request{150, 250, make(chan int)}
// send requests on the service channel
adder <- req1
adder <- req2
// ask for the results: ( method String() is called )
fmt.Println(req1, req2)
// shutdown server:
quit <- true
fmt.Print("done")
}
/* output:
3+4=7 150+250=400
done
*/
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import "fmt"
type Request struct {
a, b int
replyc chan int // reply channel inside the Request
}
type binOp func(a, b int) int
func run(op binOp, req *Request) {
req.replyc <- op(req.a, req.b)
}
func (r *Request) String() string {
return fmt.Sprintf("%d+%d=%d", r.a, r.b, <-r.replyc)
}
func server(op binOp, service chan *Request, quit chan bool) {
for {
select {
case req := <-service:
go run(op, req)
case <-quit:
return // stop infinite loop
}
}
}
func startServer(op binOp) (service chan *Request, quit chan bool) {
service = make(chan *Request)
quit = make(chan bool)
go server(op, service, quit)
return service, quit
}
func main() {
adder, quit := startServer(func(a, b int) int { return a + b })
// make requests:
req1 := &Request{3, 4, make(chan int)}
req2 := &Request{150, 250, make(chan int)}
// send requests on the service channel
adder <- req1
adder <- req2
// ask for the results: ( method String() is called )
fmt.Println(req1, req2)
// shutdown server:
quit <- true
fmt.Print("done")
}
/* output:
3+4=7 150+250=400
done
*/

203
eBook/exercises/chapter_14/polar_to_cartesian.go
View File

@@ -1,101 +1,102 @@
// polartocartesian.go
package main
import (
"bufio"
"fmt"
"math"
"os"
"runtime"
"strconv"
"strings"
)
type polar struct {
radius float64
Θ float64
}
type cartesian struct {
x float64
y float64
}
const result = "Polar: radius=%.02f angle=%.02f degrees -- Cartesian: x=%.02f y=%.02f\n"
var prompt = "Enter a radius and an angle (in degrees), e.g., 12.5 90, " + "or %s to quit."
func init() {
if runtime.GOOS == "windows" {
prompt = fmt.Sprintf(prompt, "Ctrl+Z, Enter")
} else { // Unix-like
prompt = fmt.Sprintf(prompt, "Ctrl+D")
}
}
func main() {
questions := make(chan polar)
defer close(questions)
answers := createSolver(questions)
defer close(answers)
interact(questions, answers)
}
func createSolver(questions chan polar) chan cartesian {
answers := make(chan cartesian)
go func() {
for {
polarCoord := <-questions
Θ := polarCoord.Θ * math.Pi / 180.0 // degrees to radians
x := polarCoord.radius * math.Cos(Θ)
y := polarCoord.radius * math.Sin(Θ)
answers <- cartesian{x, y}
}
}()
return answers
}
func interact(questions chan polar, answers chan cartesian) {
reader := bufio.NewReader(os.Stdin)
fmt.Println(prompt)
for {
fmt.Printf("Radius and angle: ")
line, err := reader.ReadString('\n')
if err != nil {
break
}
line = line[:len(line)-1] // chop of newline character
if numbers := strings.Fields(line); len(numbers) == 2 {
polars, err := floatsForStrings(numbers)
if err != nil {
fmt.Fprintln(os.Stderr, "invalid number")
continue
}
questions <- polar{polars[0], polars[1]}
coord := <-answers
fmt.Printf(result, polars[0], polars[1], coord.x, coord.y)
} else {
fmt.Fprintln(os.Stderr, "invalid input")
}
}
fmt.Println()
}
func floatsForStrings(numbers []string) ([]float64, error) {
var floats []float64
for _, number := range numbers {
if x, err := strconv.ParseFloat(number, 64); err != nil {
return nil, err
} else {
floats = append(floats, x)
}
}
return floats, nil
}
/* Output:
Enter a radius and an angle (in degrees), e.g., 12.5 90, or Ctrl+Z, Enter to qui
t.
Radius and angle: 12.5 90
Polar: radius=12.50 angle=90.00 degrees -- Cartesian: x=0.00 y=12.50
Radius and angle: ^Z
*/
// polartocartesian.go
package main
import (
"bufio"
"fmt"
"math"
"os"
"runtime"
"strconv"
"strings"
)
type polar struct {
radius float64
Θ float64
}
type cartesian struct {
x float64
y float64
}
const result = "Polar: radius=%.02f angle=%.02f degrees -- Cartesian: x=%.02f y=%.02f\n"
var prompt = "Enter a radius and an angle (in degrees), e.g., 12.5 90, " + "or %s to quit."
func init() {
if runtime.GOOS == "windows" {
prompt = fmt.Sprintf(prompt, "Ctrl+Z, Enter")
} else { // Unix-like
prompt = fmt.Sprintf(prompt, "Ctrl+D")
}
}
func main() {
questions := make(chan polar)
defer close(questions)
answers := createSolver(questions)
defer close(answers)
interact(questions, answers)
}
func createSolver(questions chan polar) chan cartesian {
answers := make(chan cartesian)
go func() {
for {
polarCoord := <-questions
Θ := polarCoord.Θ * math.Pi / 180.0 // degrees to radians
x := polarCoord.radius * math.Cos(Θ)
y := polarCoord.radius * math.Sin(Θ)
answers <- cartesian{x, y}
}
}()
return answers
}
func interact(questions chan polar, answers chan cartesian) {
reader := bufio.NewReader(os.Stdin)
fmt.Println(prompt)
for {
fmt.Printf("Radius and angle: ")
line, err := reader.ReadString('\n')
if err != nil {
break
}
line = line[:len(line)-1] // chop of newline character
if numbers := strings.Fields(line); len(numbers) == 2 {
polars, err := floatsForStrings(numbers)
if err != nil {
fmt.Fprintln(os.Stderr, "invalid number")
continue
}
questions <- polar{polars[0], polars[1]}
coord := <-answers
fmt.Printf(result, polars[0], polars[1], coord.x, coord.y)
} else {
fmt.Fprintln(os.Stderr, "invalid input")
}
}
fmt.Println()
}
func floatsForStrings(numbers []string) ([]float64, error) {
var floats []float64
for _, number := range numbers {
if x, err := strconv.ParseFloat(number, 64); err != nil {
return nil, err
} else {
floats = append(floats, x)
}
}
return floats, nil
}
/* Output:
Enter a radius and an angle (in degrees), e.g., 12.5 90, or Ctrl+Z, Enter to qui
t.
Radius and angle: 12.5 90
Polar: radius=12.50 angle=90.00 degrees -- Cartesian: x=0.00 y=12.50
Radius and angle: ^Z
*/

85
eBook/exercises/chapter_14/producer_consumer.go
View File

@@ -1,42 +1,43 @@
// goroutines2.go
package main
import "fmt"
// integer producer:
func numGen(start, count int, out chan<- int) {
for i := 0; i < count; i++ {
out <- start
start = start + count
}
close(out)
}
// integer consumer:
func numEchoRange(in <-chan int, done chan<- bool) {
for num := range in {
fmt.Printf("%d\n", num)
}
done <- true
}
func main() {
numChan := make(chan int)
done := make(chan bool)
go numGen(0, 10, numChan)
go numEchoRange(numChan, done)
<-done
}
/* Output:
0
10
20
30
40
50
60
70
80
90
*/
// goroutines2.go
package main
import "fmt"
// integer producer:
func numGen(start, count int, out chan<- int) {
for i := 0; i < count; i++ {
out <- start
start = start + count
}
close(out)
}
// integer consumer:
func numEchoRange(in <-chan int, done chan<- bool) {
for num := range in {
fmt.Printf("%d\n", num)
}
done <- true
}
func main() {
numChan := make(chan int)
done := make(chan bool)
go numGen(0, 10, numChan)
go numEchoRange(numChan, done)
<-done
}
/* Output:
0
10
20
30
40
50
60
70
80
90
*/

59
eBook/exercises/chapter_14/producer_consumer2.go
View File

@@ -1,29 +1,30 @@
// prod_cons.go
/* producer-consumer problem in Go */
package main
import "fmt"
var done = make(chan bool)
var msgs = make(chan int)
func produce() {
for i := 0; i < 10; i++ {
msgs <- i
}
done <- true
}
func consume() {
for {
msg := <-msgs
fmt.Print(msg, " ")
}
}
func main() {
go produce()
go consume()
<-done
}
// Output: 0 1 2 3 4 5 6 7 8 9
// prod_cons.go
/* producer-consumer problem in Go */
package main
import "fmt"
var done = make(chan bool)
var msgs = make(chan int)
func produce() {
for i := 0; i < 10; i++ {
msgs <- i
}
done <- true
}
func consume() {
for {
msg := <-msgs
fmt.Print(msg, " ")
}
}
func main() {
go produce()
go consume()
<-done
}
// Output: 0 1 2 3 4 5 6 7 8 9

46
eBook/exercises/chapter_14/random_bitgen.go
View File

@@ -1,23 +1,23 @@
package main
import (
"fmt"
)
func main() {
c := make(chan int)
// consumer:
go func() {
for {
fmt.Print(<-c, " ")
}
}()
// producer:
for {
select {
case c <- 0:
case c <- 1:
}
}
}
package main
import (
"fmt"
)
func main() {
c := make(chan int)
// consumer:
go func() {
for {
fmt.Print(<-c, " ")
}
}()
// producer:
for {
select {
case c <- 0:
case c <- 1:
}
}
}

92
eBook/exercises/chapter_15/client1.go
View File

@@ -1,46 +1,46 @@
package main
import (
"fmt"
"os"
"net"
"bufio"
"strings"
)
func main() {
var conn net.Conn
var error error
var inputReader *bufio.Reader
var input string
var clientName string
// maak connectie met de server:
conn, error = net.Dial("tcp", "localhost:50000")
checkError(error)
inputReader = bufio.NewReader(os.Stdin)
fmt.Println("First, what is your name?")
clientName, _ = inputReader.ReadString('\n')
// fmt.Printf("CLIENTNAME %s",clientName)
trimmedClient := strings.Trim(clientName, "\r\n") // "\r\n" voor Windows, "\n" voor Linux
for {
fmt.Println("What to send to the server? Type Q to quit. Type SH to shutdown server.")
input, _ = inputReader.ReadString('\n')
trimmedInput := strings.Trim(input, "\r\n")
// fmt.Printf("input:--%s--",input)
// fmt.Printf("trimmedInput:--%s--",trimmedInput)
if trimmedInput == "Q" {
return
}
_, error = conn.Write([]byte(trimmedClient + " says: " + trimmedInput))
checkError(error)
}
}
func checkError(error error) {
if error != nil {
panic("Error: " + error.Error()) // terminate program
}
}
package main
import (
"bufio"
"fmt"
"net"
"os"
"strings"
)
func main() {
var conn net.Conn
var error error
var inputReader *bufio.Reader
var input string
var clientName string
// maak connectie met de server:
conn, error = net.Dial("tcp", "localhost:50000")
checkError(error)
inputReader = bufio.NewReader(os.Stdin)
fmt.Println("First, what is your name?")
clientName, _ = inputReader.ReadString('\n')
// fmt.Printf("CLIENTNAME %s",clientName)
trimmedClient := strings.Trim(clientName, "\r\n") // "\r\n" voor Windows, "\n" voor Linux
for {
fmt.Println("What to send to the server? Type Q to quit. Type SH to shutdown server.")
input, _ = inputReader.ReadString('\n')
trimmedInput := strings.Trim(input, "\r\n")
// fmt.Printf("input:--%s--",input)
// fmt.Printf("trimmedInput:--%s--",trimmedInput)
if trimmedInput == "Q" {
return
}
_, error = conn.Write([]byte(trimmedClient + " says: " + trimmedInput))
checkError(error)
}
}
func checkError(error error) {
if error != nil {
panic("Error: " + error.Error()) // terminate program
}
}

39
eBook/exercises/chapter_15/hello_server.go
View File

@@ -1,19 +1,20 @@
// hello_server.go
package main
import (
"fmt"
"net/http"
)
type Hello struct{}
func (h Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Hello!")
}
func main() {
var h Hello
http.ListenAndServe("localhost:4000",h)
}
// Output in browser-window with url http://localhost:4000: Hello!
// hello_server.go
package main
import (
"fmt"
"net/http"
)
type Hello struct{}
func (h Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Hello!")
}
func main() {
var h Hello
http.ListenAndServe("localhost:4000", h)
}
// Output in browser-window with url http://localhost:4000: Hello!

62
eBook/exercises/chapter_15/http_fetch2.go
View File

@@ -1,31 +1,31 @@
// httpfetch.go
package main
import (
"bufio"
"fmt"
"net/http"
"io/ioutil"
"log"
"os"
"strings"
)
func main() {
fmt.Print("Give the url from which to read: ")
iread := bufio.NewReader(os.Stdin)
url, _ := iread.ReadString('\n')
url = strings.Trim(url," \n\r") // trimming space,etc.
// fmt.Println("***", url,"***") // debugging
res, err := http.Get(url)
CheckError(err)
data, err := ioutil.ReadAll(res.Body)
CheckError(err)
fmt.Printf("Got: %q", string(data))
}
func CheckError(err error) {
if err != nil {
log.Fatalf("Get: %v", err)
}
}
// httpfetch.go
package main
import (
"bufio"
"fmt"
"io/ioutil"
"log"
"net/http"
"os"
"strings"
)
func main() {
fmt.Print("Give the url from which to read: ")
iread := bufio.NewReader(os.Stdin)
url, _ := iread.ReadString('\n')
url = strings.Trim(url, " \n\r") // trimming space,etc.
// fmt.Println("***", url,"***") // debugging
res, err := http.Get(url)
CheckError(err)
data, err := ioutil.ReadAll(res.Body)
CheckError(err)
fmt.Printf("Got: %q", string(data))
}
func CheckError(err error) {
if err != nil {
log.Fatalf("Get: %v", err)
}
}

150
eBook/exercises/chapter_15/server1.go
View File

@@ -1,75 +1,75 @@
package main
import (
"fmt"
"os"
"net"
"strings"
)
// Map of the clients: contains: clientname - 1 (active) / 0 - (inactive)
var mapUsers map[string]int
func main() {
var listener net.Listener
var error error
var conn net.Conn
mapUsers = make(map[string]int)
fmt.Println("Starting the server ...")
// create listener:
listener, error = net.Listen("tcp", "localhost:50000")
checkError(error)
// listen and accept connections from clients:
for {
conn, error = listener.Accept()
checkError(error)
go doServerStuff(conn)
}
}
func doServerStuff(conn net.Conn) {
var buf []byte
var error error
for {
buf = make([]byte, 512)
_, error = conn.Read(buf)
checkError(error)
input := string(buf)
if strings.Contains(input, ": SH") {
fmt.Println("Server shutting down.")
os.Exit(0)
}
// op commando WHO: write out mapUsers
if strings.Contains(input, ": WHO") {
DisplayList()
}
// extract clientname:
ix := strings.Index(input, "says")
clName := input[0:ix-1]
//fmt.Printf("The clientname is ---%s---\n", string(clName))
// set clientname active in mapUsers:
mapUsers[string(clName)] = 1
fmt.Printf("Received data: --%v--", string(buf))
}
}
// advantage: code is cleaner,
// disadvantage: the server process has to stop at any error:
// a simple return continues in the function where we came from!
func checkError(error error) {
if error != nil {
panic("Error: " + error.Error()) // terminate program
}
}
func DisplayList() {
fmt.Println("--------------------------------------------")
fmt.Println("This is the client list: 1=active, 0=inactive")
for key, value := range mapUsers {
fmt.Printf("User %s is %d\n", key, value)
}
fmt.Println("--------------------------------------------")
}
package main
import (
"fmt"
"net"
"os"
"strings"
)
// Map of the clients: contains: clientname - 1 (active) / 0 - (inactive)
var mapUsers map[string]int
func main() {
var listener net.Listener
var error error
var conn net.Conn
mapUsers = make(map[string]int)
fmt.Println("Starting the server ...")
// create listener:
listener, error = net.Listen("tcp", "localhost:50000")
checkError(error)
// listen and accept connections from clients:
for {
conn, error = listener.Accept()
checkError(error)
go doServerStuff(conn)
}
}
func doServerStuff(conn net.Conn) {
var buf []byte
var error error
for {
buf = make([]byte, 512)
_, error = conn.Read(buf)
checkError(error)
input := string(buf)
if strings.Contains(input, ": SH") {
fmt.Println("Server shutting down.")
os.Exit(0)
}
// op commando WHO: write out mapUsers
if strings.Contains(input, ": WHO") {
DisplayList()
}
// extract clientname:
ix := strings.Index(input, "says")
clName := input[0 : ix-1]
//fmt.Printf("The clientname is ---%s---\n", string(clName))
// set clientname active in mapUsers:
mapUsers[string(clName)] = 1
fmt.Printf("Received data: --%v--", string(buf))
}
}
// advantage: code is cleaner,
// disadvantage: the server process has to stop at any error:
// a simple return continues in the function where we came from!
func checkError(error error) {
if error != nil {
panic("Error: " + error.Error()) // terminate program
}
}
func DisplayList() {
fmt.Println("--------------------------------------------")
fmt.Println("This is the client list: 1=active, 0=inactive")
for key, value := range mapUsers {
fmt.Printf("User %s is %d\n", key, value)
}
fmt.Println("--------------------------------------------")
}

220
eBook/exercises/chapter_15/statistics.go
View File

@@ -1,110 +1,110 @@
// statistics.go
package main
import (
"fmt"
"net/http"
"sort"
"strings"
"strconv"
"log"
)
type statistics struct {
numbers []float64
mean float64
median float64
}
const form = `<html><body><form action="/" method="POST">
<label for="numbers">Numbers (comma or space-separated):</label><br>
<input type="text" name="numbers" size="30"><br />
<input type="submit" value="Calculate">
</form></html></body>`
const error = `<p class="error">%s</p>`
var pageTop = ""
var pageBottom = ""
func main() {
http.HandleFunc("/", homePage)
if err := http.ListenAndServe(":9001", nil); err != nil {
log.Fatal("failed to start server", err)
}
}
func homePage(writer http.ResponseWriter, request *http.Request) {
writer.Header().Set("Content-Type", "text/html")
err := request.ParseForm() // Must be called before writing response
fmt.Fprint(writer, pageTop, form)
if err != nil {
fmt.Fprintf(writer, error, err)
} else {
if numbers, message, ok := processRequest(request); ok {
stats := getStats(numbers)
fmt.Fprint(writer, formatStats(stats))
} else if message != "" {
fmt.Fprintf(writer, error, message)
}
}
fmt.Fprint(writer, pageBottom)
}
func processRequest(request *http.Request) ([]float64, string, bool) {
var numbers []float64
var text string
if slice, found := request.Form["numbers"]; found && len(slice) > 0 {
//处理如果网页中输入的是中文逗号
if strings.Contains(slice[0], "&#65292") {
text = strings.Replace(slice[0], "&#65292;", " ", -1)
} else {
text = strings.Replace(slice[0], ",", " ", -1)
}
for _, field := range strings.Fields(text) {
if x, err := strconv.ParseFloat(field, 64); err != nil {
return numbers, "'" + field + "' is invalid", false
} else {
numbers = append(numbers, x)
}
}
}
if len(numbers) == 0 {
return numbers, "", false // no data first time form is shown
}
return numbers, "", true
}
func getStats(numbers []float64) (stats statistics) {
stats.numbers = numbers
sort.Float64s(stats.numbers)
stats.mean = sum(numbers) / float64(len(numbers))
stats.median = median(numbers)
return
}
func sum(numbers []float64) (total float64) {
for _, x := range numbers {
total += x
}
return
}
func median(numbers []float64) float64 {
middle := len(numbers)/2
result := numbers[middle]
if len(numbers)%2 == 0 {
result = (result + numbers[middle-1]) / 2
}
return result
}
func formatStats(stats statistics) string {
return fmt.Sprintf(`<table border="1">
<tr><th colspan="2">Results</th></tr>
<tr><td>Numbers</td><td>%v</td></tr>
<tr><td>Count</td><td>%d</td></tr>
<tr><td>Mean</td><td>%f</td></tr>
<tr><td>Median</td><td>%f</td></tr>
</table>`, stats.numbers, len(stats.numbers), stats.mean, stats.median)
}
// statistics.go
package main
import (
"fmt"
"log"
"net/http"
"sort"
"strconv"
"strings"
)
type statistics struct {
numbers []float64
mean float64
median float64
}
const form = `<html><body><form action="/" method="POST">
<label for="numbers">Numbers (comma or space-separated):</label><br>
<input type="text" name="numbers" size="30"><br />
<input type="submit" value="Calculate">
</form></html></body>`
const error = `<p class="error">%s</p>`
var pageTop = ""
var pageBottom = ""
func main() {
http.HandleFunc("/", homePage)
if err := http.ListenAndServe(":9001", nil); err != nil {
log.Fatal("failed to start server", err)
}
}
func homePage(writer http.ResponseWriter, request *http.Request) {
writer.Header().Set("Content-Type", "text/html")
err := request.ParseForm() // Must be called before writing response
fmt.Fprint(writer, pageTop, form)
if err != nil {
fmt.Fprintf(writer, error, err)
} else {
if numbers, message, ok := processRequest(request); ok {
stats := getStats(numbers)
fmt.Fprint(writer, formatStats(stats))
} else if message != "" {
fmt.Fprintf(writer, error, message)
}
}
fmt.Fprint(writer, pageBottom)
}
func processRequest(request *http.Request) ([]float64, string, bool) {
var numbers []float64
var text string
if slice, found := request.Form["numbers"]; found && len(slice) > 0 {
//处理如果网页中输入的是中文逗号
if strings.Contains(slice[0], "&#65292") {
text = strings.Replace(slice[0], "&#65292;", " ", -1)
} else {
text = strings.Replace(slice[0], ",", " ", -1)
}
for _, field := range strings.Fields(text) {
if x, err := strconv.ParseFloat(field, 64); err != nil {
return numbers, "'" + field + "' is invalid", false
} else {
numbers = append(numbers, x)
}
}
}
if len(numbers) == 0 {
return numbers, "", false // no data first time form is shown
}
return numbers, "", true
}
func getStats(numbers []float64) (stats statistics) {
stats.numbers = numbers
sort.Float64s(stats.numbers)
stats.mean = sum(numbers) / float64(len(numbers))
stats.median = median(numbers)
return
}
func sum(numbers []float64) (total float64) {
for _, x := range numbers {
total += x
}
return
}
func median(numbers []float64) float64 {
middle := len(numbers) / 2
result := numbers[middle]
if len(numbers)%2 == 0 {
result = (result + numbers[middle-1]) / 2
}
return result
}
func formatStats(stats statistics) string {
return fmt.Sprintf(`<table border="1">
<tr><th colspan="2">Results</th></tr>
<tr><td>Numbers</td><td>%v</td></tr>
<tr><td>Count</td><td>%d</td></tr>
<tr><td>Mean</td><td>%f</td></tr>
<tr><td>Median</td><td>%f</td></tr>
</table>`, stats.numbers, len(stats.numbers), stats.mean, stats.median)
}

59
eBook/exercises/chapter_15/template_validation_recover.go
View File

@@ -1,29 +1,30 @@
// template_validation_recover.go
package main
import (
"text/template"
"fmt"
"log"
)
func main() {
tOk := template.New("ok")
tErr := template.New("error_template")
defer func() {
if err := recover(); err != nil {
log.Printf("run time panic: %v", err)
}
}()
//a valid template, so no panic with Must:
template.Must(tOk.Parse("/* and a comment */ some static text: {{ .Name }}"))
fmt.Println("The first one parsed OK.")
fmt.Println("The next one ought to fail.")
template.Must(tErr.Parse(" some static text {{ .Name }"))
}
/* Output:
The first one parsed OK.
The next one ought to fail.
2011/10/27 10:56:27 run time panic: template: error_template:1: unexpected "}" in command
*/
// template_validation_recover.go
package main
import (
"fmt"
"log"
"text/template"
)
func main() {
tOk := template.New("ok")
tErr := template.New("error_template")
defer func() {
if err := recover(); err != nil {
log.Printf("run time panic: %v", err)
}
}()
//a valid template, so no panic with Must:
template.Must(tOk.Parse("/* and a comment */ some static text: {{ .Name }}"))
fmt.Println("The first one parsed OK.")
fmt.Println("The next one ought to fail.")
template.Must(tErr.Parse(" some static text {{ .Name }"))
}
/* Output:
The first one parsed OK.
The next one ought to fail.
2011/10/27 10:56:27 run time panic: template: error_template:1: unexpected "}" in command
*/

67
eBook/exercises/chapter_15/twitter_status_json.go
View File

@@ -1,33 +1,34 @@
// twitter_status_json.go
package main
import (
"net/http"
"fmt"
"encoding/json"
"io/ioutil"
)
type Status struct {
Text string
}
type User struct {
Status Status
}
func main() {
/* perform an HTTP request for the twitter status of user: Googland */
res, _:= http.Get("http://twitter.com/users/Googland.json")
/* initialize the structure of the JSON response */
user := User{Status{""}}
/* unmarshal the JSON into our structures */
temp, _ := ioutil.ReadAll(res.Body)
body := []byte(temp)
json.Unmarshal(body, &user)
fmt.Printf("status: %s", user.Status.Text)
}
/* Output:
status: Robot cars invade California, on orders from Google:
Google has been testing self-driving cars ... http://bit.ly/cbtpUN http://retwt.me/97p
*/
// twitter_status_json.go
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
type Status struct {
Text string
}
type User struct {
Status Status
}
func main() {
/* perform an HTTP request for the twitter status of user: Googland */
res, _ := http.Get("http://twitter.com/users/Googland.json")
/* initialize the structure of the JSON response */
user := User{Status{""}}
/* unmarshal the JSON into our structures */
temp, _ := ioutil.ReadAll(res.Body)
body := []byte(temp)
json.Unmarshal(body, &user)
fmt.Printf("status: %s", user.Status.Text)
}
/* Output:
status: Robot cars invade California, on orders from Google:
Google has been testing self-driving cars ... http://bit.ly/cbtpUN http://retwt.me/97p
*/

48
eBook/exercises/chapter_15/webhello2.go
View File

@@ -1,24 +1,24 @@
// webhello2.go
package main
import (
"net/http"
"fmt"
"strings"
)
func helloHandler(w http.ResponseWriter, r *http.Request) {
remPartOfURL := r.URL.Path[len("/hello/"):] //get everything after the /hello/ part of the URL
fmt.Fprintf(w, "Hello %s!", remPartOfURL)
}
func shouthelloHandler(w http.ResponseWriter, r *http.Request) {
remPartOfURL := r.URL.Path[len("/shouthello/"):] //get everything after the /shouthello/ part of the URL
fmt.Fprintf(w, "Hello %s!", strings.ToUpper(remPartOfURL))
}
func main() {
http.HandleFunc("/hello/", helloHandler)
http.HandleFunc("/shouthello/", shouthelloHandler)
http.ListenAndServe("localhost:9999", nil)
}
// webhello2.go
package main
import (
"fmt"
"net/http"
"strings"
)
func helloHandler(w http.ResponseWriter, r *http.Request) {
remPartOfURL := r.URL.Path[len("/hello/"):] //get everything after the /hello/ part of the URL
fmt.Fprintf(w, "Hello %s!", remPartOfURL)
}
func shouthelloHandler(w http.ResponseWriter, r *http.Request) {
remPartOfURL := r.URL.Path[len("/shouthello/"):] //get everything after the /shouthello/ part of the URL
fmt.Fprintf(w, "Hello %s!", strings.ToUpper(remPartOfURL))
}
func main() {
http.HandleFunc("/hello/", helloHandler)
http.HandleFunc("/shouthello/", shouthelloHandler)
http.ListenAndServe("localhost:9999", nil)
}