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可以使用+进行连接

关键字和保留字

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

预定义标识符

append	bool	byte	cap	close	complex	complex64	complex128	uint16
copy	false	float32	float64	imag	int	int8	int16	uint32
int32	int64	iota	len	make	new	nil	panic	uint64
print	println	real	recover	string	true	uint	uint8	uintptr

数据类型

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

数字类型

整型

uint8	无符号 8 位整型
uint16	无符号 16 位整型
uint32	无符号 32 位整型
uint64	无符号 64 位整型
int8	有符号 8 位整型
int16	有符号 16 位整型
int32	有符号 32 位整型
int64	有符号 64 位整型
uint	无符号整型 至少32位
int	整型 至少32位
uintptr	等价于无符号64位整型，但是专用于存放指针运算，用于存放死的指针地址。

浮点型

float32	32位浮点数
float64	64位浮点数

复数

complex128	64位实数和虚数
complex64	32位实数和虚数

常量

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

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

常量声明时需使用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
}