go学习第一课--语法基础
一.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.cnblogs.com/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.TitleGo会打印两天错误信息，一个函数调用有一条，程序甚至不能运行！
你周围的事物通常可以根据它们的用途分为不同的类型，早餐不吃汽车或者卡车（因为它们是交通工具）。也不会开着煎蛋卷或者一碗麦片去上班（因为它们是早餐食品）。
同样，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 = 4cannot 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命令编译并运行一个程序，而不将可执行文件保存在当前目录中。
