一.hello world
新建文件helloworld.go
package main import "fmt" func main() { fmt.Println( "Hello world!" ) }
运行代码
go run helloworld.go
Hello world!
代码说明
1.每个Go文件都是以package “包名” 开头,
package main 这行表示文件中的所有其余代码都属于main 包
2.import “fmt” 语句 导入需要的包
3.func main() main函数比较特殊,当程序运行时首先运行它。
4. fmt.Println(“Hello world!”)
从fmt包调用Println函数实现在终端打印Hello world!
附录: 网页练习go语言
打开网站:https://go.dev/play/
输入代码可直接执行
转载请在文章开头附上原文链接地址:https://www.gaodi.net/Sunzz/p/15956313.html
二 函数
1.函数调用
要调用函数,需要输入函数名(本例中为Println),以及一对圆括号
fmt.Println()
2.函数参数
与其他函数一样,Println可以接受一个或者多个参数,参数鞋子函数名后面的原括号中
fmt.Println( "First argument" , "Second argument" )
输出
First argument Second argument
3.Println函数
当我们想要查看程序在做什么的时候可以使用Println函数。传递给它的任何参数都将会在终端打印出来,每个参数用空格分隔。
打印完所有参数后,Println将跳动新的终端行,这就是为什么”ln”在它名字的末尾。
package main import "fmt" func main() { fmt.Println( "First argument" , "Second argument" , "Third argument" ) fmt.Println( "Another line" ) }
输出如下
First argument Second argument Third argument Another line
三、使用其它包中的函数
我们第一个helloworld.go程序中的代码时main包的一部分,但是Println函数在fmt包,为了能够调用Println,我们必须首先到人包含它的包
import “fmt”
导入包后,我们可以通过包名、点和我们想要的函数名来访问它提供的任何函数。
fmt.Println()
1.示例
package main import ( // import语句的这种替代格式运行一次导入多个包 "math" //导入math包,这样就可以使用maht.Floor函数来 "strings" ) func main() { math.Floor(2.75) // 调用math包中的Floor函数 strings.Title( "Hello world!" ) //调用strings中的Title函数 }
运行代码
go run example1. go
你会发现没有任何输出,不用担心,也不要着急
2.函数返回值
调用fmt.Println函数之后,我们不需要和它进一步的通信。我们传递一个或者多个值让Println函数打印,我们相信它会打印出这些值。但是有时候程序需要能够调用函数并从那儿获取数据。因此大多数编程语言中的函数都有返回值:函数计算后并返回给调用者的值。
math.Floor和strings.Title都是使用返回值的函数的示例。 math.Floor函数拿到一个浮点数,将其向下取整为最接近的整数,然后返回该整数。strings.Title函数拿到一个字符串,将它的包含的每个单词的第一个字母大写(首字母大写),并返回大写后的字符串。
要实际查看这些函数调用的结果,我们需要获取它们的返回值并将其传递给fmt.Println
example2 :
package main import ( "fmt" "math" "strings" ) func main() { fmt.Println(math.Floor(2.75)) fmt.Println(strings.Title( "hello world!" )) }
go run example.go
输出
2 Hello World!
说明:
fmt.Println(math.Floor(2.75))
math.Floor 取2.75的整数2返回给fmt.Println函数
strings.Title(“hello world”) 取一个字符串,然后将其中的每个单词首字母大写后返回给 fmt.Println函数
Go程序模板
对于下面的代码,想象一下将它们插入到这个完整的Go程序中:
package main import "fmt" func main() { fmt.Println("xxxxxxxxxxx") //在这里插入你的代码 }
更好的方法是,试着在Go Playground中输入这个程序,然后一次插入一个片段,看看它们会做什么!
字符串
我们将字符串作为参数传递给Println。字符串是一系列字节,通常表示文本字符。你可以在代码中直接使用字符串字面量来定义字符串: 双引号之间的文本,Go将把它们视为字符串。
”hello world!“
在字符串中,换行符、制表符和其他难以包含在程序代码中的字符可以用转义序列来表示:反斜杠后跟表示另一个字符的字符。
转义序列 | 值 |
/n | 换行符 |
/t | 制表符 |
/” | 双引号 |
// | 反斜杠 |
符文
字符串通常用于表示一些列文本字符,而Go的符文(rune)则用于表示单个字符。
字符串字面量由双引号(”)包围,但rune字面量由单引号(‘)包围。
Go程序几乎可以使用地球上任何语言的任何字符,因为Go使用Unicode标准来存储runes。runes被保存未数字代码,而不是字符本身,如果你把runes传递给fmt.Println,你会在输出中看到数字代码,而不是原始字符。
package main import "fmt" func main() { fmt.Println('A') fmt.Println('B') fmt.Println('Z') }
65 66 90
与字符串字面量一样,转义虚了也可以用在runes字面量中,用来表示程序代码中难以包含的字符:
func main() { fmt.Println('/t') fmt.Println('/n') fmt.Println('//') }
9 10 92
布尔值
布尔值只能是两个值中的一个:true或false。它们对于条件语句特别有用,条件语句只在条件未true或者false时才会导致代码段运行。
func main() { fmt.Println(true) fmt.Println(false) }
true false
数字
你可以直接在代码中定义数字,它甚至比字符串字面量更简单:只需输入数字即可:
func main() { fmt.Println(42) fmt.Println(3.14159265) }
42 3.14159265
稍后我们将看到,Go将整数和浮点数视为不同的数据类型,因此请记住,可以使用小数点来区分整数和浮点数。
数学运算与比较
Go的基本数学运算符的工作方式与大多数其他语言一样。符号+表示加法,-表示减法,*表示乘法,/表示除法。
可以使用<和>来比较两个值,看看其中一个值是否小于或者大于另一个值,可以使用==来查看两个值是否相等,已经!=来查看两个值是否不相等。<=测试第二个值是否大于或者等于第一个值,>=测试第二个值是否小于或者等于第一个值。
比较结果是一个布尔值,要么true,要么false
fmt.Println(4 < 6) | true |
fmt.Println(4 > 6) | false |
fmt.Println(2+2 == 5) | false |
fmt.Println(2+2 != 5) | true |
fmt.Println(4 <= 6) | true |
fmt.Println(4 >= 4) | true |
类型
在前面的代码示例中,我们看到了math.Floor函数,它将浮点数向下取舍为最接近的整数,已经strings.Title函数,它将字符串转换为首字母大写。将数字转换为参数传递给Floor函数,将字符串作为参数传递给Title函数,也是有意义的,但是如果将字符串传递给Floor,将数字传递给Title,会发生什么呢?
package main import ( "fmt" "math" "strings" ) func main() { fmt.Println(math.Floor("head first go")) fmt.Println(strings.Title(2.75)) }
cannot use "head first go" (type untyped string) as type float64 in argument to math.Floor cannot use 2.75 (type untyped float) as type string in argument to strings.Title
Go会打印两天错误信息,一个函数调用有一条,程序甚至不能运行!
你周围的事物通常可以根据它们的用途分为不同的类型,早餐不吃汽车或者卡车(因为它们是交通工具)。也不会开着煎蛋卷或者一碗麦片去上班(因为它们是早餐食品)。
同样,Go中的值都被划分为不同的类型,这些类型指定了这些值的用途,整数可以用在数学运算符中,但字符串不行,字符串可以大写,但是数字不行,等等这些。。。
Go是静态类型的,这意味着它甚至在程序运行之前就知道值得类型是什么,函数期望它的参数具有特定得类型,它们的返回值也具有类型(可能与参数类型相同,也肯定不同)。如果你不小心在错误的地方使用了错误类型的值,Go会给你一个错误消息。这是一件好事:它让你在用户发现问题之前就发现了问题!
可以通过将任何值传递给reflect包的TypeOf函数,来查看它们的类型,让我们看看对于已经看到的一些值,它们的类型是什么:
package main import ( "fmt" "reflect" //导入reflect包以便使用TypeOf函数 ) func main() { fmt.Println(reflect.TypeOf(42)) fmt.Println(reflect.TypeOf(3.1459265)) fmt.Println(reflect.TypeOf(true)) fmt.Println(reflect.TypeOf("Hello, world!")) }
int float64 bool string
以下是这些类型的用途:
类型 | 描述 |
int | 整数,保存数字 |
float64 |
浮点数,保存带小数部分的数字(类型中的64是因为要用64为的数据来保存数字。这意味着在四舍五入之前,float64值可以相当精确,但也不是无限精确。) |
bool | 布尔值,只能是true或false |
string | 字符串,通常表示文本字符的一系列数据 |
声明变量
在Go中,变量是包含值得一块存储,可以使用变量声明为变量命名,只需使用var关键字,后面跟所需得名称以及变量将保存得值的类型。
var quantity int //quantity为变量名,int为变量将保存的值的类型。 var length, width float64 //可以一次声明同一类型的多个变量 var customerName string
一旦声明了一个变量,就可以用=(这是一个等号)为它分配该类型的任何值:
quantity = 2 customerName = "Damon cloe"
可以在同一语句中为多个变量赋值,只需将多个变量名放在=的左侧,将数量相同的值放在右侧,并使用逗号分隔。
lenth, width = 1.2, 2.4
一旦给变量赋了值,就可以在任何要使用原始值的上下文中使用它们:
package main import "fmt" func main() { var quantity int var length, width float64 var customerName string quantity = 2 length, width = 1.2, 2.4 customerName = "Damon cloe" fmt.Println(customerName) fmt.Println("has ordered", quantity, "sheets") fmt.Println("echo with an area of") fmt.Println(length*width, "square meters") }
Damon cloe has ordered 2 sheets echo with an area of 2.88 square meters
如果事先知道变量的值是什么,可以什么变量并在同一行赋值:
var quantity int = 4 var length, width float64 = 1.2, 2.4 var customerName string = "Damon Coie"
可以为现有的变量分配心值,但它们必须是相同类型的值。Go的静态类型确保你不会意外第将错误类型的值赋给变量。
var quantity int = 4 var customerName string = "Damon Cole" quantity = "Damon Cole" customerName = 4
cannot use "Damon Cole" (type untyped string) as type int in assignment cannot use 4 (type untyped int) as type string in assignment
如果在声明变量的同时为其赋值,通常可以在声明中省略变量类型,这个分配给变量的值的类型将作为该变量的类型。
func main() { var quantity = 4 var length, width = 1.2, 2.4 var customerName = "Damon cloe" fmt.Println(reflect.TypeOf(quantity)) fmt.Println(reflect.TypeOf(length)) fmt.Println(reflect.TypeOf(width)) fmt.Println(reflect.TypeOf(customerName)) }
int float64 float64 string
零值
如果声明一个变量而没有给它赋值,该变量将包含其类型的零值。对于数值类型,零值实际上就是0:
var myInt int var MyFloat float64 fmt.Println(myInt, MyFloat)
0 0
但是对于其他类型来说,0值是无效的,因此该类型的零值可能是其他的值。例如,字符串变量的零值是空字符串,布尔值变量的零值是false。
var myString string var myBool bool fmt.Println(myString, myBool)
string变量的零值是空字符串,bool变量的零值是false
false
段变量声明
我们提到过,可以声明变量并在同一行上为其赋值:
var quantity = 4 var length, width = 1.2, 2.4 var customerName = "Damon cloe"
但是,如果你声明变量时就知道它的初始值时什么,那么更有代表性的时使用短变量声明。不必很明确地声明变量的类型并在之后使用=为其赋值,而是同时使用 “:=”。
package main import "fmt" func main() { quantity := 4 length, width := 1.2, 2.4 customerName := "Damon Cole" fmt.Println(customerName) fmt.Println("has ordered", quantity, "sheets") fmt.Println("each with an area of") fmt.Println(length*width, "square meters") }
Damon Cole has ordered 4 sheets each with an area of 2.88 square meters
不需要明确地声明变量的类型;赋给变量的值的类型称为该变量的类型。由于短变量声明非常方便和简洁,因此它们比常规声明更常用。不过,仍然会偶尔看到这两种形式,因此熟悉这两种形式很重要。
命名规则
Go有一天简单的规则,适用于变量、函数和类型的名称:
- 名称必须以字面开通,并且可以有任意熟悉的额外的字面和数字。
- 如果变量、函数或者类型的名称以大写字面开头,则认为它是导出的,可以从当前包之外的包访问。(这就是为什么fmt.Println中的P时大写的:这样它就可以在main包或者任何其他包中使用。如果变量/函数/类型阿名称是以小写字面开头的,则认为该名称是未导出的,只能在当前包中使用。)
这些是该语言强制执行的唯一规则。但是Go社区还遵循一些额外的约定:
- 如果一个名称由多个单词组成,那么第一个单词之后的每个单词都应该首字面大写,并且它们应该连接在一起,中间没有空格,比如toPrice、RetryConnection,等等。(名称的第一个字面只有在你想从包中导出时才大写)。这种样式通常称为驼峰大小写,因为大写字母看起来像驼峰。
- 当名称的含义在上下文种很明显时,Go社区的惯例是缩写它:用i代替index,用max代替maximum,等等。
只有名称是以大写字面开头的变量、函数或类型才被认为是可导出的:可以从当前包之外的包访问。
转换
Go中的数学运算和比较运算要求包含的值具有相同的类型。如果不是的话,则在尝试运行代码时会报错。
var length float64 = 1.2 var width int = 2 fmt.Println("Area is", length*width) //如果我们在数学运算中同时使用float64浮点数和整型数... fmt.Println("length > width?", length > width)
invalid operation: length * width (mismatched types float64 and int) invalid operation: length > width (mismatched types float64 and int)
为变量分配新值也是如此,如果所赋值的类型与变量的声明类型不匹配,也会报错。
var length float64 = 1.2 var width int = 2 length = width fmt.Println("Area is", length)
cannot use width (type int) as type float64 in assignment
解决方法是使用转换,它允许你将值从一种类型转换为另一种类型,只需要提供将值转换的类型,后面紧接着是在圆括号中的要转换的值。
var myInt int =2
float(myInt)
float64 为需要转换的类型,myInt为要转换的值
结果是所需类型的新值。下面是我们对整型变量中的值调用TypeOf,以及在转换为float64后对相同的值再次调用TypeOf时得到的结果:
var myInt int = 2 fmt.Println(reflect.TypeOf(myInt)) //没做转换 fmt.Println(reflect.TypeOf(float64(myInt))) //做了转换
int float64
让我们更新失败的代码示例,在任何数学运算中,或者与其他float64值进行比较前,先将int值转换为float64值。
var length float64 = 1.2 var width int = 2 fmt.Println("Area is", length*float64(width)) //在讲int数与另一个float64数相乘之前,先将其转换为float64. fmt.Println("length > width?", length > float64(width))
Area is 2.4 length > width? false
数学运算和比较现在都能正常工作!
现在让我们尝试在将一个int值转换为float64之前,先把它赋值给float64变量:
var length float64 = 1.2 var width int = 2 length = float64(width) //在讲int数赋值给float64变量之前,先将其转换为float64。 fmt.Println(length)
同样,转换就绪后,赋值成功了。
在进行转换时,请注意它们可能会如何更改结果值。例如,float64变量可以存储小数值,但是int变量不能,当你float64转换为int时,小数部分会被简单的删除!这可能会抛弃用结果执行的任何操作。
var length float64 = 3.75 var width int = 5 width = int(length) fmt.Println(width)
3
不过只有你保存谨慎,你就会反省转换在使用Go时时必不可少的,它们允许不兼容的类型一起工作。
在你的计算机上安装Go
Go Playgroud时一种很好的尝试语言的方法,但它的实际用途是有限的,例如,你不能使用它来处理文件,它没有办法从终端获取用户的输入,而这些都是我们在即将推出的程序中所需要的。
所以,为了圆满完成这一章,请在你的计算机上下载并安装Go。
别担心,Go团队以及让这项工作变得很容易了!对于大多数操作系统,只需要运行一个安装程序就可以了。
1.在Web浏览器上访问 https://go.dev
2.点击下载链接
3.选择合适你的操作系统(OS)的安装包。下载应该自动开始。
4.访问适合你操作系统的“安装说明”页面(下载开始后,你可能会被自动带到那里),并按照那里的说明进行操作。
5.打开一个新的终端或命令提升窗口
6.在提示符处输入go version并按下enter键,确认Go安装好了,应该能开到一条包含了所安装的Go的版本信息的信息
编译Go代码
我们与Go Playground的互动包括了输入代码并神秘地运行它们,既然我们以及在你的电脑上安装了Go,现在是时候仔细看看它是如何工作的了。
计算机实际上是不能直接运行Go代码的,在此之前,我们需要获取源代码文件并进行编译:将其转换为CPU可以执行的二进制格式。
让我们尝试使用新安装的Go来编译和运行我们之前的例子“Hello, world!”
package main import "fmt" func main() { fmt.Println("Hello world!") }
1.使用你喜欢的文本编辑器,写入以上代码并命名为hello.go的存文本文件。
2.打开一个新的终端或者命令提示窗口
3.在终端上,切换到保存hello.go的目录
4.运行go fmt hello.go整理代码格式(这一步不是必需的,但无论如何这是个好主意)
5.运行go build hello.go编译源代码。这将向当前目录添加一个可执行文件。在macOS或者Linux上,可执行文件将命名为hello,在window上,可执行文件将命名为hello.exe
6.运行可执行文件,在macOS或者Linux上,输入./hello即可,在Windows上,输入hello.exe。
go build hello.go
$ ./hello.exe Hello world!
Go工具
当你安装Go时,它会将一个名为go的可执行文件添加到命令提示符中,go可执行文件运训访问各种命令,包括:
命令 | 描述 |
go build | 将源码文件编译为二进制文件 |
go run | 编译并运行程序,而不保存可执行文件 |
go fmt | 使用go标准格式重新格式化源文件 |
go version | 显示当前Go版本号 |
我们刚刚尝试了go fmt命令,它将你的代码重新格式化为标准的Go格式,相当于Go Playground网站上的Format按钮,我们建议对创建的每个源文件都运行go fmt。
我们还使用go build命令将代码编译成可执行文件,这样的可执行文件可以分发给用户,即使用户没有安装Go,也可以运行它们。
但是我们还没有尝试go run命令,让我们现在开始吧。
使用Go run快速尝试代码
go run 命令编译并运行源文件,而不将可执行文件保存到当前目录。非常适合快速尝试简单的程序,让我们用它来运行hello.go示例。
1.打开一个新的终端或命令提示窗口
2.在终端上,切换到保存hello.go的目录
3.输入go run hello.go,然后按回车键,
你将看到程序输出。如果对源码进行更改,则不必执行单独的编译步骤,只需使用go run运行代码,即可立即看到结果。当你在处理小程序时,go run 是一个很方便的工具!
函数调用
函数是一段代码,你可以从程序的其他位置调用它。
调用函数时,可以使用参数向函数提供数据。
类型
Go中的值被分为不同的类型,这些类型指定了值得用途。
不同类型直接进行数学运算和比较是不允许的,但如果需要,可以将值转换为新类型。
Go变量只能存储其声明的类型
要点
- 包是一组相关函数和其他代码的组合
- 在Go文件中使用包的函数之前,需要先导入该包。
- string是一系列字节,通常表示文本字符。
- runes表示单个文本字符。
- Go最常见的两种数字类型是int(保存整数)和float64(保存浮点数)。
- bool类型保存布尔值,这些值要么为true,要么为false。
- 变量是一段可以包含指定类型值的存储
- 如果没有给变量赋值,它将包含其类型的零值。零值的示例包括对int或float64变量来说是0,对string变量来说是“”(空字符串)。
- 你可以使用 := 短变量声明来声明一个变量,并同时为其赋值。
- 如果变量、函数或类型的名称以大写字面开头,则只能从其他包的代码中访问它们。
- go fmt命令自动重新格式化源文件以使用Go标准格式,如果你打算与其他人共享任何代码,你应该岁它们运行go fmt。
- go build 命令将Go源代码编译成计算机可以执行的二进制格式。
- go run命令编译并运行一个程序,而不将可执行文件保存在当前目录中。