Golang学习
马-动态网站开发-复合数据类型.docx
GoWeb编程实战派-从入门到精通2.pptx
Java转Go
Go配置
注意
root去运行idea等等 ， go环境变量会失效 ， 需在root权限下重新进bashrc设置
用到的命令
#没有vim
sudo apt install vim
#编辑
sudo vim ~/.bashrc
#设置环境变量
export GOROOT=/usr/local/go
export PATH=$PATH:$GOROOT/bin
export GOPROXY=https://goproxy.io,direct
#生效
source ~/.bashrc
#终端输入goLinux安装Vscode
sudo snap install --classic code不出意外 直接code就行打开
1 . 基础
1.1 包管理
1.2 输入
1.3 输出
1.4 注释
1.5 数据类型
1.6 变量
1.7 常量
1.8 条件语句
Day1整体
package main
import (
"awesomeProject/api"
"fmt"
"math"
)
//go关键字 : 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
/*
*
全局常量
*/
const Data = 999
const (
pi = 3.1415926
gender = "男"
)
func main() {
curriculum()
gotoFunc(1)
}
/*
*
输出
*/
func Scan() {
//fmt.Scan函数用于按空格分隔的连续输入，将用户输入的值分配给传递给它的参数。
var x, y int
fmt.Scan(&x, &y)
//fmt.Scanln函数用于按行读取用户输入，
//类似于fmt.Scan，但在读取输入后会自动换行。
var name string
var age int
fmt.Scanln(&name, &age)
//fmt.Scanf函数用于根据指定的格式从输入中读取用户输入。
//您可以使用格式字符串来指定要读取的值的类型和顺序。
fmt.Scanf("%s %d", &name, &age)
}
/*
*
全局与局部变量
*/
var number = 99
func bianliang() {
//number := 66
//if true {
// number := 33
// fmt.Println(number) //33
//}
//fmt.Println(number) //66
//number := 66
//if true {
// number := 33
// fmt.Println(number) //33
//}
//number = 88
//fmt.Println(number) //88
if true {
fmt.Println(number) //99
}
number = 88
fmt.Println(number) //88
}
/*
*
上课用的
*/
func curriculum() {
//map遍历 键值对
m := map[string]int{
"go": 100,
"web": 200,
"java": 10000,
}
for key, value := range m {
fmt.Println(key, value)
}
//通道
c := make(chan int) //创建一个整型类型通道
go func() { //启动一个goroutine
//顺序表
c <- 7 //将数据推送进通道
c <- 8
c <- 9
close(c)
}()
for v := range c {
fmt.Println(v)
}
//switch语句
var language = "golang"
switch language {
case "golang":
fmt.Println("并发")
case "java":
fmt.Println("Popular languages")
}
/* 声明函数变量 */
getSquareRoot := func(x float64) float64 {
return math.Sqrt(x)
}
fmt.Println(getSquareRoot(9))
//break和continue语句
OuterLoop: //外层循环的标签
for i := 0; i < 2; i++ { //双层循环
for j := 0; j < 5; j++ {
switch j { //使用 switch 进行数值分支判断
case 1:
fmt.Println(i, j)
//继续 循环内层
continue
// continue OuterLoop 会直接跳到外层循环
case 3:
fmt.Println("循环结束", i, j)
break OuterLoop //退出 OuterLoop 对应的循环之外
}
}
}
}
/*
*
goto语句
*/
func gotoFunc(err int) {
if err != 1 {
goto doExit //跳转到错误处理标签处执行
}
if err != 2 {
goto doExit
}
fmt.Println("over")
return
doExit: //跳转标签
fmt.Println("错误的", err)
}
/*
*
基础
*/
func foundation() {
// 包管理
fmt.Println("1")
api.Add()
//输出
print("内置")
println("内置")
fmt.Print("fmt包")
fmt.Println("fmt包")
// %s 字符串 %d 数字 %.2f浮点数
fmt.Printf("老汉开着%s,"+
"去接%s的媳妇，多少钱一次？%d块。"+"\n"+
"嫂子给打折吧，%.2f怎么样？小哥哥包你100%%满意",
"车", "老男孩", 100, 3.889)
// 数据类型
fmt.Println("Atanycosts" + "666")
//变量
//一个变量未引用时会报红, 不管,跟Java一样
var a string = "Go中变量的用法"
var b int = 10
var c bool = true
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
if c == true {
fmt.Println("为真")
}
//变量简写
//var n string = "武沛齐"
//var wuhan = "武沛齐"
//声明并赋值
n := "武沛齐" // 推荐
fmt.Println(n)
//先声明 再赋值
var name, message, data string
name = "武沛齐"
message = "中奖了"
data = "中了5000w"
fmt.Println(name, message, data)
//转Java用不习惯的方法
//变量的因式分解
var (
ming = "武沛齐"
age = 18
hobby = "大保健"
salary = 1000000
gender string // 只声明但不赋值，有一个默认： ""
length int // 只声明但不赋值，有一个默认： 0
sb bool // 只声明但不赋值，有一个默认： false
)
fmt.Println(ming, age, hobby, salary, gender, length, sb)
//作用域跟Java差不多
//方法内的为局部 , 方法外的为全局
newName := name
var name2 = "武沛齐"
fmt.Println("newName赋值:", newName, name2)
bianliang()
//常量定义
const nameAB = "At"
fmt.Println(nameAB)
// 常量因式分解
const (
v1 = 123
v2 = 456
pi = 9.9
)
fmt.Println(v1, v2, pi, gender)
//iota 在声明常量时的一个计数器。
const (
monday = iota + 1
tuesday
wednesday
thursday
friday
saturday
sunday
)
fmt.Println(monday, thursday, wednesday,
thursday, friday, saturday, sunday)
}
Day2整体
package main
import (
"bytes"
"fmt"
"strings"
)
//day2整体
//字符串操作
func main() {
arr()
}
// 字符串拼接
func StringJoin() {
n := "hello world"
m := "I am Tom"
j := n + "," + m //用+号连接
fmt.Println(j)
k := fmt.Sprintf("%s,%s", n, m) //用Sprintf函数连接
fmt.Println(k)
g := strings.Join([]string{n, m}, ",")
//用strings.Join函数连接
fmt.Println(g)
var builder strings.Builder
builder.WriteString(n) //用string.Builder
builder.WriteString(",")
builder.WriteString(m)
fmt.Println(builder.String())
var buffer bytes.Buffer //用bytes.Buffer连接
buffer.WriteString(n)
buffer.WriteString(",")
buffer.WriteString(m)
fmt.Println(buffer.String())
}
func stringCourse() {
//ASCII
str := "programming"
fmt.Println(str[1]) //获取字符码点 ASCII
fmt.Println(str[1:3]) //获取字符子串 ro
fmt.Println(str[1:]) //截取从1到结尾的子串
fmt.Println(str[:3]) //截取从0到2位的字串 pro
fmt.Println(len(str)) //获取字串字节数
fmt.Println([]rune(str)) //将字串每个字节转换为码点
fmt.Println(string(str[1])) //获取索引位为1的字符
//遍历
str1 := "I love go web 编程技术" //str[0]提取的是单个字节
chars := []rune(str1) //将字符串转换为rune切片，就可以按字符提取了
for _, char := range chars {
fmt.Printf(string(char))
}
fmt.Println("!")
//比较ASCII大小
fmt.Println(str[0] >= str1[2])
//迭代
for index, char := range str {
fmt.Printf("%d %U %c \n", index, char, char)
}
//字符串的修改
//[]byte
str2 := "Hi 世界"
by := []byte(str2)
by[2] = ',' //把空格改为逗号，
fmt.Printf("%s\n", str2)
fmt.Printf("%s\n", by)
//[]rune
str3 := "Hi 世界"
by1 := []rune(str3)
by1[3] = '中'
by1[4] = '国'
fmt.Printf("%s\n", str3)
fmt.Printf(string(by1))
//字符串分割
n := "hello@-world@-I@-am@-Tom"
m := strings.Split(n, "@-")
fmt.Printf("分割后的数据类型： %T\n", m)
for _, i := range m {
fmt.Println(i)
}
}
// 优化后
func arr() {
//没使用报红
// var array_name[10] int
var numbers = [5]float32{100.0, 8.0, 9.4, 6.8, 30.1}
//声明i并赋值 索引-1
for i := 0; i < 5; i++ {
//先强转
numbers[i] = (float32(i + 66))
//打印
fmt.Printf("numbers[%d] = %.0f\n", i, numbers[i])
}
}Day 3整体
package main
import (
"awesomeProject/api"
"bytes"
"fmt"
"math"
"strings"
)
//go关键字 : 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
/*
*
结构体
*/
type Book struct {
title string
author string
subject string
press string
}
/*
*
全局常量
*/
const Data = 999
const (
pi = 3.1415926
gender = "男"
)
func main() {
//day1()
//day2()
day3()
}
/*
* 基础
*/
func day1() {
curriculum()
gotoFunc(1)
}
/*
* 字符串
*/
func day2() {
bianliang()
StringJoin()
stringCourse()
}
/*
*
复合数据类型
*/
func day3() {
arr()
structCourse()
sliceCourse()
}
// 修改后
func sliceCourse() {
map1 := map[string]string{"first": "go", "second": "web"}
createdMap := make(map[string]float32)
createdMap["k1"] = 99
createdMap["k2"] = 199
var map2 map[string]string
map2 = map1 // 对map引用的内容修改会影响原始map的值
mapA := make(map[int][]int) // 切片可以作为map的值
mapB := make(map[int]*[]int) // 切片指针作为map的值
fmt.Println(map1, createdMap, map2, mapA, mapB)
}
/*
结构体
*/
func structCourse() {
// 创建一个新的结构体
fmt.Println(Book{"Go Web编程实战派从入门到精通",
"廖显东", "Go语言教程", "电子工业出版社"})
// 也可以使用 key => value 格式
fmt.Println(Book{title: "Go Web编程实战派从入门到精通",
author: "廖显东", subject: "Go语言教程", press: "电子工业出版社"})
// 忽略的字段为 0 或 空
fmt.Println(Book{title: "Go Web编程实战派从入门到精通",
author: "廖显东"})
}
// 优化后 复合数据类型
func arr() {
//没使用报红
// var array_name[10] int
var numbers = [5]float32{100.0, 8.0, 9.4, 6.8, 30.1}
//声明i并赋值 索引-1
for i := 0; i < 5; i++ {
//先强转
numbers[i] = (float32(i + 66))
//打印
fmt.Printf("numbers[%d] = %.0f\n", i, numbers[i])
}
}
// 字符串拼接
func StringJoin() {
n := "hello world"
m := "I am Tom"
j := n + "," + m //用+号连接
fmt.Println(j)
k := fmt.Sprintf("%s,%s", n, m) //用Sprintf函数连接
fmt.Println(k)
g := strings.Join([]string{n, m}, ",")
//用strings.Join函数连接
fmt.Println(g)
var builder strings.Builder
builder.WriteString(n) //用string.Builder
builder.WriteString(",")
builder.WriteString(m)
fmt.Println(builder.String())
var buffer bytes.Buffer //用bytes.Buffer连接
buffer.WriteString(n)
buffer.WriteString(",")
buffer.WriteString(m)
fmt.Println(buffer.String())
}
func stringCourse() {
//ASCII
str := "programming"
fmt.Println(str[1]) //获取字符码点 ASCII
fmt.Println(str[1:3]) //获取字符子串 ro
fmt.Println(str[1:]) //截取从1到结尾的子串
fmt.Println(str[:3]) //截取从0到2位的字串 pro
fmt.Println(len(str)) //获取字串字节数
fmt.Println([]rune(str)) //将字串每个字节转换为码点
fmt.Println(string(str[1])) //获取索引位为1的字符
//遍历
str1 := "I love go web 编程技术" //str[0]提取的是单个字节
chars := []rune(str1) //将字符串转换为rune切片，就可以按字符提取了
for _, char := range chars {
fmt.Printf(string(char))
}
fmt.Println("!")
//比较ASCII大小
fmt.Println(str[0] >= str1[2])
//迭代
for index, char := range str {
fmt.Printf("%d %U %c \n", index, char, char)
}
//字符串的修改
//[]byte
str2 := "Hi 世界"
by := []byte(str2)
by[2] = ',' //把空格改为逗号，
fmt.Printf("%s\n", str2)
fmt.Printf("%s\n", by)
//[]rune
str3 := "Hi 世界"
by1 := []rune(str3)
by1[3] = '中'
by1[4] = '国'
fmt.Printf("%s\n", str3)
fmt.Printf(string(by1))
//字符串分割
n := "hello@-world@-I@-am@-Tom"
m := strings.Split(n, "@-")
fmt.Printf("分割后的数据类型： %T\n", m)
for _, i := range m {
fmt.Println(i)
}
}
/*
*
输出
*/
func Scan() {
//fmt.Scan函数用于按空格分隔的连续输入，将用户输入的值分配给传递给它的参数。
var x, y int
fmt.Scan(&x, &y)
//fmt.Scanln函数用于按行读取用户输入，
//类似于fmt.Scan，但在读取输入后会自动换行。
var name string
var age int
fmt.Scanln(&name, &age)
//fmt.Scanf函数用于根据指定的格式从输入中读取用户输入。
//您可以使用格式字符串来指定要读取的值的类型和顺序。
fmt.Scanf("%s %d", &name, &age)
}
/*
*
全局与局部变量
*/
var number = 99
func bianliang() {
//number := 66
//if true {
// number := 33
// fmt.Println(number) //33
//}
//fmt.Println(number) //66
//number := 66
//if true {
// number := 33
// fmt.Println(number) //33
//}
//number = 88
//fmt.Println(number) //88
if true {
fmt.Println(number) //99
}
number = 88
fmt.Println(number) //88
}
/*
*
上课用的
*/
func curriculum() {
//map遍历 键值对
m := map[string]int{
"go": 100,
"web": 200,
"java": 10000,
}
for key, value := range m {
fmt.Println(key, value)
}
//通道
c := make(chan int) //创建一个整型类型通道
go func() { //启动一个goroutine
//顺序表
c <- 7 //将数据推送进通道
c <- 8
c <- 9
close(c)
}()
for v := range c {
fmt.Println(v)
}
//switch语句
var language = "golang"
switch language {
case "golang":
fmt.Println("并发")
case "java":
fmt.Println("Popular languages")
}
/* 声明函数变量 */
getSquareRoot := func(x float64) float64 {
return math.Sqrt(x)
}
fmt.Println(getSquareRoot(9))
//break和continue语句
OuterLoop: //外层循环的标签
for i := 0; i < 2; i++ { //双层循环
for j := 0; j < 5; j++ {
switch j { //使用 switch 进行数值分支判断
case 1:
fmt.Println(i, j)
//继续 循环内层
continue
// continue OuterLoop 会直接跳到外层循环
case 3:
fmt.Println("循环结束", i, j)
break OuterLoop //退出 OuterLoop 对应的循环之外
}
}
}
}
/*
*
goto语句
*/
func gotoFunc(err int) {
if err != 1 {
goto doExit //跳转到错误处理标签处执行
}
if err != 2 {
goto doExit
}
fmt.Println("over")
return
doExit: //跳转标签
fmt.Println("错误的", err)
}
/*
*
基础
*/
func foundation() {
// 包管理
fmt.Println("1")
api.Add()
//输出
print("内置")
println("内置")
fmt.Print("fmt包")
fmt.Println("fmt包")
// %s 字符串 %d 数字 %.2f浮点数
fmt.Printf("老汉开着%s,"+
"去接%s的媳妇，多少钱一次？%d块。"+"\n"+
"嫂子给打折吧，%.2f怎么样？小哥哥包你100%%满意",
"车", "老男孩", 100, 3.889)
// 数据类型
fmt.Println("Atanycosts" + "666")
//变量
//一个变量未引用时会报红, 不管,跟Java一样
var a string = "Go中变量的用法"
var b int = 10
var c bool = true
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
if c == true {
fmt.Println("为真")
}
//变量简写
//var n string = "武沛齐"
//var wuhan = "武沛齐"
//声明并赋值
n := "武沛齐" // 推荐
fmt.Println(n)
//先声明 再赋值
var name, message, data string
name = "武沛齐"
message = "中奖了"
data = "中了5000w"
fmt.Println(name, message, data)
//转Java用不习惯的方法
//变量的因式分解
var (
ming = "武沛齐"
age = 18
hobby = "大保健"
salary = 1000000
gender string // 只声明但不赋值，有一个默认： ""
length int // 只声明但不赋值，有一个默认： 0
sb bool // 只声明但不赋值，有一个默认： false
)
fmt.Println(ming, age, hobby, salary, gender, length, sb)
//作用域跟Java差不多
//方法内的为局部 , 方法外的为全局
newName := name
var name2 = "武沛齐"
fmt.Println("newName赋值:", newName, name2)
bianliang()
//常量定义
const nameAB = "At"
fmt.Println(nameAB)
// 常量因式分解
const (
v1 = 123
v2 = 456
pi = 9.9
)
fmt.Println(v1, v2, pi, gender)
//iota 在声明常量时的一个计数器。
const (
monday = iota + 1
tuesday
wednesday
thursday
friday
saturday
sunday
)
fmt.Println(monday, thursday, wednesday,
thursday, friday, saturday, sunday)
}day 4 整体
package main
import "fmt"
var nameCourse string = "go"
func main() {
sli := []int{1, 6, 8}
// 使用匿名函数打印切片的内容
visPrint(sli, func(value int) { /*f函数的实参函数*/
fmt.Println(value)
})
myname := deferCousre()
fmt.Printf("main 函数里的name: %s\n", nameCourse)
fmt.Println("main 函数里的myname: ", myname)
funcCourse()
deferCousre()
}
/* 遍历切片中每个元素，通过给定的函数访问元素*/
func visPrint(list []int, f func(int)) {
for _, value := range list {
f(value)
/*每个元素用f函数处理一遍*/
}
}
/*
*
匿名函数
*/
func funcCourse() {
f := func(data int) {
// 定义匿名函数并赋值给f变量
fmt.Println("hi, this is a closure", data)
}
f(6) // 此时f变量的类型是func(), 可以直接调用
func(data int) {
fmt.Println("hi, this is a closure, directly", data)
}(8) //直接声明并调用
}
/*
*
延迟执行
*/
func deferCousre() string {
defer func() {
nameCourse = "python"
}()
fmt.Printf("myfunc 函数里的name：%s\n", nameCourse)
return nameCourse
}package main
import (
"crypto/sha256"
"fmt"
)
type MerkleTree struct {
nodes []string
}
func (mt *MerkleTree) insert(data string) {
mt.nodes = append(mt.nodes, data)
}
func (mt *MerkleTree) getLeafHashes() []string {
hashes := make([]string, len(mt.nodes))
for i, node := range mt.nodes {
hashes[i] = fmt.Sprintf("%x", sha256.Sum256([]byte(node)))
}
return hashes
}
func (mt *MerkleTree) getParentHashes(hashes []string) []string {
parentHashes := make([]string, len(hashes)/2)
for i := 0; i < len(hashes); i += 2 {
parentHash := fmt.Sprintf("%x", sha256.Sum256([]byte(hashes[i]+hashes[i+1])))
parentHashes[i/2] = parentHash
}
return parentHashes
}
func (mt *MerkleTree) display() {
hashes := mt.getLeafHashes()
parentHashes := mt.getParentHashes(hashes)
for i, hash := range hashes {
fmt.Printf("%d --> %s\n", i, hash)
}
for i, hash := range parentHashes {
fmt.Printf("%d --> %s\n", i+len(hashes), hash)
}
}
func main() {
mt := &MerkleTree{}
mt.insert("a")
mt.insert("b")
mt.insert("c")
mt.insert("d")
mt.insert("e")
mt.insert("f")
mt.insert("g")
mt.insert("h")
mt.insert("i")
mt.insert("j")
mt.display()
}
day 5 整体
package main
import "fmt"
/**
封装
*/
type Triangle struct {
Bottom float32
Height float32
}
type Student struct {
name string
score float32
Age int
}
type Square struct {
sideLen float32
}
type Shape interface {
Area() float32
}
//
type Engine interface {
Run()
Stop()
}
type Bus struct {
Engine
}
/**
函数
*/
//面积计算
func (t *Triangle) Area() float32 {
return (t.Bottom * t.Height) / 2
}
func (sq *Square) Area() float32 {
return sq.sideLen * sq.sideLen
}
//getter和setter
func (s *Student) GetName() string { // 获取 name
return s.name
}
func (s *Student) SetName(newName string) {
s.name = newName // 设置 name
}
func (s *Student) GetAge() int {
return s.Age // 获取age
}
func (s *Student) SetAge(newName int) {
s.Age = newName // 设置age
}
//工作
func (c *Bus) Working() {
c.Run()
c.Stop()
}
func main() {
//面积
//｛｝直接传参数
//类似实例化对象
t := &Triangle{6, 8}
s := &Square{8}
shapes := []Shape{t, s}
for n, _ := range shapes {
fmt.Println("图形数据: ", shapes[n])
fmt.Println("面积：", shapes[n].Area())
}
//getter和setter
a := new(Student)
a.SetName("Shirdon")
fmt.Println(a.GetName())
fmt.Println()
}
4 条评论
这是一篇佳作，无论是从内容、语言还是结构上，都堪称完美。
真好呢
pwmoze76284BR-文章很不错，感谢作者！https://kan.xiaoxinbk.com/9682.html/
https://img.atanycosts.cn/app/thumb.php?img=/i/2023/10/12/sl2635.webp