03.Golang基础之变量与常量

Leefs 2022-06-28 PM 649℃ 0条

[TOC]

### 前言

![03.GO语言基础之变量与常量01.jpeg](https://lilinchao.com/usr/uploads/2022/06/746951624.jpeg)

### 一、变量

#### 1.1 概述

程序在运行过程中，数据保存在内存当中。

在代码中，可以通过以下两种方式到内容中访问具体的数据：

+ **直接引用该数据的内存地址访问数据**
+ **通过创建变量将数据的内存地址保存起来，然后通过引用变量名去访问数据**

和后者相比前者的可读性差，并且容易出错，所以在程序中通常会通过定义一个简短有意义的名称来用于对数据的访问。

**简言之，变量就是一块存放（可变）数据的内存空间，引用变量名就可以到该内存空间上访问（查找or修改）数据。**

##### 组成

变量由**内存地址**，**数据类型**和**值**组成：

+ **内存地址**：给出了变量在内存中存储的起始地址，一般占用4或8字节（32位、64位机器）。

+ **数据类型**：定义了变量占用内存的大小。
+ **值**：表示内存地址中存放的内容。

#### 1.2 变量定义方式

**（1）标准声明**

使用var关键字是Go最基本的定义变量方式，与C语言不同的是Go把变量类型放在变量名后面：

```go
//单变量
var 变量名 变量类型

//多变量同类型
var 变量名1,变量名2,变量名3,... 变量类型
```

**示例**

```go
//单变量声明
var name string  //字符串型变量
var age int      //整型变量
var flage bool    //布尔型变量

//多变量同类型声明
var v1,v2,v3 string //v1,v2,v3都为字符串类型
```

**（2）批量声明**

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

```go
var (
    name string		//字符串型变量
    age int		 	//整型变量
    flage bool		//布尔型变量
    score float32	//浮点型变量
)
```

**（2）变量的初始化**

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值。

**例如**：

+  整型和浮点型变量的默认值为`0`。
+ 字符串变量的默认值为`空字符串`。
+ 布尔型变量默认为`false`。 
+  切片、函数、指针变量的默认为`nil`。

当然也可在声明变量的时候为其指定初始值。

**变量初始化的标准格式如下：**

```go
var 变量名 类型 = 表达式
```

**示例**

```go
//方法一:声明一个变量,默认的值是0
var a int
fmt.Println("a = ",a)
fmt.Printf("a的数据类型是:%T\n",a)

//方法二:声明一个变量,并初始化一个值
var b int = 100
fmt.Printf("b = %d,type of b = %T\n",b,b)

var st string = "欢迎来到李林超博客"
fmt.Printf("st = %s,st的类型是:%T\n",st,st)
```

**（3）类型推导**

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

```go
var c = 10
fmt.Printf("c = %d,type of c = %T\n",c,c)
var name = "Leefs"
fmt.Printf("name = %s,type of name = %T\n",name,name)

//一次初始化多个变量(类型可以不相同)
var name, age,score = "Leefs",20,89.9
```

**（4）短变量声明**

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

**注意：**

+  短声明是在函数或方法内部使用, 不支持全局变量声明
+  `:=` 符号左侧的变量中，必须至少有一个变量是第一次声明的变量。

**示例**

```go
package main

import (
	"fmt"
)
// 全局变量m
var m = 100

func main() {
	m := 10
	fmt.Printf("m = %d,type of m:%T\n",m,m)
    
    m,n := 30,20.3
	fmt.Printf("m = %d, n = %f \n",m,n)
    
    e := "www.lilinchao.com"
	fmt.Printf("e = %s,type of e:%T\n",e,e)
}
```

**（5）匿名变量**

在使用多重赋值时，如果想要忽略某个值，可以使用`匿名变量（anonymous variable）`。 匿名变量用一个下划线`_`表示，例如：

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

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。 `_`多用于占位，表示忽略值。

### 二、常量

#### 2.1 概述

+ 常量是与变量相对的一个概念，都是对应一块内存，只是变量可以被修改，常量一旦定义就不能被修改。
+ 常量在编译时就创建，只能定布尔，字符串和数字型（包括整型，字符，浮点型，复数）。
+ 常量的算数、逻辑、比较运算的结果也是常量。
+ `len、cap、real、image、complex、unsafe.Sizeof`的调用返回是常量。

#### 2.2 常量定义方式

**（1）标准声明**

常量的声明和变量声明非常类似，只是把`var`换成了`const`，常量在定义的时候必须赋值。

```
const 常量名称 [常量类型] = 常量值
```

`常量类型` 是可选的，因为 go 会通过常量的值自行推导数据类型。

> 在 Go 中，必须在开始编译之前给常量赋值。不能用函数的返回值给常量赋值。 `const a = math.Sqrt(4)` 是非法语句，因为 `a` 的值是要在运行中计算出来的。

**示例**

```go
//常量(只读属性)
const length int = 100
//length = 200	//常量是不允许被修改的
fmt.Println("length = ",length)

//省略数据类型
const a = 100
const b = 20.3
```

**（2）批量声明**

```go
//方式一
const pi, e = 3.1415, 2.7182

//方式二
const (
    pi = 3.1415
    e = 2.7182
    blogName = "李林超博客"
)
```

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

```go
const (
    n1 = 100
    n2
    n3
)
```

上面示例中，常量`n1`、`n2`、`n3`的值都是100。

#### 2.3 iota

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

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

**举个例子：**

```go
const (
    m1 = iota //0
    m2        //1
    m3        //2
    m4        //3
)

const(
	n1 = 10 * iota	//0
	n2				//10
	n3				//20
	n4				//30
)
```

**几个常见的`iota`示例**

+ 使用`_`跳过某些值

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

+ `iota`声明中间插队

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

+ 定义数量级

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

这里的`<<`表示左移操作，`1<<10`表示将1的二进制表示向左移10位，也就是由`1`变成了`10000000000`，也就是十进制的1024。

同理`2<<2`表示将2的二进制表示向左移2位，也就是由`10`变成了`1000`，也就是十进制的8。

+ 多个`iota`定义在一行

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

### 三、标识符和关键字

#### 3.1 标识符

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

#### 3.2 关键字

关键字是 Go 语言中预先保留的单词，在程序中有特殊含义，不能用来定义变量或常量。

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    |

*附参考文章链接*

*https://www.liwenzhou.com/posts/Go/01_var_and_const/*

标签: Golang基础

非特殊说明，本博所有文章均为博主原创。

如若转载，请注明出处：https://lilinchao.com/archives/2190.html

上一篇 02.Golang入门程序

下一篇 04.Golang基本数据类型

03.Golang基础之变量与常量

评论啦~

栏目分类

标签云

友情链接申请

03.Golang基础之变量与常量

 评论啦~

 栏目分类

标签云

友情链接申请

评论啦~

栏目分类

标签云

友情链接申请