Go语言之基本语法(八)

Go语言的基本语法

1.变量

什么是变量?

变量就是可变的量,可以重新修改的值
变量是为存储特定类型 值而提供给内存位置的名称。
变量的本质是一小块内存,用于存储数据,**在程序运行过程中数值可以改变**

如何声明变量?

第一种:指定变量的类型,声明后若不赋值,使用默认值 	
		 var name type 	
		 name = value 
第二种:根据值自行判定变量类型
	 	 var name = value
第三种:使用 := 来声明变量,省略var
		 name := value

第三种方式注意事项:
1.注意 :=左侧的变量不应该是已经声明过的
2.(多个变量同时声明时,至少保证每一个是新变量),否则会导致编译错误(简短声明)
3.第三种方式只能被用在函数体内,而不可以用于全局变量的声明与赋值

多变量声明的方式?

第一种,以逗号分隔,声明与赋值分开,若不赋值,存在默认值
	var name1, name2, name3 type
	name1, name2, name3 = v1, v2, v3

第二种,直接赋值,下面的变量类型可以是不同的类型
       var name1, name2, name3 = v1, v2, v3
例子:  var name1,name2,name3 = 3,"小榕",3.1415

第三种,集合类型
	var (
	    name1 type1
	    name2 type2
	)

变量注意事项:

- 变量必须先定义才能使用
- go语言是静态语言,要求变量的类型和赋值的类型必须一致。
- 变量名不能冲突。(同一个作用于域内不能冲突)
- 简短定义方式,左边的变量名至少有一个是新的
- 简短定义方式,不能定义全局变量。
- 变量的零值。也叫默认值。
- 变量定义了就要使用,否则无法通过编译。
如果在相同的代码块中,我们不可以再次对于相同名称的变量使用初始化声明,
例如:a := 20 就是不被允许的,编译器会提示错误 no new variables on left side of :=,
但是 a = 20 是可以的,因为这是给相同的变量赋予一个新的值。
如果你在定义变量 a 之前使用它,则会得到编译错误 undefined: a。
如果你声明了一个局部变量却没有在相同的代码块中使用它,同样会得到编译错误,例如下面这个例子当中的变量 a:
func main() {
   var a string = "abc"
   fmt.Println("hello, world")
}
虽然定义了变量a,但是并没有打印这个变量a,所以尝试编译这段代码将得到错误 a declared and not used
在同一个作用域中,已存在同名的变量,则之后的声明初始化,则退化为赋值操作。
但这个前提是,最少要有一个新的变量被定义,且在同一作用域,
例如,下面的y就是新定义的变量
package main

import (
	"fmt"
)

func main() {
	x := 140
	fmt.Println(&x)
	x, y := 200, "abc"
	fmt.Println(&x, x)
	fmt.Print(y)
}

运行结果:
	0xc04200a2b0
	0xc04200a2b0 200
	abc

2.常量

什么是常量?

常量就是一个值的简单标识符,在程序运行期间无法进行修改。

如何声明常量?

const 标识符 [类型] = 值

显式类型定义: const name string = "abc"
隐式类型定义: const number = "abc"

常量可以作为枚举,常量组

const (
    Unknown = 0
    Female = 1
    Male = 2
)

常量组中如不指定类型和初始化值,则与上一行非空常量右值相同

package main

import (
	"fmt"
)

func main() {
	const (
		x uint16 = 16
		y
		s = "abc"
		z
	)
	fmt.Printf("%T,%v\n", y, y)
	fmt.Printf("%T,%v\n", z, z)
}

运行结果:
	uint16,16
	string,abc

常量的注意事项:

常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型

不曾使用的常量,在编译的时候,是不会报错的

显示指定类型的时候,必须确保常量左右值类型一致,需要时可做显示类型转换。这与变量就不一样了,变量是可以是不同的类型值

3.iota

iota是什么?

iota是一个特殊常量,可以认为是一个可以被编译器修改的常量。

每当定义一个const,iota的初始值为0
每当定义一个常量,就会自动累加1
直到下一个const出现,清零
第一个 iota 等于 0,每当 iota 在新的一行被使用时,它的值都会自动加 1

iota用法

package main

import "fmt"

func main() {
    const (
    		//第一个 iota 等于 0,每当 iota 在新的一行被使用时,它的值都会自动加 1
            a = iota   //0
            b          //1
            c          //2
            d = "ak"   //独立值,iota += 1
            e          //"ak"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数,如果中断iota后,想要恢复iota,需要显式恢 复
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

运行结果:
0 1 2 ak ak 100 100 7 8

注意事项:

只能在常量的表达式中使用。

如果中断iota自增,则必须显式恢复。且后续自增值按行序递增

自增默认是int类型,可以自行进行显示指定类型

数字常量不会分配存储空间,无须像变量那样通过内存寻址来取值,因此无法获取地址
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页