Golang基础-1

关注

原创最新推荐文章于 2026-08-29 10:10:03 发布 625 阅读 AI 写同款· GEO 优化 ›

人大金仓数据库Kingbase FlySync同步程序安装 Kingbase FlySync同步程序（以下简称 KFS）是面向异地容灾、数据集中共享的场景推出的具备在异构数据平台间实现实时、增量数据同步的工具类产品，主要采用了物理日志解析技术，帮助用户解决不同数据平台的数据间可实现任意方向实时移动流转的问题，并保证此过程中数据不丢失，状态可监控，流转数据量可统计。KFS 需要安装的主要组件有 2 个，分别是后端同步程序和管理控制平台，另外KFS的部署方式也有2种，为分离部署何集中部署•集中部署：KFS与数据库部署在同一机器上。阅读详情

Go语言基础

介绍

介绍

本文介绍Go语言中变量命名规则、变量使用、变量的数据类型、枚举类型等相关知识。

基础

1. 变量命名规则

变量名称必须以字母或下划线开始，后面可以跟任意数量的字母、数字或下划线，且变量名称区分大小写。
不能使用保留关键字作为变量名。
变量的命名一般遵循驼峰命名法（Camel Case）或者短横线分隔命名法（snake_case）。

驼峰命名法：
首单词首字母小写，后面的单词首字母大写（也称为驼峰式大小写或者驼峰记法），如：myName。
短横线分隔命名法：
所有字母都是小写，单词之间用短横线分隔，如：my-name。

var myName string         // 驼峰命名法
var my_name string        // 短横线分隔命名法
var user_id int           // 短横线分隔命名法，常用于导出变量
var userID int            // 驼峰命名法，常用于导出变量
const MaxConnections = 10 // 导出常量，驼峰命名法

2. 变量的使用

变量基本使用示例

package main

import (
	"fmt"
)

// 全局变量,
var g1 int = 10

func main() {
	fmt.Println("----------局部变量----------")
	// 变量定义、赋值
	var age int8 = 18
	fmt.Println(age)

	// 变量定义，使用默认初始值
	var age2 int
	fmt.Println(age2)

	/*
		// go1.22版本报错，should merge variable declaration with assignment on next line (S1021)
		var age3 int
		age3 = 20
		fmt.Println(age3)
	*/

	// 变量定义、使用、赋值
	var age3 int
	fmt.Println(age3)
	age3 = 20
	fmt.Println(age3)

	// 变量类型自动推导
	var age4 = 30
	fmt.Println(age4)

	// 短变量定义，自动类型推导
	age5 := 40
	fmt.Println(age5)

	// 定义多个变量，使用默认初始化
	var n1, n2, n3 int
	fmt.Println(n1, ", ", n2, ", ", n3)

	// 定义多个变量，同时初始化，自动推导类型
	var m1, m2, m3 = 12, "MMM", 54
	fmt.Println(m1, ", ", m2, ", ", m3)

	// 短变量定义多个变量，自动推导类型
	s1, s2, s3 := 12, "MMM", 54
	fmt.Println(s1, ", ", s2, ", ", s3)

	// 定义多个变量，多用于全局变量
	var (
		v1 int
		v2 string
	)

	v1 = 16
	v2 = "4545"

	fmt.Println(v1, ", ", v2)

	// 常量，值不可改变
	const c1 int = 18
	fmt.Println(c1)
	// c1 = 10, 错误：cannot assign to c1 (neither addressable nor a map index expression) (compile)

	fmt.Println("----------全局变量----------")

	// 打印全局变量
	fmt.Println(g1)
}

一些注意事项
|- 变量赋值时类型不匹配会报错；变量声明后不使用会报错；变量重复声明会报错；
|- 全局变量名称首字母大写可导出包，供其它包使用。

3. 变量数据类型

大类型分为基本数据类型和复杂数据类型。
基本数据类型：

类型名称	描述
整型	int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,byte,rune
浮点型	float32,float64
字符型	使用byte保存单个字符
布尔型	bool
字符串	string

package main

import (
	"fmt"
	"math"
	"reflect"
)

func main() {
	var age0 int = 18
	fmt.Println(reflect.TypeOf(age0), math.MinInt, " ~ ", math.MaxInt)
	var age1 int8 = 18
	fmt.Println(reflect.TypeOf(age1), math.MinInt8, " ~ ", math.MaxInt8)
	var age2 int16 = 18
	fmt.Println(reflect.TypeOf(age2), math.MinInt16, " ~ ", math.MaxInt16)
	var age3 int32 = 18
	fmt.Println(reflect.TypeOf(age3), math.MinInt32, " ~ ", math.MaxInt32)
	var age4 int64 = 18
	fmt.Println(reflect.TypeOf(age4), math.MinInt64, " ~ ", math.MaxInt64)

	var age5 uint = 18
	fmt.Println(reflect.TypeOf(age5), 0, " ~ ", uint(math.MaxUint))
	var age6 uint8 = 18
	fmt.Println(reflect.TypeOf(age6), 0, " ~ ", math.MaxUint8)
	var age7 uint16 = 18
	fmt.Println(reflect.TypeOf(age7), 0, " ~ ", math.MaxUint16)
	var age8 uint32 = 18
	fmt.Println(reflect.TypeOf(age8), 0, " ~ ", math.MaxUint32)
	var age9 uint64 = 18
	fmt.Println(reflect.TypeOf(age9), 0, " ~ ", uint64(math.MaxUint64))
    var n0 float32 = 18.16
	fmt.Println(reflect.TypeOf(n0), math.SmallestNonzeroFloat32, " ~ ", math.MaxFloat32)
	var n1 float64 = 18.1616262626262626262
	fmt.Println(reflect.TypeOf(n1), math.SmallestNonzeroFloat64, " ~ ", math.MaxFloat64)
}

类型	范围
int	-9223372036854775808 ~ 9223372036854775807
int8	-128 ~ 127
int16	-32768 ~ 32767
int32	-2147483648 ~ 2147483647
int64	-9223372036854775808 ~ 9223372036854775807
uint	0 ~ 18446744073709551615
uint8	0 ~ 255
uint16	0 ~ 65535
uint32	0 ~ 4294967295
uint64	0 ~ 18446744073709551615
float32	1.401298464324817e-45 ~ 3.4028234663852886e+38
float64	5e-324 ~ 1.7976931348623157e+308

复杂数据类型：

类型名称	描述
指针	指向某内存块， (var ptr *int)
数组	一段连续的内存块，(var arr [10]int)
结构体	定义了一种数据的布局，(type Test struct{})
管道	语言层面提供的协程通信方式，(var ch chan int)
函数	为完成某一功能的程序指令（语句）的集合，(func Sums(a int, b int) int {// TODO…})
切片	对数组的一个连续片段的引用，(var s []int)
接口	接口类型就是一组方法的集合，(type Shape interface{// TODO…})
map	一种无序的键值对的集合，(var mp map[string]int)

4. 枚举类型

Go语言没有内置枚举类型，需要通过其它方式实现类似枚举类型的功能
自定义枚举值：

func TestEnum() {
	const (
		kEqual = 0
		kGreator
		kLess
	)
	a := 10
	b := 20
	if a > b {
		fmt.Println(kGreator)
	} else if a == b {
		fmt.Println(kEqual)
	} else {
		fmt.Println(kLess)
	}
}

自增枚举值：

func TestEnum() {
	const (
		kEqual = iota
		kGreator
		kLess
	)

	a := 10
	b := 20
	if a > b {
		fmt.Println(kGreator)
	} else if a == b {
		fmt.Println(kEqual)
	} else {
		fmt.Println(kLess)
	}
}

iota用法：

func TestIota() {
	// 只能在常量的表达式中使用
	// fmt.Println(iota) //错误，cannot use iota outside constant declaration (compile)

	// 默认值为 0，在const中每增加一行，值加 1
	const (
		a = iota //0
		b        //1
		c        //2
	)
	fmt.Printf("a=%d  b=%d  c=%d\n", a, b, c)

	// 多个 const出现时，每次 const 都会使 iota 值初始化为0
	const d = iota // a=0
	const (
		e = iota //b=0
		f        //c=1
	)
	fmt.Printf("d=%d  e=%d  f=%d\n", d, e, f)

	// 如果中断 iota，必须显式指定 iota 恢复，中断后其后边的值将保存最后一次指定的值
	const (
		Low    = iota //0
		Medium        //1
		High   = 100  //100
		Super         //100
		Band   = iota //4
	)
	fmt.Printf("Low=%d  Medium=%d  High=%d  Super=%d  Band=%d\n", Low, Medium, High, Super, Band)

	// 如果是同一行，不管多少 iota，其值都一样
	const (
		i          = iota             // 0
		j1, j2, j3 = iota, iota, iota // 1
		k          = iota             // 2
	)
	fmt.Printf("i=%d  j1=%d  j2=%d  j3=%d  k=%d\n", i, j1, j2, j3, k)

	// iota 值可以被忽略
	const (
		k1 = iota // 0
		k2        // 1
		_         // 2
		_         // 3
		k3        // 4
	)
	fmt.Printf("k1=%d  k2=%d  k3=%d \n", k1, k2, k3)

	// 在中间插入一个值
	const (
		Sun = iota // 0
		Mon        // 1
		Tue = 7    // 7
		Thu = iota // 3
		Fri        // 4
	)
	fmt.Printf("Sun=%d  Mon=%d  Tue=%d  Thu=%d  Fri=%d\n", Sun, Mon, Tue, Thu, Fri)
}

起始