1 简介

本文介绍在go中初始化数据的方法，并且包括数据类型转换示例：转字符串、strconv包用于数字和布尔值转换，以及interface转换。

文章通过数组、切片、映射和结构体的创建展示了数据初始化和零值的使用。此外，还提供了检查映射中键是否存在及结构体创建的方法

2 初始化 数据

在 Go 中，任何类型在未初始化时都对应一个零值：

bool 布尔类型是 false ，

	var boo1 bool
	fmt.Println(boo1)   // false

int 整型是 0

	var in2 int
	fmt.Println(in2) // 0

byte 是0，

	var bt2 byte
	fmt.Println(bt2) // 0

string 字符串是 “”

	var st2 string
	fmt.Println(st2)  // ""

pointer指针 初始化零值 是 nil，

	var p1 *int
	fmt.Println(p1)  // nil

function 函数 初始化零值是 nil，

	var func1 func()
	fmt.Println(func1) // nil

interface 接口 初始化零值是 nil，

	var inter1 interface{}
	fnt.Println(inter1)  // nil

slice 切片 初始化零值是 nil，

切片列表 值如果 没有初始化 将填充为对于的 初始化值

	var slice1 [3]int
	fmt.Println(slice1) // [0,0,0]

	var mslice2 make([]int, 5)
	fmt.Println(mslice2) //[0 0 0 0 0]

	var slice1 [3]byte
	fmt.Println(slice1) // [0,0,0]

channel 通道初始化零是nil，

	idleConnsClosed := make(chan int, 1)
	var c1 = make(chan int, 1) 

	fmt.Printf("c1 : %v (%T)\n", c1, c1)  //0xc0000b8000 (chan int)
	fmt.Println(&c1 )   //0xc0000b2018

map 初始化的零值是 nil

	var arr map[string]int
	fmt.Printf("array: %v (%T)\n", arr, arr)   //array: map[] (map[string]int)
	fmt.Println(arr)   //map[]

本质上 0 引用 nil

3 数据类型转换

几个例子

• 转字符串

   ins := fmt.Sprintf("%v", ms)     
   // j sj star to int
   intsj, _ := strconv.ParseInt(sj, 10, 64)
  

• strconv 字符数字转换 int或float: strconv

   s := "1.1314";fmt.Printf("%T  \\n", s);z1, _:= strconv.ParseFloat(s, 64);fmt.Println(float64(z) + z1)  //1.1314
   i, _ := strconv.ParseInt("-42", 10, 64) //-42
   u, _ := strconv.ParseUint("42", 10, 64) //42
   b, _ := strconv.ParseBool("true") //true
   ia,_ := strconv.Atoi("-11")  //-11
  

• interface 转其他类型

    import (
    "encoding/json"
    "strconv"
  )
  

Strval 获取变量字符串， 浮点型 3.0 将转换为字符串 3，非数值 或 字符类型的 变量 将被转换为 JSON格式 字符串

  func InterToString(value interface{}) string {
	var key string
	if value == nil {
		return key
	}
	switch value.(type) {
	case float64:
		ft := value.(float64)
		key = strconv.FormatFloat(ft, 'f', -1, 64)
	case float32:
		ft := value.(float32)
		key = strconv.FormatFloat(float64(ft), 'f', -1, 64)
	case int:
		it := value.(int)
		key = strconv.Itoa(it)
	case int8:
		it := value.(int8)
		key = strconv.Itoa(int(it))
	case uint8:
		it := value.(uint8)
		key = strconv.Itoa(int(it))
	case int16:
		it := value.(uint16)
		key = strconv.Itoa(int(it))
	case int32:
		it := value.(int32)
		key = strconv.Itoa(int(it))
	case int64:
		it := value.(int64)
		key = strconv.FormatInt(it, 10)
	case uint64:
		it := value.(uint64)
		key = strconv.FormatUint(it, 10)
	case string:
		key = value.(string)
	case []byte:
		key = string(value.([]byte))
	default:
		Nv, _ := json.Marshal(value)
		key = string(Nv)
	}
	return key
}

4 示例：数据的初始化和零值使用方法

我们通过数组的定义和初始化来理解goalng中变量定义方式。

如下一个数组的3种方式

• 先定义后赋值

var studentsAge [10]int
studentsAge = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

• 在定义时同时赋值
  var studentsAge = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

• 简短形式
  studentsAge := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

另外还可以使用golang内置函数创建变量

比如Go 提供了一个make函数，您可以使用该函数通过指定切片的长度来创建切片。
创建后，Go 将用其类型的零值填充切片：

sliceOfInt := make([]int, 5) // [0 0 0 0 0]
sliceOfBool := make([]bool, 3) // [false false false]

每个切片都有长度和容量。切片的长度是切片中的元素数，而容量是基础数组中的元素数，从切片中的第一个元素开始计数。

该函数允许我们创建具有指定容量的切片。如下创建一个长度为5，容量为10的切片。

sliceOfStrings := make([]string, 5, 10)

或者用于创建字典映射。

var studentsAge map[string]int
studentsAge = make(map[string]int)

检查某个键是否存在

element, ok := studentsAge[“solomon”]
fmt.Println(element, ok) // false

• 结构体的创建 类似变量

  type Rectangle struct {}
  
  var myRectangle Rectangle
  

创建一个空的实例

  myRectangle := Rectangle{}

也可以使用内置的关键字函数

  myRectangle := new(Rectangle)

查看数据

 fmt.Println(myRectangle, *myRectangle) // &{0 0} {0 0}

5 小结

在本文中，我们了解了 Go 中的各种数据结构，如数组、切片、映射和结构。我们还展示了多个代码示例、用例和函数。

我希望这是一本有用的指南，可以解决通常很复杂的话题。以本文为参考指南，您可以自信地为您的用例使用正确的数据结构，并创建快速、高性能的应用程序。