GO-常用基础包

目录

• 1.fmt包
  • 输人Scanf类似input
  • fmt.Sprintf格式化输出
• 2.int取值范围
• 3.查看容量-cap
• 4.常量定义iota枚举
• 5.MD5使用
• 6.murmurhash3非加密哈希
• 7.utf8-gbk编码转换,ascii码与字符串相互转换
• 8.copier.Copy
• 9.内库copy

1.fmt包

输人Scanf类似input

    var v int
    fmt.Println("请输入一个整型：")
    fmt.Scanf("%d", &v)
    //fmt.Scan(&v)
    fmt.Println("v = ", v)

fmt.Sprintf格式化输出

func main() {
	name := "jeff"
	a := fmt.Sprintf("我的名字是%s", name)
	fmt.Println(a) // 我的名字是jeff
}

2.int取值范围

int取值范围

int8: -128 ~ 127
int16: -32768 ~ 32767
int32: -2147483648 ~ 2147483647
int64: -9223372036854775808 ~ 9223372036854775807
uint8: 0 ~ 255
uint16: 0 ~ 65535
uint32: 0 ~ 4294967295
uint64: 0 ~ 18446744073709551615
GO语言中int类型的大小是不确定的，与具体的平台有关系
一般来说，int在32位系统中是4字节，在64位系统中是8字节
使用自动推导类型初始化一个整数，默认为int类型

// 输出各int类型的取值范围
fmt.Println("各int类型的取值范围为：")
fmt.Println("int8:", math.MinInt8, "~", math.MaxInt8)
fmt.Println("int16:", math.MinInt16, "~", math.MaxInt16)
fmt.Println("int32:", math.MinInt32, "~", math.MaxInt32)
fmt.Println("int64:", math.MinInt64, "~", math.MaxInt64)

3.查看容量-cap

li := []int{1, 2, 3, 4, 5}
fmt.Println(cap(li))  //5
li = append(li, 123)
fmt.Println(li) //[1 2 3 4 5 123]
fmt.Println(cap(li)) //10
li = append(li, 456)
fmt.Println(li) //[1 2 3 4 5 123 456]
fmt.Println(cap(li)) //10,空间还没有占完，所以还没有扩展



数组：v中的元素数（与len（v）相同）。
指向数组的指针：* v中的元素数（与len（v）相同）。
切片：切片后可以达到的最大长度；
如果v为零，则cap（v）为零。
Channel：通道缓冲容量，以元素为单位；
如果v为零，则cap（v）为零。

4.常量定义iota枚举

常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。

在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。

const (
	CodeSuccess ResCode = 1000 + iota
	CodeInvalidParam
	CodeUserExist
	CodeUserNotExist
	CodeInvalidPassword
	CodeServerBusy
)

const (
    x = iota // x == 0
    y = iota // y == 1
    z = iota // z == 2
    w  // 这里隐式地说w = iota，因此w == 3。其实上面y和z可同样不用"= iota"
)

const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0

const (
    h, i, j = iota, iota, iota //h=0,i=0,j=0 iota在同一行值相同
)

const (
    a       = iota //a=0
    b       = "B"
    c       = iota             //c=2
    d, e, f = iota, iota, iota //d=3,e=3,f=3
    g       = iota             //g = 4
)

const (
    x1 = iota * 10 // x1 == 0
    y1 = iota * 10 // y1 == 10
    z1 = iota * 10 // z1 == 20
)

5.MD5使用

package pkg

import (
	"crypto/md5"
	"encoding/hex"
)

var md5Pool = sync.Pool{
	New: func() interface{} {
		return md5.New()
	},
}

func MD5(str string) string {
	h := md5.New()
        //使用对象池
        //h := md5Pool.Get().(hash.Hash)
	str = str + "加盐加盐"
	h.Write([]byte(str)) // 需要加密的字符串为 123456
	cipherStr := h.Sum(nil)
	return hex.EncodeToString(cipherStr) // 输出加密结

}

6.murmurhash3非加密哈希

加密哈希，如MD5，SHA256等，
非加密哈希，如MurMurHash，CRC32，DJB等

能够满足这样的哈希算法有很多，这里推荐 Google 出品的 MurmurHash 算法，MurmurHash 是一种非加密型哈希函数，适用于一般的哈希检索操作。与其它流行的哈希函数相比，对于规律性较强的 key，MurmurHash 的随机分布特征表现更良好。非加密意味着着相比 MD5，SHA 这些函数它的性能肯定更高（实际上性能是 MD5 等加密算法的十倍以上），也正是由于它的这些优点，所以虽然它出现于 2008，但目前已经广泛应用到 Redis、MemCache、Cassandra、HBase、Lucene 等众多著名的软件中。

package main

import "fmt"
import "github.com/spaolacci/murmur3"

func main() {
	b := murmur3.Sum32WithSeed([]byte("hello word"),0x1234ABCD)
	fmt.Println(b) //1380922724

	foo := int64(murmur3.Sum64WithSeed([]byte("hello word"), 0x1234ABCD))
	fmt.Println(foo) //4946771540764450955
}

7.utf8-gbk编码转换,ascii码与字符串相互转换

utf8-gbk

import "github.com/axgle/mahonia"

func main() {
	enc := mahonia.NewEncoder("utf-8")
	//converts a  string from UTF-8 to gbk encoding.
	fmt.Println(enc.ConvertString("hello,世界"))
}

/*
A-Z:65-90
a-z:97-122
0-9:48-57
*/

ascii码与字符串相互转换

//ascii码转string
i := rune(65)
fmt.Println(i)         //65
fmt.Println(string(i)) //A

//string转ascii
i := 'A'               //i :=  rune('A')
fmt.Println(i)         // fmt.Println(int(i))        //65
fmt.Println(string(i)) // A

8.copier.Copy

import (
	"fmt"

	"github.com/jinzhu/copier"
)

type User struct {
	Id   int
	Name string
}

func main() {
	jeff := User{
		Id:   1,
		Name: "jeff",
	}
	user := User{}
	//jeff拷贝到user
	copier.Copy(&user, jeff)
	fmt.Println(user)
}

9.内库copy

func main() {
	/*
		copy:b的值拷贝给a。容量最大为a的容量
	*/

	a1 := []int{1, 2, 3}
	b1 := []int{4, 5}
	copy(a1, b1) //a=[4,5,3]

	a2 := []int{1, 2, 3}
	b2 := []int{4, 5, 6}
	copy(a2, b2) //a=[4,5,6]

	a3 := []int{1, 2, 3}
	b3 := []int{4, 5, 6, 7}
	copy(a3, b3) //a=[4,5,6]
}