go 基础（一）

学习资料

https://gobyexample.com/

 

windows安装

下载：https://golang.google.cn/dl/

golang在设置windows环境变量的时候有点问题，喜欢在文件夹后面加\,设置完之后最好自己再改一遍。

编辑环境变量GOROOT,将D:\Go\改成D:\Go

编辑环境变量path，删掉;D:\Go\bin\,然后在最开头写上%GOROOT%\bin;

编辑环境变量GOPATH，设置项目路径

 

 

官网学习: https://tour.go-zh.org/welcome/1

开发工具：https://www.jetbrains.com/go/

包：https://go-zh.org/pkg/

安装第三方包go get

go get github.com/go-sql-driver/mysql

 

 

Centos 7 安装

1、下载安装包go1.9.2.linux-amd64.tar.gz

2、上传到服务器，解压文件

tar -C /usr/local -xzf go1.9.2.linux-amd64.tar.gz

3、配置环境变量

cd ~
vi .bash_profile 
export GOROOT=/usr/local/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
export GOPATH=$HOME/gopath

注：要加载的包的源代码必须放在GOPATH路径下的src目录，否则还是提示加载不到包

4、测试

cd ~
mkdir -p gopath/src/hello
cd /root/gopath/src/hello

编辑文件

vi hello.go
package main

import "fmt"

func main() {
    fmt.Printf("hello, world\n")
}

编译

cd /root/gopath/src
go install hello　

运行

$GOPATH/bin/hello

 

Go基本命令

go run 快速执行go文件，就像执行脚本一样

go build 编译程序，生成二进制可执行文件

go install 安装可执行文件到bin目录

go test 执行单元测试或压力测试

go env 显示go相关的环境变量

go fmt 格式化源代码

godoc -http=:9090  本地启动go帮助文档

 

Go程序结构

go源码按package进行组织，并且package要放到非注释的第一行

一个程序只有一个main包和一个main函数

main函数是程序的执行入口

 

 

文件名&关键字&标识符

1. 所有go源码以.go结尾

2. 标识符以字母或下划线开头，大小写敏感

3. _是特殊标识符，用来忽略结果

4. 保留关键字

基本结构体打码，文件名hello.go

package main

import(
	"fmt"
)

func main() {
	fmt.Println("hello world")
}

说明：

• 任何一个代码文件隶属于一个包
• import 关键字，引用其他包：

import(“fmt”)
import(“os”)
通常习惯写成：
import (
      “fmt”
       “os”
)

• golang可执行程序，package main， 并且有且只有一个main入口函数
• 包中函数调用：a. 同一个包中函数，直接调用； b. 不同包中函数，通过包名+点+函数名进行调用
• 包访问控制规则：a.大写意味着这个函数/变量是可导出的；b. 小写意味着这个函数/变量是私有的，包外部不能访问

运行方式：go run  hello.go

编译方式：go build -o bin/hello.exe go_dev\main（备注：编译时src路径可以不写，go会默认去src下寻找的go_dev\main）

 

 

Go 初始化过程

1、首先是import pkg的初始化过程

2、pkg中定义的const变量初始化

3、pkg中定义的var全局变量

4、pkg中定义的init函数，可能有多个

在 pkg 内，pkg level的 var 变量按照声明的顺序进行声明，但是要在依赖初始化变量的后面。

初始化的顺序： d, b, c, a

https://golang.org/ref/spec#Program_initialization_and_execution

package main

import(
	"fmt"
)

var (
	a = c + b
	b = f()
	c = f()
	d = 3
)

func f() int {
	d++
	return d
}

func main(){
	fmt.Println(d,c,b,a)
}

 

常量

1、常量使用const 修饰，代表永远是只读的，不能修改。

2、const 只能修饰boolean，number（int相关类型、浮点类型、complex）和string。

3、语法：const identifier [type] = value，其中type可以省略。

举例：

const b string = "hello world"
const b = "hello world"
const Pi = 3.1415926
const a = 9/3

写法二：

const(
    a = 0
    b = 1
    c = 2
)

写法三：

const(
    a = iota
    b //1
    c //2
)

 

变量

1、语法：var identifier type

举例：

var a int
var b string
var c bool
var d int = 8
var e string = "hello world"

写法二：

var(
    a int //默认为0
    b string //默认为""
    c bool //默认为false
    d int = 8
    e string = "hello world"
)

写法三：

var(
    a int
    b string
    c bool
    d = 8
    e = "hello world"
)

 

值类型和引用类型

1、值类型：变量直接存储值，内存通常在栈中分配。

基本数据类型int、float、bool、string以及数组和struct。

2、引用类型：变量存储的是一个地址，这个地址存储最终的值。内存通常在 堆上分配。通过GC回收。

引用类型：指针、slice、map、chan等都是引用类型。

 

变量的作用域

1、在函数内部声明的变量叫做局部变量，生命周期仅限于函数内部。

2、在函数外部声明的变量叫做全局变量，生命周期作用于整个包，如果是大写的， 则作用于整个程序。

package main

import "fmt"

func isPrime(n int) bool{
	/*
	判断 101-200 之间有多少个素数，并输出所有素数
	定义：为在大于1的自然数中，除了1和它本身以外不再有其他因数的数称为质数
	 */
	for i := 2; i < n; i ++ {
		if n%i == 0 {
			return false
		}
	}
	return true
}

func main(){
	var n int
	var m int
	fmt.Scanf("%d%d", &n, &m)
	/*
	var n int是声明，但是没有赋值，它作用于main函数中
	n是值，&n是n的地址，
	Scanf是一个函数，如果传入的是n，它是将n拷贝一份，传入Scanf进行处理,没有将main中的n赋值成功，只是改变了赋值后的n
	传入&n地址，它指向n的存储地址，通过Scanf处理，可以真正改变n的值
	 */
	fmt.Printf("%d %d\n", n, m)

	for i := n; i < m; i ++ {
		if isPrime(i) == true {
			fmt.Printf("%d\n", i)
			continue
		}
	}
}

 

数据类型和操作符

1、bool类型，只能存true和false，默认值是false

var a bool
var a bool = true
var a = true

2、相关操作符， ！、&&、|| （取反、与、或）

3、数字类型，主要有int、int8、int16、int32、int64、uint8、uint16、uint32、uint64、float32、float64

• int有符号，正负
• int8一个字节，int16两个字节
• uint无符号
• uint8一个字节，0-255

注：int后面带数字，跟操作系统无关；int后面无数据，根据不同操作系统，占用字节数不同。

4、类型转换，type(variable），比如：var a int=8;  var b int32=int32(a)

注：Go是强类型语⾔言，不不同类型相加以及赋值是不不允许的，需要类型转换。

5、逻辑操作符： == 、!=、<、<=、>和 >=

6、数学操作符：+、-、*、/、%

7、字符类型：var a byte，字符是单引号

• 在Go语言中支持两个字符类型，一个是 byte （实际上是 uint8 的别名），代表UTF-8字符串的单个字节的值；
• 另一个是 rune ，代表单个Unicode字符。出于简化语言的考虑，Go语言的多数API都假设字符串为UTF-8编码。

8、字符串类型： var str string，字符串表示两种方式： 1）双引号    2）``   （反引号）

• 双引号， ""，可以包含控制字符
• 反引号， ``，所有字符都是原样输出

9、复数类型：complex64和complex128，var c complex64 = 5 + 10i

内置函数 complex(re, im) 构造一个复数

10、位操作符

• 与操作： &

1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0

• 或操作：|

1 | 1 = 1
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0

• 异或： ^

1 ^ 1 = 0
1 ^ 0 = 1
0 ^ 1 = 1
0 ^ 0 = 0

• 左移 <<

1 << 10 = 1024
1 << 20 = 1M
1 << 30 = 1G

• 右移 >>

1024 >> 10 = 1
1024 >> 1 = 512
1024 >> 2 = 256

 

占位符

万能输出占位符: %v