go语言变量

变量由字母、数字、下划线 组成。

定义变量

1、var 变量 变量类型

2、var 变量1，变量2 变量类型
var 变量 = 值

—给变量进行赋值

1、变量没有赋值 即变量为零

2、变量赋值没有定义变量类型自行判定变量类型

3、变量省略var 注意**:=** 左侧如果没有申明新的变量，则会编译错误

多变量申明

var 变量1，变量2，变量3

变量1，变量2，变量3 = 1,  2, 3

简约形式 := 赋值操作符

前言
任何一门语言里面最基础的莫过于变量了。如果把内存比喻成一格一格整齐排列的储物箱，那么变量就是每个储物箱的标识，我们通过变量来访问计算机内存。没有变量的程序对于人类来说是可怕的，需要我们用数字位置来定位内存的格子，人类极不擅长这样的事。这就好比一岁半左右的幼儿还没有学会很多名词，只能用手来对物体指指点点来表达自己的喜好。变量让程序逻辑有了丰富的表达形式。


定义变量的三种方式
Go 语言的变量定义有多种形式，我们先看最繁琐的形式
package main

import "fmt"

func main() {
    var s int = 42
    fmt.Println(s)
}

-------------
42

注意到我们使用了 var 关键字，它就是用来显式定义变量的。还注意到在变量名称 s 后面声明了变量的类型为整形 int，然后再给它赋上了一个初值 42。上面的变量定义可以简化，将类型去掉，因为编译器会自动推导变量类型，效果也是一样的，如下
package main

import "fmt"

func main() {
    var s = 42
    fmt.Println(s)
}

---------------
42

更进一步，上面的变量定义还可以再一次简化，去掉 var 关键字。
package main

import "fmt"

func main() {
    s := 42
    fmt.Println(s)
}

---------------
42

注意到赋值的等号变成了 :=，它表示变量的「自动类型推导 + 赋值」。
这三种变量定义方式都是可行的，各有其优缺点。可读性最强的是第一种，写起来最方便的是第三种，第二种是介于两者之间的形式。
类型是变量身份的象征，如果一个变量不那么在乎自己的身份，那在形式上就可以随意一些。var 的意思就是告诉读者「我很重要，你要注意」，:= 的意思是告诉读者「我很随意，别把我当回事」。var 再带上显式的类型信息是为了方便读者快速识别变量的身份。
如果一个变量很重要，建议使用第一种显式声明类型的方式来定义，比如全局变量的定义就比较偏好第一种定义方式。如果要使用一个不那么重要的局部变量，就可以使用第三种。比如循环下标变量
for i:=0; i<10; i++ {
  doSomething()
}

那第二种方式能不能用在上面的循环下标中呢，答案是不可以，你无法将 var 关键字直接写进循环条件中的初始化语句中，而必须提前声明变量，像下面这样，这时就很明显不如简写的形式了
var i = 0
for ; i<10; i++ {
  doSomething()
}

如果在第一种声明变量的时候不赋初值，编译器就会自动赋予相应类型的「零值」，不同类型的零值不尽相同，比如字符串的零值不是 nil，而是空串，整形的零值就是 0 ，布尔类型的零值是 false。
package main

import "fmt"

func main() {
    var i int
    fmt.Println(i)
}

-----------
0

全局变量和局部变量
上面我们在代码例子中编写的变量都是局部变量，它定义在函数内部，函数调用结束它就消亡了。与之对应的是全局变量，在程序运行期间，它一直存在，它定义在函数外面。
package main

import "fmt"

var globali int = 24

func main() {
    var locali int = 42
    fmt.Println(globali, locali)
}

---------------
24 42

如果全局变量的首字母大写，那么它就是公开的全局变量。如果全局变量的首字母小写，那么它就是内部的全局变量。内部的全局变量只有当前包内的代码可以访问，外面包的代码是不能看见的。
学过 C 语言的同学可能会问，Go 语言里有没有静态变量呢？答案是没有。
变量与常量
Go 语言还提供了常量关键字 const，用于定义常量。常量可以是全局常量也可以是局部常量。你不可以修改常量，否则编译器会抱怨。常量必须初始化，因为它无法二次赋值。全局常量的大小写规则和变量是一致的。
package main

import "fmt"

const globali int = 24

func main() {
    const locali int = 42
    fmt.Println(globali, locali)
}

指针类型
Go 语言被称为互联网时代的 C 语言，它延续使用了 C 语言的指针类型。


package main

import "fmt"

func main() {
    var value int = 42
    var pointer *int = &value
    fmt.Println(pointer, *pointer)
}

--------------
0xc4200160a0 42

我们又看到了久违的指针符号 * 和取地址符 &，在功能和使用上同 C 语言几乎一摸一样。同 C 语言一样，指针还支持二级指针，三级指针，只不过在日常应用中，很少遇到。
package main


import "fmt"


func main() {
    var value int = 42
    var p1 *int = &value
    var p2 **int = &p1
    var p3 ***int = &p2
    fmt.Println(p1, p2, p3)
    fmt.Println(*p1, **p2, ***p3)
}

----------
0xc4200160a0 0xc42000c028 0xc42000c030
42 42 42

指针变量本质上就是一个整型变量，里面存储的值是另一个变量内存的地址。* 和 & 符号都只是它的语法糖，是用来在形式上方便使用和理解指针的。* 操作符存在两次内存读写，第一次获取指针变量的值，也就是内存地址，然后再去拿这个内存地址所在的变量内容。


如果普通的变量是一个储物箱，那么指针变量就是另一个储物箱，这个储物箱里存放了普通变量所在储物箱的钥匙。通过多级指针来读取变量值就好比在玩一个解密游戏。
Go 语言基础类型大全
Go 语言定义了非常丰富的基础类型，下面我列举了所有的基础数据类型。
package main

import "fmt"

func main() {
    // 有符号整数，可以表示正负
    var a int8 = 1 // 1 字节
    var b int16 = 2 // 2 字节
    var c int32 = 3 // 4 字节
    var d int64 = 4 // 8 字节
    fmt.Println(a, b, c, d)

    // 无符号整数，只能表示非负数
    var ua uint8 = 1
    var ub uint16 = 2
    var uc uint32 = 3
    var ud uint64 = 4
    fmt.Println(ua, ub, uc, ud)

    // int 类型，在32位机器上占4个字节，在64位机器上占8个字节
    var e int = 5
    var ue uint = 5
    fmt.Println(e, ue)

    // bool 类型
    var f bool = true
    fmt.Println(f)

    // 字节类型
    var j byte = 'a'
    fmt.Println(j)

    // 字符串类型
    var g string = "abcdefg"
    fmt.Println(g)

    // 浮点数
    var h float32 = 3.14
    var i float64 = 3.141592653
    fmt.Println(h, i)
}

-------------
1 2 3 4
1 2 3 4
5 5
true
abcdefg
3.14 3.141592653
97

编程最简单的算法之一，莫过于变量交换。交换变量的常见算法需要一个中间变量进行变量的临时保存。用传统方法编写变量交换代码如下：
var a int = 100
var b int = 200
var t int
t = a
a = b
b = t
fmt.Println(a, b)

在计算机刚发明时，内存非常“精贵”。这种变量交换往往是非常奢侈的。于是计算机“大牛”发明了一些算法来避免使用中间变量：
var a int = 100
var b int = 200
a = a ^ b
b = b ^ a
a = a ^ b
fmt.Println(a, b)

这样的算法很多，但是都有一定的数值范围和类型要求。
到了Go语言时，内存不再是紧缺资源，而且写法可以更简单。使用 Go 的“多重赋值”特性，可以轻松完成变量交换的任务：
var a int = 100
var b int = 200
b, a = a, b
fmt.Println(a, b)

多重赋值时，变量的左值和右值按从左到右的顺序赋值。
多重赋值在Go语言的错误处理和函数返回值中会大量地使用。例如使用Go语言进行排序时就需要使用交换，代码如下：
type IntSlice []int
func (p IntSlice) Len() int           { return len(p) }
func (p IntSlice) Less(i, j int) bool { return p[i] < p[j] }
func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

代码说明如下：

第 1 行，将 IntSlice 声明为 []int 类型。
第 3 行，为 IntSlice 类型编写一个 Len 方法，提供切片的长度。
第 4 行，根据提供的 i、j 元素索引，获取元素后进行比较，返回比较结果。
第 5 行，根据提供的 i、j 元素索引，交换两个元素的值。

变量降维: （Variable dimension reduction） 涉及因子分析/主成分分析等，通过使用这个工具，可以将多个变量减少，用新的核心变量进行替代，并将新变量用线性关系表示。从而减少变量字段过多造成的数据分析复杂度。将20个变量用6个变量进行替换，该6个变量及就成为新的变量。
# Retain numeric digits
covariances<-newdata
covariances<- cov(covariances)
correlations<-cov2cor(covariances)
print(correlations)
library(psych)
fa.parallel(correlations,n.obs=length(newdata[,1]),fa="both",n.iter=100,main="Scree plots with parallel analysis")
fa<-fa(correlations,nfactors=n,rotate="none",fm="pa")
print(fa)
fa.varimax<-fa(correlations,nfactors= n,rotate="varimax",fm="pa")
print(fa.varimax)
library(GPArotation)
fa.promax<-fa(correlations,nfactors=n,rotate="promax",fm="pa")
print(fa.promax)

上述进行的是主成分分析，对因子进行降维，因子一般为数值型变量  。
fsm<-function(oblique){
  if(class(oblique)[2]=="fa"&is.null(oblique$Phi)){
    warning("Object doesn't look like oblique EFA")
  }else{
    P<-unclass(oblique$loading)
    F<-P%*%oblique$Phi
    colnames(F)<-c("PA1","PA2")
    return (F)
  }
}
fsm(fa.promax)
factor.plot(fa.promax,labels=rownames(fa.promax$loadings))
fa.diagram(fa.promax,simple=TRUE)
print(fa.promax$weights)

上述是对因子进行了因子旋转降维，最终可以查看因子载荷和相关系数。