Golang基础篇(1)
Golang
Golang基础篇(1)
Golang

Golang基础篇(1)

环境准备

下载连接:
https://studygolang.com/dl
https://golang.google.cn/dl

#linux安装方法
[root@ubuntu2004 ~]#tar xf go1.19.2.linux-amd64.tar.gz -C /usr/local 

[root@ubuntu2004 ~]#mkdir /data/go_path -p

[root@ubuntu2004 ~]#vim .bashrc 
export GOROOT=/usr/local/go
export GOPATH=/data/go_path
export GO111MODULE=on
export GOPROXY=https://goproxy.cn
export PATH=$PATH:$GOTOOR/bin:$GOPATH/bin

[root@ubuntu2004 ~]#source ~/.bashrc 

[root@ubuntu2004 ~]#go env
GO111MODULE="on"
GOARCH="amd64"
GOBIN=""
GOCACHE="/root/.cache/go-build"
GOENV="/root/.config/go/env"
GOEXE=""
GOEXPERIMENT=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/data/go_path/pkg/mod"
GONOPROXY=""
GONOSUMDB=""
GOOS="linux"
GOPATH="/data/go_path"
GOPRIVATE=""
GOPROXY="https://goproxy.cn"
GOROOT="/usr/local/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/usr/local/go/pkg/tool/linux_amd64"
GOVCS=""
GOVERSION="go1.19.2"
GCCGO="gccgo"
GOAMD64="v1"
AR="ar"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD="/dev/null"
GOWORK=""
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fno-caret-diagnostics -Qunused-arguments -Wl,--no-gc-sections -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build1359194636=/tmp/go-build -gno-record-gcc-switches"

[root@ubuntu2004 ~]#mkdir /data/go_path/{src,pkg,bin}
[root@ubuntu2004 ~]#tree /data/go_path/
/data/go_path/
├── bin
├── pkg
└── src
windows11

安装go开发工具

web在线开发工具

https://play.golang.wiki
https://go.dev/play/
https://goplay.space/
https://goplay.tools/

goland(收费软件)

vscode(免费推荐使用)

地址:https://code.visualstudio.com/

三个简易的go代码

HelloWorld

创建项目目录

cmd内用go命令创建项目

D:\Program Files\go_projects\firstgo_projects>go mod init firstgo
go: creating new go.mod: module firstgo

使用Vscode打开项目

package main

import (
    "fmt"
)

func main() {
    fmt.Println("Hello World")
}

跨包引用

创建文件夹和调用的函数文件

package mypath

func Add(a int, b int) int {
  return a + b
}
package main

import (
  "firstgo/mypath"
  "fmt"
)

func main() {
  a := 4
  fmt.Println("Hello World", a)
  b := 7
  c := mypath.Add(a, b)
  fmt.Print(c)
}

第三方依赖库

下载依赖

PS D:\Program Files\go_projects\firstgo_projects> go get gonum.org/v1/gonum/stat
go: downloading gonum.org/v1/gonum v0.12.0
go: added gonum.org/v1/gonum v0.12.0
package main

import (
	"firstgo/mypath"
	"fmt"

	"gonum.org/v1/gonum/stat"
)

func main() {
	a := 4
	fmt.Println("Hello World", a)
	b := 7
	c := mypath.Add(a, b)
	fmt.Println(c)

	arr := []float64{1, 2, 3, 4, 5, 6, 7, 8}
	v := stat.Variance(arr, nil)
	fmt.Printf("方差=%f\n", v)
}

常用Go命令

1.查看帮助文档
go help
2.对源码文件进行打包构建,生成可执行文件
go build -o <name> <sourcefile>
3.编译并安装包到$GOPATH/bin下
go install <sourcefile>
4.下载第三方依赖库到当前module中
go get <dependency package>
5.创建go项目
go mod init <name>
6.扫描当前项目中是否调用了但未添加的依赖或删除未被使用的依赖
go mod tidy <name>
7.对代码进行格式化
go fmt entrance  <file>
8.查看库帮助文档
go doc <dependency package>
9.查看go的版本
go version
10.查看go环境信息
go env

GO标识符和关键字

go变量、常量、自定义类型、包、函数的命名方式需要遵循以下规则:
1.首字符可以是任意Unicode字符或下划写
2.首字符可以是任意Unicode字符、下划写或数字
3.名字长度无限制

关键字

break  default  func  interface  select  defer  case  map  struct  go  chan  else  package
switch  goto  constif  type  continue  range  for  impor  treturn  fallthrough  var

保留字

·常量
true false iota nil
·数据类型
int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 uintptr float32 float64 complex128 complex64 bool byte rune string error
·函数
make len cap new append copy close delete complexreal imag panic recover

操作符与表达式

运算符描述
+加
–减
*乘
/除
%取余
==判断是否相等
!=判断是否不等
>判断是否大于
>=判断是否大于等于
<判断是否小于
<=判断是否小于等于
&&逻辑运算符,与运算,两个都为真结果才真,否则假
||逻辑运算符,或运算,只需一个为真结果为真,否则为假
!逻辑运算符,取反运算
&参与运算的两组二进制数对应位相与(同为1为1,不同则为0)
|参与运算的两组二进制数对应位相或(有一个为1则为1,都为0则为0)
^参与运算的两组二进制数对应位异或(不同为1,相同为0);对于单个二进制数据运算时表示按位取反,符号位也要改变
<<对二进制数进行左移n位,就是乘以2的n次方.
>>对二进制数进行右移n位,就是除以2的n次方.
=简单赋值
+=相加后赋值
-=相减后赋值
*=相乘后赋值
/=相除后赋值
%=取余后赋值
<<=位运算向左移后赋值
>>=位运算向右移后赋值
&=位运算相与后赋值
|=位运算相或后赋值
^=位运算相异或后赋值

变量常量字面量

变量

类型go变量类型fmt输出
整形int int8 int32 int64 uint uint8 uint16 uint16 uint32 uint64%d
浮点型float32 float64%f %e %g
复数complex128 complex64%v
布尔型bool%t
指针uinptr%p
引用map slice channel%v
字节byte%d
任意字符rune%d %c
字符串string%s
错误error%v

变量初始化

● 如果声明后未显式初始化，数值型初始化0，字符串初始化为空字符串，布尔型初始化为false，引用类型、函数、指针、接口初始化为nil
● var a string=”china”
● var a,b int=3,7
● var a=”china”,类型推断
● var a,b=”china”,7

变量初始化

● 函数内部的变量(非全局变量)可以通过:=声明并初始化
● a:=3
● 下划线表示匿名变量
● _=2+4
● 匿名变量不占命名空间，不会分配内存，因此可以重复使用

常量

常量在定义时必须赋值,且程序运行期间其值不能改变
const Pl float32=3.14 const(
const( a=100
PI=3.14 b //100，跟上一行的值相同
E=2.71 c //100，跟上一行的值相同
) )

iota

const( const( const(
a=iota//0 a=iota//0 a=iota//0
b //1 b //1 b=30
c //2 _ //2 c=iota//2
d //3 d //3 d //3
) ) )

字面量

●字面量:没有出现变量名，直接出现了值。基础类型的字面量相当于是常量
fmt.Printf(” %t\n”,04 == 4.00)//用到了整型字面量和浮点型字面量
fmt.Printf(“%v\n”, .4i)//虚数字面量0.4i
fmt.Printf(“%t\n”, ‘\u4f17’== ‘众’Y//Unicode和rune字面量
fmt.Printf(“Hello\nWorld\n!\n”)//字符串字面量

变量的作用域

var (
A=3 //全局变量，大写字母开头，所有地方都可以访问，跨package访问时需要带上package名称
b=4 //全局变量，小写字母开头，本package内都可以访问
)
func foo(){
b:=5 //局部变量，仅本函数内可以访问。内部声明的变量可以跟外部声明的变量有冲突，以内部的为准
{b:=6 //仅0圈定的作用域内可以访问，可以跟外部的变量有冲突}
}

代码示例

package main

import (
	"fmt"
	"runtime"
	"strconv"
	"test1/util"
)

func atc() {
	var a float32 = 8
	var b float32 = 3
	var c float32 = a + b
	var d float32 = a - b
	var e float32 = a * b
	var f float32 = a / b
	var n int = 8
	var m int = 3
	var g int = n % m

	fmt.Printf("c=%f\n", c)
	fmt.Println(d)
	fmt.Println(e)
	fmt.Println(f)
	fmt.Println(g)
}

func rel() {
	var a float32 = 8
	var b float32 = 3
	var c float32 = 5
	fmt.Println(a > b)
	fmt.Println(a > b && b > c)
	fmt.Println(a > b || b < c)
	fmt.Println(b > c || a > b)
	fmt.Println(!(a > b))
}

func bit_op() {
	fmt.Printf("os arch %s, int size %d\n", runtime.GOARCH, strconv.IntSize)
	fmt.Printf("260 %s\n", util.BinaryFormat(260)) //260=2^8+2^2 从零开始算第二位和第八位为1,100000100
	fmt.Printf("-260 %s\n", util.BinaryFormat(-260))
	fmt.Printf("260>>23 %s\n", util.BinaryFormat(260>>23))
	fmt.Printf("260<<23 %s\n", util.BinaryFormat(260<<23))
	fmt.Printf("-260>>23 %s\n", util.BinaryFormat(-260>>23))
	fmt.Printf("-260<<23 %s\n", util.BinaryFormat(-260<<23))

	fmt.Printf("%d\n", 6&8)  // 6 0110 & 8 1000 = 13 0000
	fmt.Printf("%d\n", 6|8)  //  6 0110 | 8 1000 =  14 1110
	fmt.Printf("%d\n", 6^5)  //  6 0110 ^ 5 0101 =  3 0011
	fmt.Printf("%d\n", ^5)   //
	fmt.Printf("%b\n", 5>>1) // 5 0101 =  0010
	fmt.Printf("%b\n", 5<<1) // 5 0101 =  1010
}

func test() {
	var a int = 7
	var b int = a / 2
	var c int = a >> 1 //性能快于普通运算,底层架构尝使用
	fmt.Println(b, c)
}

func prt() {
	a := 5
	prt := &a
	fmt.Printf("%p %d %x\n", prt, prt, prt)
}

func test2() {
	a := 50000000000000.0
	fmt.Printf("%f\n", a)
	fmt.Printf("%e\n", a)
	fmt.Printf("%g\n", a)
	fmt.Printf("%.0f\n", a)
	fmt.Printf("%e.0\n", a)
	fmt.Printf("%g\n", a)
	var u uint = 255 // 2^8 255 11111111
	var b byte = 255 //=uint8
	var d rune = 10000
	fmt.Printf("%d\n", u)
	fmt.Printf("%d\n", b)
	fmt.Printf("%c\n", u)
	fmt.Printf("%c\n", d)
}

func test3() {
	const (
		a = iota
		b
		c
		d
	)
	println(a, b, c, d)
	const (
		_  = 1 << (10 * iota)
		KB = 1 << (10 * iota)
		MB = 1 << (10 * iota)
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
	)
	println("KB=", KB)
	println("MB=", MB)
	println("GB=", GB)
	println("TB=", TB)

	var r rune = '舒'
	fmt.Printf("%d %x\n", r, r)
	fmt.Printf("%t\n", '舒' == '\u8212')
}

var (
	A = 3
	b = 2
)

func scop() {
	fmt.Printf("A=%d\n", A)
	fmt.Printf("b=%d\n", b)
	b := 5
	fmt.Printf("b=%d\n", b)
	C := "abc"
	fmt.Printf("C=%s\n", C)
	{
		C := 9
		D := false
		fmt.Printf("C=%d,D=%t\n", C, D)
	}
	fmt.Printf("C=%s\n", C)
}

func main() {
	atc()
	rel()
	bit_op()
	test()
	prt()
	test2()
	test3()
	scop()
}
package util

import (
	"math"
	"strings"
)

func BinaryFormat(n int64) string {
	sb := strings.Builder{}     //字符串连接
	c := int64(math.Pow(2, 31)) //math.Pow()此处表示的是2的31次方
	//fmt.Println(c)
	for i := 0; i < 32; i++ {
		if n&c != 0 {
			sb.WriteString("1")
		} else {
			sb.WriteString("0")
		}
		c >>= 1
	}
	return sb.String()
}
PS D:\Program Files\go_projects\test1> go run .\oprator\mian.go
c=11.000000
5
24
2.6666667
2
true
false
true
true
false
os arch amd64, int size 64
260 00000000000000000000000100000100
-260 11111111111111111111111011111100
260>>23 00000000000000000000000000000000
260<<23 10000010000000000000000000000000
-260>>23 11111111111111111111111111111111
-260<<23 01111110000000000000000000000000
0
14
3
-6
10
1010
3 3
0xc0000a61c8 824634401224 c0000a61c8
50000000000000.000000
5.000000e+13
5e+13
50000000000000
5.000000e+13.0
5e+13
255
255
ÿ
✐
0 1 2 3
KB= 1024
MB= 1048576
GB= 1073741824
TB= 1099511627776
33298 8212
true
A=3
b=2
b=5
C=abc
C=9,D=false
C=abc

注释和go doc和godoc

注释

●单行注释。以//打头
●多行注释。连续多行以//打头，或者在段前使用/，段尾使用/
●多行注释之间不能出现空行
●NOTE:引人注意，TOD0:将来需要优化，Deprecated:变量或函数强烈建议不要再使用
●注释行前加缩进即可写go代码

注释的位置

●包注释。在package xxx的上方。一个包只需要在一个地方写包注释,通常会专门写一个doc.go，里面只有一行packagexxx和关于包的注释
●结构体注释。在type xxx struct上方·函数注释。在func xxx()上方
●行注释。在行上方或右侧

go doc

●go doc是go自带的命令
●go doc entranc …class/util

godoc

godoc可以为项目代码导出网页版的注释文档
●需要先安装go get golang.org/x/tools/cmd/godoc·启动http: godoc -http=:6060
●用浏览器访问:http://127.0.0.1:6060/pkg/go-course/entrance..class

Print Friendly, PDF & Email