package main
import "fmt" 
func main() {
   fmt.Println("Hello, World!")
}

package main
import (
  "fmt"
  "time"
)
func main() {
  fmt.Println("Hello World!")
  fmt.Println("The time is", time.Now())
}

var p *int

i := 42
p = &i

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i

package main
import "fmt"
func main() {
  i, j := 42, 2701
  p := &i         // 指向我 i
  fmt.Println(*p) // 通过指针读 i
  *p = 21         // 通过指针设置 i
  fmt.Println(i)  // 看到i的新值

  p = &j         // 指向我 j
  *p = *p / 37   // 通过指针划分 j
  fmt.Println(j) // 看到j的新值
}

// 格式化输入：从输入端读取字符串（以空白分隔的值的序列），
// 并解析为具体的值存入相应的 arg 中，arg 必须是变量地址。
// 字符串中的连续空白视为单个空白，换行符根据不同情况处理。
// \r\n 被当做 \n 处理。

// 以动词 v 解析字符串，换行视为空白
Scan(arg列表)
// 以动词 v 解析字符串，换行结束解析
Scanln(arg列表)
// 根据格式字符串中指定的格式解析字符串
// 格式字符串中的换行符必须和输入端的换行符相匹配。
Scanf(格式字符串, arg列表)

// Scan 类函数会返回已处理的 arg 数量和遇到的错误信息。

break      default       func      interface    select
case       defer         go        map          struct
chan       else          goto      package      switch
const      fallthrough   if        range        type
continue   for           import    return       var

append  bool    byte    cap     close  complex complex64 complex128 uint16
copy    false   float32 float64 imag   int     int8      int16      uint32
int32   int64   iota    len     make   new     nil       panic      uint64
print   println real    recover string true    uint      uint8      uintptr

// 单行注释

/*
  多行注释
*/

import "fmt"
import "os"
import "io"

import (
  "fmt"
  "os"
  "io"
)

import(
  ff "fmt"
)

// 或者
import ff "fmt"

// 别名包调用
ff.Println('Hello World!')

import(
  . "fmt"
)
func main() {
  // 省略调用
  Println('Hello World!')
}

var b bool
b  = true
fmt.Printf("b is of type %t\n", b)
e := bool(true)
fmt.Printf("e is of type %t\n", e)

package main
import "fmt"
func main() {
  // n 是一个长度为 10 的数组
  var n [10]int 
  var i,j int

  /* 为数组 n 初始化元素 */         
  for i = 0; i < 10; i++ {
    n[i] = i + 100 /* 设置元素为 i + 100 */
  }

  /* 输出每个数组元素的值 */
  for j = 0; j < 10; j++ {
    fmt.Printf("Element[%d] = %d\n", j, n[j] )
  }
}

u8 := []uint8{98, 99}

a := byte(255)  //11111111 这是byte的极限， 因为 a := byte(256)//越界报错， 0~255正好256个数，不能再高了
b := uint8(255) //11111111 这是uint8的极限，因为 c := uint8(256)//越界报错，0~255正好256个数，不能再高了
c := int8(127)  //01111111 这是int8的极限， 因为 b := int8(128)//越界报错， 0~127正好128个数，所以int8的极限只是256的一半
d := int8(a)    //11111111 打印出来则是-0000001，int8(128)、int8(255)、int8(byte(255))都报错越界，因为int极限是127，但是却可以写：int8(a)，第一位拿来当符号了
e := int8(c)    //01111111 打印出来还是01111111
fmt.Printf("%08b %d \n", a, a)
fmt.Printf("%08b %d \n", b, b)
fmt.Printf("%08b %d \n", c, c)
fmt.Printf("%08b %d \n", d, d)
fmt.Printf("%08b %d \n", e, e)

// 这里不能写成 b := []byte{"Golang"}，这里是利用类型转换。
b := []byte("Golang")
c := []byte("go")
d := []byte("Go")
println(b,c,d)

package main
import (
  "bytes"
  "fmt"
)
func main() {
  // 这里不能写成 b := []byte{"Golang"}，这里是利用类型转换。
  b := []byte("Golang")
  subslice1 := []byte("go")
  subslice2 := []byte("Go")
  // func Contains(b, subslice [] byte) bool
  // 检查字节切片b ，是否包含子字节切片 subslice
  fmt.Println(bytes.Contains(b, subslice1))
  fmt.Println(bytes.Contains(b, subslice2))


  s2 := []byte("同学们，上午好")
  m := func(r rune) rune {
    if r == '上' {
      r = '下'
    }
    return r
  }
  fmt.Println(string(s2))
  // func Map(mapping func(r rune) rune, s []byte) []byte
  // Map函数: 首先将 s 转化为 UTF-8编码的字符序列，
  // 然后使用 mapping 将每个Unicode字符映射为对应的字符，
  // 最后将结果保存在一个新的字节切片中。
  fmt.Println(string(bytes.Map(m, s2)))


  s3 := []byte("google")
  old := []byte("o")
  //这里 new 是一个字节切片，不是关键字了
  new := []byte("oo")
  n := 1
  // func Replace(s, old, new []byte, n int) []byte
  //返回字节切片 S 的一个副本， 并且将前n个不重叠的子切片 old 替换为 new，如果n < 0 那么不限制替换的数量
  fmt.Println(string(bytes.Replace(s3, old, new, n)))
  fmt.Println(string(bytes.Replace(s3, old, new, -1)))


  // 将字节切片 转化为对应的 UTF-8编码的字节序列，并且返回对应的 Unicode 切片。
  s4 := []byte("中华人民共和国")
  r1 := bytes.Runes(s4)
  // func Runes(b []byte) []rune
  fmt.Println(string(s4), len(s4))  // 字节切片的长度
  fmt.Println(string(r1), len(r1))  // rune 切片的长度


  // 字节切片 的每个元素，依旧是字节切片。
  s5 := [][]byte{
    []byte("你好"),
    []byte("世界"),  //这里的逗号，必不可少
  }
  sep := []byte(",")
  // func Join(s [][]byte, sep []byte) []byte
  // 用字节切片 sep 吧 s中的每个字节切片连接成一个，并且返回.
  fmt.Println(string(bytes.Join(s5, sep)))
}

package main
import "fmt"

func main() {
  var x float64
  x = 20.0
  fmt.Println(x)
  fmt.Printf("x is of type %T\n", x)

  a := float64(20.0)
  b := 42 
  fmt.Println(a)
  fmt.Println(b)
  fmt.Printf("a is of type %T\n", a)
  fmt.Printf("b is of type %T\n", b)
}

// 示例：通过指针修改结构体字段
package main
import (
  "fmt"
  "unsafe"
)

func main() {
  s := struct {
    a byte
    b byte
    c byte
    d int64
  }{0, 0, 0, 0}

  // 将结构体指针转换为通用指针
  p := unsafe.Pointer(&s)
  // 保存结构体的地址备用（偏移量为 0）
  up0 := uintptr(p)
  // 将通用指针转换为 byte 型指针
  pb := (*byte)(p)
  // 给转换后的指针赋值
  *pb = 10
  // 结构体内容跟着改变
  fmt.Println(s)

  // 偏移到第 2 个字段
  up := up0 + unsafe.Offsetof(s.b)
  // 将偏移后的地址转换为通用指针
  p = unsafe.Pointer(up)
  // 将通用指针转换为 byte 型指针
  pb = (*byte)(p)
  // 给转换后的指针赋值
  *pb = 20
  // 结构体内容跟着改变
  fmt.Println(s)

  // 偏移到第 3 个字段
  up = up0 + unsafe.Offsetof(s.c)
  // 将偏移后的地址转换为通用指针
  p = unsafe.Pointer(up)
  // 将通用指针转换为 byte 型指针
  pb = (*byte)(p)
  // 给转换后的指针赋值
  *pb = 30
  // 结构体内容跟着改变
  fmt.Println(s)

  // 偏移到第 4 个字段
  up = up0 + unsafe.Offsetof(s.d)
  // 将偏移后的地址转换为通用指针
  p = unsafe.Pointer(up)
  // 将通用指针转换为 int64 型指针
  pi := (*int64)(p)
  // 给转换后的指针赋值
  *pi = 40
  // 结构体内容跟着改变
  fmt.Println(s)
}

var variable_name [SIZE]variable_type

package main
import "fmt"
func main() {
  // 声明一个长度为5的整数数组
  // 一旦数组被声明了，那么它的数据类型跟长度都不能再被改变。
  var array1 [5]int
  
  fmt.Printf("array1: %d\n\n", array1)

  // 声明一个长度为5的整数数组
  // 初始化每个元素
  array2 := [5]int{12, 123, 1234, 12345, 123456}
  array2[1] = 5000
  fmt.Printf("array2: %d\n\n", array2[1])
  
  // n 是一个长度为 10 的数组
  var n [10]int 
  var i,j int

  /* 为数组 n 初始化元素 */         
  for i = 0; i < 10; i++ {
    n[i] = i + 100 /* 设置元素为 i + 100 */
  }

  /* 输出每个数组元素的值 */
  for j = 0; j < 10; j++ {
    fmt.Printf("Element[%d] = %d\n", j, n[j] )
  }

  /* 数组 - 5 行 2 列*/
  var a = [5][2]int{ {0,0}, {1,2}, {2,4}, {3,6},{4,8}}
  var e, f int

  /* 输出数组元素 */
  for  e = 0; e < 5; e++ {
    for f = 0; f < 2; f++ {
        fmt.Printf("a[%d][%d] = %d\n", e,f, a[e][f] )
    }
  }
}

var array1 = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

float32 salary = array1[9]

// 三行四列
a = [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11}   /*  第三行索引为 2 */
}

// 访问第2行第3列
int val = a[2][3]

package main
import "fmt"
type Vertex struct {
  X int
  Y int
}
func main() {
  fmt.Println(Vertex{1, 2})
  
  // 结构体字段使用点号来访问。
  v := Vertex{1, 2}
  v.X = 4
  fmt.Println(v.X)
  
  // 结构体字段可以通过结构体指针来访问。
  e := Vertex{1, 2}
  p := &e
  p.X = 1e9
  fmt.Println(e)
  
  
  var (
    v1 = Vertex{1, 2}  // 类型为 Vertex
    v2 = Vertex{X: 1}  // Y:0 被省略
    v3 = Vertex{}      // X:0 和 Y:0
    p  = &Vertex{1, 2} // 类型为 *Vertex , 特殊的前缀 & 返回一个指向结构体的指针
  )
  fmt.Println(v1, p, v2, v3)
}

type T struct {a, b int}

var s T
s.a = 5
s.b = 8

var t *T
t = new(T)

var str string //声明一个字符串
str = "Go lang"  //赋值
ch :=str[0]    //获取第一个字符
len :=len(str) //字符串的长度,len是内置函数 ,len=5

package main
import (
   "fmt"
   "math"
)

/* 定义一个 interface */
type shape interface {
   area() float64
}

/* 定义一个 circle */
type circle struct {
   x,y,radius float64
}

/* 定义一个 rectangle */
type rectangle struct {
   width, height float64
}

/* 定义一个circle方法 (实现 shape.area())*/
func(circle circle) area() float64 {
   return math.Pi * circle.radius * circle.radius
}

/* 定义一个rectangle方法 (实现 shape.area())*/
func(rect rectangle) area() float64 {
   return rect.width * rect.height
}

/* 定义一个shape的方法*/
func getArea(shape shape) float64 {
   return shape.area()
}

func main() {
   circle := circle{x:0,y:0,radius:5}
   rectangle := rectangle {width:10, height:5}

   fmt.Printf("circle area: %f\n",getArea(circle))
   fmt.Printf("rectangle area: %f\n",getArea(rectangle))
}

package main
import "fmt"
type functinTyoe func(int, int) // 声明了一个函数类型
func (f functinTyoe)Serve() {
  fmt.Println("serve2")
}
func serve(int,int) {
  fmt.Println("serve1")
}
func main() {
  a := functinTyoe(serve)
  a(1,2)
  a.Serve()
}

// 通过 make 来创建
dict := make(map[string]int)
// 通过字面值创建
dict := map[string]string{"Red": "#da1337", "Orange": "#e95a22"}

// 给 map 赋值就是指定合法类型的键，然后把值赋给键
colors := map[string]string{}
colors["Red"] = "#da1337"

// 不初始化 map , 就会创建一个 nil map。nil map 不能用来存放键值对，否则会报运行时错误
var colors map[string]string
colors["Red"] = "#da1337"
// Runtime Error:
// panic: runtime error: assignment to entry in nil map

//选择是只返回值，然后判断是否是零值来确定键是否存在。
value := colors["Blue"]
if value != "" {
  fmt.Println(value)
}

func main() {
  colors := map[string]string{
     "AliceBlue":   "#f0f8ff",
     "Coral":       "#ff7F50",
     "DarkGray":    "#a9a9a9",
     "ForestGreen": "#228b22",
  }
  for key, value := range colors {
      fmt.Printf("Key: %s  Value: %s\n", key, value)
  }
  removeColor(colors, "Coral")
  for key, value := range colors {
      fmt.Printf("Key: %s  Value: %s\n", key, value)
  }
}
func removeColor(colors map[string]string, key string) {
    delete(colors, key)
}

type (
  byte int8
  rune init32
  文本 string
)
var b 文本
b = "别名类型，可以是中文！"

package main
import "unsafe"
// 常量可以用len(), cap(), unsafe.Sizeof()常量计算表达式的值。
// 常量表达式中，函数必须是内置函数，否则编译不过：
const (
  a = "abc"
  b = len(a)
  c = unsafe.Sizeof(a)
)

func main(){
  const (
    PI     = 3.14
    const1 = "1"
  )
  const LENGTH int = 10
  const e, f, g = 1, false, "str" //多重赋值
  println(a, b, c,PI, LENGTH)
}

package main
import "fmt"
func main() {
  const (
    // 第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；
    // 所以 a=0, b=1, c=2 可以简写为如下形式：
    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
  )
  fmt.Println(a,b,c,d,e,f,g,h,i)
}

var (
  name  = "gopher"
  name1 = "1"
)
// 变量声明
var a int
a = 11 /* 赋值 */

// 变量声明 并赋值
var b int = 12

// 应用在函数体内的方式
var a, b, c, d int = 1, 2, 3, 4
// a =1 
// b =2 
// c =3 
// d =4 


var a, _, c, d int = 1, 2, 3, 4
// 忽略 _ 返回值忽略

// 只能类型显式转换
var a float32 = 1.1
// 省略var, 简短形式，使用 := 赋值操作符
b := int(a)
// 不兼容的类型不能转换类型

var x, y int
// 这种因式分解关键字的写法一般用于声明全局变量
var (
  a int
  b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

package main
import "fmt"
func main() {
  var a int = 21
  var b int = 10
  var c int
  c = a + b
  fmt.Printf("第一行 - c 的值为 %d\n", c ) // 第一行 - c 的值为 31
  c = a - b
  fmt.Printf("第二行 - c 的值为 %d\n", c ) // 第二行 - c 的值为 11
  c = a * b
  fmt.Printf("第三行 - c 的值为 %d\n", c ) // 第三行 - c 的值为 210
  c = a / b
  fmt.Printf("第四行 - c 的值为 %d\n", c ) // 第四行 - c 的值为 2
  c = a % b
  fmt.Printf("第五行 - c 的值为 %d\n", c ) // 第五行 - c 的值为 1
  a++
  fmt.Printf("第六行 - a 的值为 %d\n", a ) // 第六行 - a 的值为 22
  a--
  fmt.Printf("第七行 - a 的值为 %d\n", a ) // 第七行 - a 的值为 21
}

package main
import "fmt"
func main() {
   var a int = 21
   var b int = 10
   if( a == b ) {
      fmt.Printf("第一行 - a 等于 b\n" )
   } else {
      fmt.Printf("第一行 - a 不等于 b\n" )
   }
   if ( a < b ) {
      fmt.Printf("第二行 - a 小于 b\n" )
   } else {
      fmt.Printf("第二行 - a 不小于 b\n" )
   } 
   
   if ( a > b ) {
      fmt.Printf("第三行 - a 大于 b\n" )
   } else {
      fmt.Printf("第三行 - a 不大于 b\n" )
   }
   /* 让我们改变a和b的值 */
   a = 5
   b = 20
   if ( a <= b ) {
      fmt.Printf("第四行 - a 小于等于 b\n" )
   }
   if ( b >= a ) {
      fmt.Printf("第五行 - b 大于等于 a\n" )
   }
}

package main
import "fmt"
func main() {
  var a bool = true
  var b bool = false
  if ( a && b ) {
    fmt.Printf("第一行 - 条件为 true\n" )
  }
  if ( a || b ) {
    fmt.Printf("第二行 - 条件为 true\n" )
  }
  /* 修改 a 和 b 的值 */
  a = false
  b = true
  if ( a && b ) {
    fmt.Printf("第三行 - 条件为 true\n" )
  } else {
    fmt.Printf("第三行 - 条件为 false\n" )
  }
  if ( !(a && b) ) {
    fmt.Printf("第四行 - 条件为 true\n" )
  }
}

package main
import "fmt"
func main() {

  var a uint = 60  /* 60 = 0011 1100 */  
  var b uint = 13  /* 13 = 0000 1101 */
  var c uint = 0          

  c = a & b       /* 12 = 0000 1100 */ 
  fmt.Printf("第一行 - c 的值为 %d\n", c ) // 第一行 - c 的值为 12

  c = a | b       /* 61 = 0011 1101 */
  fmt.Printf("第二行 - c 的值为 %d\n", c )  // 第二行 - c 的值为 61

  c = a ^ b       /* 49 = 0011 0001 */
  fmt.Printf("第三行 - c 的值为 %d\n", c ) // 第三行 - c 的值为 49

  c = a << 2     /* 240 = 1111 0000 */
  fmt.Printf("第四行 - c 的值为 %d\n", c ) // 第四行 - c 的值为 240

  c = a >> 2     /* 15 = 0000 1111 */
  fmt.Printf("第五行 - c 的值为 %d\n", c )  // 第五行 - c 的值为 15
}

package main
import "fmt"
func main() {
  var a int = 21
  var c int

  c =  a
  fmt.Printf("第 1 行 - =  运算符实例，c 值为 = %d\n", c )
  // 第 1 行 - =  运算符实例，c 值为 = 21
  c +=  a
  fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c )
  // 第 2 行 - += 运算符实例，c 值为 = 42
  c -=  a
  fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c )
  // 第 3 行 - -= 运算符实例，c 值为 = 21
  c *=  a
  fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c )
  // 第 4 行 - *= 运算符实例，c 值为 = 441
  c /=  a
  fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c )
  // 第 5 行 - /= 运算符实例，c 值为 = 21
  c  = 200; 
  c <<=  2
  fmt.Printf("第 6 行  - <<= 运算符实例，c 值为 = %d\n", c )
  // 第 6 行  - <<= 运算符实例，c 值为 = 800
  c >>=  2
  fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c )
  // 第 7 行 - >>= 运算符实例，c 值为 = 200
  c &=  2
  fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c )
  // 第 8 行 - &= 运算符实例，c 值为 = 0
  c ^=  2
  fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c )
  // 第 9 行 - ^= 运算符实例，c 值为 = 2
  c |=  2
  fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c )
  // 第 10 行 - |= 运算符实例，c 值为 = 2
}

package main
import "fmt"
func main() {
  var a int = 4
  var b int32
  var c float32
  var ptr *int

  /* 运算符实例 */
  fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a ); // 第 1 行 - a 变量类型为 = int
  fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b ); // 第 2 行 - b 变量类型为 = int32
  fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c ); // 第 3 行 - c 变量类型为 = float32

  /*  & 和 * 运算符实例 */
  ptr = &a  /* 'ptr' 包含了 'a' 变量的地址 */
  fmt.Printf("a 的值为  %d\n", a);   // a 的值为  4
  fmt.Printf("*ptr 为 %d\n", *ptr); // *ptr 为 4
}

package main
import "fmt"
func main() {
  var a int = 20
  var b int = 10
  var c int = 15
  var d int = 5
  var e int;
  // 通过使用括号来临时提升某个表达式的整体运算优先级。
  e = (a + b) * c / d;      // ( 30 * 15 ) / 5
  fmt.Printf("(a + b) * c / d 的值为 : %d\n",  e );
  e = ((a + b) * c) / d;    // (30 * 15 ) / 5
  fmt.Printf("((a + b) * c) / d 的值为  : %d\n" ,  e );
  e = (a + b) * (c / d);   // (30) * (15/5)
  fmt.Printf("(a + b) * (c / d) 的值为  : %d\n",  e );
  e = a + (b * c) / d;     //  20 + (150/5)
  fmt.Printf("a + (b * c) / d 的值为  : %d\n" ,  e );  
}

package main
import "fmt"
func main() {
  sum := 0
  // 如果条件表达式的值变为 false，那么迭代将终止。
  for i := 0; i < 10; i++ {
    sum += i
  }
  fmt.Println(sum)
  
  // 循环初始化语句和后置语句都是可选的。
  // for 是 Go 的 “while”
  // 基于此可以省略分号：C 的 while 在 Go 中叫做 for 。
  // 如果省略了循环条件，循环就不会结束，因此可以用更简洁地形式表达死循环。
  sum2 := 1
  for ; sum2 < 1000; {
    sum2 += sum2
  }
  fmt.Println(sum2)
}

package main
import (
  "fmt"
  "math"
)
func sqrt(x float64) string {
  if x < 0 {
    return sqrt(-x) + "i"
  }
  return fmt.Sprint(math.Sqrt(x))
}
func main() {
  fmt.Println(sqrt(2), sqrt(-4))
}

package main
import (
  "fmt"
  "math"
)

func pow(x, n, lim float64) float64 {
  if v := math.Pow(x, n); v < lim {
    return v
  }
  return lim
}
func main() {
  fmt.Println(
    pow(3, 2, 10),
    pow(3, 3, 20),
  )
}

package main
import (
  "fmt"
  "math"
)
func pow(x, n, lim float64) float64 {
  if v := math.Pow(x, n); v < lim {
    return v
  } else {
    fmt.Printf("%g >= %g\n", v, lim)
  }
  // 这里开始就不能使用 v 了
  return lim
}

func main() {
  // 两个 pow 调用都在 main 调用 fmt.Println 前执行完毕了。
  fmt.Println(
    pow(3, 2, 10),
    pow(3, 3, 20),
  )
}

package main
import (
  "fmt"
  "runtime"
)
func main() {
  fmt.Print("Go runs on ")
  switch os := runtime.GOOS; os {
    case "darwin":
      fmt.Println("OS X.")
    case "linux":
      fmt.Println("Linux.")
    default:
      // freebsd, openbsd,
      // plan9, windows...
      fmt.Printf("%s.", os)
  }
}

package main
import (
  "fmt"
  "time"
)
func main() {
  fmt.Println("When's Saturday?")
  today := time.Now().Weekday()
  switch time.Saturday {
    case today + 0:
      fmt.Println("Today.")
    case today + 1:
      fmt.Println("Tomorrow.")
    case today + 2:
      fmt.Println("In two days.")
    default:
      fmt.Println("Too far away.")
  }
}

package main
import (
  "fmt"
  "time"
)
func main() {
  t := time.Now()
  switch {
    case t.Hour() < 12:
      fmt.Println("Good morning!")
    case t.Hour() < 17:
      fmt.Println("Good afternoon.")
    default:
      fmt.Println("Good evening.")
  }
}

package main
import "fmt"
func main() {
  // 2. 在输出 world
  defer fmt.Println("world")
  // 1. 先输出 hello
  fmt.Println("hello")
}

package main
import "fmt"
func main() {
  fmt.Println("counting")
  for i := 0; i < 10; i++ {
    defer fmt.Println(i)
  }
  fmt.Println("done")
}

package main
import "fmt"
type Vertex struct {
  X int
  Y int
}
func main() {
  v := Vertex{1, 2}
  v.X = 4
  fmt.Println(v.X)
}

package main
import "fmt"
type Vertex struct {
  X int
  Y int
}
func main() {
  v := Vertex{1, 2}
  p := &v
  p.X = 1e9
  fmt.Println(v)
}

package main
import "fmt"
type Vertex struct {
  X int
  Y int
}
func main() {
  v := Vertex{1, 2}
  p := &v
  p.X = 1e9
  fmt.Println(v)
}