Go语言入门教程-Go语言变量 - Go语言中文社区

Go语言入门教程-Go语言变量

文章目录


Golang

1. Go语言中的命名

1.1 命名规则

GO语言中的变量名、函数名、类型名、常量名、包名等等的命名都应该遵循一个基本的原则，那就是 命名应该是以一个英文字母或者一个下划线开头，后面可以跟任意数量的英文字母，数字和下划线，且区分字母大小写 ,命名尽量做到见名知意.

package main

import "fmt"

const PI float64  = 3.1415926
var 姓名 string = "张三"

func main(){
	name := "demo1"
	namE := "demo2"
	fmt.Println(PI)
	fmt.Println(姓名)
	fmt.Println(name)
	fmt.Println(namE)
}

输出

3.1415926
张三
demo1
demo2

我们可以看到Go语言中可以使用中文作为变量名,但是实际开发中没人这么做.

1.2 关键字

比较常见的编程语言中都有关键字,这些特定的关键字是在一些特定的语法中使用,不能滥用.Go语言中有25个关键字,关键字不能用于自定义名字

下面列举了 Go 代码中会使用到的 25 个关键字或保留字：

break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var

除了关键字还有一些内建常量,类型和函数,我们在自定义名称的时候也不要与他们重名

内建常量: 
    true false iota nil
内建类型: 
        int int8 int16 int32 int64
        uint uint8 uint16 uint32 uint64 uintptr
        float32 float64 complex128 complex64
        bool byte rune string error
内建函数: 
        make len cap new append copy close delete
        complex real imag
        panic recover

2. Go语言变量

2.1 什么是变量

高级编程语言编写的程序中,变量是组成程序的基本单位. 变量的作用是存储用户数据,就本质而言,变量相当于对一块数据存储空间的命名,程序通过定义一个变量在内存中申请一块数据存储空间,然后通过引用变量名来使用这块存储空间

我们能总结 变量 的关键要素 是 变量名,变量类型,变量值

2.2 变量的使用概述

1.声明变量

2.初始化变量

3.给变量赋值

4.使用变量

2.2.1 变量声明的基本语法

var 变量名 数据类型

package main

import (
	"fmt"
	"github.com/go-redis/redis"
)

var i int
var s string
var f float64
var v1 struct{
	cc int
}
var v2 *int
var v3 map[string]int
var v4 func(a int) int
var r *redis.Client

func main(){
	fmt.Printf("value = %vn",i)
	fmt.Printf("type = %T",s)
}

声明之后不赋值,那么就使用默认值

2.2.2 声明变量,并且赋值
package main

import (
	"fmt"
)

var v1 int = 99
var v2 string
var v3 float64
var v4 map[string]int

func main(){
	v2 = "Hi"
	v3  = 99.9
	v4 = map[string]int{"age":100}
	fmt.Printf("value = %vn",v1)
	fmt.Printf("type = %Tn",v1)
	fmt.Printf("value = %vn",v2)
	fmt.Printf("type = %Tn",v2)
	fmt.Printf("value = %vn",v3)
	fmt.Printf("type = %Tn",v3)
	fmt.Printf("value = %vn",v4)
	fmt.Printf("type = %Tn",v4)
}


value = 99
type = int
value = Hi
type = string
value = 99.9
type = float64
value = map[age:100]
type = map[string]int
2.2.3 多变量声明

既一次性声明多个变量

package main

import (
	"fmt"
)

var (
	v1 int = 99
	v2 string
	v3 float64
	v4 map[string]int
)

func main() {
	v2 = "Hi"
	v3 = 99.9
	v4 = map[string]int{"age": 100}
	fmt.Printf("value = %vn", v1)
	fmt.Printf("type = %Tn", v1)
	fmt.Printf("value = %vn", v2)
	fmt.Printf("type = %Tn", v2)
	fmt.Printf("value = %vn", v3)
	fmt.Printf("type = %Tn", v3)
	fmt.Printf("value = %vn", v4)
	fmt.Printf("type = %Tn", v4)
}


value = 99
type = int
value = Hi
type = string
value = 99.9
type = float64
value = map[age:100]
type = map[string]int
2.2.5 类型推导

根据值自动判断变量类型

package main

import (
	"fmt"
)

var (
	v1  = 99
	v2  = "golang"
)

func main() {
	fmt.Printf("value = %vn", v1)
	fmt.Printf("type = %Tn", v1)
	fmt.Printf("value = %vn", v2)
	fmt.Printf("type = %Tn", v2)
}


value = 99
type = int
value = golang
type = string
2.2.6 省略var的声明方式
package main

import (
	"fmt"
)

func main() {
	v3 := "hello world"
	fmt.Printf("value = %vn", v3)
	fmt.Printf("type = %Tn", v3)
	v3 = "hi world"
	fmt.Printf("value = %vn", v3)
	fmt.Printf("type = %Tn", v3)
}


value = hello world
type = string
value = hi world
type = string
2.2.7 全局变量

在函数外部声明的变量就是全局变量

package main

import (
	"fmt"
)
var (
	// 定义的全局变量
	v1  = 500
	v2  = "Monkey King"
)

func getInfo()  {
	// 函数内使用全局变量
	v1 = 999
	v2 = "one"
	fmt.Println(v1,v2)
}
func main() {
	v3 := "hello world"
	fmt.Printf("value = %vn", v3)
	fmt.Printf("type = %Tn", v3)
    // 在主函数中使用全局变量
	fmt.Println(v2)
    // 调用函数
	getInfo()
}


value = hello world
type = string
Monkey King
999 one
2.2.8 多变量赋值
package main

import "fmt"

var x int = 99
var y int = 88

func main() {
	fmt.Printf("x  = %vn",x)
	fmt.Printf("y  = %vn",y)
	// 交换变量值,也是多重赋值
	x,y = y,x
	fmt.Printf("x  = %vn",x)
	fmt.Printf("y  = %vn",y)
}


x  = 99
y  = 88
x  = 88
y  = 99

package main

import (
	"fmt"
)

// 给v3,v4,v5 赋值
var v3, v4, v5 = 100, "ddemo", map[string]int{"name": 99}

func main() {

	fmt.Printf("value = %vn", v5)
	fmt.Printf("type = %Tn", v5)
}
2.2.9 匿名变量

我们在调用一个函数的时为了获取某一个值,却因为函数返回多个值而不得不定义一些无意义的变量,可以使用匿名变量避免这种情况

package main

import (
	"fmt"
)

func getName()(firstname,lastname,nickname string){
	return "king","pick","tom"
}
func main() {

	// _(下划线)可以看作是特殊的变量名,赋予他的值都会丢弃
	_, i, j, _ := 10, 20, 30, 40
	fmt.Println(i, j)
    // 只需要获取昵称
	_,_,nickname := getName()
	fmt.Println("my name is",nickname)

}



20 30
my name is tom
2.2.10 变量重名

变量在同一作用域(同一函数或者代码块中)不能重名

package main

import "fmt"

var v1 string
func main() {
	v1 = "captain"
	fmt.Println(v1)
	v1 := "tom"
	fmt.Println(v1)
	v1 := "red" //与上一个v1重名了
	fmt.Println(v1)
}

3. 变量默认值

Go语言如果声明了变量,但是没有赋值,那么编译器会使用默认值,变量类型不同, 默认值也是不同的

package main

import "fmt"

var v1 int
var v2 int8
var v3 int16
var v4 float32
var v5 float64
var v6 string
var v7 bool
var v8 complex64
var v9 complex128
var v10 error
var v11 interface{}
func main() {
	fmt.Printf("v1 = %vn",v1)
	fmt.Printf("v2 = %vn",v2)
	fmt.Printf("v3 = %vn",v3)
	fmt.Printf("v4 = %vn",v4)
	fmt.Printf("v5 = %vn",v5)
	fmt.Printf("v6 = %vn",v6)
	fmt.Printf("v7 = %vn",v7)
	fmt.Printf("v8 = %vn",v8)
	fmt.Printf("v9 = %vn",v9)
	fmt.Printf("v10 = %vn",v10)
	fmt.Printf("v11 = %vn",v11)
}


v1 = 0
v2 = 0
v3 = 0
v4 = 0
v5 = 0
v6 = 
v7 = false
v8 = (0+0i)
v9 = (0+0i)
v10 = <nil>
v11 = <nil>

3. GO语言常量

在Go语言中，常量是指编译期间就已知且不可改变的值。常量可以是数值类型（包括整型、
浮点型和复数类型）、布尔类型、字符串类型等

3.1 常量的定义

GO语言中通过关键字 const 定义一个常量

package main

import "fmt"

const OS = "Linux"
const HOST = "127.0.0.1"
const(
	MEMORY = 32
	zero = 0.0
)
const a,b,c = "A","B","C"

func main() {
	fmt.Printf("type = %Tn",OS)
	fmt.Printf("value = %vn",OS)
}


type = string
value = Linux

3.2 iota枚举

iota 被认为是一个可以被编译器修改的常量,在每个const 关键字出现时被重置为0 ,在下一次出现const出现之前,每出现一次iota,其所代表的数字都会自动加1,我们也可以将iota描述为是GO语言中的常量计数器,只能在常量表达式中使用

package main

import "fmt"

const(
	x = iota 	// iota = 0       0
	y = iota	// iota + 1 = 1   1
	z = iota	// iota + 1 = 2	  2
	v       	// 隐式 v= iota    3

)
const(
	a,b,c = iota,iota,iota		//iota在同一行所有值相同 都是0
)
const w = iota // 遇见const iota重置为0
const(
	x1 = iota*2
	y1 = iota*2
	z1 = iota*2
	v1 = iota*2
)
const(
	d  = iota
	e  = "e"
	f  = iota
	g
	h,i,j = iota,iota,iota

)
func main() {
	fmt.Println(x,y,z,v)
	fmt.Println(a,b,c)
	fmt.Println(w)
	fmt.Println(x1,y1,z1,v1)
	fmt.Println(d,e,f,g,h,i,j)
}


0 1 2 3
0 0 0
0
0 2 4 6
0 e 2 3 4 4 4

package main

import "fmt"

const(
	_ = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
	Sunday
)
func main(){
	fmt.Println(Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday)
}


1 2 3 4 5 6 7

4. 变量作用域

函数内部声明和定义的变量叫做 局部变量 ,作用域仅限于 该函数内部

函数外部声明和定义的变量叫做 全局变量 , 作用域在整个包内都有效 ,如果首字母大写那么在整个程序都有效

  • 变量首字母大写,则该变量可见性最高
package main

import "fmt"

// 声明一个全局变量 globalP
var globalP int
func demo1(){
	//使用全局变量
	globalP = 66
	fmt.Println(globalP)
}
func main()  {
	// 声明一个局部变量 part
	var part int
	// 只能在定义的函数内部使用
	part = 99
	fmt.Println(part)
	//包内都可用
	globalP = 55
	fmt.Println(globalP)
	demo1()

}

99
55
66
版权声明：本文来源CSDN，感谢博主原创文章，遵循 CC 4.0 by-sa 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/weixin_37717557/article/details/102872197
站方申明：本站部分内容来自社区用户分享，若涉及侵权，请联系站方删除。

你可能感兴趣的文章

精选的优质文章

0 条评论

请先 登录 后评论

官方社群

GO教程

推荐文章

猜你喜欢

随便看看

来源51CTO

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！