Golang

# 安装包
go get <path>
# 安装且更新为最新的包
go get -u <path>
# 升级全部依赖
go get -u all

# go fmt 
# go 脚本格式化; 全目录，like IDE
go fmt ./...

# 列表当前项目包或模块
go list -m -json all

# 打印中 yangsu.exe 的符号
#
# 如果使用 <-ldflags "-s -w"> 清除符号后，无法获取符号
go tool nm ./yangsu.exe

// path = ../name 
package name

func TestName (t *testing.T)
// t.Error/t.Fail   意识着测试失败

# 指定文件夹
go test ./str/

# 指定文件
go test -v ./str/calc_test.go ./str/calc.go


# 指定文件函数
go test -v ./str/ '-test.run' TestFloatSimple

# 指定包以及测试函数
go test -v ./ysu/tools '-test.run' '^\QTestNewXRsa\E$'

func BenchmarkStructToMapLStyle(b *testing.B) {
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		StructToMapLStyle(tom)
	}
}


// goos: windows
// goarch: amd64
// pkg: gitee.com/conero/uymas/util
// cpu: xxx(R) Core(TM) i5-10200H CPU @ 2.40GHz
// BenchmarkStructToMapLStyle
// BenchmarkStructToMapLStyle-8   	   90331	     12899 ns/op
// 标识循环：90331 次, 每次循环花费的时间: 12899 ns.

# 编译单文件
go build -buildmode=c-shared -o exportgo.dll exportgo.go

# 编译目录
go build -buildmode=c-shared -o shared.dll .

func main(){
    var str1 = "字符串"
	str2 := `多行字符串`
    fmt.Println(str1, str2)
}

func init(){
	// 单行注释
    t1, n1 := `ffff`, 5
    /*
    多行注释
    */
    fmt.Println(t1, n1)
}

break        default      func         interface    select
case         defer        go           map          struct
chan         else         goto         package      switch
const        fallthrough  if           range        type
continue     for          import       return       var

+    &     +=    &=     &&    ==    !=    (    )
-    |     -=    |=     ||    <     <=    [    ]
*    ^     *=    ^=     <-    >     >=    {    }
/    <<    /=    <<=    ++    =     :=    ,    ;
%    >>    %=    >>=    --    !     ...   .    :
     &^          &^=

n10, n8, n16 := 0, o5, 0x100
f1, f2 := 072.47, 3.45e5
// 1e-3 = 0.001
// 1e3 = 1000

// utype = 2^n - 1
uint8       the set of all unsigned  8-bit integers (0 to 255), 2百
uint16      the set of all unsigned 16-bit integers (0 to 65535), 6万
uint32      the set of all unsigned 32-bit integers (0 to 4294967295) 42亿
uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)

int8        the set of all signed  8-bit integers (-128 to 127)
int16       the set of all signed 16-bit integers (-32768 to 32767)
int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

float32     the set of all IEEE-754 32-bit floating-point numbers
float64     the set of all IEEE-754 64-bit floating-point numbers

complex64   the set of all complex numbers with float32 real and imaginary parts
complex128  the set of all complex numbers with float64 real and imaginary parts

byte        alias for uint8
rune        alias for int32

uint        either 32 or 64 bits
int         same size as uint
uintptr     an unsigned integer large enough to store the uninterpreted bits of a pointer value

string_lit             = raw_string_lit | interpreted_string_lit
// 原始字符串
raw_string_lit         = "`" { unicode_char | newline } "`"
// 解析字符串
interpreted_string_lit = `"` { unicode_value | byte_value } `"`

n := len(raw_string_lit)	// 0 ... len(s) -1

转义字符
\x0c   清屏并输出

package main

import "fmt"

type A interface {
	Name() string
	Cal(params ...int) int
}

type A1 struct {
}

func (a1 *A1) Name() string {
	return "Add"
}

func (a1 *A1) Cal(params ...int) int {
	all := 0
	for _, n := range params {
		all += n
	}
	return all
}

type A2 struct {
}

func (a2 *A2) Name() string {
	return "Reduce"
}

func (a2 *A2) Cal(params ...int) int {
	all := 0
	for _, n := range params {
		all -= n
	}
	return all
}

func GetA(vtype string) A {
	var a A = nil
	switch vtype {
	case "A1":
		//a = A1{}
		// ERROR: cannot use A1 literal (type A1) as type A in assignment:
		a = new(A1)
	case "A2":
		a = new(A2)
	}
	return a
}

func main() {
	param := []int{100, 10, 1, 0}
	var a1, a2 A
	a1 = GetA("A1")
	a2 = GetA("A2")
	fmt.Println(a1.Name(), a1.Cal(param...))
	fmt.Println(a2.Name(), a2.Cal(param...))
}

// 无缓存的数据通道
ch := make(chan int)

// 带缓存的数据通道
ch2:= make(chan int, 1024)

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// 注: 上面注释不会显示为文档；单独的 “//” 可用换行

// Package path implements utility routines for manipulating slash-separated
// paths.
//
// The path package should only be used for paths separated by forward
// slashes, such as the paths in URLs. This package does not deal with
// Windows paths with drive letters or backslashes; to manipulate
// operating system paths, use the path/filepath package.
package path

# 开启一个godoc小型server, -play可以使用playground运行Example代码
godoc -http=:6060 -play

// Deprecated: 遗弃代码，IDE 高亮显示

go help

# 代码编译
go build 加上可以编译的go源文件可以得到一个可执行文件。
# 批量[cmd]下所有二级制程序编译
# 注意：cmd 目录有效，其他目录经测试无法通过
go build -o ./bin ./cmd/...

# 使用 ldflags 简化过编译文件大小
# 优化文件大小
# -s 忽略调试信息
# -w 忽略DWARF表符号
go build -o ./bin -ldflags "-s -w" ./cmd/...

# go 代码生成，当前下的所有代码
go generate ./...

# 本地项目安装
go install 在编译源代码之后还安装到指定的目录

# 依赖下载，在mod开启的情况下，其实下载到本地项目
go get 从指定源上面下载或者更新指定的代码和依赖，并对他们进行编译和安装

#
#
# 项目模块
go mod 项目模块系统

go mod init 	项目初始化
# 项目不在 【GOPATH】中时，需要指定模块名称，如
go mod init [module] 

go mod vendor 	模块自动拉取，并生产vendor目录

// +build embed_mode
// 自定义编译模式

//go:build embed
// 自定义编译模式

# 使用自定义模式进行编译即可
go build -tags embed_mode

# 支持多个tags 如t1/t2/t3
go build -tags "t1 t2 t3"

# 不使用 tags
go build 

module conero.cn/firefly/secret

go 1.21.3

replace conero.cn/firefly/ffutil => ../ffutil

require (
    conero.cn/firefly/ffutil v0.0.0 // 可以是任意占位符版本号
    gitee.com/conero/uymas v1.4.0-alpha.1.0.20240116060107-6d9af8acb109
)

// +build

// 示例
// +build linux darwin
// +build amd64
// +build linux,386 darwin,!cgo
// +build linux,cgo darwin,cgo
// +build !linux,!darwin !cgo

// 操心系统来源常量: runtime.GOOS
// 操心系统架构来源常量: runtime.GOARCH

*_GOOS
*_GOARCH
*_GOOS_GOARCH

# 如: 
#  source_windows_amd64.go

go/src/builtin/builtin.go   内建函数文档包，可直接使用而不用引入包
go调用C/C++，或dll文件

无参数、返回值
main	只能应用于package main
init		能够应用于所有的package	可选


C/C++中接收命令行参数是通过~main函数传入，而go可以使用 os ,flag 库。	os.Args 命令行

范本： 2006-01-02 15:04:05

如： 获取当前的时间
	time.Now().Format("2006-01-02 15:04:05")  

# golangci-lint
golangci-lint run

# 运行所有
golangci-lint run ./...

# 指定目录
golangci-lint run dir1 dir2/...
golangci-lint run file1.go

go build -ldflags -H=windowsgui <filename>

 # 设置环境变量
 # linux, darwin, windows, netbsd
 $env:GOOS="linux"
 
 # 系统架构
 # amd64, 386, arm, ppc64
 $env:GOARCH = "amd64"
 
 # 运行，即使对应操作系统的脚本
 go build