极速Go语言入门(超全超详细)-基础篇

package main //一个文件都要归属于一个包
import "fmt"
func main() {
  fmt.Println("hello word")
}

package main //一个文件都要归属于一个包
import "fmt"
func main() {
  fmt.Println("hello word")
}

package main
import "fmt"
func main() {
  //创建变量
  var a int
  //变量赋值
  a = 10
  //使用变量(进行打印)
  fmt.Println("a = ", a)
}

package main
import fmt "fmt"
// /全局变量///
var age, name = 18, "小明"
///全局变量///
func main() {
    //创建变量
  //变量=变量名+值+数据类型，这一点请大家注意，变量的三要素
  //Golang 的变量如果没有赋初值，编译器会使用默认值, 比如 int 默认值 0 string 默认值为空串， 小数默认为 0
  ///局部变量///
  //1、创建变量但 不赋值 使用的默认值(int 默认值为0)
  var a int
  //使用变量(进行打印)
  fmt.Println("a = ", a)
  //2、创建变量但不赋予类型，根据值自行判定变量类型(类型推导)
  var b = 10
  //fmt.Printf格式化输出 %v:输出值， %T:输出值的类型 \n:换行
  fmt.Printf("b = %v, type: %T  \n", b, b)
  //3、使用:=声明变量
  //c := "Go" 等价于 var c string = "Go";
  c := "Go"
  fmt.Printf("c = %v, type: %T \n", c, c)
  //4、多变量声明,带值声明或者不带值声明
  var d, e, f int              //不带值
  var d1, e1, f1 int = 1, 2, 3 //带值(相同类型)
  d2, e2, f2 := 1, "123", 's'  //带值(相同类型)
  fmt.Println(d, e, f, "------", d1, e1, f1, "------", d2, e2, f2)
  //注意⚠️:在同一代码块中，不能对类型再次赋予类型
  //var testA int = 10;
  //testA  := 20; // ❌
  ///局部变量///
  //输出全局变量
  fmt.Println(age, name)
}

package main
import (
  "fmt"
  "strconv"
  "unsafe"
)
func main() {
    println("----byte类型----")
  //Golang 程序中整型变量在使用时，遵守保小不保大的原则，即：在保证程序正确运行下，尽量 使用占用空间小的数据类型。【如：年龄】
  //bit: 计算机中的最小存储单位。byte:计算机中基本存储单元。[二进制再详细说] 1byte = 8 bit
  var n0 byte = 10
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", n0, n0, unsafe.Sizeof(n0))
  println("----int类型----")
  //int 类型
  var n1 int = 20
  var n2 int8 = 21
  var n3 int16 = 22
  var n4 int32 = 23
  var n5 int64 = 24
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", n1, n1, unsafe.Sizeof(n1))
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", n2, n2, unsafe.Sizeof(n2))
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", n3, n3, unsafe.Sizeof(n3))
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", n4, n4, unsafe.Sizeof(n4))
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", n5, n5, unsafe.Sizeof(n5))
  println("----float类型----")
  //float 类型
  var f1 float32 = 30.23748734872346 //会损失精度，如果我们要保存一个精度高的数，则应该选用 float64
  var f2 float64 = 21.23748734872346
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", f1, f1, unsafe.Sizeof(f1))
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", f2, f2, unsafe.Sizeof(f2))
  println("----字符类型----")
  //字符类型(英文字母占1 个字节 汉字占3 个字节)， 可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的 unicode 字符
  //Go 语 言 的 字 符 使 用 UTF-8 编 码 ， 如 果 想 查 询 字 符 对 应 的 utf8 码 值 http://www.mytju.com/classcode/tools/encode_utf8.asp
  //不理解utf-8、ASCII和Unicode可以看考这篇文章:https://www.bilibili.com/read/cv16001311/
  var c0 int = 's'
  var c1 int = '北'
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d, 显示信息=%c \n", c0, c0, unsafe.Sizeof(c0), c0)
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d, 显示信息=%c \n", c1, c1, unsafe.Sizeof(c1), c1)
  println("----布尔类型----")
  //bool 类型占 1 个字节。适于逻辑运算，一般用于程序流程控制
  var flagControl bool = true
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", flagControl, flagControl, unsafe.Sizeof(flagControl))
  for i := 0; i < 100; i++ {
    if i == 10 {
      //do something
      flagControl = false
    }
    if flagControl == false {
      fmt.Println("结束循环, i= ", i)
      break
    }
  }
  println("----string 类型----")
  //字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本
  //Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本，这样 Golang 统一使用 UTF-8 编码,中文 乱码问题不会再困扰程序员。
  var str string = "测试字符串"
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", str, str, unsafe.Sizeof(str))
  //注意⚠️:字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的。
  //var str1 string = "abc"
  //str1[0] = 'c' //❌ 不可取，不可修改里面的内容
  //字符串的两种表示形式 (1) 双引号, 会识别转义字符 (2) 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果 【案例演示】
  //方式1
  var str2 string = "测试字符串"
  //方式2
  var str3 string = `
      测试字符串表示形式，
      我是以字符串的原生形式输出，可以实现防止攻击、输出源代码等效果
      var str4 string = "4"
  `
  //字符串拼接方式 "" + "",当一行字符串太长时，需要使用到多行字符串，可以如下处理
  var str5 string = "hello" + "word" + "hello" + "word" + "hello" + "word" +
    "test" + "str"
  fmt.Println(str2, str3, str5)
  println("----指针类型----")
  //基本数据类型，变量存的就是值，也叫值类型。 获取变量的地址，用&，比如： var num int, 获取 num 的地址：&num
  //指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值
  var i int = 10
  //1、ptr是一个指针变量 2、ptr存的是i变量的地址 3、类型是*int
  var ptr *int = &i
  fmt.Printf("指针存储的值:%v, 类型:%T, 占内存字节数:%d, 指针存储地址指向的值:%d, 指针的地址:%v \n", ptr, ptr, unsafe.Sizeof(ptr), *ptr, &ptr)
  println("-----基本数据类型的相互转换----")
  基本数据类型的相互转换///
  //Golang 和 java / c 不同，Go 在不同类型的变量之间赋值时需要显式转换。也就是说 Golang 中数 据类型不能自动转换。
  var int_1 int = 100
  var float1 float32 = float32(int_1)
  var int_2 int8 = int8(int_1)
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", float1, float1, unsafe.Sizeof(float1))
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", int_2, int_2, unsafe.Sizeof(int_2))
  //在转换中，比如将 int64 转成 int8 【-128---127】 ，编译时不会报错，只是转换的结果是按 溢出处理，和我们希望的结果不一样。 因此在转换时，需要考虑范围.
  var int_3 int64 = 999
  var int_4 int8 = int8(int_3) //转换的时候值溢出
  fmt.Printf("值:%v, 类型:%T, 占内存字节数:%d \n", int_4, int_4, unsafe.Sizeof(int_4))
  //基本类型和string互转
  //方式 1：fmt.Sprintf("%参数", 表达式)
  var number1 int = 999
  var number2 float64 = 999.999
  var bool_1 bool = false
  var byte_1 byte = 'a'
  var str_1 string
  str_1 = fmt.Sprintf("%d", number1)
  fmt.Printf("1、转换后的值:%v, 类型:%T, 占内存字节数:%d \n", str_1, str_1, unsafe.Sizeof(str_1))
  str_1 = fmt.Sprintf("%f", number2)
  fmt.Printf("2、转换后的值:%v, 类型:%T, 占内存字节数:%d \n", str_1, str_1, unsafe.Sizeof(str_1))
  str_1 = fmt.Sprintf("%t", bool_1)
  fmt.Printf("3、转换后的值:%v, 类型:%T, 占内存字节数:%d \n", str_1, str_1, unsafe.Sizeof(str_1))
  str_1 = fmt.Sprintf("%c", byte_1)
  fmt.Printf("4、转换后的值:%v, 类型:%T, 占内存字节数:%d \n", str_1, str_1, unsafe.Sizeof(str_1))
  //方式 2：使用 strconv 包的函数
  var number4 int32 = 888
  var number5 float64 = 888.888
  var bool_2 bool = false
  str_1 = strconv.FormatInt(int64(number4), 10)
  fmt.Printf("5、转换后的值:%v, 类型:%T, 占内存字节数:%d \n", str_1, str_1, unsafe.Sizeof(str_1))
  //FormatFloat(f float64, fmt byte, prec, bitSize int),参数依次表示为转换的值、转换的格式、保留小数后多少位、是转换成float64还是float32
  str_1 = strconv.FormatFloat(number5, 'f', 2, 64)
  fmt.Printf("6、转换后的值:%v, 类型:%T, 占内存字节数:%d \n", str_1, str_1, unsafe.Sizeof(str_1))
  str_1 = strconv.FormatBool(bool_2)
  fmt.Printf("7、转换后的值:%v, 类型:%T, 占内存字节数:%d \n", str_1, str_1, unsafe.Sizeof(str_1))
  //string 类型转基本数据类型
  var str_2 string = "true"
  var bool_3 bool
  //strconv.ParseBool返回两个值, _标识忽略返回的第二个值
  bool_3, _ = strconv.ParseBool(str_2)
  fmt.Printf("8、转换后的值:%v, 类型:%T, 占内存字节数:%d \n", bool_3, bool_3, unsafe.Sizeof(bool_3))
  //  strconv.ParseFloat()同理
  //  strconv.ParseInt()同理
  //  strconv.ParseUint()同理
  //注意⚠️事项:在将 String 类型转成 基本数据类型时，要确保 String 类型能够转成有效的数据
  //比如 我们可以 把 "123" ,转成一个整数，但是不能把 "hello" 转成一个整数，如果这样做，Golang 直接将其转成 0 ， 其它类型也是一样的道理. float => 0 bool => false
  var str_4 string = "hello"
  var int_5 int64
  int_5, _ = strconv.ParseInt(str_4, 10, 64)
  fmt.Printf("9、转换后的值:%v, 类型:%T, 占内存字节数:%d \n", int_5, int_5, unsafe.Sizeof(int_5))
}

----byte类型----
值:10, 类型:uint8, 占内存字节数:1 
----int类型----
值:20, 类型:int, 占内存字节数:8 
值:21, 类型:int8, 占内存字节数:1 
值:22, 类型:int16, 占内存字节数:2 
值:23, 类型:int32, 占内存字节数:4 
值:24, 类型:int64, 占内存字节数:8 
----float类型----
值:30.237488, 类型:float32, 占内存字节数:4 
值:21.23748734872346, 类型:float64, 占内存字节数:8 
----字符类型----
值:115, 类型:int, 占内存字节数:8, 显示信息=s 
值:21271, 类型:int, 占内存字节数:8, 显示信息=北 
----布尔类型----
值:true, 类型:bool, 占内存字节数:1 
结束循环, i=  10
----string 类型----
值:测试字符串, 类型:string, 占内存字节数:16 
测试字符串 
                        测试字符串表示形式，
                        我是以字符串的原生形式输出，可以实现防止攻击、输出源代码等效果
                        var str4 string = "4"
         hellowordhellowordhellowordteststr
----指针类型----
指针存储的值:0x14000126050, 类型:*int, 占内存字节数:8, 指针存储地址指向的值:10, 指针的地址:0x14000120020 
-----基本数据类型的相互转换----
值:100, 类型:float32, 占内存字节数:4 
值:100, 类型:int8, 占内存字节数:1 
值:-25, 类型:int8, 占内存字节数:1 
1、转换后的值:999, 类型:string, 占内存字节数:16 
2、转换后的值:999.999000, 类型:string, 占内存字节数:16 
3、转换后的值:false, 类型:string, 占内存字节数:16 
4、转换后的值:a, 类型:string, 占内存字节数:16 
5、转换后的值:888, 类型:string, 占内存字节数:16 
6、转换后的值:888.89, 类型:string, 占内存字节数:16 
7、转换后的值:false, 类型:string, 占内存字节数:16 
8、转换后的值:true, 类型:bool, 占内存字节数:1 
9、转换后的值:0, 类型:int64, 占内存字节数:8 

package main
import (
  "fmt"
)
func main() {
  var num_0 int = 100
  var num_1 int = 100
  var num_2 int = num_1 + num_0/num_0*num_1
  println(num_2)
  // 演示 % 的使用
  //看一个公式 a % b = a - a / b * b
  fmt.Println("10%3=", 10%3)
  fmt.Println("-10%3=", -10%3)
  fmt.Println("10%-3=", 10%-3)
  fmt.Println("-10%-3=", -10%-3)
  //i++, i--
  var i_0 int8 = 0
  i_0++
  var i_1 int8 = 0
  i_1--
  fmt.Printf("i_0 = %d, i_1 = %d \n", i_0, i_1)
  //Golang 的自增自减只能当做一个独立语言使用时，不能这样使
  /**
  var i_3 int = i_0 ++    //❌ 错误用法
  if i_0 ++ > 1{}    //❌ 错误用法
  */
}

  package main
  func main() {
  //逻辑运算符
  var number_0 int8 = 10
  var number_1 int8 = 15
  if number_1 == 11 || number_0 < 10 {
    println("我是1")
  } else if number_1 == 15 && number_0 == 10 {
    println("我是2")
  } else if !(number_1 == 15) {
    println("我是3")
  }
  }

package main
import "fmt"
func main() {
    var name string
    var age int
    var address string
    //方式1:fmt.Scanln
    fmt.Println("请输入姓名")
    fmt.Scanln(&name)
    fmt.Println("请输入年龄")
    fmt.Scanln(&age)
    fmt.Println("请输入地址")
    fmt.Scanln(&address)
    fmt.Printf("姓名:%v, 年龄:%v, 地址:%v   \n", name, age, address)
    //方式2:fmt.Scanf
    println("----------------------")
    var name_1 string
    var age_1 int
    var address_1 string
    println("请输入你的姓名、年龄、地址，依次按照空格隔开")
    fmt.Scanf("%s %d %s", &name_1, &age_1, &address_1)
    fmt.Printf("姓名:%v, 年龄:%v, 地址:%v   \n", name_1, age_1, address_1)
}

请输入姓名
测试
请输入年龄
18
请输入地址
北京朝阳区
姓名:测试, 年龄:18, 地址:北京朝阳区   
----------------------
请输入你的姓名、年龄、地址，依次按照空格隔开
测试 18 北京朝阳区
姓名:测试, 年龄:18, 地址:北京朝阳区   

package main
import "fmt"
func main() {
  println("-------if else流程控制------")
  //流程控制
  num := 10
  //单分支语句
  if num <= 10 {
    //满足条件进入流程
    fmt.Println("单分支测试")
  }
  //双分支语句
  if num > 10 {
    fmt.Println("双分支测试01")
  } else {
    fmt.Println("双分支测试02")
  }
  //多分支语句，注意⚠️:双分支语句或者多分支语句执行后只会进入到一个流程当中，代码由上而下执行，只要满足即出流程不会就算是其他分支满足条件也不会进入到分支里
  if num > 10 {
    fmt.Println("多分支测试01")
  } else if num == 10 {
    fmt.Println("多分支测试02")
  } else {
    fmt.Println("多分支测试03")
  }
  //嵌套语句(在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分 支外面的分支结构称为外层分支。)
  num_01 := 20
  if num > 10 {
    fmt.Println("多分支测试04")
  } else if num == 10 {
    if num_01 > 20 {
      fmt.Println("嵌套分支测试01")
    } else if num_01 == 20 {
      fmt.Println("嵌套分支测试02")
    }
    fmt.Println("分支测试05")
  }
  println("-------switch case流程控制------")
  //switch case流程控制
  currentTemperature := 25
  switch currentTemperature {
  case 10:
    fmt.Println("当前天气凉")
  case 25:
    fmt.Println("当前天气温暖～")
  case 40:
    fmt.Println("当前天气热死了！")
  default:
    //以上条件都不符合才会进入这里
    fmt.Println("这鬼天气多变！")
  }
}

-------if else流程控制------
单分支测试
双分支测试02
多分支测试02
嵌套分支测试02
分支测试05
-------switch case流程控制------
当前天气温暖～

package main
import "fmt"
func main() {
  //简单示例，循环10次
  for i := 0; i < 10; i++ {
    fmt.Println("循环次数 i = ", i)
  }
  //上述还可以这样写
  j := 0
  for j < 10 {
    fmt.Println("循环次数 j = ", j)
    j++
  }
}

循环次数 i =  0
循环次数 i =  1
循环次数 i =  2
循环次数 i =  3
循环次数 i =  4
循环次数 i =  5
循环次数 i =  6
循环次数 i =  7
循环次数 i =  8
循环次数 i =  9
循环次数 j =  0
循环次数 j =  1
循环次数 j =  2
循环次数 j =  3
循环次数 j =  4
循环次数 j =  5
循环次数 j =  6
循环次数 j =  7
循环次数 j =  8
循环次数 j =  9

package main
import "fmt"
func main() {
    println("------break测试-----")
  k := 0
  for { //等价于 for ; ;
    if k >= 10 {
      //退出循环
      break
    }
    fmt.Println("循环次数 k = ", k)
    k++
  }
    /continue测试///
  println("------continue测试-----")
  l := 0
  for l < 10 {
    if l == 2 {
      fmt.Println("我是continue测试, l = ", l)
      l++
      continue
    }
    fmt.Println("循环测试, l = ", l)
    l++
  }
    /goto测试///
  println("------goto测试-----")
  flag := false
  if flag == false {
    goto label_01
  }
  println("------goto测试----1-----")
  println("------goto测试----2-----")
  label_01: //跳转标识，上述输出不会打印
  println("------goto测试----3-----")
  println("------goto测试----4-----")
    /return测试///
  println("------return测试-----")
  returnTestNum := 0
  if returnTestNum == 0 {
    println("-----到此为止了！-----")
    return
  }
  println("-----执行动作1-----")
  println("-----执行动作2-----")
}

------break测试-----
循环次数 k =  0
循环次数 k =  1
循环次数 k =  2
循环次数 k =  3
循环次数 k =  4
循环次数 k =  5
循环次数 k =  6
循环次数 k =  7
循环次数 k =  8
循环次数 k =  9
------continue测试-----
循环测试, l =  0
循环测试, l =  1
我是continue测试, l =  2
循环测试, l =  3
循环测试, l =  4
循环测试, l =  5
循环测试, l =  6
循环测试, l =  7
循环测试, l =  8
循环测试, l =  9
------goto测试-----
------goto测试----3-----
------goto测试----4-----
------return测试-----
-----到此为止了！-----

package main
import (
  "fmt"
  "math/rand"
  "time"
)
func main() {
  time.Now().UnixNano() 返回当前系统的纳秒数
  rand.Seed(time.Now().Unix())
  rangerNum := 0
  for i := 0; i < 10; i++ {
    rangerNum = rand.Intn(100) + 1
    fmt.Println(rangerNum)
  }
}

package main
import (
  "fmt"
)
func main() {
  //创建数组
  var arr_0 [4]int = [4]int{1, 2, 3, 4}
  var arr_1 = [4]float64{111.000, 222, 333, 444.444}
  var arr_2 = [...]bool{false, true, true}      // 自行判断长度，中括号里...一个不能少
  var arr_3 = [...]byte{1: 'a', 0: 'b', 2: 'c'} // 指定索引和值
  fmt.Printf("arr_0= %v, 类型:%T \n", arr_0, arr_0)
  fmt.Printf("arr_1= %v, 类型:%T \n", arr_1, arr_1)
  fmt.Printf("arr_2= %v, 类型:%T \n", arr_2, arr_2)
  fmt.Printf("arr_3= %v, 类型:%T \n", arr_3, arr_3)
}

package main
import "fmt"
func main() {
    //数组
  array_0 := [...]int{1, 2, 3, 4}
  //切片(将数组下标为1到3的数据取出来,不含3)
  slice := array_0[1:3]
  fmt.Printf("slice 内容:%v \n", slice)
  fmt.Printf("数组下标为1的数据为:%v, 数组下标为2的数据为:%v \n", array_0[1], array_0[2])
  //通过make创建一个数组，但是过程对我们是不可见的
  sl := make([]int, 5)
  fmt.Printf("切片sl类型:%T, 数据为:%v, 长度:%v \n", sl, sl, len(sl))
  println("-------追加内容测试-------")
  //追加数据到切片中,尾部追加
  sl = append(sl, 1, 2, 3, 3, 4)
  fmt.Printf("尾部追加切片sl类型:%T, 数据为:%v 长度:%v \n", sl, sl, len(sl))
  //追加切片到切片中,尾部追加
  sl = append(sl, []int{1, 2, 3}...)
  fmt.Printf("尾部追加切片后切片sl类型:%T, 数据为:%v 长度:%v \n", sl, sl, len(sl))
  //追加数据到切片中,头部追加
  sl = append([]int{0, 1, 2}, sl...)
  fmt.Printf("头部追加切片sl类型:%T, 数据为:%v 长度:%v \n", sl, sl, len(sl))
  println("-------合并内容测试-------")
  //合并两个切片内容,注意⚠️:切片相同下标的元素会被合并的元素覆盖
  copy(sl, slice)
  fmt.Printf("合并后切片sl类型:%T, 数据为:%v 长度:%v \n", sl, sl, len(sl))
  strArray_1 := [...]string{"123", "234", "456", "999"}
  strArray_2 := [...]string{"111", "222", "333", "888"}
  strSlice_1 := strArray_1[0:4]
  strSlice_2 := strArray_2[1:4]
  fmt.Printf("原有strSlice_1 内容:%v \n", strSlice_1)
  fmt.Printf("原有strSlice_2 内容:%v \n", strSlice_2)
  copy(strSlice_1, strSlice_2)
  fmt.Printf("合并后strSlice_1 内容:%v \n", strSlice_1)
  fmt.Printf("合并后strSlice_2 内容:%v \n", strSlice_2)
  println("-------删除内容测试-------")
  //删除内容
  newSlice := []int{1, 2, 3}
  newSlice = newSlice[1:] //从下标1开始取所有数据，相当于删除了下标为0(即第一个元素)
  fmt.Printf("删除后newSlice 内容:%v \n", newSlice)
  //删除尾部元素
  newSlice = []int{1, 2, 3, 4, 5, 6, 7, 8}
  newSlice = newSlice[0 : len(newSlice)-1] //删除最后一个元素
  fmt.Printf("删除后newSlice 内容:%v \n", newSlice)
  newSlice = newSlice[0 : len(newSlice)-3] //删除最后3个元素
  fmt.Printf("删除后newSlice 内容:%v \n", newSlice)
  //进行略复杂删除，使用append删除
  newArray_01 := [...]string{"a", "b", "c", "d"}
  stringsSlice_01 := append(newArray_01[:2], newArray_01[3]) //删除中间下标为2的元素,公式即append(newArray_01[:i], newArray_01[i + 1]),i= 2,删除多个可以参考
  fmt.Printf("删除后newArray_01 内容:%v \n", stringsSlice_01)
  //进行略复杂删除，使用copy删除
  newArray_02 := [...]string{"e", "f", "g", "h"}
  fmt.Printf("%v, ---, %v \n", newArray_02[:2], newArray_02[3:])
  //看输出内容加以理解，此处将元素["e", "f"] ["h"] 合并后 变为 ->["h", f],可以看下上面切片合并加以理解
  //按照需求切分，此处比较绕，多思考
  copyAfterLen := copy(newArray_02[:2], newArray_02[3:])
  fmt.Printf("copy 后长度:%v newArray_02内容:%v \n", copyAfterLen, newArray_02)
  stringsSlice_02 := newArray_02[:copyAfterLen]
  fmt.Printf("删除后newArray_02 内容:%v \n", stringsSlice_02)
}

slice 内容:[2 3] 
数组下标为1的数据为:2, 数组下标为2的数据为:3 
切片sl类型:[]int, 数据为:[0 0 0 0 0], 长度:5 
-------追加内容测试-------
尾部追加切片sl类型:[]int, 数据为:[0 0 0 0 0 1 2 3 3 4] 长度:10 
尾部追加切片后切片sl类型:[]int, 数据为:[0 0 0 0 0 1 2 3 3 4 1 2 3] 长度:13 
头部追加切片sl类型:[]int, 数据为:[0 1 2 0 0 0 0 0 1 2 3 3 4 1 2 3] 长度:16 
-------合并内容测试-------
合并后切片sl类型:[]int, 数据为:[2 3 2 0 0 0 0 0 1 2 3 3 4 1 2 3] 长度:16 
原有strSlice_1 内容:[123 234 456 999] 
原有strSlice_2 内容:[222 333 888] 
合并后strSlice_1 内容:[222 333 888 999] 
合并后strSlice_2 内容:[222 333 888] 
-------删除内容测试-------
删除后newSlice 内容:[2 3] 
删除后newSlice 内容:[1 2 3 4 5 6 7] 
删除后newSlice 内容:[1 2 3 4] 
删除后newArray_01 内容:[a b d] 
[e f], ---, [h] 
copy 后长度:1 newArray_02内容:[h f g h] 
删除后newArray_02 内容:[h] 

  //初始化一个map,长度为10
  stringStringMap := make(map[string]string, 10)
  //向map增加元素
  stringStringMap["name"] = "Mir Li"
  stringStringMap["age"] = "18"
  fmt.Printf("stringMap 内容:%v 类型：%T, 长度:%d \n", stringStringMap, stringStringMap, len(stringStringMap))
  //覆盖元素操作
  stringStringMap["name"] = "Mir Zhang"
  fmt.Printf("stringMap 内容:%v 类型：%T, 长度:%d \n", stringStringMap, stringStringMap, len(stringStringMap))
  //删除元素操作
  delete(stringStringMap, "age")
  fmt.Printf("stringMap 内容:%v 类型：%T, 长度:%d \n", stringStringMap, stringStringMap, len(stringStringMap))
  //判断是否存在元素
  _, present := stringStringMap["name"]
  fmt.Printf("stringStringMap 元素是否存在%v元素:%v \n", "name", present)
  //其他初始化方式，初始即赋值
  stringIntMap := map[string]int{
    "Jan": 31, "Feb": 28, "Mar": 31,
    "Apr": 30, "May": 31, "Jun": 30,
    "Jul": 31, "Aug": 31, "Sep": 30,
    "Oct": 31, "Nov": 30, "Dec": 31,
  }
  fmt.Printf("stringIntMap 内容:%v 类型：%T, 长度:%d \n", stringIntMap, stringIntMap, len(stringIntMap))

stringMap 内容:map[age:18 name:Mir Li] 类型：map[string]string, 长度:2 
stringMap 内容:map[age:18 name:Mir Zhang] 类型：map[string]string, 长度:2 
stringMap 内容:map[name:Mir Zhang] 类型：map[string]string, 长度:1 
stringStringMap 元素是否存在name元素:true 
stringIntMap 内容:map[Apr:30 Aug:31 Dec:31 Feb:28 Jan:31 Jul:31 Jun:30 Mar:31 May:31 Nov:30 Oct:31 Sep:30] 类型：map[string]int, 长度:12 

func (p mytype) funcname(q int) (r,s int) { return 0,0 }
}

package main
import (
  "fmt"
)
func main() {
  returnValue_1, returnValue_2 := testFunction(10)
  //打印返回值
  fmt.Printf("returnValue_1 = %v, returnValue_2 = %v", returnValue_1, returnValue_2)
}
//testFunction:函数名, value:函数入参， b、c:函数执行返回参数
func testFunction(value int) (b int, c int) {
  fmt.Println("value = ", value)
  return 10, 10
}