Go语言学习

tsuyokuninaru

已于 2023-02-07 15:09:15 修改

阅读量205

点赞数

分类专栏： go 文章标签： go

于 2020-03-09 01:34:48 首次发布

本文链接：https://blog.csdn.net/qq_30923243/article/details/104569092

版权

go 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

接口，函数式编程，CSP并发模型
基本语法

第一章 go环境搭建

# 镜像下载地址
GOPROXY=https://proxy.golang.org,direct 
# 更换到国内网址
go env -w GOPROXY=https://goproxy.cn,direct
go env -w GO111MODULE=on
# 验证仓库是否好使
go get -v golang.org/x/tools/cmd/goimports

第二章 go文件执行

go run test.go   //执行文件
go build test.go //生成可执行文件test.exe

第三章 go语言数据类型

3.1 布尔值【可以声明为常量】

3.2 数字【可以声明为常量】

3.2.1 Go 基于架构的类型，例如：int、uint 和 uintptr

序号	类型	描述
1	uint8	无符号 8 位整型 (0 到 255)
2	uint16	无符号 16 位整型 (0 到 65535)
3	uint32	无符号 32 位整型 (0 到 4294967295)
4	uint64	无符号 64 位整型 (0 到 18446744073709551615)
5	int8	有符号 8 位整型 (-128 到 127)
6	int16	有符号 16 位整型 (-32768 到 32767)
7	int32	有符号 32 位整型 (-2147483648 到 2147483647)
8	int64	有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

package main
import "fmt"
// 相同变量不允许重复声明
func main(){
	//这种因式分解关键字的写法一般用于声明全局变量
	var (
	a, b = 1, 2
	)
	//var 声明方式
	var c int
	c = 3
	//冒号方式声明，不能与var 声明同时存在
	d := 4
	fmt.Println(a, b, c, d )
}

3.2.2 浮点型

序号	类型	描述
1	float32	IEEE-754 32位浮点型数
2	float64	IEEE-754 64位浮点型数
3	complex64	32 位实数和虚数
4	complex128	64 位实数和虚数

3.2.3 其他数字类型

序号	类型	描述
1	byte	类似 uint8
2	rune	类似 int32
3	uint	32 或 64 位
4	int	与 uint 一样大小
5	uintptr	无符号整型，用于存放一个指针

3.3 字符串类型【可以声明为常量】

3.4 派生类型

3.4.1 指针类型（Pointer）

一个指针变量指向了一个值的内存地址。
类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：

var var_name *var-type

在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。

package main

import "fmt"

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  ) // c0000100a0

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip ) // c0000100a0

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip ) // 20
}

3.4.2 数组类型

var variable_name [SIZE] variable_type

var balance=[5]float32{1,2,3,4,5}
fmt.Println(balance)
//可变长度数组
long_blong_alance := [...]float32{1,2,3,4,5,6,7}
fmt.Println(long_blong_alance)

3.4.3 结构化类型(struct)

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

package main

import "fmt"

type People struct{
	money int 
	date string
}
func main() {
  var tianyu People 
	tianyu.money = 10
	tianyu.date = "2020-03-09"
	fmt.Println("today is", tianyu.date, ",I have money", tianyu.money)
	var paopao People
	paopao.money = 20
	paopao.date = "2020-03-09"
	show(&paopao)
}
//结构体作为函数参数,指向结构体的指针
func show( paopao *People ){
	fmt.Println("today is", paopao.date, ",paopao have money", paopao.money)
}
//today is 2020-03-09 ,I have money 20
//today is 2020-03-09 ,paopao have money 10

3.4.4 Channel 类型

3.4.5 函数类型

3.4.6 切片类型

Go 语言切片是对数组的抽象。
var identifier []type 不指定数组长度即可表示切片
或者

//定义切片
var slice1 []type = make([]type, len)
也可以简写为
slice1 := make([]type, len)

//切片初始化
s :=[] int {1,2,3 }  

len() 和 cap() 函数
切片是可索引的，并且可以由 len() 方法获取长度。
切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

3.4.7 接口类型（interface）

// You can edit this code!
// Click here and start typing.
package main

import "fmt"

type notifier interface {
	notify()
}

type user struct {
	name string
	age  uint64
}

func (u *user) notify() {
	fmt.Printf("%s...%d", u.name, u.age)
}

type admin struct {
	user
	level uint64
}

func (a *admin) notify() {
	fmt.Printf("%s...%d", a.name, a.level)
}

func main() {
	u := user{
		name: "user-test",
		age:  10,
	}
	sendNotify(&u)

	ad := admin{
		user: user{
			name: "ty",
			age:  10,
		},
		level: 111,
	}
	ad.user.notify()
	ad.notify()
	sendNotify(&ad)
}

func sendNotify(n notifier) {
	n.notify()
}

3.4.8 Map 类型

类似于python的dict

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

package main

import "fmt"

func main() {
    var countryCapitalMap map[string]string /*创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap [ "France" ] = "巴黎"
    countryCapitalMap [ "Italy" ] = "罗马"
    countryCapitalMap [ "Japan" ] = "东京"
    countryCapitalMap [ "India " ] = "新德里"

    /*使用键输出地图值 */
    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap [country])
    }

    /*查看元素在集合中是否存在 */
    capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(capital) */
    /*fmt.Println(ok) */
    if (ok) {
        fmt.Println("American 的首都是", capital)
    } else {
        fmt.Println("American 的首都不存在")
    }
}

3.5 默认值

int 0
float 0
pointer nil

第四章 go常量

const 常量声明
只有布尔值、数字、字符串可以声明为常量

iota特殊常量，可以认为是一个可以被编译器修改的常量。

package main

import "fmt"

func main() {
    const (
        a = iota   //0
        b          //1
        c          //2
        d = "ha"   //独立值，iota += 1
        e          //"ha"   iota += 1
        f = 100    //iota +=1
        g          //100  iota +=1
        h = iota   //7,恢复计数
        i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}
//0 1 2 ha ha 100 100 7 8

第五章面向对象

package main

import "fmt"

type TreeNode struct {
	value       int
	left, right *TreeNode
}

// 入参TreeNode类型的node变量
func (node TreeNode) print() {
	fmt.Printf("调用者value为")
	fmt.Println(node.value)
}

func (node *TreeNode) set_value(value int) {
	node.value = value
}

func creatNode(value int) *TreeNode {
	return &TreeNode{value: value}
}

func main() {
	var root TreeNode
	root = TreeNode{value: 3}
	root.left = &TreeNode{}
	root.right = &TreeNode{5, nil, nil}
	root.right.left = new(TreeNode)
	root.right.left.set_value(666)
	root.right.left.print()
	root.left.right = creatNode(4)
	fmt.Println(root.right.left)
	fmt.Println(root.left.right)

	root.print()
	node := []TreeNode{
		{value: 3},
		{},
		{5, nil, new(TreeNode)},
	}
	fmt.Println(node)
}

第六章我先随便写点

6.1 方法集

方法集定义了接口的接受规则
规范里描述的方法集

Values	Method Receivers
T	（t T）
*T	（t T） and （t *T）

从接收者角度看方法集

Method Receivers	Values
（t T）	T and *T
（t *T）	*T

go语言的依赖管理

GOPATH

默认在~/go（unix，Linux），%USERPROFILE%\go（window）
go目录下必须有src文件夹
go env 查看
go get -u go.uber.org/zap

GOVENDOR

export GO111MODULE=off当前环境关闭 go mod
go env -w GO111MODULE=off 全局关闭go mod

GOMODULE

tsuyokuninaru

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Go语言学习

Go学习该go语言的依赖管理接口，函数式编程，CSP并发模型基本语法该给给# 镜像下载地址GOPROXY=https://proxy.golang.org,direct # 更换到国内网址go env -w GOPROXY=https://goproxy.cn,directgo env -w GO111MODULE=on# 验证仓库是否好使go get -v golang....
复制链接

扫一扫