func (t *T) MethodName(argType T1, replyType *T2) error

func decodeString(s string) string {
    numStack := make([]int, 0)      // 记录需要重复的次数
    strStack := make([]string, 0)   // 记录待解码的字符串
    i := 0      // 扫描字符串的下标
    for i < len(s) {
        if '0' <= s[i] && s[i] <= '9' {     // 若扫描到数字
            k := int(s[i]-'0')      // 重复次数k
            j := i+1
            for ; j < len(s) && '0' <= s[j] && s[j] <= '9'; j++ {   // 转化为int型
                k = k*10 + int(s[j]-'0')
            }
            // 重复次数入栈
            numStack = append(numStack, k)
            // 更新下标
            i = j
        } else if s[i] == ']' {     // 扫描到右括号，需要解码
            var subStr string      // 待解码的字符串
            // 依次出栈，直到遇到左括号
            cur := strStack[len(strStack)-1]
            for cur != "[" {
                subStr = cur + subStr
                strStack = strStack[:len(strStack)-1]
                cur = strStack[len(strStack)-1]
            }
            strStack = strStack[:len(strStack)-1]   // 弹出左括号
            // 弹出一个重复数字
            k := numStack[len(numStack)-1]
            numStack = numStack[:len(numStack)-1]
            // 重复k次，加入到栈中
            var encoded string
            for ; k > 0; k-- {
                encoded = encoded + subStr
            }
            strStack = append(strStack, encoded)
            i++
        } else {    // 扫描到字母、左括号时直接入栈
            strStack = append(strStack, string(s[i]))
            i++
        }
    }

    var res string      // 返回结果
    // 从底向顶扫描栈，依次加入结果
    for i := 0; i < len(strStack); i++ {
        res += strStack[i]
    }

    return res
}

func sortArray(nums []int) []int {
    len := len(nums)
    heapSort(nums, len)     // 堆排序

    return nums
}

func heapSort(nums []int, len int) {
    // 建成大根堆
    buildHeap(nums, len)
    
    for len > 1 {
        // 大根堆的根节点放到最后
        nums[0], nums[len-1] = nums[len-1], nums[0]
        // 剩余节点重新调整为大根堆
        len--
        adjestHeap(nums, 0, len)
    }
    
}

func buildHeap(nums []int, len int) {
    for i := (len/2)-1; i >= 0; i-- {   // 从最后一个分支节点开始，依次向上调整堆
        adjestHeap(nums, i, len)
    }
}

func adjestHeap(nums []int, i, len int) {   // 以nums[i]为根节点调整成大根堆
    for 2*(i+1) <= len {     // 自上而下调整
        leftChild := 2*(i+1)-1      // 左孩子下标
        rightChild := leftChild+1   // 右孩子下标
        var larger int  // 左右孩子中较大者的下标
        if rightChild < len && nums[rightChild] > nums[leftChild] {
            // 右孩子较大
            larger = rightChild
        } else {
            // 左孩子较大
            larger = leftChild
        }
        if nums[i] < nums[larger] {
            // 孩子节点更大，则交换
             nums[i], nums[larger] = nums[larger], nums[i]
        }
        i = larger
    }
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func kthLargest(root *TreeNode, k int) int {
    rightNodeNum := nodeNum(root.Right)    // 右子树节点个数
    if k == rightNodeNum+1 {
        // 当前根节点就是第k大节点
        return root.Val
    } else if k <= rightNodeNum {
        // 第k大节点在右子树中
        return kthLargest(root.Right, k)
    } else {
        // 第k大节点在左子树中
        // 在左子树中找第(k-1-rightNodeNum)大的节点
        return kthLargest(root.Left, k-1-rightNodeNum)
    }
}

func nodeNum(root *TreeNode) int {      // 求以root为根节点的树的节点总数
    if root != nil {
        left := nodeNum(root.Left)      // 左子树的节点个数
        right := nodeNum(root.Right)    // 右子树的节点个数
        
        return 1+left+right
    } else {
        return 0
    }
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) []int {
    res := []int{}
    var postorder func(root *TreeNode)
    postorder = func(root *TreeNode) {
        if root != nil {
            postorder(root.Left)
            postorder(root.Right)
            res = append(res, root.Val)
        }
    }
    postorder(root)

    return res
}

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func postorderTraversal(root *TreeNode) []int {
    res := make([]int, 0)
    stack := make([]*TreeNode, 0)
    cur := root
    var pre *TreeNode

    for len(stack) > 0 || cur != nil {
        for cur != nil {
            stack = append(stack, cur)
            cur = cur.Left
        }
        if len(stack) > 0 {
            cur = stack[len(stack)-1]
            if cur.Right == nil || pre == cur.Right {
                // 若栈顶节点右子树为空，或者刚刚遍历过右子树
                // 遍历栈顶节点并弹出
                res = append(res, cur.Val)
                pre = cur
                stack = stack[:len(stack)-1]
                cur = nil
            } else {
                // 否则进入右子树
                cur = cur.Right
            }
        }
    }

    return res
}

import "math"

type Point struct {
    X, Y float64
}

// 一个方法的声明
func (p Point) Distance(q Point) float64 {
    return math.Htpot(q.X-p.X, q.Y-p.Y)
}

// 接收器为指针类型
func (p *Point) ScaleBy(factor float64) {
	p.X *= factor
	p.Y *= factor
}

type Point struct{
    X, Y float64 
}

type RGBA struct {
    R, G, B, A uint8
}

type ColoredPoint struct {
	Point				// 嵌入匿名结构体
	Color color.RGBA
}

red := color.RGBA{255, 0, 0, 255}
blue := color.RGBA{0, 0, 255, 255}

var p = ColoredPoint{Point{1, 1}, red}
var q = ColoredPoint{Point{5, 4}, blue}

fmt.Println(p.Distance(q.Point)) // "5"
p.ScaleBy(2)
q.ScaleBy(2)
fmt.Println(p.Distance(q.Point)) // "10"

/*
p.Distance(q) // compile error: cannot use q (ColoredPoint) as Point
*/

p := Point{1, 2}
q := Point{4, 6}

distanceFromP := p.Distance			// method value
fmt.Println(distanceFromP(q))		// "5"
var origin Point					// {0, 0}
fmt.Println(distanceFromP(origin))	// "2.23606797749979", sqrt(5)

scaleP := p.ScaleBy		// method value
scaleP(2)				// p becomes (2, 4)
scaleP(3)				// then (6, 12)
scaleP(10)				// then (60, 120)

p := Point{1, 2}
q := Point{4, 6}

distance := Point.Distance // method expression
fmt.Println(distance(p, q)) // "5"
fmt.Printf("%T\n", distance) // "func(Point, Point) float64"

scale := (*Point).ScaleBy
scale(&p, 2)
fmt.Println(p) // "{2 4}"
fmt.Printf("%T\n", scale) // "func(*Point, float64)"

type Point struct{ X, Y float64 }

func (p Point) Add(q Point) Point { return Point{p.X + q.X, p.Y + q.Y} }
func (p Point) Sub(q Point) Point { return Point{p.X - q.X, p.Y - q.Y} }

type Path []Point

func (path Path) TranslateBy(offset Point, add bool) {
	var op func(p, q Point) Point
	if add {
		op = Point.Add
	} else {
		op = Point.Sub
	}
	for i := range path {
		// Call either path[i].Add(offset) or path[i].Sub(offset).
		path[i] = op(path[i], offset)
	}
}

package person

import "fmt"

// 定义不能导出的结构体
type person struct {
   name string
   age  int
   sal float64
}

// 定义工厂模式的函数 首字母大写 类似构造函数
func  NewPerson(name string) *person{
   return &person{
      name:name,
   }
}

// 提供一个setter 设置年龄
func (user *person) Setage(age int) {
   if age >0  && age < 150 {
      user.age = age
   }else {
      fmt.Println("年龄数值不对！")
   }
}

// 获取年龄
func (user *person) Getage() int{
   return  user.age
}

// 更改姓名
func  (user *person) Updatename(name string) string{
   user.name=name
   return  user.name
}

value, ok := cache.Lookup(key)

if !ok {
	// ...cache[key] does not exist…
}

resp, err := http.Get(url)
if err != nil{
    // 执行失败，直接返回
	return nil, err
}

// WaitForServer attempts to contact the server of a URL.
// It tries for one minute using exponential back-off.
// It reports an error if all attempts fail.
func WaitForServer(url string) error {
	const timeout = 1 * time.Minute
	deadline := time.Now().Add(timeout)
    
	for tries := 0; time.Now().Before(deadline); tries++ {
		_, err := http.Head(url)
		if err == nil {
			return nil // success
		}
		log.Printf("server not responding (%s);retrying…", err)
		time.Sleep(time.Second << uint(tries)) // exponential back-off
	}
    
	return fmt.Errorf("server %s failed to respond after %s", url, timeout)
}

// (In function main.)
if err := WaitForServer(url); err != nil {
	fmt.Fprintf(os.Stderr, "Site is down: %v\n", err)
	os.Exit(1)
    // 以上两条等价于
    // log.Fatalf("Site is down: %v\n", err)
}

if err := Ping(); err != nil {
	log.Printf("ping failed: %v; networking disabled",err)
    // fmt.Fprintf(os.Stderr, "ping failed: %v; networking disabled\n", err)
}

var EOF = errors.New("EOF")

in := bufio.NewReader(os.Stdin)
for {
	r, _, err := in.ReadRune()
	if err == io.EOF {
		break // finished reading
	}
	if err != nil {
		return fmt.Errorf("read failed:%v", err)
	}
	// ...use r…
}

var f func(int) int
if f != nil {
	f(3)
}

func f(pre, post func()) {
    if pre != nil {
        // 在执行f之前调用pre()
        pre()
    }
    /*
    	中间的函数体
    	.....
    */
    if post != nil {
        // 在执行f之后调用post
        post()
    }
}

// squares返回一个匿名函数。
// 该匿名函数每次被调用时都会返回下一个数的平方。
func squares() func() int {
	var x int
	return func() int {
		x++
		return x * x
	}
}

func main() {
	f := squares()
	fmt.Println(f()) // "1"
	fmt.Println(f()) // "4"
	fmt.Println(f()) // "9"
	fmt.Println(f()) // "16"
}

var preorder func(root *TreeNode)
preorder = func(root *TreeNode) {	// 二叉树的前序遍历
    if root != nil {
        visit(root)
        preorder(root.Left)
        preorder(root.Right)
    }
}

func sum(vals...int) int {
	total := 0
	for _, val := range vals {
		total += val
	}
	return total
}

fmt.Println(sum()) 				// "0"
fmt.Println(sum(3))				// "3"
fmt.Println(sum(1, 2, 3, 4))	// "10"

values := []int{1, 2, 3, 4}
fmt.Println(sum(values...)) // "10"

func f(...int) {}
func g([]int) {}
fmt.Printf("%T\n", f)	// "func(...int)"
fmt.Printf("%T\n", g)	// "func([]int)"

func ReadFile(filename string) ([]byte, error) {
	f, err := os.Open(filename)
    defer f.Close()
	if err != nil {
		return nil, err
	}
	return ReadAll(f)
}

func bigSlowOperation() {
	defer trace("bigSlowOperation")() // don't forget the extra parentheses
	// ...lots of work…
	time.Sleep(10 * time.Second) // simulate slow operation by sleeping
}

func trace(msg string) func() {
	start := time.Now()
	log.Printf("enter %s", msg)
	return func() {
		log.Printf("exit %s (%s)", msg,time.Since(start))
	}
}

func double(x int) (result int) {
	defer func() { fmt.Printf("double(%d) = %d\n", x,result) }()
	return x + x
}

_ = double(4)
// Output:
// "double(4) = 8"

func triple(x int) (result int) {
	defer func() { result += x }()
	return double(x)
}
fmt.Println(triple(4)) // "12"

func Parse(input string) (s *Syntax, err error) {
	defer func() {
		if p := recover(); p != nil {
			err = fmt.Errorf("internal error: %v", p)
		}
	}()
	// ...parser...
}

func f() (res string, err error) {
    type someKindError struct{}
    defer func(){
        switch p := recover(); p {
            case nil:	//	no panic
            case someKindError{}:	// expected panic
            	err = fmt.Errorf("Take place someKindError.....")
            default:
            	panic(p)	// unexpected panic
        }
    }()
    // 其他工作
    // ....
    if 某种类型的异常发生了{
        panic(someKindError{})
    }
}

delete(hashMap, "dawn")	// 从map中移除key为dawn的元素

p := &hashMap["dawn"]	// error

var names []string

for name := range ages {
    names = append(names, name)
}
// 显式的对key排序
sort.Strings(names)
// 依据顺序的key对map顺序遍历
for _, name := range names {
    fmt.Printf("%s\t%d\n", name, ages[name])
}

if age, ok := ages["dawn"]; !ok {
    // ...
}

func k(list []string) string {	// 将slice转为string
    return fmt.Sprintf("%q", list)
}

var hashMap = make(map[string]int)
keySlice := []string{/* ... */}
hashMap[k(keySlice)]++	// 对map操作时先将slice转为string

type address struct {
    hostname string
    port int
}

counts := make(map[address]int)		// address结构体作为key

// 坐标点
type Point struct {
	X, Y int
}
// 圆
type Circle struct {
	Center Point	// 圆心
	Radius int		// 半径
}
// 轮子
type Wheel struct {
	Circle Circle
	Spokes int		// 径向辐条的数量
}

var w Wheel
w.Circle.Center.X = 1
w.Circle.Center.Y = 1
w.Circle.Radius = 2
w.Spokes = 10

type Circle struct {
	Point		// 匿名结构体
	Radius int
}
type Wheel struct {
	Circle		// 匿名结构体
	Spokes int
}

var w Wheel
w.X = 1
w.Y = 1
w.Radius = 2
w.Spokes = 10d