go demo小结

go常用demo小结

/*
 * 使用命令行参数输入 另一种flag随后补充
 */
package main

import (
	"fmt"
	"os"
	"reflect"
	"strconv"
)

var Usage = func() {
	("USAGE: calc command [arguments] ...")
	("\nThe commands are:\n\tadd\tAddition of two values.\n\tsqrt\tSquare root of a non-negative value.")
}

func main() {
	args := 
	if args == nil || len(args) < 2 {
		Usage()
		return
	}
	("args[0] = ", args[0])
	("args[1] = ", args[1])

	args2, _ := (args[2])
	("args2 = ", args2, (args2))

	if args[1] == "out" {

		a := 5
		("a", a)
	}

	//("a", a) //a :作用域只是在if中
}


/*
 *byte_to_int.go 整形转换成字节 字节转换成整形
 */
package main

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"reflect"
)

//整形转换成字节
func IntToBytes(n int) []byte {
	tmp := int32(n)
	bytesBuffer := ([]byte{})
	(bytesBuffer, , &tmp)
	return ()
}

//字节转换成整形
func BytesToInt(b []byte) int {
	bytesBuffer := (b)
	var tmp int32
	(bytesBuffer, , &tmp)
	return int(tmp)
}

func main() {

	a := 128
	b := IntToBytes(a)
	("b = ", b, len(b), (b))

	var c = []byte{0x00, 0x00, 0x00, 0x08}
	d := BytesToInt(c)
	("d = ", d, (d))

	(c, string(c))

}


/*
 * 多个[]byte数组合并成一个[]byte
 */
package main

import (
	"bytes"
	"fmt"
	"reflect"
)

//BytesCombine 多个[]byte数组合并成一个[]byte
func BytesCombine(pBytes ...[]byte) []byte {
	len := len(pBytes)
	s := make([][]byte, len)
	for index := 0; index < len; index++ {
		s[index] = pBytes[index]
	}
	sep := []byte("")
	return (s, sep)
}

//BytesCombine 多个[]byte数组合并成一个[]byte
func PlusBytesCombine(pBytes ...[]byte) []byte {
	return (pBytes, []byte(""))
}

func main() {
	var a = []byte{1, 2, 3, 4}
	var b = []byte{1, 2, 3, 4}
	var c = []byte{1, 2, 3, 4}

	(a, b, c)

	d := BytesCombine(a, b, c)
	(d)

	e := PlusBytesCombine(a, b, c)
	("e =", e, (e))
}


/*
 * 压缩 解压[]byte
 */
package main

import (
	"bytes"
	"compress/zlib"
	"fmt"
	"io/ioutil"
)

//压缩byte
func ZipBytes(input []byte) []byte {
	var buf 
	compressor, err := (&buf, )
	if err != nil {
		return input
	}
	(input)
	()
	return ()
}

//解压byte
func UnzipBytes(input []byte) []byte {
	b := (input)
	r, err := (b)
	defer ()
	if err != nil {
		panic(err)
	}
	data, _ := (r)
	return data
}

func main() {
	var input = []byte("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKsAAAAgCAYAAABtn4gCAAAI9klEQVR4Xu2cfYxcVRmHn3Pu3Nm6lXa2ta0AYlsgFSGgThMU0W5hGkqApNGARk3cGm3BRN3FYGuCISrBXaNphcSkG2I3hn9gY2gSNWq32AoE1C6KRihFti2QSgvsTmm783HvOa+zM69cSS8Tacsq7n2SX87cj5P7ZvLs2ztnbseICG8HMjIsbxMyMnIoxhja8fJnriuYMNdjOsIVNhd0Y0wBRbxH6nHZ16OdUot2iXNDC3/2mzJtOImOnpHJ2p4Xr13ZkDTYJLHrwRgw4L1gAptIFzt87AoSuzXi/BqJ3KZ/XL1iSGLXd9aOh8u81WRksh5cefmUeFuBgmBABHEeEziwBrUVvCCxayWaSow419MY17zw4eVrz3ls9zbeKjIyWV+4bPkmiVyvCtnqps6Bta2uahJZxQs4jziHxP7fxS1I7B947tJLN5/7xBN9tIeN37yNN0EXME6LecAEGfR/746ZJeuBSy9RUVsiGucxsYPAYuxUzOtlFQEniG8JS+xRaTW+d/+y97P46Sf7yMg4")
	zipInput := ZipBytes(input)
	("input =", len(input))
	("zipIput =", len(zipInput))

	UnZipOut := UnzipBytes(zipInput)
	("UnZipOut =", UnZipOut, "\n", len(UnZipOut))

}


/*
 * base64编码 解码
 */
 package main

import (
	"encoding/base64"
	"fmt"
	"reflect"
)

func main() {
	input := []byte("hello golang base64 快乐编程http:// +~")

	// 演示base64编码 输入类型：[]byte类型 输出类型：string类型
	encodeString := (input)
	(encodeString, (encodeString))

	// 对上面的编码结果进行base64解码 输入类型：string类型 输出类型：[]byte类型
	decodeBytes, err := (encodeString)
	if err != nil {
		panic(err)
	}
	(string(decodeBytes), (decodeBytes))
}


/*
 *gen_rsakey.go 产生rsa公私钥
 */
 package main

import (
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"flag"
	"log"
	"os"
)

func main() {
	var bits int
	(&bits, "b", 1024, "密钥长度，默认为1024位")
	if err := GenRsaKey(bits); err != nil {
		("密钥文件生成失败！")
	}
	("密钥文件生成成功！")
}

func GenRsaKey(bits int) error {
	// 生成私钥文件
	privateKey, err := (, bits)
	if err != nil {
		return err
	}
	derStream := x509.MarshalPKCS1PrivateKey(privateKey)
	block := &{
		Type:  "私钥",
		Bytes: derStream,
	}
	file, err := ("vgate_private.pem")
	if err != nil {
		return err
	}
	err = (file, block)
	if err != nil {
		return err
	}
	// 生成公钥文件
	publicKey := &
	derPkix, err := (publicKey)
	if err != nil {
		return err
	}
	block = &{
		Type:  "公钥",
		Bytes: derPkix,
	}
	file, err = ("vgate_public.pem")
	if err != nil {
		return err
	}
	err = (file, block)
	if err != nil {
		return err
	}
	return nil
}


/*
 * rsa示例
 */
package main

import (
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/hex"
	"encoding/pem"
	"errors"
	"fmt"
	"io/ioutil"
	"os"

	"reflect"
)

var privateKey, publicKey []byte

func init() {
	var err error
	publicKey, err = ("")
	if err != nil {
		(-1)
	}
	privateKey, err = ("")
	if err != nil {
		(-1)
	}
}

func main() {
	var data []byte
	var err error
	data, err = RsaEncrypt([]byte("hello world"))
	if err != nil {
		panic(err)
	}
	(string(data))
	origData, err := RsaDecrypt(data)
	if err != nil {
		panic(err)
	}
	(string(origData))

	src := "test sign"
	signData, err := RsaSign([]byte(src), crypto.MD5)
	if err != nil {
		panic(err)
	}
	sign := (signData)
	("signData type:", (signData))
	("sign type:", (sign))
	(sign)
	(len(sign))
	(len(signData))

	signB, err := (sign)

	err = RsaVerify([]byte(src), signB, crypto.MD5)
	if err != nil {
		panic(err)
	}
	("verify success")
}

// Rsa加密
func RsaEncrypt(origData []byte) ([]byte, error) {
	block, _ := (publicKey)
	if block == nil {
		return nil, ("public key error")
	}
	pubInterface, err := ()
	if err != nil {
		return nil, err
	}
	pub := pubInterface.(*)
	return rsa.EncryptPKCS1v15(, pub, origData)
}

// Rsa解密
func RsaDecrypt(ciphertext []byte) ([]byte, error) {
	block, _ := (privateKey)
	if block == nil {
		return nil, ("private key error!")
	}
	priv, err := x509.ParsePKCS1PrivateKey()
	if err != nil {
		return nil, err
	}
	return rsa.DecryptPKCS1v15(, priv, ciphertext)
}

//Rsa签名
func RsaSign(src []byte, hash ) ([]byte, error) {
	block, _ := (privateKey)
	if block == nil {
		return nil, ("private key error!")
	}
	priv, err := x509.ParsePKCS1PrivateKey()
	if err != nil {
		return nil, err
	}

	h := ()
	(src)
	hashed := (nil)
	return rsa.SignPKCS1v15(, priv, hash, hashed)
}

//Rsa验签
func RsaVerify(src []byte, sign []byte, hash ) error {
	block, _ := (publicKey)
	if block == nil {
		return nil
	}
	pubInterface, err := ()
	if err != nil {
		return nil
	}
	pub := pubInterface.(*)

	h := ()
	(src)
	hashed := (nil)
	return rsa.VerifyPKCS1v15(pub, hash, hashed, sign)
}


/*
 * aes示例
 */
 package main

import (
	"crypto/aes"
	"crypto/cipher"
	"fmt"
)

type AesEncrypt struct {
}

//加密字符串 输入类型：string 返回类型：[]byte
func (this *AesEncrypt) Encrypt(key []byte, strMesg string) ([]byte, error) {

	var iv = []byte(key)[:]
	encrypted := make([]byte, len(strMesg))
	aesBlockEncrypter, err := (key)
	if err != nil {
		return nil, err
	}
	aesEncrypter := (aesBlockEncrypter, iv)
	(encrypted, []byte(strMesg))
	return encrypted, nil
}

//解密字符串 输入类型：[]byte  返回类型：string
func (this *AesEncrypt) Decrypt(key []byte, src []byte) (strDesc string, err error) {
	defer func() {
		//错误处理
		if e := recover(); e != nil {
			err = e.(error)
		}
	}()

	var iv = []byte(key)[:]
	decrypted := make([]byte, len(src))
	var aesBlockDecrypter 
	aesBlockDecrypter, err = ([]byte(key))
	if err != nil {
		return "", err
	}
	aesDecrypter := (aesBlockDecrypter, iv)
	(decrypted, src)
	return string(decrypted), nil
}

func main() {
	aesEnc := AesEncrypt{}
	key := "1234567890123456"

	arrEncrypt, err := ([]byte(key), "0123456789abcdef123")
	if err != nil {
		(arrEncrypt)
		return
	}
	(arrEncrypt)

	strMsg, err := ([]byte(key), arrEncrypt)
	if err != nil {
		(arrEncrypt)
		return
	}
	(strMsg)
}


/*
 * md5示例
 */
package main

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

type MD5Client struct {
}

var MD5 = MD5Client{}

func (this *MD5Client) Encrypt(plantext []byte) []byte {
	result := (plantext)
	return result[:]
}

func main() {
	sum := ([]byte(`红薯鸭`))
	("sum is:", sum)

	sumStr := (sum)

	("sumStr is:", sumStr)
}