Sunzz

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

 

分类:

Go

技术点:

相关文章: