Go lang phase 1

First Post:

Last Update:

Word Count:
1.2k

Read Time:
4 min

Go First

Env

  • go 1.21.2 Stable Version
  • Goland 2023.2.2

Hello World

1
2
3
4
5
6
7
package main

import "fmt"

func main() {
    fmt.Println("Hello World")
}

package main ：Go感觉上和Java有点像，都需要声明该源文件属于哪个包，package main代表其是一个可以独立执行的程序，同样和Java一样，每个Go应用程序都需要有一个main包

import "fmt"：告诉ide这个程序需要用fmt这个包，而fmt中实现了格式化IO函数

func main()：除init()外启动后第一个执行的函数

fmt.Println()：格式化输出，会在字符串后自动增加\n

对于一个标识符，如果其以大写字母开头，则可以被包外引用，类似于public；而如果以小写字母开头，则只能在包内使用，类似于protected

在Go中，{ 是不能单独放在一行里的，意味着在上方的helloworld.go中，只能写作func main() {而不能分在两行

Run Go

Go的源文件后缀为.go，在使用cli而非Goland等工具编写时，可以使用run和build指令

1
2
3
4
5
6
7
8
// Run
PS > go run .\helloworld.go
Hello world

//Build
PS > go build .\helloworld.go
PS > ./helloworld.exe
Hello world

Basic Syntax

Line separator

在Go中，每一行代表着一条语句的结束，而不需要使用;，但如果要在一行内执行多条语句，则需要使用;将他们分隔开

Exegesis

1
2
3
4
5
6
// Single-line exegesis

/*
	Multi-line
	exegesis
*/

Identifier

在Go中，标识符的命名和大多数语言一样，可以由大小写字母、数字、下划线共同构成，同样，必须以字母或下划线开头，而非使用数字

Strings

Concatenation

在Go中，字符串拼接非常简单，只需要使用+即可

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main() {
	fmt.Println("Hello" + "world")
}

// helloworld

Formation

在Go中，可以使用fmt.Sprintf和fmt.Printf来格式化字符串

  • func Sprintf(format string, a ...any) string：格式化字符串并赋值给新串

根据格式化参数生成格式化的字符串并返回该字符串，格式化样式中，格式化符号以%开头，%s为字符串，%d为十进制整数；参数列表中，各个参数之间以,隔开，其个数必须与前面的格式化样式对应

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Example 1
func main() {
    var str1 = "abc"
    var str2 = "zyx"
    var template = "str1 is %s and str2 = %s"
    var output = fmt.Sprintf(template, str1, str2)
    fmt.Println(output)
}

// str1 is abc and str2 = zyx

// Example 2
func main() {
	var num1 = 123
	var num2 = 987
	var template = "num1 is %d and num2 is %d"
	var output = fmt.Sprintf(template, num1, num2)
	fmt.Println(output)
}

// num1 is 123 and num2 is 987

常用的格式化符号

%v 按值的本来值输出
%+v 在 %v 基础上，对结构体字段名和值进行展开
%#v 输出 Go 语言语法格式的值
%T 输出 Go 语言语法格式的类型和值
%% 输出 % 本体
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%d 整型以十进制方式显示
%x 整型以十六进制方式显示
%X 整型以十六进制、字母大写方式显示
%U Unicode 字符
%f 浮点数
%p 指针，十六进制方式显示
  • func Printf(format string, a ...any) (n int, err error)：格式化字符串并写入标准输出

大体上和Sprintf类似，但不是赋值而是直接输出

Variable

声明变量一般使用var，格式为var name1, name2, ... type，如果定义一个变量但没有初始化，则会默认为零值，在Go中，变量也会自动判断类型，比如var name = value，会将name认为成和value一样的类型，

:=：在Go中可以使用该符号来快速定义一个变量，name := 1等价于var name int; name = 1，所以我们不能对一个已经声明过的变量使用:=

_

在Go中，_是空白标识符，作用是用来抛弃某个值，其存在的意义与Go对变量的要求有关

Go要求所有局部变量必须被使用（全局变量不需要，赋值不算做使用），而如果一个函数的返回值有多个，但我们不想全部使用，则可以如下操作：

1
2
3
4
5
6
7
8
9
10
11
12
func main() {
    // 只需要第二个返回值
    _, num, _ = gen()
    fmt.Println(num)
}

func gen() (int, int, int) {
    a, b, c := 1, 2, 3
    return a, b, c
}

// 2

而与此同时，由于Go中相同类型的变量可以使用a, b = b, a进行快速的数值互换，所以在_, b = b, a中，b原先的值就被抛弃了

Constant

常量实在程序运行时不会被修改的量，定义如下

1
const name [type] = value

这里的type可以省略，让其自行判断类型

1
2
3
4
5
const (
	a = "hah"
    b = len(a)
    c = unsafe.Sizeof(a)
)

使用常量进行枚举时，函数必须得是内置函数，比如len()，unsafe.Sizeof()等等

iota

iota是Go中一个特殊的常量，其可以被编译器进行修改。iota在const出现时会被重置为0，而在之后每新增一项声明就会使iota += 1

1
2
3
4
5
6
const (
	a = iota
    b = iota
)

// a = 0, b = 1
reward
Alipay
Wechat
≡