【GO】基础篇02--变量和常量

「已注销」

已于 2023-10-24 09:27:12 修改

阅读量31

点赞数

分类专栏： # go 文章标签： 1024程序员节 golang

于 2023-10-24 09:26:27 首次发布

本文链接：https://blog.csdn.net/weixin_57451673/article/details/134004309

版权

go 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1、变量

1.1 声明变量

var名称类型是声明单个变量的语法。

以字母或下划线开头，由一个或多个字母、数字、下划线组成

声明一个变量

第一种，指定变量类型，声明后若不赋值，使用默认值

var name type
name = value

第二种，根据值自行判定变量类型(类型推断Type inference)

如果一个变量有一个初始值，Go将自动能够使用初始值来推断该变量的类型。因此，如果变量具有初始值，则可以省略变量声明中的类型。

var name = value

第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时，至少保证一个是新变量)，否则会导致编译错误(简短声明)

这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值
name := value

// 例如
var a int = 10
var b = 10
c : = 10

e.g:

package main

import "fmt"

func main() {
	// 基本数据类型
	var a int = 10 // 整型
	var b float64 = 3.14 // 浮点型
	var c bool = true // 布尔型
	var d string = "Hello Go!" // 字符串类型

	fmt.Println("Integer:", a)
	fmt.Println("Float:", b)
	fmt.Println("Boolean:", c)
	fmt.Println("String:", d)

	// 引用类型
	var e []int // 切片类型
	e = []int{1, 2, 3}
	fmt.Println("Slice:", e)

	var f map[string]int // 映射类型
	f = map[string]int{"a": 1, "b": 2, "c": 3}
	fmt.Println("Map:", f)

	var g chan int // 通道类型
	g = make(chan int)
	fmt.Println("Channel:", g)

	var h func(int) int // 函数类型
	h = func(x int) int {
		return x * 2
	}
	fmt.Println("Function:", h)

	var i *int // 指针类型
	num := 42
	i = &num
	fmt.Println("Pointer:", *i)
}

1.2 多变量声明

第一种，以逗号分隔，声明与赋值分开，若不赋值，存在默认值

var name1, name2, name3 type
name1, name2, name3 = v1, v2, v3

第二种，直接赋值，下面的变量类型可以是不同的类型

var name1, name2, name3 = v1, v2, v3

第三种，集合类型

var (
    name1 type1
    name2 type2
)

e.g:

package main

import "fmt"

func main() {
	// 第一种方式：逗号分隔的声明和赋值
	var name1, name2, name3 string
	name1, name2, name3 = "libin9iOak", "Bob", "Alice"

	// 第二种方式：直接赋值，类型可以不同
	var age1, age2, age3 = 20, 30, 40

	// 第三种方式：集合类型
	var (
		score1 int
		score2 int
	)
	score1, score2 = 99, 90

	// 输出变量的值
	fmt.Println("Name1:", name1)
	fmt.Println("Name2:", name2)
	fmt.Println("Name3:", name3)
	fmt.Println("Age1:", age1)
	fmt.Println("Age2:", age2)
	fmt.Println("Age3:", age3)
	fmt.Println("Score1:", score1)
	fmt.Println("Score2:", score2)
}

1.3 注意：

变量必须先定义才能使用
go语言是静态语言，要求变量的类型和赋值的类型必须一致。
变量名不能冲突。(同一个作用于域内不能冲突)
简短定义方式，左边的变量名至少有一个是新的
简短定义方式，不能定义全局变量。
变量的零值。也叫默认值。
变量定义了就要使用，否则无法通过编译。

2、常量

2.1常量声明 constant

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

const identifier [type] = value

显式类型定义： const b string = "abc"
隐式类型定义： const b = "abc"

package main

import "fmt"

func main() {
	const LENGTH int = 10 // 声明一个名为LENGTH的常量，类型为int，值为10
	const WIDTH = 5       // 隐式类型定义的常量，类型会根据赋值自动推断

	var area int                    // 声明一个名为area的变量，类型为int
	const a, b, c = 1, false, "str" // 多重赋值的常量

	area = LENGTH * WIDTH // 计算面积
	fmt.Printf("面积为：%d\n", area)
	fmt.Println(a, b, c) // 打印多重赋值的常量
}

常量可以作为枚举，常量组

const (
    Unknown = 0
    Female = 1
    Male = 2
)

e.g:

package main

import "fmt"

func main() {
	const (
		Unknown = 0 // 未知
		Female  = 1 // 女性
		Male    = 2 // 男性
	)

	fmt.Println(Unknown, Female, Male)

	const (
		x uint16  = 16 // 声明一个类型为uint16的常量x，值为16
		y              // 与上一行的非空常量右值相同类型和值，即uint16类型的16
		s = "abc"      // 声明一个类型为string的常量s，值为"abc"
		z              // 与上一行的非空常量右值相同类型和值，即string类型的"abc"
		f              // 与上一行的非空常量右值相同类型和值，即string类型的"abc"
	)

	fmt.Printf("%T, %v\n", y, y) // 打印y的类型和值
	fmt.Printf("%T, %v\n", z, z) // 打印z的类型和值
	fmt.Printf("%T, %v\n", f, f) // 打印f的类型和值
}

2.2 iota

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

iota 可以被用作枚举值：

const (
    a = iota
    b = iota
    c = iota
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

const (
    a = iota
    b
    c
)

用法：

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)
}

以上示例展示了iota的枚举值和用法，以及使用中断和恢复iota计数。请注意，iota在每个const块中都是独立计数的，且后续自增值按行序递增。此外，iota的类型默认为int，可以根据需要显式指定类型。

希望这样的解释能够帮助您理解iota的概念和用法。

如果中断iota自增，则必须显式恢复。且后续自增值按行序递增

自增默认是int类型，可以自行进行显示指定类型

数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址.