go int32不能打印0_Go语言基础（二）

Go语言基础（二）

一、标识符与关键字

二、变量

1、标准变量

2、短变量声明

3、匿名变量

三、常量

四、基本数据类型

---

一、标识符与关键字

Go语言中标识符由字母和数字以及_(下划线)组成，并且只能以字母和_开头

关键字有25个：

break    default        func       interface    select
case     defer          go         map          struct
chan     else           goto       package      switch
const    fallthrough    import     if           range
type     for            continue   var          return

此外，go语言还有37个保留字。

Constants:    true   false    iota    nil

Types:        int      int8      int16      int32      int64
              uint     uint8     uint16     uint32     uint64
              float32  float64   complex128    complex64
              bool     byte      string     error

Functions:    make     len     cap     new     append     copy     close     delete
              complex     real      imag
              panic       recover

二、变量

1、标准变量

Go语言中的变量必须先声明再使用，Go语言变量声明格式：

var 变量名 变量类型

变量声明以关键字var开头，变量类型放在变量名后，举个例子：

var name string
var age int
var isOk bool

当然也可以批量声明变量：

package main

import "fmt"

var (
	name string
	age  int
	isOk bool
)

func main() {
	name = "理想"
	age = 19
	isOk = true
	fmt.Print(name)
	fmt.Printf("age:%d", age)
	fmt.Println()
}

注意事项：Go语言中非全局变量声明后必须使用，否则编译失败报错。此外Go语言中推荐使用驼峰式命名。在同一个作用域中不能重复声明同名变量。

变量初始化的标准格式如下：

var 变量名 类型 = 表达式

举个例子：声明变量的同时进行赋值

var name string = "zhangsan"
var age int = 16

或者一次初始化多个变量

var name, age = 'zhangsan', 16

有时候可以将变量的类型忽略，这时候编译器就会根据等号右侧的值来推导变量的类型完成初始化，这就是类型推导。

2、短变量声明

在函数内部，可以使用更简略的方式 := 方式声明并初始化变量

package main

import "fmt"

func main(){
	n := 10
	m := 200
	fmt.Println(m, n)
}
// 注意事项：一定是在函数内部，才能使用简短变量声明

3、匿名变量

在使用多重赋值时，如果需要忽略某个值，可以使用匿名变量，一个下划线_表示。

package main

import "fmt"

var x int
var y string

func foo()(int, string){
	return 10, "mogul"
}

func main(){
	x, _ = foo()
	_, y = foo()
	fmt.Println("x", x)
	fmt.Println("y", y)
}

注意：匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

三、常量

常量在定义的时候必须赋值。一旦定义常量之后不能被修改，

const pi = 3.1415
const e = 2.7182

// 或者批量声明常量

const (
	pi = 3.1415
	e = 2.7182
)

需要注意的是在批量声明常量的过程中，如果出现声明常量没有赋值，默认就和上一行一致

package main

import "fmt"

const (
	n1 = 100
	n2
	n3
)

func main(){
	fmt.Println("n1", n1)
	fmt.Println("n2", n2)
	fmt.Println("n3", n3)
}

iota是go语言中的常量计数器，只能在常量的表达式中使用。iota在const关键字出现的时候将被重置为0，const中每新增一行声明，iota计数一次。

const (
	a1 = iota // 0
	a2        // 1
	a3        // 2
)

const (
        b1 = iota // 0
	b2 = 100  // 100
	b3 = iota // 2
        b4        // 3
)

const (
        d1, d2 = iota + 1, iota + 2    // d1:1   d2:2
	d3, d4 = iota + 1, iota + 2    // d3:2   d4:3 
)

//定义数量级
const (
        _ = iota
	KB = 1 << (10 * iota)
        MB = 1 << (10 * iota)
        GB = 1 << (10 * iota)
        TB = 1 << (10 * iota)
        PB = 1 << (10 * iota)
)

四、基本数据类型

Go语言中除了基本的数据类型有整型、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道等。

1、整型

整型主要分为以下两类：有符号int8，int16，int32，int64；

无符号uint8，uint16，uint32，uint64

其中，uint8就是熟知的byte类型，int16对应C中的short，int64对应C中的long；

特殊整型

2、8进制&16进制

Go语言中无法直接定义一个二进制数。

%b，把十进制输出二进制

%o，把十进制输出八进制，八进制数一般用于文件权限

%x，把十进制输出十六进制，十六进制数一般用于内存地址

%T，查看变量类型

package main

import "fmt"

func main(){
	var a int = 10
	fmt.Printf("%dn", a)  // 10
	fmt.Printf("%bn", a)  //1010 占位符%b表示二进制

	// 八进制，以0开头
	var b int = 077
	fmt.Printf("%on", b)  // 77

	// 十六进制，以0x开头
	var c int = 0xff    
	fmt.Printf("%xn", c)  // ff
	fmt.Printf("%Xn", c)  // FF
}

3、浮点型

Go语言支持两种浮点型：float32和float64，这两种浮点型数据格式遵循IEEE754标准，float32的浮点数最大范围是3.4e38，可以使用常量定义：math.Maxfloat32。float64的浮点数的最大范围是1.8e308，可以使用常量定义：math.Maxfloat64。

Go语言中小数默认是float64类型。

%f：输出浮点数

package main

import "fmt"

func main(){
	f1 := 1.23456
	fmt.Printf("%Tn", f1)
	f2 := float32(1.23456)
	fmt.Printf("%Tn", f2)
}
// 注意f1 = f2是错误的，因为二者属于不同的数据类型不能直接赋值

4、复数

complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

5、布尔值

跟其他语言一样，布尔型数据只有true和false两个值，但是值得特别注意的是：

a、Go语言中不允许整型强制转换为布尔型；

b、布尔型数据无法参与数值运算，也无法与其他类型进行转换；

c、布尔型变量默认是false

package main

import "fmt"

func main(){
	b1 := true
	var b2 bool
	fmt.Printf("%Tn", b1)
	fmt.Printf("%T value:%vn", b2, b2)
}

6、字符串

Go语言中字符串内部实现使用utf-8编码，且只能用双引号包括起来。用单引号包括的是字符。

s := "henan"
c := 'h'
// 字节： 1字节=8bit(8个二进制位)
// 1个字符=1个字节
// 1个utf-8编码的汉字 = 一般占3个字节

字符串的转义符

举个例子，打印一个双引号包括的路径：

package main

import "fmt"

func main(){
	path := ""D:go_projectsrcstudygoday01helloworld""
	fmt.Println(path)
}

定义多行字符串

s := `
   世情薄
   人情恶
   雨送黄昏花易落
`

字符串的常用操作：

s1 := "he"
s2 := "nan"
ss1 = s1 + s2
ss2 = fmt.Sprintf("%s%s", s1, s2)

遍历字符串

package main

import "fmt"

func main(){
	path := ""D:go_projectsrcstudygoday01helloworld""
	for _, c := range path{
		fmt.Printf("%cn", c)
	}
}

修改字符串

如果需要修改字符串，需要先将其转换为[]rune类型或者[]byte类型，无论哪种转换都会重新分配内存并赋值字节数据。

package main

import "fmt" 

func main(){
	s1 := "白萝卜"
	s2 := []rune(s1)
	s2[0] = '红'
	fmt.Println(string(s2))
}

7、byte和rune

组成每个字符串的元素叫做字符，可以通过遍历或者单个获取字符串得到字符。

Go语言中包括两种字符：

a、uint8类型，或者叫bytes类型，代表ASCII码的一个字符

b、rune类型，代表了一个utf-8字符

当需要处理中文、日文、或者其他符合字符时，则需要用到rune类型，实际上它是int32类型，Go使用特殊的rune类型来处理Unicode。

package main

import "fmt" 

func main(){
	c1 := "白"
	c2 := '白'
	fmt.Printf("c1:%T,c2:%Tn", c1, c2)
}

8、类型转换

Go语言中只有强制类型转换，没有隐式类型转换，该语法只能在两个数据类型之间支持相互转换的时候才能使用。

package main

import "fmt" 

func main(){
	n := 10  //int
	var f float64
	f = float64(n)
	fmt.Println(f)
	fmt.Printf("%Tn", f)
}

我是尾巴

每日一句毒鸡汤：单纯地相信当然不会让事情变好，但是相信点什么总不是件坏事，一切都会变好的。

本次推荐：http://www.shipinyu.cn/ 一款音乐搜索神器，多站合一！

[全网音乐下载](http://www.shipinyu.cn/)

继续加油~