go基础

查看go版本

shell

go version

创建项目

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

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

shell

go mod init 模块名

创建test.go文件

package main // 这里必须是 main

import "fmt"

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

终端运行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"
	"strconv"
)

func main() {
	// int 转 string
	num := 42
	str := strconv.Itoa(num)
	fmt.Printf("int转string: %d -> %q (类型: %T)\n", num, str, str)

	// string 转 int
	str2 := "123"
	num2, err := strconv.Atoi(str2)
	if err != nil {
		fmt.Printf("转换错误: %v\n", err)
	} else {
		fmt.Printf("string转int: %q -> %d (类型: %T)\n", str2, num2, num2)
	}
}

int64 和 string 互转

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// int64 转 string
	var num64 int64 = 9876543210
	str64 := strconv.FormatInt(num64, 10)
	fmt.Printf("int64转string: %d -> %q\n", num64, str64)

	// string 转 int64
	str3 := "9876543210"
	num642, err := strconv.ParseInt(str3, 10, 64)
	if err != nil {
		fmt.Printf("转换错误: %v\n", err)
	} else {
		fmt.Printf("string转int64: %q -> %d\n", str3, num642)
	}
}

数组/切片和字符串互转

package main

import (
	"fmt"
	"strings"
)

func main() {
	// 字节切片与字符串互转
	byteSlice := []byte{'H', 'e', 'l', 'l', 'o'}
	strFromBytes := string(byteSlice)
	fmt.Printf("字节切片转字符串: %v -> %q\n", byteSlice, strFromBytes)

	bytesFromStr := []byte("Hello")
	fmt.Printf("字符串转字节切片: %q -> %v\n", "Hello", bytesFromStr)

	// rune切片与字符串互转（处理Unicode字符）
	runeSlice := []rune{'世', '界', '你', '好'}
	strFromRunes := string(runeSlice)
	fmt.Printf("rune切片转字符串: %v -> %q\n", runeSlice, strFromRunes)

	runesFromStr := []rune("世界你好")
	fmt.Printf("字符串转rune切片: %q -> %v\n", "世界你好", runesFromStr)

	// 字符串分割为字符串切片
	csvString := "apple,banana,cherry"
	stringSlice := strings.Split(csvString, ",")
	fmt.Printf("字符串分割为切片: %q -> %v\n", csvString, stringSlice)

	// 字符串切片合并为字符串
	joinedString := strings.Join(stringSlice, "|")
	fmt.Printf("切片合并为字符串: %v -> %q\n", stringSlice, joinedString)
	
	/**
	字节切片转字符串: [72 101 108 108 111] -> "Hello"
	字符串转字节切片: "Hello" -> [72 101 108 108 111]
	rune切片转字符串: [19990 30028 20320 22909] -> "世界你好"
	字符串转rune切片: "世界你好" -> [19990 30028 20320 22909]
	字符串分割为切片: "apple,banana,cherry" -> [apple banana cherry]
	切片合并为字符串: [apple banana cherry] -> "apple|banana|cherry"
	*/
	
}

float和字符串互转

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// float64 转 string
	f := 3.1415926535
	str := strconv.FormatFloat(f, 'f', 4, 64) // 保留4位小数
	fmt.Printf("float64转string: %f -> %q\n", f, str)

	// string 转 float64
	str2 := "2.71828"
	f2, err := strconv.ParseFloat(str2, 64)
	if err != nil {
		fmt.Printf("转换错误: %v\n", err)
	} else {
		fmt.Printf("string转float64: %q -> %f\n", str2, f2)
	}

	// 使用fmt.Sprintf进行更灵活的转换
	str3 := fmt.Sprintf("%.2f", f)
	fmt.Printf("使用Sprintf转换: %f -> %q\n", f, str3)

	/**
	float64转string: 3.141593 -> "3.1416"
	string转float64: "2.71828" -> 2.718280
	使用Sprintf转换: 3.141593 -> "3.14"
	*/
}

int和float互转

package main

import (
	"fmt"
)

func main() {
	// int 转 float
	i := 42
	f := float64(i)
	fmt.Printf("int转float: %d -> %f (类型: %T)\n", i, f, f)

	// float 转 int（会丢失小数部分）
	f2 := 3.14
	i2 := int(f2)
	fmt.Printf("float转int: %f -> %d (类型: %T)\n", f2, i2, i2)

	// 四舍五入转换
	f3 := 3.6
	i3 := int(f3 + 0.5) // 四舍五入
	fmt.Printf("四舍五入: %f -> %d\n", f3, i3)

	/**
	int转float: 42 -> 42.000000 (类型: float64)
	float转int: 3.140000 -> 3 (类型: int)
	四舍五入: 3.600000 -> 4
	*/
}

字符串和布尔值互转

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// string 转 bool
	str1 := "true"
	b1, err := strconv.ParseBool(str1)
	if err != nil {
		fmt.Printf("转换错误: %v\n", err)
	} else {
		fmt.Printf("string转bool: %q -> %t\n", str1, b1)
	}

	// bool 转 string
	b2 := false
	str2 := strconv.FormatBool(b2)
	fmt.Printf("bool转string: %t -> %q\n", b2, str2)

	// 处理各种布尔字符串表示
	truthyValues := []string{"1", "t", "T", "TRUE", "true", "True"}
	for _, val := range truthyValues {
		if result, err := strconv.ParseBool(val); err == nil {
			fmt.Printf("布尔字符串 %q 转换为: %t\n", val, result)
		}
	}

	/**
	string转bool: "true" -> true
	bool转string: false -> "false"
	布尔字符串 "1" 转换为: true
	布尔字符串 "t" 转换为: true
	布尔字符串 "T" 转换为: true
	布尔字符串 "TRUE" 转换为: true
	布尔字符串 "true" 转换为: true
	布尔字符串 "True" 转换为: true
	*/
}

格式化输出

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)
}

条件判断

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")
}

go基础 ​

查看go版本 ​

创建项目 ​

变量初始化 ​

常量 && 枚举 ​

基础数据类型 ​

类型转换 ​

字符串和数字互转 ​

int64 和 string 互转 ​

数组/切片和字符串互转 ​

float和字符串互转 ​

int和float互转 ​

字符串和布尔值互转 ​

格式化输出 ​

输入 ​

时间 ​

程序执行时间 ​

条件判断 ​

循环 ​

for ​

range ​

goto跳转语句 ​

go基础

查看go版本

创建项目

变量初始化

常量 && 枚举

基础数据类型

类型转换

字符串和数字互转

int64 和 string 互转

数组/切片和字符串互转

float和字符串互转

int和float互转

字符串和布尔值互转

格式化输出

输入

时间

程序执行时间

条件判断

循环

for

range

goto跳转语句