1.静态语言和动态语言在变量处理上的区别

1.1 什么是变量的声明

为了方便对内存的操作，编程语言中，将一个名字

1.2 静态语言和动态语言在变量处理上的区

静态语言：在变量声明的时候，必须说明

动态语言：

2.Go变量的声明和赋值

2.1 变量的声明

  • var语句用于声明变量/变量列表，类型放在最后

  • var语句可以出现在包或函数级别

  • 可以一次声明多个变量

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

var c, jython, java bool //出现在包级别，一次声明多个变量

func main(){

  var i int //出现在函数级别

  fmt.Println(i, c, python, java) //输出是0 false false false

}

2.2 变量的赋值

2.2.1 变量的初始化

  • 在定义变量的时候声明变量的类型并且给变量赋值

  • 变量的值如果是默认类型，在进行变量赋值的时候也可以省略类型

1
2
3
4
5
6
7
8
9
10
//在定义变量的时候声明变量的类型并且给变量赋值

Var a int = 1

//go有类型推断能力，如果使用默认类型（数值型、字符型、布尔型、字符串）的话，可以在声明变量的时候把类型删掉

Var（
    a = 1
    b = 1
）
2.2.2 可以同时对多个变量进行初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//同时声明多个变量可以进行简写

Var a int = 1
Var b int = 2

//以上两行可以简写为

Var（
    a int = 1
    b int = 2
）

//也可以简写为

var a, b int = 1, 2
2.2.3 可以先给变量声明，再赋值
1
2
3
4
5
//先声明变量的类型，后给变量赋值

Var a int //注意，在声明变量a的时候，类型放在最后

a=1
2.2.4 短变量声明

定义：在变量初始化时省略变量的类型，由系统自行判断

1
a, b :=50 ,"abc"  //a和b的类型（int，string）由系统自行判断

这种声明方式只能用在函数体内，不可以用于全局变量的声明和赋值

在相同的代码块中，不可以对同一个名称的变量进行再次初始化声明；但是可以对一个已经初始化声明的变量进行再次赋值

2.2.5 交换两个变量的值
1
a,b=b,a
2.2.6 零值（没有明确初始值的变量会被赋予 零值）
1
2
3
4
5
6
7
8
9
10
11
数值类型为 0，

布尔类型为 false，

字符串为 ""（空字符串），判断字符串的为空时，判断字符串是否等于 ""  而不是判断字符串是否等于nil

float :0.0

pointer, function, interface, slice, channel, map:nil

复合类型: go语言会自动递归地将每一个元素初始化为其类型对应的零值。比如：数组， 结构体 。

说明：风格尽量简单一致，因此后续可能有一部分功能可能会被禁用

2.3 变量的声明和其它语言的差异

go是一种强类型语言

  • 赋值可以进行自动类型判断

  • 在一个赋值语句中可以对多个变量同时进行赋值

3.常量的定义

常量的声明与变量类似，只不过是使用 const 关键字

常量可以是字符、字符串、布尔值或数值

常量不能用 := 语法声明

数值常量：一个未指定类型的常量由上下文来决定它的类型

1
2
3
4
5
6
7
//连续的变量赋值

Const(
    Monday = iota + 1 //代表后面的变量依次在iota的基础上加1
    Tuesday  //tuesday会被自动赋值为2
    Wednesday  //wednes会被自动赋值为3
)
1
2
3
4
5
6
//连续的位运算

const(
    Open = 1 << iota  //代表后面的变量依次在iota的基础上左移一位
    close
)

补充：iot从常量结构的第一行（不包含注释和空行）开始，从0逐行加1