go-course/go20
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: go-course:0a286d150c86914f188c180d7189e29b4ca9e89b
Branches Tags
go-course:main
..
compare: go-course:1d62dac00c22a3709703f74c73623ff3903c30df
Branches Tags
go-course:main

No commits in common. "0a286d150c86914f188c180d7189e29b4ca9e89b" and "1d62dac00c22a3709703f74c73623ff3903c30df" have entirely different histories.
0a286d150c ... 1d62dac00c

8 changed files with 2 additions and 283 deletions
Show Stats Expand all files Collapse all files

2
day01/README.md
View File

@ -18,7 +18,7 @@
+ [第一个程序](./hello_world/README.md) + [第一个程序](./hello_world/README.md)
+ [开发环境搭建](./env/README.md) + [开发环境搭建](./env/README.md)
+ [基础语法](./syntax/README.md) + 基础语法
+ 基础类型 + 基础类型
+ 变量常量与值 + 变量常量与值
+ 变量作用域 + 变量作用域

50
day01/env/README.md vendored
View File

@ -20,56 +20,8 @@ Windows: 需要 配置容器, 基于DevContaienr来进行开发(Linux 容器,
## IDE与插件 ## IDE与插件
[vscode](https://code.visualstudio.com/)
+ vscode: [Go 插件](https://marketplace.visualstudio.com/items?itemName=golang.Go) + vscode: [Go 插件](https://marketplace.visualstudio.com/items?itemName=golang.Go)
## 基于vscode 做项目开发(demo工程) ## 基于vscode 做项目开发
+ 项目工程: vscode的工程目录
使用code cli 快速打开一个 vsocde 项目
![alt text](image.png)
创建一个Go项目: Demo工程:
+ 初始化项目工程:
```sh
➜ demo git:(main) ✗ go mod init demo
go: creating new go.mod: module demo
```
+ 使用vscode 打开demo工程:
```sh
cd demo && code .
```
+ 创建程序入口: main.go
```go
// Hello World 示例程序
// package 包的名称, 每个go文件都必须属于某个包, 程序入口 必须是 main 包, main函数
package main
// import Go 引入依赖的语法
// go 的内在库中包含了大量常用的包, 安装了go语言就自带
// 三方包, 需要独立安装才能使用 比如 gorm: go install gorm.io/gorm
import (
"fmt"
"gorm.io/driver/sqlite"
// 三方包: go install gorm.io/gorm
// 直接使用 go mod tidy 安装: 安装项目中所有没有安装的包
"gorm.io/gorm"
)
// main 函数是程序入口: 编译后运行, go run快捷运行
func main() {
fmt.Println("Hello, World!")
db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
if err != nil {
panic("failed to connect database")
}
fmt.Println(db)
}
```

15
day01/env/demo/go.mod vendored
View File

@ -1,15 +0,0 @@
module demo
go 1.25.5
require (
gorm.io/driver/sqlite v1.6.0
gorm.io/gorm v1.31.1
)
require (
github.com/jinzhu/inflection v1.0.0 // indirect
github.com/jinzhu/now v1.1.5 // indirect
github.com/mattn/go-sqlite3 v1.14.22 // indirect
golang.org/x/text v0.20.0 // indirect
)

12
day01/env/demo/go.sum vendored
View File

@ -1,12 +0,0 @@
github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug=
golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4=
gorm.io/driver/sqlite v1.6.0 h1:WHRRrIiulaPiPFmDcod6prc4l2VGVWHz80KspNsxSfQ=
gorm.io/driver/sqlite v1.6.0/go.mod h1:AO9V1qIQddBESngQUKWL9yoH93HIeA1X6V633rBwyT8=
gorm.io/gorm v1.31.1 h1:7CA8FTFz/gRfgqgpeKIBcervUn3xSyPUmr6B2WXJ7kg=
gorm.io/gorm v1.31.1/go.mod h1:XyQVbO2k6YkOis7C2437jSit3SsDK72s7n7rsSHd+Gs=

25
day01/env/demo/main.go vendored
View File

@ -1,25 +0,0 @@
// Hello World 示例程序
// package 包的名称, 每个go文件都必须属于某个包, 程序入口 必须是 main 包, main函数
package main
// import Go 引入依赖的语法
// go 的内在库中包含了大量常用的包, 安装了go语言就自带
// 三方包, 需要独立安装才能使用 比如 gorm: go install gorm.io/gorm
import (
"fmt"
"gorm.io/driver/sqlite"
// 三方包: go install gorm.io/gorm
// 直接使用 go mod tidy 安装: 安装项目中所有没有安装的包
"gorm.io/gorm"
)
// main 函数是程序入口: 编译后运行, go run快捷运行
func main() {
fmt.Println("Hello, World!")
db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
if err != nil {
panic("failed to connect database")
}
fmt.Println(db)
}

BIN
day01/env/image.png vendored
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 30 KiB

126
day01/syntax/README.md
View File

@ -1,126 +0,0 @@
# 基础语法
如下是一个程序的基本组成结构:
```go
// 当前程序的包名, main包表示入口包, 是编译构建的入口
package main
// 导入其他包
import "fmt"
// 全局变量声明和赋值
var name = "fly"
// 常量定义
const PI = 3.1415
// 一般类型声明
type newType int
// 结构体声明
type student struct{}
// 接口声明
type reader interface{}
// 程序入口
func main() {
fmt.Println("hello world, this is my first golang program!")
}
```
## 变量与常量
为什么需要变量: 变量是程序运行过程中动态改变的值, 常量是程序运行过程中不变的值
```go
package main
import "fmt"
// 根据值自动推导变量类型, 必须放到函数内部 (在包的顶部， 这个是最常用)
// 在程序运行时，是在编译时完成类型推导，运行时分配内存
var (
score = 99.5
// skill = "golang"
)
// const 定义常量
// 通常常量大写
// 什么时候需要常量, 当一个值不会被修改时, 使用常量
// 变量时, 做完程序数据存在的
// 常量, 值在编译时就已经确定下来了，被编译成为程序一部分
const (
PI = 3.14
SKILL_GOlANG = "golang"
SKILL_PYTHON = "python"
)
// var var1 = "hello"
// var var2 = 100
// var var3 = true
func main() {
// 有一个插槽来存储 用户的数据，或者程序的输入, 这种 插槽叫 变量
// 变量的声明: var 变量名 变量类型
// 变量的赋值: 变量名 = 值
// 名称变量(最麻烦的写法)
var name string
name = "bob"
// 变量的声明和赋值可以合并成一句话
// var agt int
// age = 18
var age int = 18
// 自动推导变量类型, 只能放到函数内部 (在函数内部，这个是最常用的)
// := 左侧是变量名, 右侧是值
country := "china"
_ = country
fmt.Println("hello, " + name + "!")
fmt.Println("age =", age)
fmt.Println("score =", score)
fmt.Println("country =", country)
// hello, bob!
// age = 18
// score = 99.5
// country = china
}
```
## Go的基础类型(基础数据结构)
在这个结构里面必须要符合Go程序的语法, 编写出来的程序才是合法的，才能被编译器识别, 编译器识别代码的基础单位是Lexical Token(词法标记)，比如 如下一段代码:
```go
func main() {
fmt.Println("hello world, this is my first golang program!")
}
```
他包含的Lexical Token(词法标记)，有如下12个:
```
func // 关键字 func
main // 标识符 函数名称
( // LPAREN 左小括号
{ // LBRACE 左花括号
fmt // 标识符 包名称
. // PERIOD 调用符
Println // 标识符 函数名称
( // LPAREN 左小括号
"hello world, this is my first golang program!" // 标识符 字符串常量
) // RPAREN 右小括号
} // RBRACE 右花括号
// （此处无多余 token，上一行已闭合）
```

55
day01/syntax/main.go
View File

@ -1,55 +0,0 @@
package main
import "fmt"
// 根据值自动推导变量类型, 必须放到函数内部 (在包的顶部， 这个是最常用)
// 在程序运行时，是在编译时完成类型推导，运行时分配内存
var (
score = 99.5
// skill = "golang"
)
// const 定义常量
// 通常常量大写
// 什么时候需要常量, 当一个值不会被修改时, 使用常量
// 变量时, 做完程序数据存在的
// 常量, 值在编译时就已经确定下来了，被编译成为程序一部分
const (
PI = 3.14
SKILL_GOlANG = "golang"
SKILL_PYTHON = "python"
)
// var var1 = "hello"
// var var2 = 100
// var var3 = true
func main() {
// 有一个插槽来存储 用户的数据，或者程序的输入, 这种 插槽叫 变量
// 变量的声明: var 变量名 变量类型
// 变量的赋值: 变量名 = 值
// 名称变量(最麻烦的写法)
var name string
name = "bob"
// 变量的声明和赋值可以合并成一句话
// var agt int
// age = 18
var age int = 18
// 自动推导变量类型, 只能放到函数内部 (在函数内部，这个是最常用的)
// := 左侧是变量名, 右侧是值
country := "china"
_ = country
fmt.Println("hello, " + name + "!")
fmt.Println("age =", age)
fmt.Println("score =", score)
fmt.Println("country =", country)
// hello, bob!
// age = 18
// score = 99.5
// country = china
}