package main
package config

var i int = 1
var f32 float32 = 1.0
var f64 float64 = 1.0

var name string = "wii"

// 拼接
var name string = "name" + " : " + "wii"

// 取长度
len("wii")

// 截断

val b bool = true

var i, s, b = 1, "wii", false

const (
  a = iota   //0
  b          //1
  c          //2
  d = "ha"   //独立值，iota += 1
  e          //"ha"   iota += 1
  f = 100    //iota +=1
  g          //100  iota +=1
  h = iota   //7,恢复计数
  i          //8
)

const (
    i=1<<iota	// 1
    j=3<<iota // 6
    k         // 12
    l         // 24
)

var identifier [type] = v
var id1, id2 [type] = v1, v2  // 如果只声明，不初始化值，必须制定类型；制定初始化值，编译器可自行推断
id3 := value                  // OK := 左侧需要有未被声明过的标识符，有即可
id1 := value                  // ERROR id1 已被声明
id1, id4 := v1, v2            // OK id4 未被声明

var (                         // 因式分解式，一般用于声明全局变量
  id5 type
  id6 type
)

var a string = "wii"
var b, c int = 1, 2

var e, f = 123, "hello"
g, h := 123, "hello"

var variable_name [SIZE] variable_type
var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type  // 多维数组

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
il := []int{1, 2}

// ... 代替长度
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

// 通过下表初始化
balance := [5]float32{1:2.0,3:7.0}   // 将索引为 1 和 3 的元素初始化

// 初始化二维数组
a := [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11},   /* 第三行索引为 2 */
}

// 创建空数组
s := make([]int, 0, 10)
// 获取长度
len(s) // 0
// 获取容量
cap(s) // 10

// 先声明后赋值
values := [][]int{}            // 创建数组
row1 := []int{1, 2, 3}
row2 := []int{4, 5, 6}
values = append(values, row1)  // 使用 appped() 函数向空的二维数组添加两行一维数组
values = append(values, row2)

// 维度不一致数组
animals := [][]string{}
row1 := []string{"fish", "shark", "eel"}
row2 := []string{"bird"}
row3 := []string{"lizard", "salamander"}
animals = append(animals, row1)
animals = append(animals, row2)
animals = append(animals, row3)

var m map[string]string = map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo"}
m := make(map[int]int)

// 遍历参考章节 循环

// 单行注释

/*
 多行注释
*/

// 1. 类似于 for(...; ...; ...)
for init; condition; post { }

// 2. 类似于 while
for condition { }

// 3. 类似于 for (;;)
for { }

// map
for key, value := range oldMap {
    newMap[key] = value
}

strings := []string{"google", "runoob"}
for i, s := range strings {
    fmt.Println(i, s)
}

// list - 顺序
for i := l.Front(); i != nil; i = i.Next() {
    fmt.Println(i.Value)
}
// list - 
for i := l.Back(); i != nil; i = i.Prev() {
		fmt.Println(i.Value)
}

// 数组
for i := 0; i < len(arr); i++ {
    //arr[i]
}
for index, value := range arrHaiCoder{
}
for _, value := range arrHaiCoder{  // 忽略 index
}

func function_name( [parameter list] ) [return_types] {
   // 函数体
}

func swap(x, y string) (string, string) {
   return y, x
}

// 值传递
func swap(x, y int) int {
   var temp int

   temp = x /* 保存 x 的值 */
   x = y    /* 将 y 值赋给 x */
   y = temp /* 将 temp 值赋给 y*/

   return temp;
}
swap(a, b)

// 引用传递
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保持 x 地址上的值 */
   *x = *y      /* 将 y 值赋给 x */
   *y = temp    /* 将 temp 值赋给 y */
}
swap(&a, &b)

// 函数参数
getSquareRoot := func(x float64) float64 {
  return math.Sqrt(x)
}
fmt.Println(getSquareRoot(9))

package main
import "fmt"

// 声明一个函数类型
type cb func(int) int

func main() {
    testCallBack(1, callBack)
    testCallBack(2, func(x int) int {
        fmt.Printf("我是回调，x：%d\n", x)
        return x
    })
}

func testCallBack(x int, f cb) {
    f(x)
}

func callBack(x int) int {
    fmt.Printf("我是回调，x：%d\n", x)
    return x
}

func getSequence() func() int {
   i:=0
   return func() int {
      i+=1
     return i  
   }
}

func (variable_name variable_data_type) function_name() [return_type]{
   /* 方法体 */
}

package main

import (
   "fmt"  
)

/* 定义结构体 */
type Circle struct {
  radius float64
}

func main() {
  var c1 Circle
  c1.radius = 10.00
  fmt.Println("圆的面积 = ", c1.getArea())
}

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

// 定义
type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

// 声明
variable_name := structure_variable_type {value1, value2...valuen}
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

type Data struct {
  s    string
	sl   []string
	ll   [][]string
}

data := Data {s: "yes"}

// 定义接口
type FileReader interface {
	NextLine() string
	HasNext() bool
	Close()
}

// 定义实现接口实现结构
type FileReaderImpl struct {
	dataPath string
	file     *os.File
	scanner  *bufio.Scanner
	done     bool
	buf      string
}

// 定义接口实现方法
func (impl *FileReaderImpl) NextLine() string {
	t := impl.buf
	impl.done = !impl.scanner.Scan()

	if err := impl.scanner.Err(); err != nil {
		log.Fatal(err)
	} else {
		v := impl.scanner.Text()
		impl.buf = v
	}

	return t
}

func (impl *FileReaderImpl) HasNext() bool {
	return !impl.done
}

func (impl *FileReaderImpl) Close() {
	err := impl.file.Close()
	if err != nil {
		log.Fatal(err)
	}
}

// 定义创建接口方法
func NewFileReader(dp string) FileReader {
	file, err := os.Open(dp)
	if err != nil {
		log.Fatal(err)
	}
	scanner := bufio.NewScanner(file)
	sr := &FileReaderImpl{dataPath: dp, file: file, scanner: scanner, done: false}
	// read one line, for HasNext
	sr.NextLine()
	return sr
}

func PointArg(l interface{}) {
	fmt.Printf("%p %p\n", l, &l)
}

func main() {
	l := make([]int, 0, 10)
	fmt.Printf("%T %p\n", l, l)
	PointArg(l)
}

// 输出
[]int 0xc0000b8000
0xc0000b8000 0xc000096220

// 分析
1. l 保存的 make 返回的指针
2. 指针传参，直接打印参数值为源参数内存地址；对指针参数 & 操作，返回参数变量的内存地址

func PointArg(l interface{}) {
	fmt.Printf("%p %p\n", l, &l)
}

type Person struct {
	name string
}

func main() {
	p := Person{name: "wii"}
	fmt.Printf("%T %v %p\n", p, p, &p)
	PointArg(p)
}

// 输出
main.Person {wii} 0xc000010240
%!p(main.Person={wii}) 0xc000010270

// 分析
1. p 不是指针类型
2. 非指针参数传递，会导致内存拷贝

// i 为 interface{} 变量, 实际类型为 map[string]interface{}
for k, v := range i.(map[string]interface{}) {   // 使 i 识别为 map[string]interface{} 类型，并遍历
  ...
}  

// 保存函数
func main() {
    var fns []func()
    fns = append(fns, beeper)
    fns = append(fns, pinger)

    for _, fn := range fns {
        fn()
    }
}

func beeper() {
    fmt.Println("beep-beep")
}

func pinger() {
    fmt.Println("ping-ping")
}

// 另外一个示例
type dispatcher struct {
    listeners []func()
}

func (d *dispatcher) addListener(f func()) {
    d.listeners = append(d.listeners, f)
}

func (d *dispatcher) notify() {
    for _, f := range d.listeners {
        f()
    }
}

func ping() {
    fmt.Println("Ping... ping...")
}

func beep() {
    fmt.Println("Beep... beep...")
}

func main() {
    d := dispatcher{}
    d.addListener(ping)
    d.addListener(beep)
    d.notify()
}

t := map[string]interface{}{}
switch t.(type) {
case map[string]interface{}:
	for tk, tv := range t.(map[string]interface{}) {
		r[tk] = tv
	}
default:
	r[cvt.Name] = t
}

package tm

func Echo(s string) string {
	return s
}

package tm

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

func TestEcho(t *testing.T) {
	word := "hello"
	echo := Echo(word)
	assert.Equal(t, word, echo)
}

// Package math provides basic constants and mathematical functions.
package math

/*
Package template implements data-driven templates for generating textual
output such as HTML.
....
*/
package template