一.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!“

在字符串中，换行符、制表符和其他难以包含在程序代码中的字符可以用转义序列来表示：反斜杠后跟表示另一个字符的字符。

符文

字符串通常用于表示一些列文本字符，而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

类型

在前面的代码示例中，我们看到了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

以下是这些类型的用途：

声明变量

在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 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命令编译并运行一个程序，而不将可执行文件保存在当前目录中。