GoLang学习笔记

已于 2024-02-22 09:53:58 修改
阅读量953 收藏 23
点赞数 16
分类专栏： goLang 文章标签： golang 开发语言 后端
于 2024-02-21 15:45:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35097281/article/details/136183342
版权

前言

        本文全篇都是GoLang的学习笔记，主要从GoLang产生的背景、特性开始，将go语言学习划分成基础、进阶两个部分展开。主要针对有编程经验的开发人员食用更佳，目前暂定为学习大纲+知识点的形式罗列，后续考虑加入具体案例和思维导图表示层级关系。

        说明【?】标题中间带有？说明带有疑惑，【{}】标题层级中间带有{}说明是重点章节,【[]】标题层级中间带有[]说明章节中难度较高，建议仔细阅读。

目录

前言

Go语言简介

GoLang产生背景

GoLang特性

Go语言基础

Go程序基本概念

Go程序基本结构

应用程序入口

退出返回值

获取命令行参数

变量、常量

数据类型

基本数据类型

类型转化

类型的预定义值

指针类型与其他主要编程语言的差异

运算符

算术运算符

​编辑比较运算符

逻辑运算符

位运算符

​编辑

条件和循环

循环

条件

switch条件

【{}】数组和切片

数组

切片

​编辑

区分数组与切片的关键

Go语言进阶

Go语言简介

GoLang产生背景

2007年谷歌为了解决以下三大问题：

  1. 多核软件架构
  2. 超大规模的分布式计算集群
  3. web开发模式导致前所未有的开发规模和更新速度

GoLang特性

编译的强类型语言

  • 简单
    • 25个关键字
    • 关于并发编程、内存管理go内置并发支持、垃圾回收机制
  • 高效
    • 指针直接访问内存
    • 垃圾回收
  • 生产力
    • 简洁清晰的依赖管理
    • 独特的接口类型设计

Go语言基础

Go程序基本概念

Go程序基本结构

应用程序入口

退出返回值

获取命令行参数

变量、常量

        Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，例如： 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false。 切片、函数、指针变量的默认为nil。

/*
* 常量初始化
 */
func TestConstantInit(t *testing.T) {
	var a int = 1
	var b int = 2
	//等价于
	var (
		c int = 3
		d     = 4
	)
	//等价于
	e := 5
	t.Log(a, b, c, d, e)
	//假设交换两者之间的值
	t.Log("交换之前a,b值", a, b)
	a, b = b, a
	t.Log("交换之后a,b值", a, b)
}

=== RUN   TestConstantInit
    constant_test.go:18: 1 2 3 4 5
    constant_test.go:20: 交换之前a,b值 1 2
    constant_test.go:22: 交换之后a,b值 2 1
--- PASS: TestConstantInit (0.00s)
PASS

数据类型

        数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，这样就可以充分利用内存。

基本数据类型

  • 数字类型主要分为有符号数和无符号数，有符号数可以用来表示负数，除此之外它们还有位数的区别，不同的位数代表它们实际存储占用空间，以及取值的范围。
  • 布尔类型取值范围为 true, false

类型转化

//不支持隐式转换
	var f int32 = 1
	var g int
	g = int(f)
	t.Log(g)

类型的预定义值

指针类型与其他主要编程语言的差异

/*
*测试字符串
 */
func TestString(t *testing.T) {
	var str string
	t.Log("-" + str + "-")
	t.Logf("字符串:%d,地址：%p，", len(str), &str)
	//由此推断，判断字符串是否为空
	if str == "" {
		t.Log("正确判断")
	}
	//invalid operation: str == nil (mismatched types string and untyped nil)
	//if str == nil {
	//	t.Log("错误判断")
	//}

	//不支持指针运算
	//.\constant_test.go:44:12: cannot convert 1 (untyped int constant) to *int
	//n := 1
	//s := &n + 1
	//t.Log("-" + s + "-")
}

=== RUN   TestString
    constant_test.go:31: --
    constant_test.go:32: 字符串:0,地址：0xc0000565f0，
    constant_test.go:35: 正确判断
--- PASS: TestString (0.00s)
PASS

运算符

算术运算符

比较运算符

语义上与其他语言无区别，在比较一些特殊数据类型有区别，数组可以与数组进行比较，切片不能与切片进行比较，切片只能为nil进行比较。

在go中使用==对数组进行比较有一个前提，两个数组的维度和元素的个数相同才能进行比较。

比如：

  • 二维数组A与一维数组B不能进行比较。
  • 数组A【1，2，3，4】与数组B【3，2，1】不能进行比较。
  • 数组A【1，2，3】与数组B【3，2，1】可以进行比较。

比较原则在于数组每个位置上的元素都要相等。

比如：

  • 数组A【1，2，3】与数组B【3，2，1】不相等、数组A【1，2，3】与数组D【1，3，4】不相等。
  • 数组A【1，2，3】与数组C【1，2，3】相等。

逻辑运算符

位运算符

定义：

        按位清零是一种操作，即将指定位置的位清零（置为0），其余位保持不变。

作用：
1. 用于屏蔽或清除某些位的值，保留或重置其他位的值；
2. 在操作中去除某些标志位，以达到特定的逻辑功能。

使用场景：
1. 在编程中，可以使用按位清零操作来清除某些标志位，例如清零状态寄存器中的某些标志位；
2. 在嵌入式系统中，可以使用按位清零操作来控制硬件寄存器的某些位，例如清零或禁用某个外设的特定功能；
3. 在数据处理中，可以使用按位清零操作来屏蔽或清除某些控制位，控制数据流的处理流程。

条件和循环

循环

 for是 Go 中唯一可用的循环。Go 没有其他语言中存在的 while 或 do while 循环。在 Go 中，初始化、条件和发布这三个组件都是可选的。

在for循环中注意：

  • break 会结束所有循环。
  • continue 会跳过当前循环直接进入下一次循环。

/*
* WhileLoop
 */
func TestWhileLoop(t *testing.T) {
	n := 0
	/* while(n<5) */
	for n < 5 {
		t.Log(n)
		n++
	}
}

条件

func TestIfMultiSec(t *testing.T) {
	if a := 1 == 2; a {
		t.Log("1==1")
	} else {
		t.Log("1!=1")
	}
}

=== RUN   TestIfMultiSec
    loop_test.go:21: 1!=1
--- PASS: TestIfMultiSec (0.00s)
PASS

switch条件

func TestSwitchMultiCase(t *testing.T) {
	for i := 0; i < 5; i++ {
		switch i {
		/*说明单个case中可以出现多个结果项*/
		case 0, 2:
			t.Log("偶数")
			/*不需要一个完整break明确退出*/
		case 1, 3:
			t.Log("基数")
		default:
			t.Log("不在0-3之间")
		}
	}
}

=== RUN   TestSwitchMultiCase
    loop_test.go:33: 偶数
    loop_test.go:36: 基数
    loop_test.go:33: 偶数
    loop_test.go:36: 基数
    loop_test.go:38: 不在0-3之间
--- PASS: TestSwitchMultiCase (0.00s)
PASS


func TestSwitchCaseCondition(t *testing.T) {
	for i := 0; i < 5; i++ {
		/*不设定条件表达式之后与多个if else逻辑等同*/
		switch {
		case i%2 == 0:
			t.Log("偶数")
		case i%2 == 1:
			t.Log("基数")
		default:
			t.Log("未知")
		}
	}
}

=== RUN   TestSwitchCaseCondition
    loop_test.go:47: 偶数
    loop_test.go:49: 基数
    loop_test.go:47: 偶数
    loop_test.go:49: 基数
    loop_test.go:47: 偶数
--- PASS: TestSwitchCaseCondition (0.00s)
PASS

【{}】数组和切片

数组

        数组是具有相同 唯一类型 的一组以编号且长度固定的数据项序列。数组连续存储空间，容量不可变。Go 中的数组是值类型而不是引用类型。这意味着当数组赋值给一个新的变量时，该变量会得到一个原始数组的一个副本。如果对新变量进行更改，则不会影响原始数组。

/*
*数组初始化
 */
func TestArrayInit(t *testing.T) {
	//申明并且初始化为默认值零值
	var arr [3]int
	t.Logf("数组：%d,长度：%d,容量：%d", arr, len(arr), cap(arr))

	//声明同时初始化
	arr1 := [2]int{1, 2}
	t.Logf("数组：%d,长度：%d,容量：%d", arr1, len(arr1), cap(arr1))

	//声明同时初始化并且不指定元素个数，仅使用与一维数组
	arr2 := [...]int{1, 2, 3, 4, 5}
	t.Logf("数组：%d,长度：%d,容量：%d", arr2, len(arr2), cap(arr2))

	//多维数组初始化
	arr3 := [4][3]int{{1, 2}, {1, 1, 1}, {1, 3, 5}, {0}}
	t.Logf("数组：%v,长度：%d,容量：%d", arr3, len(arr3), cap(arr3))

	//arr4 := [...][...]int{{1, 2}, {1, 1, 1}, {1, 3, 5}, {0}}
	//t.Logf("数组：%d", arr4)
	//输出：invalid use of [...] array (outside a composite literal) 多维数组必须声明长度
}

=== RUN   TestArrayInit
    array_test.go:11: 数组：[0 0 0],长度：3,容量：3
    array_test.go:15: 数组：[1 2],长度：2,容量：2
    array_test.go:19: 数组：[1 2 3 4 5],长度：5,容量：5
    array_test.go:23: 数组：[[1 2 0] [1 1 1] [1 3 5] [0 0 0]],长度：4,容量：4
--- PASS: TestArrayInit (0.00s)
PASS

/*
*数组遍历
 */
func TestArrayTravel(t *testing.T) {
	arr2 := [...]int{1, 2, 3, 4, 5}
	//其他语言写法
	for i := 0; i < len(arr2); i++ {
		t.Log(arr2[i])
	}
	//go中写法,go中声明了未使用可以_表示弃用。
	for idx, e := range arr2 {
		t.Logf("坐标：%d,值：%d", idx, e)
	}
}

=== RUN   TestArrayTravel
    array_test.go:37: 1
    array_test.go:37: 2
    array_test.go:37: 3
    array_test.go:37: 4
    array_test.go:37: 5
    array_test.go:41: 坐标：0,值：1
    array_test.go:41: 坐标：1,值：2
    array_test.go:41: 坐标：2,值：3
    array_test.go:41: 坐标：3,值：4
    array_test.go:41: 坐标：4,值：5
--- PASS: TestArrayTravel (0.00s)
PASS

数组截取不支持负数。举例：

  • a[:] 输出 {1，2，3，4，5}
  • a[-1:] 报错
/*
* 数组截取
 */
func TestArraySection(t *testing.T) {
	arr2 := [...]int{1, 2, 3, 4, 5}
	//从零开始第三位
	arr2_sec := arr2[:3]
	t.Log(arr2_sec)
	//默认截取全部
	arr2_sec1 := arr2[:]
	t.Log(arr2_sec1)
}

=== RUN   TestArraySection
    array_test.go:52: [1 2 3]
    array_test.go:54: [1 2 3 4 5]
--- PASS: TestArraySection (0.00s)
PASS

切片

        切片（slice）是对数组一个连续片段的引用（该数组我们称之为相关数组，通常是匿名的），所以切片是一个引用类型。

Slice连续数据结构，是一个结构体，包括三个基本元素。

  • ptr指针：指向一片连续的存储空间或者数组。
  • len:元素个数，可以访问的元素，一般指设置了值、已初始化的元素。
  • cap:指针指向存储空间对应长度。当内部容量不够时当前容量*2进行扩张。

/*
* 切片初始化
 */
func TestSliceInit(t *testing.T) {
	//申明且未初始化
	var s0 []int
	t.Logf("切片：%d,长度：%d,容量：%d", s0, len(s0), cap(s0))
	s0 = append(s0, 2)
	t.Logf("切片：%d,长度：%d,容量：%d", s0, len(s0), cap(s0))

	//声明同时初始化
	s1 := []int{1, 2, 3}
	t.Logf("切片：%d,长度：%d,容量：%d", s1, len(s1), cap(s1))

	s2 := make([]int, 4, 5)
	t.Logf("切片：%d,长度：%d,容量：%d", s2, len(s2), cap(s2))

	//t.Log(s2[0], s2[1], s2[2], s2[3], s2[4])
	//panic: runtime error: index out of range [4] with length 4 [recovered]
	//说明：len代表可访问的元素个数，声明4说明只初始化了前4位，跟容量没有关系。

	t.Log(s2[0], s2[1], s2[2], s2[3])

	//添加一个元素，且长度与容量相等
	s2 = append(s2, 2)
	t.Log(s2[0], s2[1], s2[2], s2[3], s2[3], s2[4])
	t.Logf("切片：%d,长度：%d,容量：%d", s2, len(s2), cap(s2))

	//添加一个元素，且长度大于容量
	s2 = append(s2, 3)
	t.Log(s2[0], s2[1], s2[2], s2[3], s2[3], s2[4], s2[5])
	t.Logf("切片：%d,长度：%d,容量：%d", s2, len(s2), cap(s2))
}

=== RUN   TestSliceInit
    slice_test.go:11: 切片：[],长度：0,容量：0
    slice_test.go:13: 切片：[2],长度：1,容量：1
    slice_test.go:17: 切片：[1 2 3],长度：3,容量：3
    slice_test.go:20: 切片：[0 0 0 0],长度：4,容量：5
    slice_test.go:26: 0 0 0 0
    slice_test.go:30: 0 0 0 0 0 2
    slice_test.go:31: 切片：[0 0 0 0 2],长度：5,容量：5
    slice_test.go:35: 0 0 0 0 0 2 3
    slice_test.go:36: 切片：[0 0 0 0 2 3],长度：6,容量：10
--- PASS: TestSliceInit (0.00s)
PASS

/*
* 切片共享存储结构
 */
func TestSliceShareMemory(t *testing.T) {
	s := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
	s1 := s[3:6]
	//从3下标截取6-3位数。4，5，6，长度=3，容量=cap(s)-开始截取的坐标=12-3=9
	t.Logf("切片：%d,长度：%d,容量：%d", s1, len(s1), cap(s1))
	s2 := s[5:8]
	//从5下标截取8-5位数。6, 7, 8,长度=3，容量=cap(s)-开始截取的坐标=12-5=7
	t.Logf("切片：%d,长度：%d,容量：%d", s2, len(s2), cap(s2))
	s[5] = -1
	t.Log(s)
	t.Log(s1)
	t.Log(s2)
}
=== RUN   TestSliceShareMemory
    slice_test.go:45: 切片：[4 5 6],长度：3,容量：9
    slice_test.go:47: 切片：[6 7 8],长度：3,容量：7
    slice_test.go:49: [1 2 3 4 5 -1 7 8 9 10 11 12]
    slice_test.go:50: [4 5 -1]
    slice_test.go:51: [-1 7 8]
--- PASS: TestSliceShareMemory (0.00s)
PASS

区分数组与切片的关键

  1. 容量是否可以伸缩？ 数组不可以，切片可以。
  2. 是否可以进行比较？数组可以与数组进行比较，切片不可以与切片进行比较，仅可与nil进行比较。

Map

        map 一种无序的键值对, 它是数据结构 hash 表的一种实现方式。map工作方式就是：定义键和值，并且可以获取，设置和删除其中的值。

注意：

  • 与切片一样，maps 是引用类型。当一个 map 赋值给一个新的变量，它们都指向同一个内部数据结构。因此改变其中一个也会反映到另一个。
  • 须指定 key, value 的类型，插入的纪录类型必须匹配。
  • key 具有唯一性，插入纪录的 key 不能重复。
  • KeyType 可以为基础数据类型（例如 bool, 数字类型，字符串）, 不能为数组，切片，map，它的取值必须是能够使用 == 进行比较。
  • ValueType 可以为任意类型。
  • 无序性。
  • 线程不安全, 一个 goroutine 在对 map 进行写的时候，另外的 goroutine 不能进行读和写操作，Go 1.6 版本以后会抛出 runtime 错误信息。

 Map键值对与其他语言差异点:

  • 当访问key不存在时，返回零值。
  • Map的value可以是一个方法。

Map基础知识

Map声明
/*
*初始化map
 */
func TestInitMap(t *testing.T) {
	//初始化且赋值
	m1 := map[int]int{1: 1, 2: 0, 3: 2}
	t.Log(m1[1])
	t.Logf("长度m1:%d", len(m1))
	//初始化空的map
	m2 := map[int]int{}
	//给空map赋值
	m2[0] = 10
	t.Logf("长度m2:%d", len(m2))
	//使用make初始化,初始化长度是cap
	m3 := make(map[int]int, 1)
	t.Logf("长度m3:%d", len(m3))
	//,cap不能求map长度
	//.\map_test.go:22:28: invalid argument: m3 (variable of type map[int]int) for cap
	//t.Logf("长度m3:%d", cap(m3))

	//思考？通过初始化map容量与切片容量对比，不会出现超过容量翻倍增长的情况。
	m3[0] = 1
	t.Log(m3)
	t.Logf("长度m3:%d", len(m3))
	m3[1] = 2
	t.Log(m3)
	t.Logf("长度m3:%d", len(m3))
	m3[2] = 3
	t.Log(m3)
	t.Logf("长度m3:%d", len(m3))
}

=== RUN   TestInitMap
    map_test.go:11: 1
    map_test.go:12: 长度m1:3
    map_test.go:17: 长度m2:1
    map_test.go:20: 长度m3:0
    map_test.go:24: map[0:1]
    map_test.go:25: 长度m3:1
    map_test.go:27: map[0:1 1:2]
    map_test.go:28: 长度m3:2
    map_test.go:30: map[0:1 1:2 2:3]
    map_test.go:31: 长度m3:3
--- PASS: TestInitMap (0.00s)
PASS
Map元素访问

        问题1：如何判断当前key是否存在当前map?

        问题2：如何判断当前key存在且对应value为空值?

func TestAccessNotExistingKey(t *testing.T) {
	m1 := map[int]string{}
	t.Logf("访问不存在map中的key,输出为:*%s*", m1[1])
	m1[2] = ""
	t.Logf("访问map中存在的key且值为空值,输出为:*%s*", m1[2])
	//解决方案
	if v, ok := m1[3]; ok {
		t.Logf("存在map中的key,输出为:*%s*", v)
	} else {
		t.Log("key不存在map中")
	}
}

=== RUN   TestAccessNotExistingKey
    map_test.go:39: 访问不存在map中的key,输出为:**
    map_test.go:41: 访问map中存在的key且值为空值,输出为:**
    map_test.go:46: key不存在map中
--- PASS: TestAccessNotExistingKey (0.00s)
PASS
Map元素遍历

Map进阶

Map与工厂模式
func TestMapWithFunValue(t *testing.T) {
	m := map[int]func(v int) int{}
	m[0] = func(v int) int {
		return 0
	}
	m[1] = func(v int) int {
		return v
	}
	m[2] = func(v int) int {
		return v * v
	}
	m[3] = func(v int) int {
		return v * v * v
	}

	t.Log(m[0](2), m[1](2), m[2](2), m[3](2))

	//当value为方法时不能访问未定义的key
	//panic: runtime error: invalid memory address or nil pointer dereference [recovered]
	//t.Log(m[4](2))

	if fn, ok := m[4]; ok {
		t.Log(fn(2))
	} else {
		t.Log("不存在key")
	}

	m[4] = func(v int) int {
		return v * 10
	}
	if fn, ok := m[4]; ok {
		t.Log(fn(2))
	} else {
		t.Log("不存在key")
	}
}

=== RUN   TestMapWithFunValue
    map_test.go:67: 0 2 4 8
    map_test.go:76: 不存在key
    map_test.go:83: 20
--- PASS: TestMapWithFunValue (0.00s)
PASS
在Go语言中实现Set

        go未提供内置的Set

func TestMapForSet(t *testing.T) {
	mySet := map[int]bool{}
	mySet[1] = true
	n := 2
	if mySet[n] {
		t.Log(n, "key存在map中")
	} else {
		t.Log(n, "key不存在map中")
	}
	mySet[2] = true
	mySet[12] = true
	t.Log(mySet, "map长度为", len(mySet))
	//删除
	delete(mySet, 2)
	t.Log(mySet, "map长度为", len(mySet))
}


=== RUN   TestMapForSet
    map_test.go:96: 2 key不存在map中
    map_test.go:100: map[1:true 2:true 12:true] map长度为 3
    map_test.go:103: map[1:true 12:true] map长度为 2
--- PASS: TestMapForSet (0.00s)
PASS

字符串

Go语言进阶

阿凌哥哥
关注
专栏目录
【GoLang】3.2 数组
你的指尖有改变世界的力量
08-08 1159
记录了自己学习过程中遇到的Go数组语法需要注意的五点:字面量、长度、键值对、值类型、多维数组。
Golang 新手可能会踩的 N 个坑
staforn的专栏
07-22 2939
原文：https://segmentfault.com/a/1190000013739000#articleHeader9 8. 显式类型的变量无法使用 nil 来初始化 nil是 interface、function、pointer、map、slice 和 channel 类型变量的默认初始值。但声明时不指定类型，编译器也无法推断出变量的具体类型。 // 错误示例 func ma...
C语言函数传递二维数组
SanShuiGeGe的博客
08-05 5975
C语言如果给函数传递二维数组作为参数 问题的产生 先看一个传递二维数组的例子： #include <stdio.h> void foo(int a[][], int m, int n) { int i = 1; int j = 1; printf("a[%d][%d]=%d\n", i, j, a[i][j]); } int main() { int...
Go 语言变量
萧海的博客
08-06 203
变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。 变量可以通过变量名访问。 Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。 声明变量的一般形式是使用 var 关键字： var identifier type 可以一次声明多个变量： var identifier1, identifier2 type 实例 package main import "fmt" func main() { var a string = "Runoob" fmt.Println
Go语言入门-常用数据结构之数组
syouya.shiraki's blog
05-10 742
Go语言入门-常用数据结构之数组 定义 概述 An array is a numbered sequence of elements of a single type, called the element type. The number of elements is called the length of the array and is never negative.-数组是单一类型元素（元素类型）组成并且被编号序列。 元素的数量称为数组的长度，绝不能为负。 这句话体现数组的几个特点： 数组中
GoLang学习笔记1
08-03
在本篇GoLang学习笔记中，我们将探讨Go语言的基础知识，包括类型、变量、常量、自定义类型、基本类型以及复合类型。 1. 类型与变量 在Go语言中，使用`var`关键字来定义变量，并为其分配零值。例如： ```go var x ...
Golang学习笔记
技术宇宙
01-05 1990
目录特点天然并发函数可以返回多个值开发目录结构Golang 执行流程分析参考 特点 Go 语言保证了既能到达静态编译语言的安全和性能，又达到了动态语言开发维护的高效率动态语言开发维护的高效率 使用一个表达式来形容 Go 语言：Go = C + Python 说明 Go 语言既有 C 静态语言程序的运行速度，又能达到 Python 动态语言的快速开发 天然并发 从语言层面支持并发，实现简单 goroutine，轻量级线程，可实现大并发处理，高效利用多核 基于 CSP 并发模型(Communicating S
雨痕golang学习笔记第四版 加上书签版
08-05
《雨痕golang学习笔记第四版 加上书签版》是针对Go语言学习者的参考资料，作者雨痕在书中详细记录了从2012年开始学习Go语言至今的经验与成果。本书内容全面，涵盖了Go语言的基础知识、数据结构、函数特性、并发编程...
Golang学习笔记（一）：简介
01-21
安装说明 地址 http://golang.org/doc/install 包下载 地址 https://code.google.com/p/go/downloads/list 确认是否安装成功 代码如下: go version //查看版本 环境变量设置 整体目录结构 通过package组织，只有...
golang 学习笔记
10-18
golang学习笔记，需使用mybase打开 截图，https://img-bbs.csdn.net/upload/201810/18/1539860619_543624.png
06 Go语言常见语法错误
小人物、平凡，世界很大我只想在家
01-17 5406
Go语言常见语法错误 1、开大括号不能放在单独的一行 错误代码： package main import &amp;amp;amp;quot;fmt&amp;amp;amp;quot; func main() { fmt.Println(&amp;amp;amp;quot;hello world!&amp;amp;amp;quot;) } 编译错误： ./main.go:5:6: missing function body for &amp;amp;
golang数组声明
acr7720的博客
10-16 2757
格式 初始化数组 {}中的元素数不能大于[]中的数字，并且长度在初始化后不能改变，定义数组时需指定长度 ... var arrName [num]type = [num]type{value, value, value,....} 在函数调用时, 数组是值传递，而分片是引用传递 其实对于go来说，函数调用的时候都是值传递，拷贝一个副本，切片本身它就是指针...
Golang 新手可能会踩的 50 个坑
热门推荐
后台开发
10-06 1万+
前言 Go 是一门简单有趣的编程语言，与其他语言一样，在使用时不免会遇到很多坑，不过它们大多不是 Go 本身的设计缺陷。如果你刚从其他语言转到 Go，那这篇文章里的坑多半会踩到。 如果花时间学习官方 doc、wiki、讨论邮件列表、Rob Pike的大量文章以及 Go 的源码，会发现这篇文章中的坑是很常见的，新手跳过这些坑，能减少大量调试代码的时间。 初级篇：1-34 1. 左大括号{一般不能单独放一行 在其他大多数语言中，{的位置你自行决定。Go 比较特别，遵守分号注入规则（autom...
GO学习笔记5：数组
Zekho的博客
02-14 531
定义方式：var 数组变量名 [元素数量]T 例如 var a [10]int64{初始值1，初始值2} 还可以直接通过索引去定义数值：var a [10]int64{7:初始值1，8:初始值2}=={0,0,0,0,0,0,0,0,初始值1, 初始值2,0,0,0 } 多维数组同C语言 数组长度取决于元素的数量，与里面元素的类型无关，用此方式可遍历数组 a := [...][2]string 用…可以让编译器自己生成长度，但是只有第一层可以用…代替 error：use of [.....
DataWhale & Golang（二、数据类型、关键字、标识符）
我就吃一口的BLOG
12-15 482
二、数据类型、关键字、标识符 学习大纲： 目录 二、数据类型、关键字、标识符 学习大纲 补充内容 1. Go 语言的空格 1.1 补充点 2. 数字类型 3. 浮点型 4. 其他数字类型 4.1 补充点 5. 关键字 6. 知识点 7. 字符串连接 补充内容： 1. Go 语言的空格 Go 语言中变量的声明必须使用空格隔开，如：var age int; 语句中适当使用空格能让程序更易阅读。 无空格：fruit=apples+oranges; 在变量与运...
参照Java学Go（三）—— go的内置类型：数组、切片slice、map
mingjia1987的博客
05-29 2901
    前一篇说到了go的变量、常量和基本数据类型，接下来继续说一下go的其他内置类型：数组、切片（slice）和集合（map）    一，数组    go和java中肯定都有数组了，只不过在定定义上和定义变量类似，把类型放到了后边（还是觉得很难受有没有？）    首先对比一下定义：//java： int[] arr; //没有初始化 arr = new int[1]{}; ...
理解Golang中的nil
weixin_38371073的博客
04-29 746
参考： 有趣的面试题：Go语言中的nil比较 - 知乎 (zhihu.com) 理解Go语言的nil - 简书 (jianshu.com) Golang中的nil，没有人比我更懂nil！ - 知乎 (zhihu.com) 常用的nil 在写程序的时候经常会遇到nil这个词，比如说错误判断： f, err := os.Open(filePath) if err != nil { panic(err) } 这很容易理解，但是有如果对nil与nil进行比较，如下： fmt.Println(nil==.
Go 学习笔记（28）— nil（nil 不能比较、不是关键字或保留字、nil 没有默认类型、不同类型的 nil 指针是一样的、不同类型的 nil 是不能比较的、相同类型的 nil 可能也无法比较）
wohu1104的专栏
05-08 1616
在 Go 语言中，布尔类型的零值（初始值）为 false ，数值类型的零值为 0，字符串类型的零值为空字符串 ""，而指针、切片、映射、通道、函数和接口的零值则是 nil 。 nil 是 Go 语言中一个预定义好的标识符，有过其他编程语言开发经验的开发者也许会把 nil 看作其他语言中的 null （ NULL ），其实这并不是完全正确的，因为 Go 语言中的 nil 和其他语言中的 nul...
go基础面试题汇总第一弹
最新发布
weixin_43683432的博客
10-01 805
通常作为程序执行前包的初始化，例如mysql redis 等中间件的初始化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值