一. 数据互相转换

• int 转string string := strconv.Itoa(int)

• string到int int,err := strconv.Atoi(string)

• string到int64 int64, err := strconv.ParseInt(string, 10, 64)

• int64到string string := strconv.FormatInt(int64,10)

• map 到json字符串

  m := map[string]string{}
  mjson,_ :=json.Marshal(m)
  mString :=string(mjson)
  

• json到struct

  • 如果是单层可以直接用interface转为map

    jsonStr = `{}`
    var jsonStruct interface{}
    JSON.Unmarshal([]byte(jsonStr), &jsonStruct)
    

  • 有嵌套，把需要解析的字段一一列出，这里注意要首字母大写，否则无法解析。

    type MyStruct struct{
      Name string `json:"name"`
    }
    jsonStr = `{name: 12}`
    var jsonStruct MyStruct{}
    JSON.Unmarshal([]byte(jsonStr), &jsonStruct)
    

• 纯字符串拼接

  a := "hello"
  b := "world"
  // 使用操作符
  result := a + b
  // 使用Sprintf
  result := fmt.Sprintf("s%s%", a, b)
  // 使用join
  result := strings.Join([]string{a, b}, "")
  // 使用buffer
  var buffer bytes.Buffer
  buffer.WriteString(a)
  buffer.WriteString(b)
  result := buffer.String()
  
  // 以上四种方式性能最好是buffer，实际开发中自行调节即可
  /*
  BenchmarkAddStringWithJoin-8       	20785686	        51.5 ns/op
  BenchmarkAddStringWithBuffer-8     	1000000000	        0.000123 ns/op
  BenchmarkAddStringWithSprintf-8    	 5727165	        196 ns/op
  BenchmarkAddStringWithOperator-8   	39417948	        29.1 ns/op
  
  
  */
  

  package main
   
  import (
      "fmt"
      "strconv"
  )
   
  func IntToString() {
      //todo :int to string
      v := 456
      vS := strconv.Itoa(v)
      fmt.Println(vS) //方法1，简便版
   
      //todo :int64 to string
      var vI64 int64 = 789
      vInt64S := strconv.FormatInt(vI64, 10) //方法2，int64转string，可指定几进制
      fmt.Println(vInt64S)
   
      //todo :uint64 to string
      var vUI64 uint64 = 91011
      vUI64S := strconv.FormatUint(vUI64, 10) //方法3， uint64转string，可指定几进制
      fmt.Println(vUI64S)
  }
   
  func StringToInt() {
      //todo :string to int/int64
      s := "123"
      vInt, _ := strconv.Atoi(s) //方法1，便捷版
      fmt.Println(vInt)
   
      vInt64, _ := strconv.ParseInt(s, 10, 64) //方案2，有符号整型，可以指定几进制，整数长度
      fmt.Println(vInt64)
   
      vUInt64, _ := strconv.ParseUint(s, 10, 64) //方案3，无符号整型，可以指定几进制，整数长度
      fmt.Println(vUInt64)
  }
   
  func StringToFloat() {
      //todo :string to float
      f64, _ := strconv.ParseFloat("123.456", 64) //方法1，可以指定长度
      fmt.Println(f64)
  }
   
  func FloatToString() {
      //todo :float to string
      f64 := 1223.13252
      sF64 := strconv.FormatFloat(f64, 'f', 5, 64) //方法1，可以指定输出格式、精度、长度
      fmt.Println(sF64)
  }
   
  func StringToBool() {
      //todo :string to bool
       接受 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False 等字符串；
       其他形式的字符串会返回错误
      b, _ := strconv.ParseBool("1")
      fmt.Println(b)
  }
  func BoolToString() {
      //todo :bool to string
      sBool := strconv.FormatBool(true) //方法1
      fmt.Println(sBool)
  }
   
  func main() {
      StringToInt()
      IntToString()
      StringToFloat()
      FloatToString()
      BoolToString()
      StringToBool()
  }
  

二. fmt占位符

占位符	说明	举例	输出
%v	相应值的默认格式。	Printf("%v", people)	{zhangsan}
%+v	打印结构体时，会添加字段名	Printf("%+v", people)	{Name:zhangsan}
%#v	相应值的Go语法表示	Printf("#v", people)	main.Human{Name:"zhangsan"}
%T	相应值的类型的Go语法表示	Printf("%T", people)	main.Human
%%	字面上的百分号，并非值的占位符	Printf("%%")	%
%t	true 或 false。	Printf("%t", true)	true
%b	二进制表示	Printf("%b", 5)	101
%c	相应Unicode码点所表示的字符	Printf("%c", 0x4E2D)	中
%d	十进制表示	Printf("%d", 0x12)	18
%o	八进制表示	Printf("%d", 10)	12
%q	单引号围绕的字符字面值，由Go语法安全地转义	Printf("%q", 0x4E2D)	'中'
%x	十六进制表示，字母形式为小写 a-f	Printf("%x", 13)	d
%X	十六进制表示，字母形式为大写 A-F	Printf("%x", 13)	D
%U	Unicode格式：U+1234，等同于 "U+%04X"	Printf("%U", 0x4E2D)	U+4E2D
%b	无小数部分的，指数为二的幂的科学计数法，与 strconv.FormatFloat 的 'b' 转换格式一致。
%e	科学计数法，例如 -1234.456e+78	Printf("%e", 10.2)	1.020000e+01
%E	科学计数法，例如 -1234.456E+78	Printf("%e", 10.2)	1.020000E+01
%f	有小数点而无指数，例如 123.456	Printf("%f", 10.2)	10.200000
%g	根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出	Printf("%g", 10.20)	10.2
%G	根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出	Printf("%G", 10.20+2i)	(10.2+2i)
%s	输出字符串表示（string类型或[]byte)	Printf("%s", []byte("Go语言"))	Go语言
%q	双引号围绕的字符串，由Go语法安全地转义	Printf("%q", "Go语言")	"Go语言"
%x	十六进制，小写字母，每字节两个字符	Printf("%x", "golang")	676f6c616e67
%X	十六进制，大写字母，每字节两个字符	Printf("%X", "golang")	676F6C616E67
%p	十六进制表示，前缀 0x	Printf("%p", &people)	0x4f57f0