- Java锁的逻辑(结合对象头和ObjectMonitor)
- 还在用饼状图?来瞧瞧这些炫酷的百分比可视化新图形(附代码实现)⛵
- 自动注册实体类到EntityFrameworkCore上下文,并适配ABP及ABPVNext
- 基于Sklearn机器学习代码实战
示例:工程结构如下 。
GOPATH 设置为工程根目录(E:\GO_PROJECT) 。
test1.go :
package package_test
import "fmt"
/*
定义函数
*/
func Func1() {
fmt.Println("test1 func1")
}
test2.go :
package package_test
import "fmt"
func Func2() {
fmt.Println("test2 func2")
}
testmain.go :
package main
import "dir1/dir2" // 导入的是【目录名】
func main() {
package_test.Func1() // 调用的是【包名】
}
运行 :
// 方式一
go bulid testmain.go // 编译(生成可执行文件)
./ testmain // 运行(可执行文件)
//方式二
go run testmain.go // 编译+运行
导包结论 :
import 导入的是源文件所在的目录名,而不是定义的包名
。 在代码中引用包内的成员时,使用定义的包名而不是目录名
。 在同一级目录中,所有源文件只能使用相同的包名
。 同一包名下的变量名、函数名等不能重复
。 public
) private
) 为了更好的管理项目中的文件,GO 要求将文件都要放在相应的目录中,具体规定了以下目录:
src 目录
:以代码包的形式组织并保存 GO 源码文件(比如 .go 文件、.c 文件、.h 文件、.s 文件等) pkg 目录
:用于存放经由 go install 命令构建安装后的代码包(包含 GO 库源码文件)的 ".a" 归档文件。 bin 目录
:与 pkg 目录类似,在通过 go install 命令完成安装后,保存由 GO 命令源码文件生成的可执行文件。 以上目录称为工作区(Workspace),工作区其实就是一个对应于特定工程的目录.
src 目录用于包含所有的源代码,是 GO 命令行工具一个强制的规则;而 pkg 和 bin 则无需手动创建,GO 命令行工具在构建过程中会自动创建这些目录.
// 方式一:先声明(有默认值),后赋值
var a int
a = 10
var b, c string
b = "b"
c = "c"
// 方式二:声明+赋值
var a int = 10
// 方式三:自动推导类型(注意:这种方式只能在函数内使用)
a := 10
b, c := 11, 12
b, c = c, b // 值交换
// 匿名变量
_, i, _, j = 1, 2, 3, 4
格式 | 含义 |
---|---|
%% | 一个 % 字面量 |
%b | 一个二进制整数值(基数为 2),或者是一个(高级的)用科学计数法表示的指数为 2 的浮点数 |
%c | 字符型。可以把输入的数字按照 ASCII 码相应转换为对应的字符 |
%d | 一个十进制数值(基数为 10) |
%f | 以标准记数法表示的浮点数或者复数值 |
%o | 一个以八进制表示的数字(基数为8) |
%p | 以十六进制(基数为 16)表示的一个值的地址,前缀为 0x,字母使用小写的 a-f 表示 |
%q | 使用 GO 语法以及必须时使用转义,以双引号括起来的字符串或者字节切片 []byte,或者是以单引号括起来的数字 |
%s | 字符串。输出字符串中的字符直至字符串中的空字符(字符串以 '\0' 结尾,这个 '\0' 即空字符) |
%t | 以 true 或者 false 输出的布尔值 |
%T | 使用 GO 语法输出的值的类型 |
%x | 以十六进制表示的整型值(基数为十六),数字 a-f 使用小写表示 |
%X | 以十六进制表示的整型值(基数为十六),数字 A-F 使用小写表示 |
类型 | 名称 | 长度 | 零值(默认值) | 说明 |
---|---|---|---|---|
bool | 布尔类型 | 1 | false | 其值不为真即为假,不可以用数字代表 true 或 false |
byte | 字节型 | 1 | 0 | uint8 的别名 |
int, uint | 整型 | - | 0 | 有符号 32 位或无符号 64 位 |
int8 | 整型 | 1 | 0 | -128 ~ 127 |
uint8 | 整型 | 1 | 0 | 0 ~ 255 |
int16 | 整型 | 2 | 0 | -32768 ~ 32767 |
uint16 | 整型 | 2 | 0 | 0 ~ 65535 |
int32 | 整型 | 4 | 0 | -2147483648 到 2147483647 |
rune | 整型 | 4 | 0 | int32 的别名 |
uint32 | 整型 | 4 | 0 | 0 到 4294967295(42 亿) |
int64 | 整型 | 8 | 0 | -9223372036854775808到 92233720368547758070 |
uint64 | 整型 | 8 | 0 | 到 18446744073709551615(1844 京) |
float32 | 浮点型 | 4 | 0.0 | 小数位精确到 7 位 |
float64 | 浮点型 | 8 | 0.0 | 小数位精确到 15 位 |
string | 字符串 | - | "" | utf-8 字符串 |
值的字面量(literal)是指代码中值的文字表示。一个值可能存在多种字面量表示。 表示基本类型值的文本称为基本字面量。基本字面量也被称为字面量常量或未命名常量.
示例:
func main() {
var ch byte = 97 // 声明字符类型
fmt.Printf("ch=%c", ch) // 输出 a
}
这里定义了 ch 是一个字符类型,赋值却是一个整数 97,打印的结果是小写字符 'a'.
原因是:计算机不能直接存储字符类型,只能转成数字存储,那为什么小写字符 'a' 对应的整数是 97 呢?因为计算机是根据 ASCII 码来存储的.
package main
import "fmt"
func main() {
chinese := 97
math := 99
english := 96
fmt.Printf("总分是 %d,平均分(整数)是 %d, 平均分(浮点数)是 %f", chinese+math+english, (chinese+math+english)/3, float32(chinese+math+english)/3)
// 总分是 292,平均分(整数)是 97, 平均分(浮点数)是 97.333336
}
注意:
GO 语言中不允许隐式转换,所有类型转换必须显式声明(强制转换),而且转换只能发生在两种相互兼容的类型之间 。
var ch byte = 'c'
// var a int = ch // cannot use ch (type byte) as type int in assignment
var b int = int(ch) // 数据类型名(待转换的值)
package main
import fmt
func main() {
var age int
fmt.Println("请输入年龄:")
fmt.Scanf("%d", &age) // 将接收的值赋给age变量
fmt.Printf("age=%d", age)
}
func main() {
// 变量:程序运行期间,值可以改变,声明使用var
// 常量:程序运行期间,值不可以改变,声明使用const
const a int = 11
// a = 12 // error:常量不可以修改
const b = 12 // 自动推导类型(常量不可以使用:=)
}
iota 常量生成器:用于生成一组递增的整型常量,减去了每行都要写一遍初始化表达式的繁琐.
func main() {
// 在一个 const 声明语句中,在第一个声明的常量所在的行,iota 将会被置为 0,然后在每一个有常量声明的行递增 1
const (
a = iota // 0
b = iota // 1
c = iota // 2
)
const d = iota // iota 遇到const,会被置为 0
// 可以只写一个iota
const (
e = iota // 0
f // 1
g
)
// 同一行值一样
const (
h = iota // 0
i, j, k = iota, iota, iota // 1
l = iota // 2
)
}
运算符 | 术语 |
---|---|
+ | 加(既可以完成两个数字相加,又可以连接两个字符串) |
- | 减 |
* | 乘 |
/ | 除 |
% | 取模(取余) |
++ | 后自增(GO 语言中没有前自增) |
-- | 后自减(GO 语言中没有前自减) |
运算符 | 说明 | 示例 |
---|---|---|
= | 普通赋值 | c = a + b 将 a + b 表达式结果赋值给 c |
+= | 相加后再赋值 | c += a 等价于 c = c + a |
-= | 相减后再赋值 | c -= a 等价于 c = c - a |
*= | 相乘后再赋值 | c *= a 等价于 c = c * a |
/= | 相除后再赋值 | c /= a 等价于 c = c / a |
%= | 求余后再赋值 | c %= a 等价于 c = c % a |
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
== | 相等于 | 4 == 3 | false |
!= | 不等于 | 4 != 3 | true |
< | 小于 | 4 < 3 | false |
> | 大于 | 4 > 3 | true |
<= | 小于等于 | 4 <= 3 | false |
>= | 大于等于 | 4 >= 1 | true |
运算符 | 术语 | 示例 | 结果 |
---|---|---|---|
! | 非 | !a | 如果 a 为假,则 !a 为真 如果 a 为真,则 !a 为假 |
&& | 与 | a && b | 如果 a 和 b 都为真,则结果为真,否则为假 |
|| | 或 | a || b | 如果 a 和 b 有一个为真,则结果为真,二者都为假时,结果为假 |
package main
import "fmt"
func main() {
var score int
fmt.Println("请输入成绩:")
fmt.Scanf("%d", &score)
// if 语句支持一个初始化语句+判断条件
if good_score := 90; score >= good_score {
fmt.Println("优秀")
} else if soso_score := 60; score >= soso_score {
fmt.Println("及格")
} else {
fmt.Println("需要努力")
}
}
注意: case 后面默认自带 break ,如果想执行完成某个 case 后继续执行后面的 case,可以使用 fallthrough 关键字.
func main() {
bonus := 5000
var score string
finish := true
fmt.Println("请输入年终评级:")
switch fmt.Scanf("%s", &score); score {
case "A":
bonus += 1000
case "B":
bonus += 5000
case "C":
case "D":
bonus -= 1000
default:
finish = false
fmt.Println("输入有误,请输入正确的评级")
}
if finish {
fmt.Printf("您的年终奖为:%d", bonus)
}
}
GO 中的 3 种循环方式:
package main
import "fmt"
func main() {
// 第1种方式
for i := 0; i < 5; i++ {
fmt.Printf("i=%d\n", i)
}
// 第2种方式:类似while循环
num := 1
for num < 5 {
fmt.Printf("num=%d\n", num)
num++
}
// 第3种方式
for {
fmt.Println("死循环")
}
}
函数就是将一堆代码进行封装,以便重用的一种机制.
func 函数名(){
函数体
}
import "fmt"
func MyFunc(a int, b int, args ...int) { // 注意:不定长参数必须放在参数列表最后
fmt.Println("定长参数为:", a, b)
for i, data := range args { // 若不需要编号,则可使用 for _, data := range args
fmt.Println("编号为:", i)
fmt.Println("数据为:", data)
}
}
func main() {
MyFunc(1, 2, 3, 4, 5)
}
打印结果:
定长参数为: 1 2
编号为: 0
数据为: 3
编号为: 1
数据为: 4
编号为: 2
数据为: 5
// 定义返回值类型
func Add(a int, b int) int {
return a + b
}
// 给返回值命名
func Sub(a int, b int) (sub int) {
sub = a - b
return sub // 也可以只写 return
}
// 返回多个值
func Sub(a, b, c int) {
a, b, c = 1, 2, 3
return a, b, c // 也可以只写 return
}
在 GO 语言中还有另外一种定义使用函数的方式,就是函数类型.
所谓的函数类型,就是 将函数作为一种类型可以用来定义变量 ,基本使用如下:
func Test(a, b int) int {
return a + b
}
// 定义函数类型:即需要传递两个整型参数,有一个整型返回值的函数类型
type FuncType func(a int, b int) int // type关键字后面跟着类型的名字(FunType)
func main() {
var result FuncType // 类型是FuncType类型,即函数类型
result = Test
s := result(1, 2)
fmt.Printf("s=%d", s)
}
所谓匿名函数就是没有名字的函数。匿名函数最主要的功能就是实现了 闭包 .
package main
import "fmt"
func main() {
num := 9
// 使用方式一:定义匿名函数并赋值给变量
f1 := func() {
// 在匿名函数中可以直接访问main()中定义的局部变量
// 并且在匿名函数中对变量的值进行了修改,最终会影响到整个main()函数中定义的变量值
num++
fmt.Println("匿名函数:", num)
}
f1() // 10
fmt.Println("main函数:", num) // 10
// 使用方式二:通过函数类型
type FuncType func() // 没有参数,没有返回值
var f2 FuncType = f1
f2()
// 使用方式三:直接调用
func(a, b int) {
fmt.Println("a + b =", a+b)
}(3, 6)
// 有参有返回值的匿名函数
min, max := func(a, b int) (min, max int) {
if a > b {
return b, a
} else {
return a, b
}
}(12, 13)
fmt.Printf("min=%d, max=%d\n", min, max)
}
示例:阶乘 。
func Test(num int) int {
if num == 1 {
return 1
}
return num * Test(num-1)
}
func main() {
var num int
fmt.Println("请输入需要阶乘的数:")
fmt.Scanf("%d", &num)
fmt.Printf("%d的阶乘结果为:%d", num, Test(num))
}
最后此篇关于Go基础语法的文章就讲到这里了,如果你想了解更多关于Go基础语法的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
我正在使用 go 图表库 https://github.com/wcharczuk/go-chart制作条形图。我面临的问题是标签值很长,我想将文本旋转 45 度以显示完整文本 我喜欢显示的日期格式是
我在构建一个非常简单的通过 cgo 调用 c 代码的 go 程序时遇到了问题。我的设置: $: echo $GOPATH /go $: pwd /go/src/main $: ls ctest.c
没有 C 的背景,只有 Go 的“初学者”经验,我正在尝试弄清楚 main.go 是实际需要的还是只是一个约定。 我想创建一个简单的网络 API,但有人可以为我澄清一下吗? 最佳答案 main.go
我read从 Go 1.4 开始,Go 运行时是用 Go 本身编写的(而不是用 C)。 这怎么可能?如果 Go 程序在运行时之上运行,并且运行时是 Go 程序,那么运行时是否在自身之上运行? 最佳答案
这是“Go 之旅”中的代码示例 Range and Close : package main import ( "fmt" ) func fibonacci(n int, c chan int
给定以下 go.mod 文件: module foo go 1.12 require ( github.com/bar/baz v1.0.0 github.com/rat/cat v1
我有一个 CI/CD 管道,它需要跨平台并与几个不同的管理程序一起工作。为了不必更改 Windows 和 Linux 的构建任务,我认为 Go 将是编写一次代码并在任何地方运行的好方法。然而,考虑到
我有一个 Dockerfile,用于使用 go build 编译 Go 应用程序。我进行了研究,确实建议将 go build 用于生产。 但是我找不到正确的答案来解释为什么。 我了解 go run 创
我尝试在命令提示符#Go lang 中运行该程序-但是当我键入运行“go run hello.go”命令时,我开始了 CreateFile hello.go:The system cannot fin
我正在使用“Go 编程语言”一书学习 Go。第一章介绍os.Open用于读取文件的模块。我尝试打开如下所示的 go 文件。 f, err = os.Open("helloworld.go") 我收
关闭。这个问题需要details or clarity .它目前不接受答案。 想改进这个问题?通过 editing this post 添加详细信息并澄清问题. 2年前关闭。 Improve this
为了解决我对 goroutine 的一些误解,我去了 Go 操场跑了 this code : package main import ( "fmt" ) func other(done cha
这个问题在这里已经有了答案: Evaluate/Execute Golang code/expressions like js' eval() (5 个回答) 1年前关闭。 对于任何 go 程序,我想
这是我基本上试图从路径打印基准的代码。 这意味着,如果用户输入“/some/random/path.java”,则输出将为“path”。同样,如果用户arg为“/another/myapp.c”,则输
$ go version 1.13.3 我的文件夹结构如下: GOPATH +---src +--- my-api-server +--- my-auth-server
这个问题在这里已经有了答案: How to embed file for later parsing execution use (4 个答案) What's the best way to bun
我觉得这有点奇怪,为什么这段代码不起作用? package main import "fmt" func main() { var i, j int = 1, 2 k
go编译器执行完如下命令后的可执行文件存放在哪里? $> go run file.go 最佳答案 在 /tmp 文件夹中,如果您使用的是 unix 机器。 如果您使用的是 Windows,则在 \Us
我目前正在开始使用 Go,并且已经深入研究了有关包命名和工作区文件夹结构的注意事项。 不过,我不太确定如何根据 Go 范式正确组织我的代码。 这是我当前的结构示例,它位于 $GOPATH/src 中:
假设我有一个接受用户输入的 Lua 程序,而该输入恰好是有效的 Lua 源代码。这是在程序仍在运行时进行清理、编译和执行的。 Go 是否(或将)实现这样的事情? 最佳答案 我认为以下两个项目之间有足够
我是一名优秀的程序员,十分优秀!