01.基础知识

Abel sun2023年1月6日约 1889 字大约 6 分钟

01.基础知识

1.go是什么？

我的Go语言入门之路也是曲曲折折，不过经过两三次学习又放下，放下重捡起的过程之后，终于能有一些小积累，现在的感受，想想其实跟Linux命令，shell脚本是一个道理，一开始各种死记硬背，不需要理解太多，这也是需要的阶段，再到后来的掌握方法，只记得大概，再到后来彻底不再记，用好百度谷歌即可。说到底就一句话，要多听，多看，多写，多练，多交流，无他，唯求手熟耳！以下学习笔记是学习过程中整理，大多参考如下两位老师：

通过观看他们的视频以及博客，算是系列性的将go语言基础内容串了下来，再次感谢二位！

:::

接下来进入个人整理笔记分享，只为以后回头翻看方便。

Go语言中包含了大量用于处理Go语言代码的命令和工具。其中，go命令是最常用的一个，它有许多参数可以使用，如下所示：

build：用于编译给定的代码包或Go语言源码文件及其依赖包。
- go build -o "xx.exe" :编译成xx.exe文件
clean：用于清除执行其他go命令后遗留的目录和文件。
doc：用于执行godoc命令以打印指定代码包。
env：用于打印Go语言环境信息。
fix：用于执行go tool fix命令以修正给定代码包的源码文件中包含的过时语法和代码调用。
fmt：用于执行gofmt命令以格式化给定代码包中的源码文件。
get：用于下载和安装给定代码包及其依赖包（提前安装git或hg）。
list：用于显示给定代码包的信息。
run：用于编译并运行给定的命令源码文件。
install：编译包文件并编译整个程序。
test：用于测试给定的代码包。
tool：用于运行go语言的特殊工具。
version：显示当前安装的go语言的版本信息。

1，包的概念

1，和Python一样，把相同功能的代码放到一个目录，称之为包。
2，包可以被其他包引用。
3，main包是用来生成可执行文件，每个程序有且只有一个main包。
4，包的主要用途是提高代码的可复用性。

输出一个hello world。

//1)go语言以包作为管理单位
//2)每个文件必须先声明包
//3)程序必须有一个main包（重要）

package main

//go语言以双斜杠作为注释的标识
/*
 这是块注释
 可以多段注释
*/

import "fmt"

//入口函数，有且只有一个
func main() { //左括号必须与函数名同行，否则会报错
 //打印
 //“hello go"打印到屏幕，Println()会自动换行
 //调用函数，大部分都需要导入包
 fmt.Println("hello go") //go语言结尾没有分号
 fmt.Println("hello haha")
}

2，变量的声明

package main

import "fmt" //导入就必须使用，否则会报错

func main() {
 /*
   1,声明格式 var 变量名 类型，变量声明了，必须使用，否则会报错
      2，只是声明而没有赋值的变量，默认值为0
   3，同一个{}当中，变量名是唯一的，不能重复
 */
 var a int
 fmt.Println("a = ", a)

 //4,可以同时声明多个变量，方式如后： var b,c int，多个变量用逗号隔开

 a = 10
 fmt.Println("a = ", a)

 //5,变量的初始化，声明变量的同时赋值
 var b int = 10 //初始化，声明变量时，同时赋值
 b = 20
 fmt.Println("b = ", b)

 //6,自动推导类型，必须初始化，程序通过初始化的值确定类型（常用）
 c := 30
 fmt.Printf("c type is %T\n", c)

}

3，printf和println的区别

package main

import "fmt"

func main() {
 a := 10

 fmt.Println("a = ", a) //一段一段处理，自动加换行

 fmt.Printf("a = %d\n", a) //格式化输出，把a的内容放在%d的位置，也就是将"a = 10\n"这个字符串输出到屏幕，”\n带边换行符“

 b := 20
 c := 30
 fmt.Println("a = ", a, ",b = ", b, ",c = ", c)
 fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}

4，多重赋值与匿名变量

多重赋值的代码如下：

package main

import (
 "fmt"
)

func main() {
 //多变量传统赋值方式
 /*
  a := 10
  b := 20
  c := 30
  fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
 */

 //可以直接写成如下方式
 /*
  a, b, c := 10, 20, 30
  fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
 */

 //交换两个变量的值得传统方式
 /*
  a, b := 10, 20
  var tmp int
  tmp = a //创建一个临时变量，然后把a的值存起来，然后利用临时变量进行过渡
  a = b
  b = tmp
  fmt.Printf("a = %d, b = %d\n", a, b)
 */

 //而在go当中，可以用如下方式表示
 i, j := 10, 20
 i, j = j, i //直接交换两者的位置即可
 fmt.Printf("i = %d, j = %d\n", i, j)
}

匿名变量的代码如下：

package main

import "fmt"

//go函数可以返回多个值，简单写法如下

func test() (a, b, c int) {
 return 1, 2, 3
}

func main() {
 var a, b, c int
 a, b, c = test() //表示将上边定义的test函数值赋给abc。
 fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)

 //而如果此时只想要部分值，而非全部的，可以使用匿名变量‘_’
 //'_'匿名变量，表示丢弃数据不处理，匿名变量匹配函数多返回值时，很有优势
 //比如我只想要b的值，可以用如下方式：

 _, b, _ = test()
 fmt.Printf("b = %d\n", b)
}

5，常量的使用

package main

import "fmt"

func main() {
 /*
  变量：是指程序运行期间，可以改变的量。变量声明的关键词是var。
  常量：是指程序运行期间，不能变量的量。常量声明的关键词是const。
 */
 const a int = 10
 //a = 20 //err,a已被定义为常量，不能更改
 fmt.Println("a = ", a)

 //常量也可以使用自动推导类型来定义
 //但是不能使用:=的方式，否则会报错。
 const b = 10 //不能使用:=
 fmt.Println("b = ", b)

 const c = 10.2
 fmt.Printf("c type is %T\n", c) //%T表示变量的类型
}

6，多个不同类型的变量或常量的定义

package main

import (
 "fmt"
)

func main() {
 //不同类型变量的定义

 /*传统方式
 var a int = 1
 var b float64 = 2.0
 */

 //另一种方式
 // var (
 //  a int = 1
 //  b float64 =2.0
 // )

 //其实类型可以省略，程序自动推导
 var (
  a = 10
  b = 3.14
 )
 fmt.Println("a = ", a)
 fmt.Println("b = ", b)

 //不同类型的常量的定义

 //传统方式
 // const i int = 10
 // const j float64 = 3.14
 //注释某段的快捷键，选中代码，按Ctrl+ /

 //另一种方式
 // const (
 //  i int     = 10
 //  j float64 = 3.14
 // )

 //其实类型可以省略，程序自动推导
 const (
  i = 10
  j = 3.14
 )
 fmt.Println("i = ", i)
 fmt.Println("j = ", j)

}

7，iota枚举

package main

import "fmt"

func main() {
 // 1，iota的功能是常量生成器，每隔一行，自动累加1
 // 2，iota给常量赋值使用

 const (
  a = iota //1
  b = iota //2
  c = iota //3
 )
 fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)

 //3，多个iota时，可以只写一个。效果与上边的一样
 const (
  a1 = iota
  b1
  c1
 )
 fmt.Printf("a1 = %d, b1 = %d, c1 = %d\n", a1, b1, c1)

 //4，iota再次遇到cost，将会重置为0
 const d = iota //0
 fmt.Println("d =", d)

 //5，如果在同一行，那么值都一样
 const (
  i          = iota
  j1, j2, j3 = iota, iota, iota
  k          = iota
 )
 fmt.Printf("i = %d, j1 = %d, j2 = %d, j3 = %d, k = %d\n", i, j1, j2, j3, k)
}

昵称

邮箱

网址

按正序
按倒序
按热度

01.基础知识

# 01.基础知识

# 1.go是什么？

# 1，包的概念

# 2，变量的声明

# 3，printf和println的区别

# 4，多重赋值与匿名变量

# 5，常量的使用

# 6，多个不同类型的变量或常量的定义

# 7，iota枚举

预览:

01.基础知识

1.go是什么？

1，包的概念

2，变量的声明

3，printf和println的区别

4，多重赋值与匿名变量

5，常量的使用

6，多个不同类型的变量或常量的定义

7，iota枚举