Go语言基础之变量Go语言基础之变量

Go语言基础之变量

前言

Hey，大家好呀，我是星期八，这次咱们继续学习Go基础之变量叭。

变量

为什么需要变量

简单点说，我们写的程序默认数据都是保存在内存条中的，我们不可能直接通过地址找到这个变量，因为地址太长了，而且不容易记。

通常我们是通过变量名找到对应的地址上面的值，再进行一系列操作。

变量类型

现在不管是什么语言，常用的变量分为以下类型。

• 整数，1，6，2，8，4...
• 浮点数，1.1，5.7767，23.99...
• 布尔型，真，假
• 字符串类型，"张三"，"李四"...
• List
• Map

大概会分为以上几种类型，不过这个不用记，了解就好。

变量定义

声明变量

格式如下。

var 变量名 变量类型
例如:
var age int
var gender bool

批量声明

上面声明变量是一个一个声明的，如果需要一次性声明一些变量，可以这样写。

var (
	age int
	gender bool
	name string
	id int
	height int
	...
)

声明时赋值

上述方式，只是声明了变量，但是并没有赋值，在后期需要时可以在赋值。

如果在声明时，就确定值是什么，可以直接赋值。

格式如下。

var 变量名 类型 = 值
例如:
var age int = 18
var name string = "张三"

在Go中的一个强制要求

在Go中，变量必须使用，至少需要fmt.Println(变量)。

类型推导方式声明变量赋值

在上述声明变量并且赋值时，还需要指定变量类型。

在Go，Go具有类型推导方式声明时赋值变量。

var age = 18
var name = "张三"

其实就是变量名后面不用写变量类型了。

:=方式变量赋值

在Go，还有一种更简单的方式声明变量赋值。

格式如下。

age := 18
name := "张三"

学过Python的可能有点开心了，除了多个一个:号，其他基本和Pyton定义变量方式一样。

注意:

age := 18 //本质是执行的两句话
//同上
var age int
age = 18

全局变量

简单说就是，在最外面的定义的变量就是全局变量。

在Go中，全局变量是有要求的。

package main

//全局变量:
// 方式一，声明全局变量，必须跟类型
//var age int

//方式二，声明变量且赋值，类型可以不用写
//var age  = 18
//var age  int = 18

//方式三，错误示例，全局变量要么只声明变量，要么声明就赋值
//var age int
//age =18

//方式四，错误示例，:=方式声明赋值
// 方式四其实就等于方式三的写法，所以不能用在全局变量中
//age := 18

func main() {

}

PS:全局变量要么只声明，要么声明时就赋值，不能写两行赋值，所以:=方式不能应用在全局变量中

匿名变量

匿名变量多用于函数返回值场景中，比如函数返回了俩值，俩值要第一个值，就可以使用匿名变量。

因为Go中，变量必须使用，如果某个变量需要忽略，使用_即可。

值得注意的是，匿名变量不会占用内存。

package main

func get_info() (string， int) {
	return "张三"， 18
}
func main() {
	//标准写法
	//name， age := get_info()
	//fmt.Println(name， age)
	
	//匿名变量方式
	//name， _ := get_info()
	//fmt.Println(name)
	
	//_，age := get_info()
	//fmt.Println(age)
}

常量

其实常量和变量基本一样，但是常量是不能修改的。

通常常量以大写定义。

package main

import "fmt"

func main() {
    //单个声明
	const PI1 int = 3
	const PI2 = 3.14
	//同时声明多个
	const (
		PI3 = 3.14
		PI4 = 3.14
	)
	//同上声明多个变量时，如果省略了值表示和上一行相同
	const (
		girl1 = 18
		girl2 // 18，和上一行相同
		girl3 // 18，和上一行相同
		girl4 = 17
		girl5 // 17，和上一行相同

	)
	fmt.Println(girl3， girl5)
}

注:常量声明时就必须赋值

错误示例。

package main

func main() {
	const age int
	age = 18
    //error
}

iota

iota是Go中的一个常量计数器，只能在跟常量(const)一块使用。

我们先来理解这一段话。

iota在const关键字出现时将被重置为0
const中每新增一行常量，iota将计数(+1)一次

示例1:

package main

import "fmt"

func main() {
	const (
		n1 = iota //在const关键字出现时将被重置为0
		n2        //没写相当于写了个n2=iota，每新增一行常量iota计数(+1)一次，n2 = 1
		n3        //同上 n3 = 2
		n4        // 同上 n4 = 3
	)
	fmt.Println(n1， n2， n3， n4)
}

示例2:

遇到_会是什么情况。

package main

import "fmt"

func main() {
	const (
		n1 = iota //在const关键字出现时将被重置为0
		n2        // n2=1
		_         //匿名变量，相当于写了个 _=iota，所以此时iota=2
		n4        //n4=3
	)
	fmt.Println(n1， n2， n4)
}

示例3:

一行多个iota。

package main

import "fmt"

func main() {
	const (
		a， b = iota + 1， iota + 2 //在const关键字出现时，iota=0，并且两次赋值在同一行，iota没有做+1
		c， d                      //同理，新增一行常量，常量个数为俩，仍然是一行，所以iota=1
		//c， d = iota + 1， iota + 2 同上，此时iota=1，c=2，d=3
		e， f // 同理，同上，e=3，f=4
	)
	fmt.Println(a， b， c， d， e， f)
}

整型

整数，很简单了，就是像1，2，3，7，11，..这样的整型数字了。

但是在Go中，整数分为两大类，正整数和没有符号的整数。

u开头的不能存负数

类型	描述
uint8	无符号 8位整型 (0 到 255)
uint16	无符号 16位整型 (0 到 65535)
uint32	无符号 32位整型 (0 到 4294967295)
uint64	无符号 64位整型 (0 到 18446744073709551615)
int8	有符号 8位整型 (-128 到 127)
int16	有符号 16位整型 (-32768 到 32767)
int32	有符号 32位整型 (-2147483648 到 2147483647)
int64	有符号 64位整型 (-9223372036854775808 到 9223372036854775807)

在不同平台上的差异。

类型	描述
uint	32位操作系统上就是uint32，64位操作系统上就是uint64
int	32位操作系统上就是int32，64位操作系统上就是int64
uintptr	无符号整型，用于存放一个指针

示例:

package main

import "fmt"

func main() {
	var a = 10             //定义一个十进制数
	fmt.Printf("%Tn"， a)  //功能:打印变量类型，结果:默认为int类型，也叫int64
	fmt.Printf("%d n"， a) //功能:十进制输出，结果:10
	fmt.Printf("%b n"， a) //功能:二进制输出，结果:1010
	fmt.Printf("%o n"， a) //功能:二进制输出，结果:12

	var b = 0b1010011010  //定义一个二进制数1010011010，以0b开头
	fmt.Printf("%dn"， b) //结果:666

	var c = 077           //定义一个八进制数77
	fmt.Printf("%dn"， c) //结果:63
	var d = 0x42          //定义一个十六进制42
	fmt.Printf("%dn"， d) //结果:66
}

浮点型

在Go中，只有float32和float64，默认使用的是float64。

示例:

package main

import "fmt"

func main() {
	var a = 1.21          //默认为float64
	fmt.Printf("%Tn"， a) //结果:float64
	fmt.Printf("%fn"，a)//功能:输出浮点型数，结果:1.210000
	fmt.Printf("%.1fn"，a)//功能:输出浮点型数，保留小数点一位，其他忽略，结果:1.2
	fmt.Printf("%.2fn"，a)//功能:输出浮点型数，保留小数点二位，其他忽略，结果:1.21
}

布尔值

在Go中，bool类型就俩值，true和false。

无示例。

注:

1. bool类型默认值为false。

2. true != 1，在Go中，bool类型和整型不能混用。

字符串

终于到字符串了，在Go中，字符串是基本数据类型，在栈中存储。

字符串的值为双引号("")中的内容。

示例:

package main

import "fmt"

func main() {
	var name = "hello"
	var name2 = "张三"
	fmt.Println(name，name2)
}

在Go中，字符串内存布局如下。

其实在Go中，字符串的本质就是一个个的字符拼接成的。

多行字符串

有时候我们可能需要一个长篇大论，需要很长的字符串，这时候我们需要用到`号。

package main

import "fmt"

func main() {
	var lyric = `
		昨夜同门云集bai 推杯又换盏
		今朝du茶凉酒寒 豪言成笑谈
		半生累 尽徒然zhi 碑文完美有谁看dao
		隐居山水之间 誓与浮名散
		湖畔青石板上 一把油纸伞
	`
	fmt.Println(lyric)
}

字符串常用操作

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix，strings.HasSuffix	前缀/后缀判断
strings.Index()，strings.LastIndex()	子串出现的位置
strings.Join(a[]string， sep string)	join操作

示例代码

package main

func main() {
	//len() 求字符串字节长度
	//var name = "你好，世界"
	//fmt.Println(len(name)) //因为中文是utf8，一个文字三个字节，再加一个，号，所以是13

	//fmt.Sprintf 或 + 拼接字符串
	//name1 := "张"
	//name2 := "三"
	//name :=name1 + name2 //拼接字符串
	//fmt.Println(name)
	//name := fmt.Sprintf("%s%s"， name1， name2)//同上，不过这种更灵活，推荐
	//name := fmt.Sprintf("我的姓名是:%s%s"， name1， name2)//自定义拼接
	//fmt.Println(name)

	//strings.Split 分割字符串
	//name := "张三|18|男|法外狂徒"
	//info := strings.Split(name， "|")
	//fmt.Println(info) //返回的是切片，[张三 18 男 法外狂徒]

	//strings.contains 是否包含
	//name := "张三666"
	//result := strings.Contains(name， "6")
	//fmt.Println(result) //返回的是bool类型，true

	//strings.HasPrefix 判断前缀(是不是以什么开头)
	//name := "web/student/xxx.html"
	//result := strings.HasPrefix(name， "web")
	//fmt.Println(result) //true

	//strings.HasSuffix 判断后缀(是不是以什么结尾)
	//name := "web/student/xxx.html"
	//result := strings.HasSuffix(name， "html")
	//fmt.Println(result)//true

	//strings.Index() 返回第一个字符串出现的位置
	//name := "hello world"
	//index := strings.Index(name， "o")
	//fmt.Println(index) //4

	//strings.LastIndex() // 正向数，返回最后一个字符串出现的位置
	//name := "hello world"
	//index := strings.LastIndex(name， "o")
	//fmt.Println(index) // 7

	//strings.Join(a[]string， sep string) 字符串拼接
	//info_list := []string{"张三"， "男"， "18"} //定义一个列表
	//name := strings.Join(info_list， "|")
	//fmt.Println(name) //张三|男|18
}

上文之字符串回顾

在上述文章中，我们学过了字符串类型。

在Go语言中，字符串类型是基本类型，在栈中存储，其结构如下。

可以看到，在Go中，字符串其实就是指向了一个连续的内存地址，并且记录了长度，读取是一次性读取出来的。

那么，如上图所示，内存里面存的一个个字母叫啥呢？？？

byte和rune类型

字符串是一个个字符拼接成的，反过来，也是一个个字符拼接成的字符串，而一个个的字符，就被称为字节(byte)

字节占用1个字节大小，只能存字母了，标点符号之类的，不能存中文。

当然，存中文怎么办???在Go中有一个rune，和byte类似，本质和byte一样，只不过rune一个占用4个字节

rune使用utf-8编码，可以存中文，各种语言。

所以，处理中文尽量用rune类型。

定义个(字节)byte类型变量

字符用单引号'号包裹起来。

代码

package main

import "fmt"

func main() {
	var a byte = 'a'
	fmt.Println(a)
}

小朋友，是否有很多疑问???为什么是97

原因

byte代表的是一个ASCII码的一个字符，同理，rune可以理解为是byte的一个超集，向下兼容byte。

package main

import "fmt"

func main() {
	var a rune = 'a'
	fmt.Println(a)
}

结果:

但是rune里面可以写中文，byte不行。

byte不能存中文

rune可以存中文

发现了吗，打印的竟然是一个数字?这是为啥？？？

就拿字母a来说，其实打印的是ASCII对应的数字，打印的是他的十进制。

同理，字符张也是，这里就不做例子了，因为utf-8表太大了。

遍历字符串

方式一

package main

import "fmt"

func main() {
	s := "我是法外狂徒，张三，hahaha"
	for _， r := range s {
		fmt.Printf("%c n"，r)
	}
}

方式二

package main

import "fmt"

func main() {
	s := "我是法外狂徒，张三，hahaha"
	for i := 0; i < len(s); i++ {
		//中文会乱码，不推荐
		fmt.Printf("%c n"，s[i])
	}
}

修改字符串

同理，字符串相当于是字节列表组成的，是不能直接修改的，想要直接修改需要打散成字节列表才行。

package main

import "fmt"

func main() {
	//只有英文的情况下
	s1 := "hello world"
	var s1_byte_list = []byte(s1) //打散成字符列表
	s1_byte_list[6] = 'F'         //修改下表为6的字符为F
	s1 = string(s1_byte_list)     //打散的字符列表在组装成字符串
	fmt.Println(s1)               //输出 hello 6orld

	//带有中文的情况
	s2 := "天空好像下雨，我好像住你隔壁vay"
	var s2_rune_list = []rune(s2) //打散成utf-8字符列表
	s2_rune_list[5] = '雪'         //修改下表为5的字符为雪
	s2 = string(s2_rune_list)     //打散的utf8字符转字符串
	fmt.Println(s2)               //输出 天空好像下雪，我好像住你隔壁
}

总结

我是码农星期八，如果觉得还不错，记得动手点赞以下哈。

感谢你的观看。

最后

以上就是花痴小白菜为你收集整理的Go语言基础之变量Go语言基础之变量的全部内容，希望文章能够帮你解决Go语言基础之变量Go语言基础之变量所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。