go变量笔记

变量

使用一个名称来绑定一块内存地址 ，
该内存地址中存放的数据类型由定义变量时指
定的类型决定，该内存地址里面存放的内容可以改变。

显式的完整声明

var a int = l
var a int = 2*3
var a int =b

短类型声明

varName := value

:=只能出现在函数内. 此时 Go 编译器自动进行数据类型推断。

Go 支持多个类型变量同 时声明并赋值

a,b := 1,”hello "

var (
    vname1 v_type1
    vname2 v_type2
)

类型不同多个变量, 全局变量, 局部变量不能使用这种方式

常量

常量使用一个名称来绑定一块内存地址，该内存地址中存放的数据类型由定义常量时指定的类型决定，而且该内存地址里面存放的内容不可以改变 。 Go 中常量分为布尔型、宇符串型和数值型常量。常量存储在程序的只读段里

预声明标识符iota 用在常量声明中，其初始值为 0。一组多个常量同时声明时其值逐行增加，iota 可以看作自增的枚举变量，专 门用来初始化常量。

const (
    c0=iota // c0 ==0
    c1=iota // c1==1
    c2=iota // c2==2
)

简写

const (
	c0=iota //c0==0
	c1 // c1==1;
	c2 // c2==2
)

iota 逐行增加

const (
	a=1 << iota // a==1 (iota==0)
	b=1 << iota // b==2 (iota==1)
	c=3          // c==3 (iota==2)
	d=1 <<iota //d==8 (iota==3)	
)

分开的 const 语句，iota 每次都从 0 开始

 const x=iota   //x==0
 const y=iota   //y==0

基本数据类型

布尔类型: bool

整型: byte int int8 int16 init32 int64 uint uint8 uint16 uint32 uint64 uintptr

浮点型: float32 float64

复数: complex64 complex128

字符 ：rune

字符串:string

错误类型：error

布尔类型

布尔类型关键字是 bool ，布尔类型只有两个值：true 和 false，true 和 false 是 Go 内置的两个预声明标识符 。

var ok bool
ok = true

布尔型数据和整型数据不能进行相互转换。

var a bool
a= 1 //error

比较表达式和逻辑表达式的结果都是布尔类型数据 。

if 和 for语句的条件部分一定是布尔类型的值或表达式 。

声明的布尔型默认是false

整型

Go 语言内置了12 种整数类型，分别是 byte 、int 、int8 、int16 、init32 、int64 、uint 、uint8 、uintl6 、uint32 、uint64 、
uintptr .其 中 byte 是 uint8 的别名，不同类型的整型必须进行强制类型转换。

var a int = 1
var b int32 = 2

浮点型

浮点型用于表示包含小数点的数据， G o 语言内置两种浮点数类型，分别是 float32 和 float64 。

浮点数字面量被自动类型推断为 float64 类型 。

两个浮点数之间不应该使用＝或!＝进行比较操作，高精度科学计算应该使用 math 标准库 。

 a :=1.0
 fmt.Println( reflect.TypeOf(a)) // float64

fmt.Println( 0.2+0.1==0.3)

Expression ‘0.2+0.1==0.3’ is always ‘false’

字符串

字符串的初始化可以使用字符串字面量。

var a = ” hello , world"

可以通过类似数组的索引访问字符串字节单元,不能修改某个字节的
值

	a := "hello,world"
	b := a[0]
	fmt.Printf("b=%c", b)// h
	
	a[0] = 'c' //cannot assign to a[0] 

字符串尾部不包含 NULL 字符

基于字符串创建的切片和原字符串指向相同的底层字符数组,一样不能修改 ， 对字符串的切片操作返回的子串仍然是由string

	a := "hello,world"
	b := a[0:2]
	fmt.Println(reflect.TypeOf(b)) // string

字符串 可以转换为字节数组

	a := "hello,world"
	b := []byte(a)
	fmt.Println(reflect.TypeOf(b)) // []uint8

字符串的运算

a := ” hello ”
b := ” world”
c : = a + b

for i , v : = range a{
	fmt . Println(i , v)
}

复合数据类型

Go 语言基本的复合数据类型有指针、数组、切片、字典（ map ）、通道、结构和接口

指针

Go 语言支持指针，指针的声明类型为*T，同样支持多级指针**T

通过在变量名前加＆来获取变量的地址

结构体指针访问结构体字段仍然使用"."点操作符，

Go 不支持指针的运算

a := 1234
P := &a
p++ //Invalid operation: p++ (non-numeric type *int)

函数 中允许返回局部变量的地址

func sum (a , b int) *int {
	sum := a+b
	return &sum
}

数组

数组的类型名是［n ] elemetType,其中 n 是数组长度，elementType 是数组元素类型 。数组一般在创建时通过字面量初始化,单独声明一个数组类型变量而不进行初始化是没有意义的.

a: =[3]int(1，2,3 }// 指定长度和初始化字面量
a: =[...]int(1，2,3 }//不指定长度，但是由后面的初始化列表数量来确定其长度

a: = [3]int{l : l , 2 : 3)//指定总长度，并通过索引值进行初始化

数组创建完长度就固定了,不可以再追加元素

数组是值类型的,数组赋值或作为函数参数都是值拷贝

数组长度是数组类型的组成部分//[10]int 和[20]int 表示不同的类型。

可以根据数组创建切片

切片

slice是一种变长数组,其数据结构中有指向数组的指针,是一种引用类型。

Go 为切片维护三个元素一一指向底层数组的指针、切片的元素数量和底层数组的容量

切片的创建,array [b:e表示创建一个包含 e -b 个元素
的切片，第一个元素是 array [b]，最后一个元素是 array[e -1]

var array = [....]int{0, 1, 2, 3, 4, 5, 6}
s1 := array[0:4]
s2 := array[:4]
s3 := array[2:]

通过内置函数 make 创建切片

a: = make([]int , 10) //len=lO , cap=lO
b := make([]int , 10 , 15) //len=lO , cap=lS

内置函数len()返回切片长度。

内置函数cap()返回切片底层数组容量。

内置函数append()对切片追加元素。

内置函数copy()用于复制一个切片。

字符串和切片的相关转换

str： ＝” hello ， 世界！” //通过字符串字面量初始化一 个字符串 str
a : = []byte(str)
b : = []rune(str)

map

map 的创建 。

使用字面量创建

ma :=map[string]int {"a": 1, "b": 2}
fmt.Println(ma["a"] )

使用make创建

mpl := make(map[int]string)

map 支持的操作。

map 的单个键值访 问格式为 mapName[key]

可以使用 range 遍历一个 map 类型变量

delete(mapName,key） 删除 map 中的某个键值

可以使用内置的 len()函数返回 map 中的键值对数量

	a := make(map[int]string)
	a[1] = "a"
	a[0] = "b"
	a[2] = "c"
	fmt.Println(len(a))//3
	delete(a, 2)
	fmt.Println(len(a))//2

想修改 map 的某个键值,则必须整体赋值

struct

struct 有两种形式 ： 一种是 struct 类型宇面量，另一种是使用 type 声明的自定义 struct 类型 。

struct 类型字面量的声明格式如下：

struct {
	FeildName FeildType
	
}

自定义 struct 类型 。

type TypeName struct {
	FeildName FeildType
}

type Person struct{
	Name string 
	Age int
}
a:=Person{"a",1}