go语言学习-类型转换

string => int :  i, err = strconv.Atoi(s)
string => bool : strconv.ParseBool("true")
string => float32 : strconv.ParseFloat(s, 32)
string => float64 : strconv.ParseFloat(s, 64)
string => uint : strconv.ParseUint()
string => int32/int64 : strconv.ParseInt(s, 10, 32)
string => []byte : []byte(string)
16进制string => int32/int64 : strconv.ParseInt(s, 0, 32)

[]byte => string : string([]byte)
[]byte => int : binary包处理, 查看下面

int => string : s = strconv.Itoa(i)  
int => int32  : i = int32(num)
int => int64 : i = int64(num)
int64/int32 => int : i = int(num)
int64 => string : strconv.FormatInt(int64, 10)
int64 => time.Duration : time.Duration(int64)
int32 => byte : bytes.NewBuffer() 看下面 int 和 byte 互转
int => float64 : float64(num) 

uint64 to string : strconv.FormatUint(unit64, 10) 

bool => string : strconv.FormatBool(true)

float64 => string : strconv.FormatFloat(float64(12), 'f', -1, 64) 
            或者 fmt.Sprintf("%.2f", float64)

float64/float32 => int : int64()/int32

数组到切片
array => slice : 
1) copy(array[:], slice[0:4])  | 全部 copy(array[:], slice)
2) for
for index, b := range someSlice {
    array[index] = b
}

切片到数组
slice=>array :    array[:]

var s string = "1"
var i int

i, err = strconv.Atoi(s) 或者 i, err = strconv.ParseInt(s, 10, 0)


// ParseInt 将字符串转换为 int64 类型
// s：要转换的字符串
// base：进位制（2 进制到 36 进制）
// bitSize：指定整数类型（0:int、8:int8、16:int16、32:int32、64:int64）
// 返回转换后的结果和转换时遇到的错误
// 如果 base 为 0，则根据字符串的前缀判断进位制（0x:16，0:8，其它:10）

//i 为int64 可以直接赋值
var i int64
i, _ = strconv.ParseInt("12", 10, 0)

//i 为int 不可以直接赋值
var i int
num, err := strconv.ParseInt(s, 10, 0)
i = int(num)

//16进制字符串
in,err := strconv.ParseInt("0x3515", 0,64)
fmt.Println(in, err)

/**
    true: "1", "t", "T", "true", "TRUE", "True"
    false: "0", "f", "F", "false", "FALSE", "False"
    其他err 不为空, 返回false
*/

 b, err = strconv.ParseBool("true")

var s string = 1
var f float32
f, err = strconv.ParseFloat(s, 32)

var f2 float64
f2, err = strconv.ParseFloat(s, 64)

/**
ParseInt 将字符串转换为 uint64 类型
param1: 值 可以是十六进制("FF")或者十进制字符串("12")
param2: 进制 "FF" 16进制   "12" 10进制
param3: 转换位数 8=>uint8 16=>unit16  64=>uint64
*/

fmt.Println(strconv.ParseUint("FF", 16, 8)) // 255

var i int = 1
var s string

s = strconv.Itoa(i) 或者 s = FormatInt(int64(i), 10) 或者 s = fmt.Sprintf("%d", i)

// FormatInt 将 int64 型整数 i 转换为字符串形式
// base：进位制（2 进制到 36 进制）
// 大于 10 进制的数，返回值使用小写字母 'a' 到 'z'
func FormatInt(i int64, base int) string

i := int64(-2048)
fmt.Println(strconv.FormatInt(i, 2))  // -100000000000
fmt.Println(strconv.FormatInt(i, 8))  // -4000
fmt.Println(strconv.FormatInt(i, 10)) // -2048
fmt.Println(strconv.FormatInt(i, 16)) // -800
fmt.Println(strconv.FormatInt(i, 36)) // -1kw

float32(i) / float64(i)

var value2 int32
value1 := 64 // value1将会被自动推导为int类型
//value2 = value1 // 编译错误
value2 = int32(value1) // 编译通过

// FormatFloat 将浮点数 f 转换为字符串值
// f：要转换的浮点数
// fmt：格式标记（b、e、E、f、g、G）
// prec：精度（数字部分的长度，不包括指数部分）
// bitSize：指定浮点类型（32:float32、64:float64）
//
// 格式标记：
// 'b' (-ddddp±ddd，二进制指数)
// 'e' (-d.dddde±dd，十进制指数)
// 'E' (-d.ddddE±dd，十进制指数)
// 'f' (-ddd.dddd，没有指数)
// 'g' ('e':大指数，'f':其它情况)
// 'G' ('E':大指数，'f':其它情况)
//
// 如果格式标记为 'e'，'E'和'f'，则 prec 表示小数点后的数字位数
// 如果格式标记为 'g'，'G'，则 prec 表示总的数字位数（整数部分+小数部分）
func FormatFloat(f float64, fmt byte, prec, bitSize int) string


var str string
str = strconv.FormatFloat(float64(12), 'f', -1, 64)



f := 100.12345678901234567890123456789
fmt.Println(strconv.FormatFloat(f, 'b', 5, 32)) // 13123382p-17
fmt.Println(strconv.FormatFloat(f, 'e', 5, 32)) // 1.00123e+02
fmt.Println(strconv.FormatFloat(f, 'E', 5, 32)) // 1.00123E+02
fmt.Println(strconv.FormatFloat(f, 'f', 5, 32)) // 100.12346
fmt.Println(strconv.FormatFloat(f, 'g', 5, 32)) // 100.12
fmt.Println(strconv.FormatFloat(f, 'G', 5, 32)) // 100.12
fmt.Println(strconv.FormatFloat(f, 'b', 30, 32)) // 13123382p-17
fmt.Println(strconv.FormatFloat(f, 'e', 30, 32)) // 1.001234588623046875000000000000e+02
fmt.Println(strconv.FormatFloat(f, 'E', 30, 32)) // 1.001234588623046875000000000000E+02
fmt.Println(strconv.FormatFloat(f, 'f', 30, 32)) // 100.123458862304687500000000000000
fmt.Println(strconv.FormatFloat(f, 'g', 30, 32)) // 100.1234588623046875
fmt.Println(strconv.FormatFloat(f, 'G', 30, 32)) // 100.1234588623046875


或者使用
var str string
var f float32 = 666.666
str = fmt.Sprintf("%.2f", f)

fmt.Println(strconv.FormatBool(0 < 1)) // true
fmt.Println(strconv.FormatBool(0 > 1)) // false

import "encoding/binary"
import "bytes"

package main  
  
import (  
    "bytes"  
    "encoding/binary"  
    "fmt"  
    "strings"  
)  
  
func main() {  
    b := []byte{0x00, 0x00, 0x03, 0xe8}  
    b_buf := bytes.NewBuffer(b)  
    var x int32  
    binary.Read(b_buf, binary.BigEndian, &x)  
    fmt.Println(x)  
  
    fmt.Println(strings.Repeat("-", 100))  
  
    x = 1000  
    b_buf = bytes.NewBuffer([]byte{})  
    binary.Write(b_buf, binary.BigEndian, x)  
    fmt.Println(b_buf.Bytes())  
}

//整形转换成字节
func IntToBytes(n int64) []byte {
	var bytesBuffer bytes.Buffer
	binary.Write(&bytesBuffer, binary.BigEndian, n)
	return bytesBuffer.Bytes()
}

//字节转换成整形
func BytesToInt(b []byte) (x int64) {
	bytesBuffer := bytes.NewBuffer(b)
	binary.Read(bytesBuffer, binary.BigEndian, &x)
	return
}

var i int32
var j int64
i, j = 1, 2
if i==j { // 编译错误
    fmt.Println("i and j are equal.")
}
if i==1||j==2 {// 编译通过
    fmt.Println("i and j are equal.")
}