Go 基础知识

基础结构

　　 在Go语言中，基础结构如下：

package main
// 当该文件作为一个可执行文件，而不是一个模块时，必须导入main

import "fmt"

// 入口函数外只能书写一些全局的变量、常量、函数名等标识符

func main(){
	fmt.Println("HELLO,WORLD") // 所有的代码，都书写在main入口函数中
}

注释方式

　　 在Go语言中，注释方式统一为//。

命名方式

　　 在GO语言中，标识符的命名必须是字母，数字，下划线组成。

　　 并且不能由数字开头。

　　 GO语言更推荐使用小驼峰的命名方式 。

var userName string // 第一个单词首字母小写，其他单词首字母大写

关键字

　　 不要使用关键字作为标识符。

　　 关键字是指编程语言中预先定义好的具有特殊含义的标识符。 Go语言中有25个保留字。

    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

保留字

　　 不要使用保留字作为标识符。

　　 Go语言中有37个保留字。

    Constants:    true  false  iota  nil

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

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

声明方式

全局声明

　　 在入口函数外声明的标识符即是全局声明。

　　 全局声明的标识符可以在程序中不进行使用，这样并不会抛出什么异常。

package main

import "fmt"

var userName string  // 全局声明

func main(){
	fmt.Println("HELLO,WORLD")
}

局部声明

　　 入口函数内声明的标识符都是局部声明。

　　 局部声明的标识符必须进行使用，如果不使用则会抛出异常。

　　 这是为了防止编译后的可执行文件体积过大的问题。

package main

import "fmt"

func main(){
	var userName string // 局部声明
	//  .	1.go:6:6: userName declared but not used
	fmt.Println("HELLO,WORLD")
}

变量相关

　　 声明一个变量使用关键字var

标准声明

　　 标准声明的声明格式如下：

var 变量名 变量类型

　　 如下，声明一个userName的变量，类型为string。

var userName string

批量声明

　　 可以使用批量声明来进行多个变量的声明。

　　 如下进行批量声明。

package main

import "fmt"

var (
	userName string
	userAge int8
	userGender bool
)

func main() {
	fmt.Println("HELLO,WORLD")
}

变量定值

　　 可以在声明的时候，对变量进行赋值。

package main

import "fmt"

var (
	userName string = "云崖先生"
)

func main() {
	fmt.Println(userName)
}

类型推导

　　 可以不指定类型，让=后面的变量值来决定变量的类型。

package main

import "fmt"

var (
	userName = "云崖先生"
)

func main() {
	fmt.Printf("变量类型：%T
变量值：%v", userName, userName)
	// 变量类型：string
	// 变量值：云崖先生
}

短变量

　　 可以不写var，使用:=来进行简便写法。

　　 注意：短变量声明的写法，只能放在局部进行声明

package main

import "fmt"


func main() {
	userName := "云崖先生"
	fmt.Printf("变量类型：%T
变量值：%v", userName, userName)
	// 变量类型：string
	// 变量值：云崖先生
}

匿名变量

　　 由于局部声明的变量必须使用，但有的时候我们对于一些变量并不想使用。

　　 如解构赋值出了函数的多个返回值，其中有一个变量没什么用，那么这个时候我们可以使用_将其作为匿名变量。

　　

　　 也就是说，匿名变量在局部即使定义后不使用，也不会抛出异常。

package main

import "fmt"

func f1() (string, string) {
	return "返回值1", "无用的返回值"
}

func main() {
	v1, _ := f1()
	fmt.Println(v1)
}

重复定义

　　 在同一个作用域下，禁止重复定义一个相同的变量。

package main

import "fmt"

func f1() (string, string) {
	return "返回值1", "无用的返回值"
}

func main() {
	v1 := "值1"
	var v1 string = "值2"
	fmt.Println(v1)
// 	# command-line-arguments
// .	1.go:11:6: v1 redeclared in this block
//         previous declaration at .	1.go:10:2
}

常量相关

　　 声明一个常量使用关键字const，常量中的值禁止再次更改，一经定义不允许修改。

　　 并且，常量在定义时必须赋值！否则就会抛出异常

标准定义

　　 标准声明的声明格式如下：

const 常量名 常量类型 = 常量值

　　 如下，声明一个userName的变量，类型为string。

const pi float64 = 3.1415926535897

批量定义

　　 可以使用批量定义来进行多个常量的声明定义。

　　 如下进行批量定义

package main

import "fmt"
const (
	pi float64 = 3.1415926535879
	height int32 = 122
	age int8 = 18
)

func main() {
	fmt.Println("hello,world")
}

省值定义

　　 在使用批量定义常量时，如果只有第一个产量给定了值而其他常量都没有给值。

　　 后面的常量将自动引用前面常量的值。

package main

import "fmt"
const (
	v1 = 100
	v2
	v3
)

func main() {
	fmt.Println(v1) // 100
	fmt.Println(v2) // 100
	fmt.Println(v3) // 100
}

iota

　　 iota是Go语言中的常量计数器，只能在定义常量时使用。

　　 iota在const关键字出现时将被重置为0。

　　 const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。

　　 使用iota能简化定义，在定义枚举时很有用。

package main

import "fmt"
const (
	v1 = iota
	v2
	v3
)

func main() {
	fmt.Println(v1) // 0
	fmt.Println(v2) // 1
	fmt.Println(v3) // 2
}

面试题

　　 使用_跳过某些值

package main

import "fmt"
const (
	v1 = iota
	_
	v2
	v3
)

func main() {
	fmt.Println(v1) // 0
	fmt.Println(v2) // 2
	fmt.Println(v3) // 3
}

　　 iota声明中间插队

package main

import "fmt"
const (
	v1 = iota
	v2
	v3
)
const v4 = 100 // 再次出现const iota清零
const v5 = iota

func main() {
	fmt.Println(v1) // 0
	fmt.Println(v2) // 1
	fmt.Println(v3) // 2
	fmt.Println(v4) // 100
	fmt.Println(v5) // 0
}

　　 多个iota定义在一行时，不会增加iota，只有当新增一行代码时（不为空）才会增加iota。

const (
		a, b = iota + 1, iota + 2 //1,2
		c, d                      //2,3
		e, f                      //3,4
	)

　　 定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）

const (
		_  = iota
		KB = 1 << (10 * iota)
		MB = 1 << (10 * iota)
		GB = 1 << (10 * iota)
		TB = 1 << (10 * iota)
		PB = 1 << (10 * iota)
	)

fmt基础

　　 fmt包中关于打印有三种。

Print

　　 Print只会进行打印，并不会进行换行，也不能进行格式化。

package main

import "fmt"

func main() {
	fmt.Print("hello,")
	fmt.Print("world!")
	// hello,world!
}

Printf

　　 Printf可以进行格式化，并不会进行换行。

package main

import "fmt"

func main() {
	number := 100
	fmt.Printf("八进制:%o", number)
	fmt.Printf("十进制:%0x", number)
	// 八进制:144十进制:64
}

Println

　　 Println可以进行换行，但不能进行格式化。

package main

import "fmt"

func main() {
	fmt.Println("hello")
	fmt.Println("world")
	// hello
	// world	
}

打印格式

　　 以下举例出一些常用的Go语言中的打印格式，关于其他打印格式在另外的编程语言分类中已有介绍。

占位符	说明
%v	值的默认格式表示
%+v	类似%v，但输出结构体时会添加字段名
%#v	值的Go语法表示
%T	打印值的类型
%%	百分号
%p	打印指针内存地址

其他内容

　　 其他内容会在后续文章，fmt标准库中进行详细罗列。