go语言

go, 学习笔记

2022-04-11

Source

Edit

History

go学习笔记

Catalogue

1. go:embed 的使用
2. nil
3. fmt.Printf()和fmt.Println()的区别

go编译报错

1. more than one character in rune literal
2. go run: cannot run non-main package
3. too many arguments to return have (error) want ()to
4. 字典
5. 时间戳
6. Strconv
7. Go语言-命令行参数（os.Args, flag包）
1. 7.1. os.Args
2. 7.2. flag包
8. const关键字（常量）
9. Golang io.Copy()用法及代码示例
10. go变量大小写
11. Go/Golang build error: //go:build comment without // +build comment
12. golang 报错illegal rune literal
13. 更新依赖包

go:embed 的使用

简介

go:embed 是 go 1.16版本添加的新特性，可以在 go 生成的应用程序中嵌入静态文件（文件，文件夹）。部署的时候，直接扔一个二进制文件即可，不用再包含一些静态文件，考虑文件相对位置，因为它们已经被打包到生成的应用程序中了。

导入 embed 的 go 源文件可以使用 //go:embed 指令在编译时从包目录或子目录中将读取的内容转换成 string, []byte, 或者 embed.FS 类型的变量。

nil

其他语言的null

fmt.Printf()和fmt.Println()的区别

获取一个变量类型

1	fmt.Println(reflect.TypeOf(var))

fmt.Println("sss")

fmt.Printf("2**%d = %d\n", index, value)
%d就是value，输出时会将value带进去运算

fmt.Println("2**%d = %d\n", index, value)
就是单纯的输出三个变量，不会带进去运算

参考链接

设置代理
go env -w GOPROXY=”https://goproxy.io,direct“

go编译报错

more than one character in rune literal

在go语法中，双引号是常用的来表达字符串，如果你使用了单引号，编译器会提示出错

单引号只能包含一个字符，例如’b’ ,程序会输出98表示字符b的ascii码。

如果非要使用单引号输出必须使用string函数转换

fmt.Println(string('b') )
Printf 和 Println 的区别
printf 输出后不换行， println输出后自动换行；
printf格式化输出，println 直接输出内容

go run: cannot run non-main package

Go的错误信息提示的很直接了当，main方法只能放在package main中，go run 是执行命令，必须要一个main用来调用，install可以直接编译成包文件，也可以编译出exe（如果有main函数的话）

too many arguments to return have (error) want ()to

没在函数中添加返回值

func XXX() (string, error){
	var x string
	var c error
	return x, c 
}

加上就行

字典

var XXX map[string]string

map[string] 字典key的类型为string
string 字典value的类型为string

时间戳

分别使用 time.Now 的 Unix 和 UnixNano，来获取从 Unix 纪元起，到现在经过的秒数和纳秒数。

package main
import (
    "fmt"
    "time"
)
func main() {

    now := time.Now()
    secs := now.Unix()
    nanos := now.UnixNano()
    fmt.Println(now)

    millis := nanos / 1000000
    fmt.Println(secs)
    fmt.Println(millis)
    fmt.Println(nanos)

    fmt.Println(time.Unix(secs, 0))
    fmt.Println(time.Unix(0, nanos))
}

$ go run epoch.go 
2012-10-31 16:13:58.292387 +0000 UTC
1351700038
1351700038292
1351700038292387000
2012-10-31 16:13:58 +0000 UTC
2012-10-31 16:13:58.292387 +0000 UTC

Go by Example 中文版: 时间戳

Strconv

主要提供字符串和其他类型之间转换的函数。常见的比如将字符串
转换成整型，这个可能在脚本类语言没有影响，但在强类型语言中极其重要

字符串转整型

1
2
3

s := "2"
res, err := strconv.Atoi(s)
fmt.Println(reflect.TypeOf(res))  // 这里用 反射 来验证类型有没有转换成功

整型转字符串#

1
2
3

i := 21111
res := strconv.Itoa(i) //将十进制数转化成字符串
fmt.Println(reflect.TypeOf(res))

Go中的strconv

FormatInt系列函数

t := 12132123132
tstring := strconv.FormatInt(t,10)
fmt.Printf("%T", tstring)

string

Go语言-命令行参数（os.Args, flag包）

os.Args

程序获取运行他时给出的参数，可以通过os包来实现。先看代码：

package main

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

func main () {
	for idx, args := range os.Args {
		fmt.Println("参数" + strconv.Itoa(idx) + ":", args)
	}
}


$go run main.go 1 3 -X ?
参数0: /tmp/go-build116558042/command-line-arguments/_obj/exe/main
参数1: 1
参数2: 3
参数3: -X
参数4: ?

可以看到，命令行参数包括了程序路径本身，以及通常意义上的参数。
程序中os.Args的类型是 []string ，也就是字符串切片。所以可以在for循环的range中遍历，还可以用 len(os.Args) 来获取其数量。

如果不想要输出os.Args的第一个值，也就是可执行文件本身的信息，可以修改上述程序：

1	for idx, args := range os.Args[1:] {

flag包

Go语言-命令行参数（os.Args, flag包）

package main
import (
	"fmt"
	"flag"
)
var b = flag.Bool("b", false, "bool类型参数")
var s = flag.String("s", "", "string类型参数")

func main() {
	flag.Parse()
	fmt.Println("-b:", *b)
	fmt.Println("-s:", *s)
	fmt.Println("其他参数：", flag.Args())
}
------------------------------------
$ go run main.go
-b: false
-s: 
其他参数： []
------------------------------------
$ go run main.go -b
-b: true
-s: 
其他参数： []
------------------------------------
$ go run main.go -b -s test others
-b: true
-s: test
其他参数： [others]
------------------------------------
$ go run main.go  -help
Usage of /tmp/go-build080353851/command-line-arguments/_obj/exe/main:
  -b	bool类型参数
  -s string
    	string类型参数
exit status 2

flag包相比单纯的通过os.Args切片分析命令行参数，提供了更强的能力。

使用flag包，首先定义待解析命令行参数，也就是以”-“开头的参数，比如这里的 -b -s -help等。-help不需要特别指定，可以自动处理。
这里指定了两个参数，-b和-s：

var b = flag.Bool("b", false, "bool类型参数")
var s = flag.String("s", "", "string类型参数")

-----------------
原型：
func Bool(name string, value bool, usage string) *bool
func String(name string, value string, usage string) *string

flag使用前，必须首先解析：

1	flag.Parse()

const关键字（常量）

Go语言中的常量使用关键字 const 定义，用于存储不会改变的数据，常量是在编译时被创建的，即使定义在函数内部也是如此，并且只能是布尔型、数字型（整数型、浮点型和复数）和字符串型。由于编译时的限制，定义常量的表达式必须为能被编译器求值的常量表达式。

const name [type] = value

const (
    e  = 2.7182818
    pi = 3.1415926
)

Golang io.Copy()用法及代码示例

Golang io.Copy()用法及代码示例%E6%88%96%E5%BC%95%E5%8F%91%E9%94%99%E8%AF%AF%E4%B8%BA%E6%AD%A2%E3%80%82)

用法：

1	func Copy(dst Writer, src Reader) (written int64, err error)

在此，“dst”是目标，“src”是将内容复制到目标的源。
返回值：它返回复制到“dst”的int64类型的字节总数，并且还返回从src复制到dst(如果有)时遇到的第一个错误。如果复制没有错误，则返回“nil”。

go变量大小写

Go语言通过首字母的大小写来控制访问权限。 无论是方法，变量，常量或是自定义的变量类型，如果首字母大写，则可以被外部包访问，反之则不可以。 而结构体中的字段名，如果首字母小写的话，则该字段无法被外部包访问

Go/Golang build error: //go:build comment without // +build comment

If version is lower than 1.17 – need to to update golang on new version for fix it.

Go to https://go.dev/doc/install and follow instructions for update.

go版本过低导致的，更新版本即可

yum更新go版本

1 2	yum remove go yum install go

https://blog.csdn.net/qq_29695701/article/details/82744684

golang 报错illegal rune literal

illegal这个单词报错比较常见，【不合法】，golang对引号使用还是很严格的，使用双引号包裹字符串，否则报上面那个错误。

更新依赖包

go mod 更新单个包的文件
go get -u code.aliyun.com/module-go/apiresult

更新所有所有文件
go get -u

使用go get命令更新go mod文件