go基础（一）

• 包声明
• 引入包
• 函数
• 变量
• 语句&表达式
• 注释

package main//包声明

import "fmt"//引入包
//函数
func main() {
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}

基础语法

标记

go程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号。

fmt.Println("Hello,World!")

1. fmt
2. .
3. Println
4. (
5. "Hello, World!"
6. )

行分隔符

go程序中，一行代表一个语句结束，每个语句不需要在结尾以分号隔开，但是如果要将多个语句写在一行，那么必须分开。

注释

同Java，c

//
/**/

不多说

标识符

标识符基本同c，字母，数字，下划线，数字不能开头。

字符串连接

同java可以使用+进行连接

关键字和保留字

预定义标识符

数据类型

• 布尔型：只能为true或者false
• 数字类型：支持复数
  • int
  • float32
  • float64
• 字符串类型：字符串类型就是一串固定长度的字符连接起来的字符序列。Go的字符串是单个字节拼接起来的。go的字符串的字节使用UTF-8编码标识Unicode文本
• 派生类型：
  • 指针类型
  • 数组类型
  • 结构化类型
  • Channel类型
  • 函数类型
  • 切片类型
  • 接口类型
  • Map类型

数字类型

整型

浮点型

复数

常量

常量只能是基本数据类型，不能是

• 除基本类型以外的其它类型，如结构体，接口，切片，数组等
• 函数的返回值

常量声明时需使用const关键字，并且声明时必须指定值。

可以使用括号扣起来指定多个常量

const(
	Count = 1
	Name = lbd
)

iota

iota是一个内置的常量标识符，常用于表示一个常量中声明中无类型整数叙述，一般都是在括号中使用。

ps：（我的理解），感觉像是数学中的数列。

变量

声明

声明基本上和Java，c一致。

写一点点区别吧。

• var 变量名 类型名
• 短变量声明 name := 1

条件控制

基本同Java一样

fallthrough关键字

可以执行swtich-case相邻的下一分支

循环控制

格式基本同Java，c，for循环更加简洁，直接取消了for的括号，并且没有while循环，for直接被当作while来使用。

for range

for range可以更加方便的遍历一些可迭代的数据结构，如数组，切片，字符串，映射表，通道。

切片，数组

数组：在go中，数组作为值类型，不是引用数据类型。并且数组是定长的数据结构，长度被指定之后不能修改，而切片是不定长的，在容量不够时会自动进行扩容。

数组

go中的数组是值类型，不是和c一样是指向头部元素的指针。

初始化

数组在声明长度时长度只能是常量，不能是变量

var a [10]int

//错误样例

len := 10
var b [len]int

但是可以使用常量来进行长度的初始化。

当然使用元素初始化也可以，同Java，c一样。

访问

数组元素的访问和Java一样，只要有数组名和下标就可以进行访问。

切割

切割数组的格式为

arr[startIndex:endIndex],区间为左闭右开
//数组在进行切割之后，就会变成切片类型
fmt.Println("hello")
	var a [5]int
	for i := 0; i < 5; i++ {
		fmt.Scanf("%d", &a[i])
	}
	fmt.Println(a)

输出

[5]int
[]int

切片

切片用于存放不知道长度的数据，并且后续使用过程中可能会频繁插入数据和删除元素。

初始化

var nums []int // 值
nums := []int{1, 2, 3} // 值
nums := make([]int, 0, 0) // 值
nums := new([]int) // 指针

切片的底层实现实际上是数组，但是切片是引用类型，可以理解为指向底层数组的指针。

插入元素

切片元素的插入一般结合append函数使用

• 从头部插入元素
• 中间下标i插入元素
• 尾部插入元素

//头
nums =  append([]int{-1, 0}, nums…)
//中间下标i
nums = append(nums[:i+1], append([]int{0, 0}, nums[i+1:]...)...)
//尾部
nums = append(nums, 2, 3)

删除元素

和插入元素一样，都需要结合append函数使用

• 从头部删除n个元素
• 从尾部删除n个元素
• 从中间指定下标i位置开始删除n个元素
• 删除所有元素

//- 从头部删除n个元素
nums = nums[n:]
//- 从尾部删除n个元素
nums = nums[:len(nunms) - n]
//- 从中间指定下标i位置开始删除n个元素
append(nums[:i], nums[i + n]…)
//- 删除所有元素
nums = nums[:0]

字符串

字符串本质上是一个不可变的字节数组，也是一片连续的内存空间。

并且字符串有两种字面量表达方式，分为普通字符串和原生字符串。

普通字符串

普通字符串由双引号表示，支持转义，不支持多行书写。

原生字符串

原生字符串由反引号表示，不支持转义，支持多行书写，原生字符串里面所有的字符都会原封不动的输出，包括换行和缩进。

指针

go语言保留了指针，但是为了保证安全，又限制了指针的使用。

同c语言一样，有取地址符&和解引用符*。但是go语言禁止指针运算，也就是指针无法偏移。

new和make

func new(Type) *Type

• 返回值是指针
• 接收参数是类型
• 用于给指针分配内存空间

func new(Type) *Type

• 返回值是值
• 接收的第一个参数是类型，不定长参数根据传入的类型不同而不同
• 用于给切片，映射表，通道分配内存

new(int) // int指针
new(string) // string指针
new([]int) // 整型切片指针
make([]int, 10, 100) // 长度为10，容量100的整型切片 
make(map[string]int, 10) // 容量为10的映射表
make(chan int, 10) // 缓冲区大小为10的通道

函数

声明

• 通过func关键字直接声明
• 通过var关键字来声明。

func sum(a int, b int) int {
	return a + b
}

var sum = func(a int, b int) int {
	return a + b
}

go语言不支持函数重载。

其他基本和Java，c一般，就不再赘述，这里只简单说一下不同

返回值

func Sum(a, b int) int {
   return a + b
}

当没有返回值时，并不需要将int改为void，直接空着就行。

并且go允许有多个返回值，需要用括号将返回值括起来。

func number(a, b int) (int , int) {

​ return a + b, a - b

}

go语言也支持具名返回值，但是不能与参数名重复，使用具名返回时，return可以不用指定返回值

func Sum(a, b int) (ans int){
	ans =  a+ b
	return
}