Go 语言数据类型

变量与常量

变量声明 ，初始化与赋值

单个变量声明和赋值

1）变量的声明格式：var <变量名称>【变量类型】

2）变量的赋值格式：<变量名称> =< 值 ，表达式，函数等>

3)声明和赋值同时进行:var <变量名称>【变量类型】=<值，表达式，函数等>

4)分明声明格式：

var(

i int

j float 32

name string

)

a.同一行声明多个变量和赋值：var a,b,c int=1,2,3 或者a,b :=1,2

b.全局变量的声明必须使用var 关键词，局部变量则可以省略,比如a.里面a,b :=1,2只能用到函数内

c,特殊变量下划线“_” 这里的_就是个垃圾桶，把值扔进了垃圾桶后，程序中再不用这个值相当于php里的unset

变量的类型转换

1)GO中不存在隐式转换，类型转换必须是显式的（必须要有目标类型）

2）类型转换只能发生在两种兼容类型之间（int和bool之间是没法转换的）

3）类型转换格式：<变量名称>[:]=<目标类型>(<需要转换的变量>)

变量可见性规则

1）大写字母开头的变量是可导出的，也就是其他包可以读取的，是公用变量

2）小写字母开头的就是不可导出的，是私有变量

test.go

package wangwawa

import "fmt"

var Name string = "wawa"; //变量名首字母大写，可被其他包引用

func init() {
   fmt.Println("this is wangwawa test")
}
func Test()  {

}

varTest.go

//程序所属包 *必须

package main

//导入依赖包

import (
   "fmt"
   "reflect"
   "unsafe"
   "awesomeProject/wangwawa"
)

var a int

var b int = 12345;

var (
   c int
   d int = 1234
   e string
)
var i,g,h int=4,5,6
var w,v,m =4,5.2,6 //类型可不写，不写就默认电脑位数类型

//main函数
func main(){

   fmt.Println(wangwawa.Name)
   ww,www,wwww := 4,5.2,6 //这种写法只能在函数内

   var k,_,kk = 3,4.4,4  //_代表放弃，垃圾桶
   var (
      f string
   )

   var n int =3
   nn := float32(n)

   fmt.Println(nn)
   fmt.Println(reflect.TypeOf(nn))
   fmt.Println(unsafe.Sizeof(nn))
   fmt.Println(a) //int默认值为0
   a = 123;
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Println(d)
   fmt.Println(e) //string默认值为空
   fmt.Println(f)
   fmt.Println(i)
   fmt.Println(h)
   fmt.Println(g)
   fmt.Println(w)
   fmt.Println(reflect.TypeOf(w))
   fmt.Println(v)
   fmt.Println(reflect.TypeOf(v))
   fmt.Println(m)
   fmt.Println(ww)
   fmt.Println(www)
   fmt.Println(wwww)
   fmt.Println(k)
   fmt.Println(kk)
}

运行结果：

this is wangwawa test
wawa
3
float32
4
0
123
12345
0
1234

4
6
5
4
int
5.2
float64
6
4
5.2
6
3
4
 

常量，常量声明和iota的使用

1)常量定义形式和常量类型范围

a.常量定义形式上可分为显式和隐式

显式：const identifier  [type] = value

隐式：const identifier = value (通常叫无类型常量)

b.常量可以使用内置表达式定义，例如：len(),unsafe.Sizeof()等

c.常量范围目前只支持布尔型、数字型（整数，浮点和复数）和字符串型

constTest.go

//程序所属包 *必须
package main

import (
   "fmt"
   "reflect"
)

const name string  = "wawa";

const w_name  = "wawa";

const (
   title = "test"
   dog string = "dog"
)

const names,code = "wawa",0
const aname  = len(dog)//表达式 这里的函数只能是内置函数，其他自定义的会报错


//第二个()是返回类型
func ic(g string)(string)  {
   return "11"
}
//main函数
func main(){
   fmt.Println(ic(w_name))
   fmt.Println(name)
   fmt.Println(w_name)
   fmt.Println(title)
   fmt.Println(dog)
   fmt.Println(names)
   fmt.Println(reflect.TypeOf(names))
   fmt.Println(code)
   fmt.Println(reflect.TypeOf(code))
   fmt.Println(aname)
}

运行结果：

11
wawa
wawa
test
dog
wawa
string
0
int
3

2)特别常量iota的使用
a. iota在const关建字出现时将被重置为0

b. const中每新增一行常量声明将使iota计算一次

c.iota常见使用法：

1.跳值使用法

2.插队使用法

3.表达式隐式使用法

4.单行使用法

iota不可以用于函数内

iotaTest.go

//程序所属包 *必须

package main

//导入依赖包

import (
   "fmt"
)
const a = iota
const (
   d = iota //0
   b  =  iota //1
   _ //垃圾桶，跳过2
   _ //垃圾桶，跳过3
   c  =  iota //4
   e  =  3.14 //中间把5插一个进来成3.14
   f  =  iota //6
   g  =  iota * 2 //7 7*2
   h //省略 iota写法，自动引用最上面非空表达式 8*2
   i //省略 iota写法，自动引用最上面非空表达式 9*2
   j = iota //10
   k,l = iota+1, iota+3 //12 14
   m,n //13  15  m引用的k,n引用的是l
   o = iota //13
)
//main函数
func main(){
   fmt.Println(a)
   fmt.Println(d)
   fmt.Println(b)
   fmt.Println(c)
   fmt.Println(e)
   fmt.Println(f)
   fmt.Println(g)
   fmt.Println(h)
   fmt.Println(i)
   fmt.Println(j)
   fmt.Println(k)
   fmt.Println(l)
   fmt.Println(m)
   fmt.Println(n)
   fmt.Println(o)
}

运行结果：

0
0
1
4
3.14
6
14
16
18
10
12
14
13
15
13