go基础

查看go版本

go version

创建项目

核心：1.必须要有go.mod文件 ； 2.可执行文件的入口必须是 package main

1. 新建文件夹demo项目
2. 初始化go.mod文件 模块名:可以是任意字符串，通常是git地址

go mod init 模块名

3. 创建test.go文件

package main // 这里必须是 main

import "fmt"

func main() {
	fmt.Println("Hello, World! Go语言环境安装成功！")
}

4. 终端运行go

go run .
// 或者指定文件名
// go run test.go

变量初始化

package main

import "fmt"

func main() {
	//多重赋值
	var v2, v3, v4 int
	v2, v3, v4 = 1, 2, 3
	fmt.Println(v2, v3, v4)
	//直接赋值
	var x = 1
	fmt.Println(x)
	//自动推导
	name := "World"
	fmt.Println(name)
}

常量 && 枚举

package main

import "fmt"

func main() {
	//单常量
	const Pi float64 = 3.14
	fmt.Println(Pi)
	//多常量
	const (
		name = "xx"
		age  = 12
	)
	fmt.Println(name, age)
}

package main

import "fmt"

func main() {
	//iota 枚举
	//在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。
	const (
		x = iota // z == 0
		y = iota // y == 1
		z = iota // z == 2
	)
	fmt.Println(x, y, z)
	const v = iota // 每遇到一个const关键字，iota就会重置，此时v == 0
	const (
		h, i, j = iota, iota, iota // h=0,i=0,j=0 iota在同一行值相同
	)
	fmt.Println(h, i, j)

	const (
		a       = iota //a=0
		b       = "B"
		c       = iota             //c=2
		d, e, f = iota, iota, iota //d=3,e=3,f=3
		g       = iota             //g = 4
	)
}

基础数据类型

类型	名称	长度	零值	说明
bool	布尔类型	1	false	其值不为真即为假，不可以用数字代表true或false
byte	字节型	1	0	uint8别名
rune	字符类型	4	0	专用于存储unicode编码，等价于uint32
int, uint	整型	4或8	0	32位或64位
int8, uint8	整型	1	0	-128 ~ 127, 0 ~ 255
int16, uint16	整型	2	0	-32768 ~ 32767, 0 ~ 65535
int32, uint32	整型	4	0	-21亿 ~ 21 亿, 0 ~ 42 亿
int64, uint64	整型	8	0
float32	浮点型	4	0.0	小数位精确到7位
float64	浮点型	8	0.0	小数位精确到15位
complex64	复数类型	8
complex128	复数类型	16
uintptr	整型	4或8		⾜以存储指针的uint32或uint64整数
string	字符串		""	utf-8字符串

格式化输出

package main

import "fmt"

func main() {
	//字符串格式化
	var str = "world"
	fmt.Printf("hello %s\n", str)

	//字符格式化
	var ch1 = 97
	fmt.Printf("ch1 = %c\n", ch1)

	//数值类型格式化
	var ch2 = 10
	fmt.Printf("ch2 = %d\n", ch2)

	//数值类型格式化
	f := 3.14
	fmt.Printf("f = %f, %g\n", f, f) //f = 3.140000, 3.14

	//布尔类型
	fmt.Printf("%t, %t\n", true, false) //true, false

	//默认格式输出或者是使用其类型的String()方式输出
	fmt.Printf("数组打印：%+v\n", []int{1, 2, 3})

	//打印变量类型 int
	fmt.Printf("type %T\n", ch2)
	
	//打印指针
	m7 := map[int]string{1: "mike", 2: "yoyo"}
	fmt.Printf("指针: %p, 值: %+v\n", &m7, m7) //指针: 0xc00006a038, 值: map[1:mike 2:yoyo]
}

输入

package main

import "fmt"

func main() {
	var v int
	fmt.Println("请输入一个整型：")
	//fmt.Scanf("%d", &v) // 第一种写法，还需要注明格式
	//第二种写法，直接赋值，更简洁
	fmt.Scan(&v)
	fmt.Println("v = ", v)
}

时间

程序执行时间

package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    start := time.Now() // 获取开始时间
 
    // 你的代码逻辑
    fmt.Println("Hello, World!")
 
    elapsed := time.Since(start) // 计算执行时间
    fmt.Printf("Execution time: %s\n", elapsed)
}

条件判断

if

package main

import (
	"fmt"
)

func main() {
	a := 3
	if a > 3 {
		fmt.Println("a>3")
	} else if a < 3 {
		fmt.Println("a<3")
	} else if a == 3 {
		fmt.Println("a==3")
	} else {
		fmt.Println("error")
	}
}

switch

package main

import (
	"fmt"
)

func main() {
	var score int = 90

	switch score {
	case 90:
		fmt.Println("优秀")
	//fallthrough //如果加上这个关键字，一旦匹配上，则后面的无条件执行
	case 80:
		fmt.Println("良好")
	//fallthrough
	case 50, 60, 70:
		fmt.Println("一般")
	//fallthrough
	default:
		fmt.Println("差")
	}
}

循环

for

package main

import (
	"fmt"
)

func main() {
	var i, sum int
	for i = 1; i <= 100; i++ {
		sum += i
	}
	fmt.Println("sum = ", sum)
}

range

关键字 range 会返回两个值，第一个返回值是元素的数组下标，第二个返回值是元素的值：

package main

import (
	"fmt"
)

func main() {
	s := "abc"
	for i, c := range s {
		fmt.Printf("%d, %c\n", i, c)
	}
}

goto跳转语句

package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 5; i++ {
		fmt.Println(i)
		goto LABEL //跳转到标签LABEL，从标签处，执行代码
	}
	fmt.Println("this is test")
LABEL:
	fmt.Println("it is over")
}