Golang基础-1

无夜_

于 2024-03-25 16:57:10 发布

阅读量441

点赞数 5

分类专栏： Golang 文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/TimerSea/article/details/137019207

版权

Golang 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文详细介绍了Go语言的基础概念，包括变量命名规则、变量的使用、数据类型（包括基本类型如整数、浮点数和字符，以及复杂类型如指针、数组、结构体等）、枚举类型的替代实现方法。

摘要由CSDN通过智能技术生成

Go语言基础

介绍

基础

1. 变量命名规则
2. 变量的使用
3. 变量数据类型
4. 枚举类型

介绍

本文介绍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)
}

起始