Golang 学习入坑（三）Go语言变量及常量及运算符

（一）GO语言变量

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字

声明变量的一般形式是使用 var 关键字：

//var identifier type
//其中 identifier  是变量，type是类型
例如：
var tongtong string = "zhang"
fmt.Println(tongtong)

//可以一起声明多个变量
var b, c int = 1, 2
fmt.Println(b,c)

（1、）数值类型变量声明如果无初始化，默认是0数值类型
（complex64/128）为 0

布尔类型为 false

字符串为 ""（空字符串）

以下几种类型为 nil：

var a *

intvar a []int

var a map[string] int

var a chan int

var a func(string) int

var a error // error 是接口
（2、）根据值自行判定变量类型。

　　　var d = true
    　　fmt.Println(d)

　　　未声明类型，根据值判断输出true

（3、）第三种，省略 var, 注意 := 左侧如果没有声明新的变量，就产生编译错误，格式：

　　

var intVal int 

intVal :=1 // 这时候会产生编译错误   因为intVal已经存在，不是新的变量

intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句
　 我们常用的是：

　    haha :=  '我在笑'

　　fmt.PrintLn(haha)

（4、）多变量声明：

　//类型相同多个变量, 非全局变量

var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

（5、）值类型和引用类型    （重要）
所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值：
当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝：
你可以通过 &i 来获取变量 i 的内存地址
f := true
fmt.PrintLn(&f)
内存地址会根据机器的不同而有所不同，甚至相同的程序在不同的机器上执行后也会有不同的内存地址。因为每台机器可能有不同的存储器布局，并且位置分配也可能不同.

　一个引用类型的变量 r1 存储的是 r1 的值所在的内存地址（数字），或内存地址中第一个字所在的位置。

　这个内存地址为称之为指针，这个指针实际上也被存在另外的某一个字中。

 

　　同一个引用类型的指针指向的多个字可以是在连续的内存地址中（内存布局是连续的），这也是计算效率最高的一种存储形式；也可以将这些字分散存放在内存中，每个字都指示了下一个字所在的内存地址。

 

　　当使用赋值语句 r2 = r1 时，只有引用（地址）被复制。

 

　　如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。

　　

 

（二）GO语言常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

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

常量的定义格式：

const identifier [type] = value

不过也可以省略类型

const b = "abc"          

常量还可以用作枚举：

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

import "unsafe"
const (
    a = "abc"
    b = len(a)                              //计算长度
    c = unsafe.Sizeof(a)　　　　　　　　　　　  //这个函数返回的是数据类型的大小
　　//这里查了一下解释下：string类型不是直接存的数据，而是一个结构体，用指针指向实际数据地址。为Golang中的sring内部实现由两部分组成，一部分是指向字符串起始地址的指针，另一部分是字符串的长度，两部分各是8字节，所以一共16字节
　　

)，

func main(){
    println(a, b, c)
}

常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过：
abc 3 16

　　

这个是字符串的结构
type stringHeader struct{
　　　　Data uintptr
　　　　Len  int
}

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

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}
0 1 2 ha ha 100 100 7 8

 运算符
　　1. 算术运算符，a + b ，包括（+，-，*，/,%，++，--）
　　2. 关系运算符，返回True或False ，a == b ，包括（==，!=，>，<，>=，<=）
　　3. 逻辑运算符，返回True或False ，包括（&&，||，!）

　　4.位运算符  &, |, 和 ^

　　5.赋值运算符  =   +=  -=  *=  /=  %=     &=       

　　7. 地址运算符 

　　　　& ： 返回变量存储地址 （&originalValue）

　　　　* ：指针变量 （*pointerValue）

　　8. 接收运算符，用于接收通道的数据或者给将数据加入通道（intChan<-1， <-intChan）

运算符号的优先级从上到下。不过我们基本都会使用小括号提升

5	* / % << >> & &^
4	+ - | ^
3	== != < <= > >=
2	&&
1	||