Golang基础

一、Golang基础

1.第一个Go程序

解读：

• 01.package:

Go源文件开头必须使用package声明代码所属包，包是Go代码分发的最基本单位。若程序需要运行，包名必须为main；

• 02.import：

import用于导入程序依赖的所有的包。此程序依赖于fmt包；

• 03func:

func用于定义函数，main函数是程序的入口，若程序需要运行必须声明main函数，main函数无参数也无返回值；

• 04fmt.Println:

调用fmt.Println函数将参数信息打印到控制台；

• 06.编译&运行:

go build:用于编译&链接程序或包;
go build -work -x -o hello_world.exe hello_world.go
go run:用于直接运行程序；
go run -work -x hello_world.go
常用参数：
-x:打印编译过程执行的命令，并完成编译或运行；
-n:只打印编译过程执行命令；
-work:打印编译过程的临时文件
-o:指定编译结果文件；

2.结构程序

Go源文件以package声明开头，说明源文件所属的包，接着使用import导入依赖的包，其次为包级别的变量、常量、类型和函数的声明和赋值。函数中可定义局部的变量与常量；

3.基本组成元素

1）：标识符

标识符是编程时所使用的名字，用于给变量、常量、函数、类型、接口、包名等进行命名，以建立名称和使用之间的关系，Go语言标识符的命名规则如下：

• A.只能由非空字母(Unicode)、数字、下划线"_"组成；
• B.只能以字母或下划线开头；
• C.不能使用Go的关键字；
• D.避免使用Go语言预定义标识符；
• E.建议使用驼峰法；
• F.标识符区分大小写；

Go语言提供一些预先定义的标识符用来标识内置的常量、类型、函数，在自定义标识符时，应避免使用；

• 内置常量：ture、false、nil、iota
• 内置类型：bool、byte、rune、int、int8、int16、int32、int64、uint、uint8、unit16、unit32、unit64、uintptr、float32、float64、complex64、complex128、string、error
• 内置函数：make、len、cap、new、append、copy、close、delete、complex、real、imag、panic、recover
• 空白标识符：_

2）：关键字

关键字用于特定的语法结构，Go语言定义25个关键字；
声明：import、package
实体声明和定义：chan、const、func、interface、map、struct、type、var
流程控制:break、case、continue、default、defer、else、fallthrough、for、go、goto、
if、range、return、select、switch

3）:字面量

字面量是值得表示方法，常用与对变量、常量进行初始化，主要分为如下：

• 标识基础数据类型值得字面量，例如：0， 1.1 ， ture , 3+4i , 'a' , "我爱中国 "
• 构造自定义的复合数据类型的类型字面量，例如：type、lnterval、int
• 用于表示复合类型值得复合字面量，用来构造array、slice、map、struct的值，例如：{1，2，3}

4）：字面量

• 算数运算符： + ， - ， * ， / ， % ， ++ ， --
• 关系运算符： > , >= ， < , <= , == , !=
• 逻辑运算符： && , || , !
• 位运算符： & , | , ^ , <<,>> , &**
• 赋值运算符：=,+=,-+,*=,/=,&=,7=，|=，……=，<<=,>>=
• 其他操作符：&(单目)，*（单目），.(点），-（单目），···，<-

5：分隔符

• 小括号（），中括号[],大括号{}，分号；，逗号，

4.声明

语句用于定义程序的各种实体对象，主要有：

• 声明变量的：var
• 声明常量的：const
• 声明函数的：func
• 声明类型的：type

5.变量

变量是指对一块存储空间定义名称，通过名称对存储空间的内容进行访问或修改，使用 var进行变量声明，常用的语法为:

• var 变量名 变量类型 = 值
  定义变量并进行初始化，例如：var name string = "slience"

• var 变量名 变量类型
  定义变量使用零值进行初始化，例如： var age int

• var 变量值 = 值
  定义变量，变量类型通过值类型进行推到，例如：var isBoy =true

• var 变量名1 ，变量名2 ，···，变量民名 变量类型
  定义多个相同类型的变量并使用零值进行初始化：例如：var prefix, suffix string

• var 变量名 1, 变量名 2 , …, 变量名 n 变量类型 = 值 1, 值 2, …, 值 n
  定义多个相同类型的变量并使用对应的值进行初始化，例如：var prev, next int = 3, 4

• var 变量名 1, 变量名 2 , …, 变量名 n = 值 1, 值 2, …, 值 n
  定义多个变量并使用对应的值进行初始化，变量的类型使用值类型进行推导，类型可不相同，例如：var name, age = "silence", 30

• 批量定义
  var (
  变量名 1 变量类型 1 = 值 1
  变量名 2 变量类型 2 = 值 2 )
  定义多个变量并进行初始化，批量复制中变量类型可省略
  例如：
  var (
  name string = "silence"
  age int = 30
  )

初始化表达式可以使用字面量、任何表达式、函数

package main

import "fmt"

var v0 int
var v1 int = 1
var v2 = 2
var v3, v4 int = 3, 4
var v5, v6 = "2", 6

func main() {
	var (
		v7 int = 2 + 9
		v8 int = v2 + v6
	)
	fmt.Println(v0,v1,v2,v3,v4,v5,v6,v7,v8)
}

6.简短声明

在函数内可以通过简短声明语句声明并初始话变量，可通过简短声明同时声明和初始化多个变量，需要注意操作符左侧的变量至少有一个未定义过

package main

import "fmt"

func main()  {
	n1, n2 := 1, 2
	fmt.Println(n1,n2)

	n2, n3  := 22, 3
	fmt.Println(n2,n3)
}

7.赋值

可以通过赋值运算=更新变量的值，Go语言支持通过元组赋值同时更新多个变量的值，例如：n1,n2 = 1,2,可用于两个变量的交换x,y=y,x

package main

import "fmt"

func main()  {
	n1, n2 := 1, 2
	fmt.Println(n1,n2)
	n1, n2 = n2, n1
	fmt.Println(n1,n2)
}

8.常量

常量用于定义不可修改的值，需要再编译过程中进行计算，只能为基础的数据类型布尔、数值、字符串，使用const进行常量声明，常用语法：

• const 常量名 类型 =
  定义常量并进行初始化，例如：const pi float64 = 3.1415926
• const 常量名 =值
  定义常量，类型通过值类型进行推导，例如：const e = 2.7182818
• 批量定义
  const (
  常量名 1 类型 1 = 值 1 常量名 2 类型 2 = 值 2 )

定义多个变量并进行初始化，批量复制中变量类型可省略，并且除了第一个常量值外其他常量可同时省略类型和值，表示使用前一个常量的初始化表达式,例如：

const (
		name string = "silence"
		age int = 30
	)
	const (
		name string = "silence"
		desc
	)

常量之间的运算，类型转换，以及对常量调用函数len、cap、real、imag、complex、unsafe.Sizeof得到的结果依然为常量

package main

import "fmt"

const c1 int = 1
	const c2 int = 3-1
	
	const c3,c4 int  = 3,4
	const c5,c6 = "5", c2 + c4

func main()  {
	const(
		c7 int = 7
		c8
	)
	fmt.Println(c1,c2,c3,c4,c5,c6,c7,c8)
}	

9.作用域

作用域指变量可以使用范围。go语言使用大括号现实的标识作用域范围，大括号内包含一连串的语句，叫做语句块。语句块可以嵌套，语句块定义的变量不能在语句块外使用
常见隐式语句块：

• 全语句块
• 包语句块
• 文件语句块
• if、switch、for、select、case语句块

作用域内定义变量只能被声明一次且变量必须使用，否则编译错误。在不同作用域可定义相同的变量，此时局部覆盖全局

package main

import "fmt"

func main()  {
	outer := 1
	{
		inner := 2
		fmt.Println(outer,inner)
		outer := 3
		fmt.Println(outer,inner)
	}
	//fmt.Println(outer,inner)
	fmt.Println(outer)

}	

10.注释

Go支持两种注释方式，行注释和块注释：

• 行注释：以//开头，例如：// 我是行注释
• 块注释：以"/"开头，以/结尾，例如：/我是块注释/

package main

import "fmt"

func main()  {
	//我是行注释
	//使用发fmt包的Println函数将Hello World字符串打印到控制台
	fmt.Println("Hello World")
	
	/*
	我是块注释
	使用发fmt包的Println函数将Hello World字符串打印到控制台
	*/
	fmt.Println("Hello World")
}	

11.问题追踪

最基本的问题跟追踪方式，我们可以用fmt包中提供的Println、Print、Printf函数用于将信息打印到控制台，帮助我们进行问题调试，基本使用方法：