Go之路二:基本语法(变量常量和数据类型)

Posted 中國颜值的半壁江山

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Go之路二:基本语法(变量常量和数据类型)相关的知识,希望对你有一定的参考价值。

函数外只能放置标识符(变量、常量、函数、类型)的声明,如
fmt.Println(“人生苦短,我用Python!”)
不能直接写在任意的位置,必须放置在函数中,python等就可以

package main // 声明 main 包,表明当前是一个可执行程序

import "fmt" // 导入内置 fmt 包

func main() { // main函数,是程序执行的入口
    fmt.Println("人生苦短,我用Python!") // 只能写在这个函数里,放在函数外部就是非法的
}

博客地址:https://www.liwenzhou.com/posts/Go/01_var_and_const/

1、标识符与关键字

在编程语言中标识符就是程序员定义的具有特殊意义的词,比如变量名、常量名、函数名等等。 Go语言中标识符由字母数字和_(下划线)组成,并且只能以字母和下划线开头。 举几个例子:abc__123a123

2、关键字

关键字是指编程语言中预先定义好的具有特殊含义的标识符。 关键字和保留字都不建议用作变量名。

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

此外,Go语言中还有37个保留字。

    Constants:    true  false  iota  nil

        Types:    int  int8  int16  int32  int64  
                  uint  uint8  uint16  uint32  uint64  uintptr
                  float32  float64  complex128  complex64
                  bool  byte  rune  string  error

    Functions:   make  len  cap  new  append  copy  close  delete
                 complex  real  imag
                 panic  recover

3、变量

3.1、变量类型

变量(Variable)的功能是存储数据。不同的变量保存的数据类型可能会不一样。经过半个多世纪的发展,编程语言已经基本形成了一套固定的类型,常见变量的数据类型有:整型、浮点型、布尔型等。

Go语言中的每一个变量都有自己的类型,并且变量必须经过声明才能开始使用。

3.2、变量声明

Go语言中的变量需要声明后才能使用,同一作用域内不支持重复声明。 并且Go语言的变量声明后必须使用。

标准声明

Go语言的变量声明格式为:

var 变量名 变量类型

变量声明以关键字var开头,变量类型放在变量的后面,行尾无需分号。 举个例子:

var name string		//字符串类型 
var age int			//整形
var isOk bool		//布尔型

批量声明

每声明一个变量就需要写var关键字会比较繁琐,go语言中还支持批量变量声明:

var (
    a string
    b int
    c bool
    d float32
)

3.3、变量的初始化

Go语言在声明变量的时候,会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值,例如: 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false。 切片、函数、指针变量的默认为nil

当然我们也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下:

举个例子:

var name string = "Lishang"
var age int = 18

或者一次初始化多个变量

var name, age = "shangge", 18

3.4、类型推导

有时候我们会将变量的类型省略,这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

var name = "Lishang"
var age = 18

3.5、短变量声明

在函数内部,可以使用更简略的 := 方式声明并初始化变量。

package main

import "fmt"

var m = 100				// 全局变量m

func main() {
	n := 10
	m := 100			// 此处为局部变量m,局部变量声明后必须使用
	fmt.Println(n, m)	
}

3.6、匿名变量

在使用多重赋值时,如果想要忽略某个值,可以使用匿名变量(anonymous variable)。 匿名变量用一个下划线_示,例如:

func foo() (int, string) {
	return 10, "Q1mi"
}
func main() {
	x, _ := foo()
	_, y := foo()
	fmt.Println("x=", x)
	fmt.Println("y=", y)
}

匿名变量不占用命名空间,不会分配内存,所以匿名变量之间不存在重复声明。 (在Lua等编程语言里,匿名变量也被叫做哑元变量。)

注意事项:

  • 函数外的每个语句都必须以关键字开始(funcvarconst等)
  • :_不能用在函数外面
  • _多用于占位,表示想忽略这个值

4、常量

相对于变量,常量是恒定不变的值,多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似,只是把var换成了const,常量在定义的时候必须赋值。

const pi = 3.1415
const e = 2.7182

声明了pie这两个常量之后,在整个程序运行期间它们的值都不能再发生变化了。

多个常量也可以一起声明:

const (
	pi = 3.141592657
    e = 2.7182
)

const同时声明多个常量时,如果省略了值则表示和上面一行的值相同。 例如:

const (
    n1 = 100
    n2
    n3
)

4.1、常量的计数器iota

iota是go语言的常量计数器,只能在常量的表达式中使用。

iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义,在定义枚举时很有用。

举个例子:

const (
		n1 = iota //0
		n2        //1
		n3        //2
		n4        //3
	)

几个常见的iota示例:

使用_跳过某些值

const (
		n1 = iota //0
		n2        //1
		_
		n4        //3
	)

iota声明中间插队

const (
		n1 = iota //0
		n2 = 100  //100
		n3 = iota //2
		n4        //3
	)
	const n5 = iota //0

定义数量级 (这里的<<表示左移操作,1<<10表示将1的二进制表示向左移10位,也就是由1变成了10000000000,也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位,也就是由10变成了1000,也就是十进制的8。)

const (
		_  = iota
		KB = 1 << (10 * iota)
		MB = 1 << (10 * iota)
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)

多个iota定义在一行

const (
		a, b = iota + 1, iota + 2 	// 1,2
		c, d                      	// 2,3
		e, f                      	// 3,4
	)

5、基本数据类型

Go语言中有丰富的数据类型,除了基本的整型、浮点型、布尔型、字符串外,还有数组、切片、结构体、函数、map、通道(channel)等。Go 语言的基本类型和其他语言大同小异。

5.1、整型

整型分为以下两个大类: 按长度分为:int8、int16、int32、int64 对应的无符号整型:uint8、uint16、uint32、uint64

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

特殊整型

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

注意: 在使用intuint类型时,不能假定它是32位或64位的整型,而是考虑intuint可能在不同平台上的差异。
注意事项: 获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中,切片map 的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时,为了保持文件的结构不会受到不同编译目标平台字节长度的影响,不要使用intuint

八进制&十六进制

数字字面量语法(Number literals syntax)

Go1.13版本之后引入了数字字面量语法,这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字,例如:

v := 0b00101101, 代表二进制的 101101,相当于十进制的 45。

v := 0o377,代表八进制的 377,相当于十进制的 255。

v := 0x1p-2,代表十六进制的 1 除以 2²,也就是 0.25。

而且还允许我们用 _ 来分隔数字,比如说: v := 123_456 表示 v 的值等于 123456。

我们可以借助fmt函数来将一个整数以不同进制形式展示。

package main

import "fmt"

func main() {
	// 十进制
	var i1 = 10
	fmt.Printf("%b\\n", i1)		// 输出i1的二进制数值
	fmt.Printf("%d\\n", i1)		// 输出i1的十进制数值
	fmt.Printf("%o\\n", i1)		// 输出i1的八进制数值
	fmt.Printf("%x\\n", i1)		// 输出i1的十六进制数值

	// 八进制	以0开头
	i2 := 077
	fmt.Printf("%d\\n",i2)

	// 十六进制	以0x开头
	i3 := 0x123abcd
	fmt.Printf("%d\\n", i3)

	fmt.Printf("%T", i2)
}

--->>>
1010
10
12
a
63
19114957
int

5.2、浮点数

Go语言支持两种浮点型数:float32float64。这两种浮点型数据格式遵循IEEE 754标准: float32 的浮点数的最大范围约为 3.4e38,可以使用常量定义:math.MaxFloat32float64 的浮点数的最大范围约为 1.8e308,可以使用一个常量定义:math.MaxFloat64

打印浮点数时,可以使用fmt包配合动词%f,代码如下:

package main

import (
	"fmt"
	"math"
)

// 浮点数

func main() {
	fmt.Printf("%f\\n", math.MaxFloat32)
	fmt.Printf("%f\\n", math.Pi)
	fmt.Printf("%.2f\\n", math.Pi)
}

5.3、复数

complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

复数有实部和虚部,complex64的实部和虚部为32位,complex128的实部和虚部为64位。

5.4、布尔值

Go语言中以bool类型进行声明布尔型数据,布尔型数据只有true(真)false(假)两个值。

注意:

  • 布尔类型变量的默认值为false
  • Go 语言中不允许将整型强制转换为布尔型.
  • 布尔型无法参与数值运算,也无法与其他类型进行转换。
package main

import "fmt"

func main() {
	b1 := true
	var b2 bool		// 默认值为false
	fmt.Printf("b1的类型为: %T, b2的类型为: %T\\n", b1, b2)
	fmt.Printf("b1的值为: %v, b2的值为: %v", b1, b2)
}

5.5、字符串

Go语言中的字符串以原生数据类型出现,使用字符串就像使用其他原生数据类型(int、bool、float32、float64 等)一样。 Go 语言里的字符串的内部实现使用UTF-8编码。 字符串的值为双引号(")中的内容,可以在Go语言的源码中直接添加非ASCII码字符,例如:

s1 := "hello"
s2 := "你好"
s3 := '沙'		// 单引号包裹的为字符

字符串转义符

转义符含义
\\r回车符(返回行首)
\\n换行符(直接跳到下一行的同列位置)
\\t制表符
\\'单引号
\\"双引号
\\\\反斜杠

举个例子,我们要打印一个Windows平台的文件路径

package main

import "fmt"

func main() {
	path := "\\"c:\\\\code\\\\lessonl\\\\go.exe\\""
	fmt.Println("path为:", path)
}

--->>>
path为: "c:\\code\\lessonl\\go.exe"

多行字符串

Go语言中要定义一个多行字符串时,就必须使用反引号字符:

s1 := `第一行
第二行
第三行
`
fmt.Println(s1)

反引号间换行将被作为字符串中的换行,但是所有的转义字符均无效,文本将会原样输出。

字符串的常用操作

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

字符串拼接举例:

// 字符串拼接
name := "孙凯欣"
word := "大帅B"
ss := name + word							// 用 + 拼接
fmt.Println(ss)								
ss1 := fmt.Sprintf("%s%s", name, word)		// 用Sptintf函数拼接
fmt.Println(ss1)

--->>>
孙凯欣大帅B
孙凯欣大帅B

分割举例:

// 分割
st := "c:\\\\code\\\\lessonl\\\\go.exe"
nst := strings.Split(st, "\\\\")
fmt.Println(nst)

--->>>
[c: code lessonl go.exe]

包含举例:

// 包含
wd := "LiShang 大帅比"
k := strings.Contains(wd, "大帅比")		// 是否包含"大帅比"
fmt.Println(k)
v := strings.Contains(wd, "李尚")			// 是否包含"李尚"
fmt.Println(v)

--->>>
true
false

前缀和后缀判断举例:

wd := "LiShang 大帅比"
// 前缀判断
fmt.Println(strings.HasPrefix(wd, "Li"))
// 后缀判断
fmt.Println(strings.HasSuffix(wd, "哥"))

--->>>
true
false

子串出现的位置举例:

// 子串出现的位置
s4 := "abcdefgb"
fmt.Println(strings.Index(s4, "b"))
fmt.Println(strings.LastIndex(s4, "b"))

--->>>
1
7

join举例

st := "c:\\\\code\\\\lessonl\\\\go.exe"
nst := strings.Split(st, "\\\\")
fmt.Println(nst)
fmt.Println(strings.Join(nst, "+"))

--->>>
[c: code lessonl go.exe]
c:+code+lessonl+go.exe

5.6、byte和rune类型

组成每个字符串的元素叫做“字符”,可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号(’)包裹起来,如:

var a = '中'
var b = 'x'

Go 语言的字符有以下两种:

  • unit8类型,或者叫byte型,代表了ASCII的一个字符
  • rune类型,代表一个utf-8字符

当需要处理中文、日文或者其他复合字符时,则需要用到rune类型。rune类型实际是一个int32

Go 使用了特殊的 rune 类型来处理 Unicode,让基于 Unicode 的文本处理更为方便,也可以使用 byte 型进行默认字符串处理,性能和扩展性都有照顾。

// 遍历字符串
func traversalString() {
	s := "hello沙河"
	for i := 0; i < len(s); i++ { //byte
		fmt.Printf("%v(%c) ", s[i], s[i])
	}
	fmt.Println()
	for _, r := range s { //rune
		fmt.Printf("%v(%c) ", r, r)
	}
	fmt.Println()
}

--->>>
104(h) 101(e) 108(l) 108(l) 111(o) 230(æ) 178(²) 153() 230(æ) 178(²) 179(³) 
104(h) 101(e) 108(l) 108(l) 111(o) 27801() 27827() 

因为UTF8编码下一个中文汉字由3~4个字节组成,所以我们不能简单的按照字节去遍历一个包含中文的字符串,否则就会出现上面输出中第一行的结果。

字符串底层是一个byte数组,所以可以和[]byte类型相互转换。字符串是不能修改的 字符串是由byte字节组成,所以字符串的长度是byte字节的长度。 rune类型用来表示utf8字符,一个rune字符由一个或多个byte组成。

修改字符串

字符串本身是不能修改的

要修改字符串,需要先将其转换成[]rune[]byte,完成后再转换为string。无论哪种转换,都会重新分配内存,并复制字节数组。

func changestring() {
	s1 := "big"
	// 强制类型转换
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "白萝卜"
	runeS2 := []rune(s2)			// 把字符串强制转换成rune切片
	runeS2[0] = '红'
	fmt.Println(string(runeS2))		// 把rune切片转换成字符串
}

--->>>
pig
红萝卜

5.7、类型转换

Go语言中只有强制类型转换,没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

强制类型转换的基本语法如下:

T(表达式)

其中,T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.

比如计算直角三角形的斜边长时使用math包的Sqrt()函数,该函数接收的是float64类型的参数,而变量a和b都是int类型的,这个时候就需要将a和b强制类型转换为float64类型。

以上是关于Go之路二:基本语法(变量常量和数据类型)的主要内容,如果未能解决你的问题,请参考以下文章

2. Go 语言基本语法

go语言学习笔记 — 基础 — 基本语法 — 常量与变量 — 常量变量的声明:单个变量的声明与赋值

2. Go语言基本语法 - 变量及常量

go语言学习笔记 — 基础 — 基本语法 — 常量与变量 — 变量的数值类型转换

go语言学习笔记 — 基础 — 基本语法 — 常量与变量 — 常量变量的声明:常量的初始化定义

go语言学习笔记 — 基础 — 基本语法 — 常量与变量 — 变量的类型零值