切片

go语言采用左闭右开的方式，即区间包括第一个索引元素，不包括最后一个。因为这样可以简化逻辑。

• 比如，a=[1,2,3,4],a[0:3]=[1,2,3],不包含最后一个元素。
• 比如s[m:n]这个切片,0 <= m <= n <= len(s)，包含n-m个元素，产生第m个元素到第n-1元素的切片。

echo 1.0

package main
import(
  "fmt"
  "os"
)
func main(){
 var s,sep string
  for i := 1;i<len(os.Args);i++{
    s += sep + os.Args[i]
    sep = " "
  }
  fmt.Println(s)
}

这个程序很简单，书中指出当参数庞大时，这种写法开销很大。

echo 1.1

使用strings包的Join函数

func main(){
  fmt.Println(strings.Join(os.Args[1:]," "))
}

练习1.1

import (
    "fmt"
    "os"
    "strings"
)

func main(){
    fmt.Println(strings.Join(os.Args[:]," "))
}

练习1.2

import (
    "fmt"
    "os"
)

func main(){
    for seq,i := range os.Args[1:]{
        fmt.Println(seq,i)
    }
}

练习1.3

package main

import (
    "strconv"
    "strings"
    "time"
    "fmt"
)

type myfunction struct {
    limit int
}

func (this myfunction)level()[]string{
    var col []string
    for i:=0;i<this.limit;i++{
        square := i * i
        col = append(col,strconv.FormatInt(int64(square),10))
    }
    return col
}

func (this myfunction)high(){
    strings.Join(this.level()," ")
}

func (this myfunction)low(){
    var s string
    for _,i := range this.level(){
        s += i
        s += " "
    }
}

func main(){
    m := myfunction{limit:100000}
    ctime := time.Now().Unix()
    m.high()
    fmt.Println("high",time.Now().Unix() - ctime)
    ctime_low := time.Now().Unix()
    m.low()
    fmt.Println("low",time.Now().Unix() - ctime_low)
}

本来想用装饰器模式精简一下代码，可是我不会写。
用goland来跑，high在0秒以内，low用了65秒，差异确实很大。