golang学习笔记1——基础知识

golang变量的声明

声明变量有两种方式：

使用var声明变量

// 声明一个整型数据
var a int

// 声明一个字符串
var s string

// 声明一个浮点数组
var c [2]float32

// 声明一个函数
var d func(int) bool

// 声明一个结构体
var e struct {
	x int
}

使用:=声明变量并赋值

例如：

age := 20
name := "zhangsan"

golang变量的初始化

使用var声明并初始化

初始化变量的格式一般为：

var 变量名 变量类型 = 表达式或值

例如：

var name string = "xiaoming"

由于编译器会自动推断数据类型，所以上面的赋值语句可以省略变量类型：

var name = "xiaoming"

使用:=声明并初始化

另外，golang中还有一种短变量的声明并初始化方式，即使用:=，例子如下：

name := "zhangsan"

需要注意的是，如果一个变量已经声明，则不能再使用:=为变量赋值，否则编译器会报错，如下代码：

var name string

name := "zhangsan" // 编译报错：no new variables on left side of :=

短变量可以一次声明多个变量并同时赋值，如下代码：

// 同时声明name和age变量并分别赋值为"zhangsan", 20
name, age := "zhangsan", 20

这种一次赋值多个变量的方式，还能轻松完成两个变量的交换，如下代码：

a := 1
b := 2
// 将a, b的值交换，交换后a = 2, b = 1
a, b = b, a

匿名变量

使用_可以表示一个匿名变量，假如有一个函数返回两个整型值，我们只需要接收第一个值，可以用如下代码：

func Test() (int, int) {
	return 1, 2
}

func main() {
	// 使用_表示匿名变量
	a, _ := Test()
	fmt.Println(a)
}

匿名变量不占用命名空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

golang基本数据类型

整型

golang中的整数分为两个大类：

1. 按长度分：int8, int16, int32, int64
2. 无符号整型：uint8, uint16, uint32, uint64

uint8对应byte类型，int16对应C语言中的short类型，int64对应C语言中的long类型

浮点型

golang支持两种浮点型数：float32, float64

bool类型

golang中的布尔类型有true false两个值，如下代码：

var b = false
success := true

注意：整型无法强转成bool类型，比如下面的代码会报错：

var a bool = 1 // 错误，整型无法强转为bool类型 

字符串

golang中的字符串必须用双引号包裹起来，如下代码：

var like string = "swimming"

var name = "zhangsan"

major := "math"

定义多行字符串可以使用反引号：

func main() {
	s := `hello,
	my name is zhangsan,
	nice to meet you!`
	fmt.Println(s)
}

字符串在任何一种编程语言中都是最常用的数据类型之一，关于golang中的字符串，需要知道如下一些基本操作：

• 字符串长度
• 字符串拼接
• 字符串查找
• 字符串格式化输出
• 字符串截取

字符串长度

golang中获取字符串长度分两种：ASCII字符串长度和Unicode字符串长度，如下代码所示：

s := "hello world"
// 字符串长度
fmt.Println(len(s)) // 11

dog := "王大锤"
// ASCII 字符串长度使用 len() 函数
fmt.Println(len(dog)) // 9
// Unicode 字符串长度使用 utf8.RuneCountInString() 函数
fmt.Println(utf8.RuneCountInString(dog)) // 3

字符串拼接

示例代码：

s := "hello world"
name := ", zhangsan"
// 字符串拼接， += 操作仅限字符串与字符串
s += name
fmt.Println(s)

// 字符串与非字符串类型的拼接
var str string = fmt.Sprintf("I am %d years old.", 20)
fmt.Println(str) // I am 20 years old.

字符串查找

示例代码：

s := "hello world"
// 查找d在s中的索引
fmt.Println(strings.Index(s, "d")) // 10

strings.Index()是正向搜索，strings.LastIndex()是反向搜索

字符串格式化输出

使用fmt.Printf()格式化输出字符串，示例代码如下：

name := "zhangsan"
age := 20
job := "teacher"
// hello, this is zhangsan, I'm 20 years old and I'm a teacher
fmt.Printf("hello, this is %v, I'm %v years old and I'm a %v", name, age, job)

格式化字符串时，有如下一些占位符：

占位符	功能
%v	按值的本来值输出
%f	浮点数
%d	整型以十进制方式显示
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%U	Unicode 字符
%p	指针，十六进制方式显示
%+v	在 %v 基础上，对结构体字段名和值进行展开
%#v	输出 Go 语言语法格式的值
%T	输出 Go 语言语法格式的类型和值
%%	输出%

字符串截取

s := "hello world"
fmt.Println(s[:5]) // hello
fmt.Println(s[6:]) // world

字符类型

golang中的字符类型分两种：ASCII字符和UTF-8字符，分别称为byte类型和rune类型，如下代码：

var b byte = 'a'
var c rune = '你'
// b: uint8, c: int32
fmt.Printf("b: %T, c: %T", b, c)

byte类型实际就是uint8，rune类型实际就是int32

常量

使用const定义常量：

const name = "zhangsan"
fmt.Println(name)
name = "lisi" // 报错：cannot assign to name

枚举

目前golang中没有枚举这个类型，可以使用const + iota的方式模拟枚举，如下代码：

package main

import "fmt"

type Color int

const (
	BLUE = iota
	RED
	GREEN
	BLACK
	WHITE
)

func main() {
	// 0 1 2 3 4
	fmt.Println(BLUE, RED, GREEN, BLACK, WHITE)
}

golang指针

golang中的指针与C语言中的指针类似，也是使用&操作符对某个变量取地址，如下代码所示：

a := "hello"
var ptr = &a // ptr是指向字符串a的指针
fmt.Println(ptr) // 打印出ptr指针的地址

获取某个指针的值，使用*操作，如下代码所示：

name := "zhangsan"
ptr := &name
// my name is zhangsan
fmt.Printf("my name is %s", *ptr)

取地址操作符&和取指针值操作符*是一对互补的操作符，&取某个变量的地址，*取某个指针的值

使用new也可以创建指针，如下代码：

str := new(string)
*str = "hello world"
// 打印出*string，表示str是一个字符串指针
fmt.Printf("%T", str)
// 打印出hello world
fmt.Printf("\n%s", *str)

golang类型定义与类型别名

golang中使用type可以定义类型别名，但是有两种不同的方式，下面说明区别：

type NewInt int

这种方式表示将NewInt定义为一个int类型，那么后面再定义整型数据时，可以使用NewInt，如下代码：

var a NewInt = 1

定义类型别名使用下面这种方式：

type IntAlias = int

这种方式表示将int类型取一个别名为IntAlias，后面也可以用IntAlias代替整型类型，如下代码所示：

var b IntAlias = 3

综上来看，在golang中，类型定义与类型别名都是用type关键字，且都可以为某中数据类型定义一个新的名称，但是这两者是有区别的：

• 类型定义是定义了一种新的数据类型
• 类型别名是将某中数据类型取别名

下面的代码显示了类型定义与类型别名的区别：

type NewInt int

type IntAlias = int

func main() {

	var a NewInt = 1

	var b IntAlias = 2

	fmt.Printf("%T \n %T", a, b)
}

以上代码输出结果为：

main.NewInt 
 int

这表示main.NewInt是一种新的数据类型，只不过这种类型与int是同一种类型，而使用type IntAlias = int定义类型别名时，IntAlias就是int类型的数据。