当前位置：首页 > article >正文

Go语言的基础知识

article 2025/1/7 15:46:22

1, Go 语言介绍

Go 即 Golang,是 Google公司2009年11月正式对外公开的一门编程语言。

根据 Go 语言开发者自述，近10多年，从单机时代的C语言到现在互联网时代的Java,都没有令人满意的开发语言，而C++往往给人的感觉是，花了100%的经历，却只有60%的开发率，产出比太低，Java和C#的哲学又来源于C++。并且，随着硬件的不断升级，这些语言不能充分的利用硬件及CPU。因此，一门高效，简洁，开源的语言诞生了。

GO语言不仅拥有静态编译语言的安全和高性能，而且又达到了动态语言开发速度和易维护性。有人形容Go语言：Go=C+Python,说明Go语言即有C语言程序的运行速度，又能达到Python语言的快速开发。

Go语言是非常有潜力的语言，是因为它的应用场景是目前互联网热门的几个领域，比如WEB开发，区块链开发，大型游戏服务端的开发，分布式/云计算开发。国内比较知名的

B站就是用Go语言开发的，像 Google,阿里，京东，百度，腾讯，小米，360d的很多应用也是使用Go语言开发的。

2，Go语言成功的项目

nsq: bitly开源的消息队列系统，性能非常高，目前他们每台处理数十亿条的消息。

docker: 基于lxc的一个虚拟打包工具，能够实现PAAS平台的组件

packer: 用来生成不同平台的镜像文件，例如VM,vbox,AWS等，作者是vagrant的作者

skynet: 分布式调度框架

Doozer：分布式同步工具，类似ZooKeeper

Heka: mazila 开源的日志处理系统

cbfs: couchbase 开源的分布式文件系统

tsuru: 开源的 PAAS 平台，和 SAE 实现的功能一模一样

groupcache: memcache 作者写的用于Google下载系统的缓存系统

god: 类似 redis 的缓存系统，但是支持分布式和扩展性

gor: 网络流量抓包和重放工具

3，哪些大公司在用 go 语言？

Google

这个不用多做介绍，作为开发Go语言的公司。当仁不让。Google基于Go有很多优秀的项目，比如： https://github.com/kubernetes/kubernetes,大家也可以在Github上 https://github.com/google/查看更多Google的Go开源项目。

Facebook

Facebook也有在用，为此他们还专门在Github上建立了一个开源组织facebookgo,大家可以通过 https://github.com/facebookgo 访问查看 facebook 开源的项目，比如著名的是平滑升级的grace.

腾讯

腾讯作为国内的大公司。还是敢于尝试的，尤其是Docker容器化这一块，他们在15年已经做了 docker 万台规模的实践，具体可以参考 http://www.infoq.com/cn/articles/tenent-millions-scale-docker-application-practice

百度

目前所知的百度的使用是在运维这边，是百度运维的一个BFE下项目。负责前端流量的接入。他们的负责人在2016年有分享，大家可以看下这个

http://www.info.com/cn/presentations/application-of-golang-in-baidu-frontend

京东

京东云消息推送系统，云存储，以及京东商城等都要使用Go做开发。

小米

小米对Golang的支持，莫过于运维监控系统的开源，也就是 http://open-falcon.com/

此外。小米互娱，小米商城，小米视频，小米生态链等团队都在使用Golang.

360

360对Golang的使用也不少，一个是开源的日志搜索系统Poseidon,托管在Github上，https://github.com/Qihoo360/poseidon

4,Go语言前景

5，Go环境 win 环境搭建

1,下载安装 Golang
Go官方下载地址： https://golang.org/dl/
Go官方镜像站(推荐)： https://golang.google.cn/dl/

2, 安装软件
双击下一步下一步进行安装

3, 验证有没有安装成功
go version

go version go1.23.3 windows/amd64


4, 查看 go 环境
go env 

C:\Users\Administrator>go env
set GO111MODULE=
set GOARCH=amd64
set GOBIN=F:\Users\AppData\Local\Programs\Microsoft VS Code\bin
set GOCACHE=G:\Users\AppData\Local\go-build
set GOENV=G:\Users\AppData\Roaming\go\env
set GOEXE=.exe
set GOEXPERIMENT=
set GOFLAGS=
set GOHOSTARCH=amd64
set GOHOSTOS=windows
set GOINSECURE=
set GOMODCACHE=G:\Users\go\pkg\mod
set GONOPROXY=
set GONOSUMDB=
set GOOS=windows
set GOPATH=G:\Users\go
set GOPRIVATE=
set GOPROXY=https://proxy.golang.org,direct
set GOROOT=F:\Files\Go
set GOSUMDB=sum.golang.org
set GOTMPDIR=
set GOTOOLCHAIN=auto
set GOTOOLDIR=F:\Files\Go\pkg\tool\windows_amd64
set GOVCS=
set GOVERSION=go1.23.3
set GODEBUG=
set GOTELEMETRY=local
set GOTELEMETRYDIR=G:\Users\AppData\Roaming\go\telemetry
set GCCGO=gccgo
set GOAMD64=v1
set AR=ar
set CC=gcc
set CXX=g++
set CGO_ENABLED=0
set GOMOD=NUL
set GOWORK=
set CGO_CFLAGS=-O2 -g
set CGO_CPPFLAGS=
set CGO_CXXFLAGS=-O2 -g
set CGO_FFLAGS=-O2 -g
set CGO_LDFLAGS=-O2 -g
set PKG_CONFIG=pkg-config

说明： Go1.11版本之后无需手动配置环境变量，使用 go mod 管理项目，也不需要非得把项目放到 GOPATH指定目录下，你可以在你磁盘的任何位置心建一个项目。

Go1.13以后可以彻底不要 GOPATH了。

6 , Go 语言开发工具 Vscode配置

1，下载安装 vscode

https://code.visualstudio.com/

2, 汉化 vscode

3,vscode中安装Go语言插件

3, Go语言 vscode 插件安装失败解决方法

go env -w GOPROXY=https://goproxy.io

4，LiteIDE安装

LiteIDE是一款简单，开源，跨平台的 GoIDE

官网：

官网：
http://liteide.org/cn
发行版下载地址：
https://sourceforge.net/projects/liteide/files

合作网站： www.itying.com(IT营)

作者专栏：

https://www.itying.com/category-79-b0.html

5，Go语言定义变量，fmt包，Print,Println,Printf,Go语言注释

import "fmt"

fmt包里面给我们提供了一些常见的打印数据的方法，比如：Print,Println,Printf,在我们实际开发中Println,Printf用的非常多。

Print和Println区别:

一次输入多个值的时候Println中间有空格Print没有

fmt.Println("go","python"."php","javascript")//go python php javascript
fmt.Print("go","python","php","javascript")//gopythonphpjavascript

Print会自动换行，Prrint不会

package main

import "fmt"

func main() {
	/*
		fmt.Println("您好,欢迎来到Go语言编程课堂!")
		fmt.Print("Hello,Go!")
	*/
	// fmt.Printf("Hello,Go!\n")
	// Print与Println的区别:Print会输出空格,Println不会输出空格
	// fmt.Println("您好,欢迎来到Go语言编程课堂!")
	// fmt.Print("Hello,Go!")

	// fmt.Println("A")
	// fmt.Println("B")
	// fmt.Println("C")

	// fmt.Print("D")
	// fmt.Print("E")
	// fmt.Print("F")

	// fmt.Printf("G")
	// fmt.Printf("H")
	// fmt.Printf("K")

	// fmt.Print("A", "B", "C")
	// fmt.Println("A", "B", "C")
	fmt.Printf("A", "B", "C")
}

PS D:\Program Files\Go\src\project\go_demo\demo02> go run main.go
A
B
C
DEFGHK

Println和Printf区别

Printf是格式化输出，在很多场景下比Println更方便，举个例子：

  a := 10
	b := 20
	c := 30
	fmt.Println("a=", a, ",b=", b, ",c=", c)//%d 打印变量a,b,c的值 a= 10 ,b= 20 ,c= 30
	fmt.Printf("a=%d,b=%d,c=%d", a, b, c)//a=10,b=20,c=30

1，Go语言定义变量

这里我们为了演示代码期间给大家先简单介绍一下变量，后面的教程还会详细讲解。

关于变量：程序运行过程中的数据都是保存在内存中，我们想要在代码中操作某个数据时就需要去内存上找到这个变量，但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。

Golang中常见的变量定义方法如下：

Golang 中常见的变量定义方法如下：

1，var 定义变量

var 变量名 类型=表达式
var name string="zhangsan"

2, 类型推导方式定义变量

a 在函数内部，可以使用更简略的 := 方式声明并初始化变量。

注意：短变量只能用于声明局部变量，不能用于全局变量的声明

变量名 := 表达式
    a := 10
    b := 20
    c := 30
    fmt.Println("a=", a, ",b=", b, ",c=", c)//%d 打印变量a,b,c的值 a= 10 ,b= 20 ,c= 30
    fmt.Printf("a=%d,b=%d,c=%d", a, b, c)//a=10,b=20,c=30

%d 是占位符，表示数字的十进制表示。Printf中的占位符与后面的数字变量一一对应。

3，Go语言中的注释

win下面 ctrl+/可以快速的注释一行，mac下面 command+/也可以快速的注释一行。

/*
    这是一个多行注释
    这是一个多行注释
*/

// 这是一个单行注释

Go 变量，常量，变量命名规则

1，变量的来历

2，变量的类型

3，Go语言中变量的声明

4，Go语言中的常量

5，Go语言变量，常量命名规则

6，Go语言代码风格

1，变量的来历

程序运行过程中的数据都是保存在内存中，我们想要在代码中操作某个数据时就需要去内存上找到这个变量，但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。

2，变量类型

变量(Variable)的功能是存储数据。不同的变量保存的数据类型可能会不一样。经过半个多世纪的发展，编程语言已经基本形成了一套固定的类型，常见变量的数据类型有：整型，浮点型，布尔型等。

Go语言中的每一个变量都要自己的类型，并且变量必须经过声明才能开始使用。

3，GO语言中变量的声明

Go语言变量名由字母，数字，下划线组成，其中首个字符不能为数字。Go语言中关键字和保留字都不能用作变量名。

Go语言中的变量需要声明后才能使用，同一作用域内部不支持重复声明。并且Go语言的变量声明后必须使用。

1，var 声明变量

var 变量名称 type

var name string
var age int
var isOK bool

举例：

package main

import "fmt"

func main() {
	// fmt.Println("变量声明: var 变量名 类型 = 表达式")
	// 	var username string

	// 	fmt.Println(username)// 变量声明后没有赋值，默认值为变量类型的零值 即变量为空值
	// var username string = "张三"
	// fmt.Println(username)

	// var 1a stringconst	// 错误 变量名不能以数字开头
	// fmt.Printf("", var)

	// var m_ = "李四"	// 正确 变量名可以以下划线开头 不推荐使用
	// fmt.Println(m_)

	// var if = "李四"	// 错误 变量名不能使用关键字
	// fmt.Println(if)

	// go语言 变量的定义以及初始化值必须使用同一个类型
	// 第一种初始化变量的方式：
	// var username string
	// username = "李四"
	// fmt.Println(username)

	// 第二种初始化变量的方式：var 变量名 类型 = 值
	// var username string = "张三" // 推荐使用
	// fmt.Println(username)

	// 第三种初始化变量的方式：变量名 := 值	// 自动推导变量类型 使用简短赋值语句 :=
	// username := "王五"
	// fmt.Println(username)

	// 第四种初始化变量的方式：同时声明多个变量
	// var username = "李四"
	// var age = 18
	// var sex = "男"
	// fmt.Println(username, age, sex)

	var username = "李四"
	var age = 18
	var sex = "男"
	username = "张三" // 变量可以重新赋值
	fmt.Println(username, age, sex)

}

https://github.com/PublicSuffixList
https://publicsuffix.org/

2, 一次定义多个变量

var identifier1,identifier2 type

package main
import "fmt"
func main() {
	var username,sex string
}

3，批量声明变量的时候指定类型

var(
	a string
	b int
	c bool
)
a = "zhangsan"
b = 20
c = true
fmt.Println(a,b,c)

4, 变量的初始化

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值。例如：整型和浮点型变量的默认值为0。字符串变量的默认值为空字符串。布尔型变量默认值为 false，切片，函数，指针变量的默认值为 nil。

当然我们也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下：

var 变量名 类型 = 表达式

举个例子：

var name string = "zhangsan"

5，类型推导

有时候我们会将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化

var name = "Q1mi"
var age = 18

6，短变量声明法

在函数内部，可以使用更简略的 := 方式声明并初始化变量。

注意：短变量只能用于声明局部变量，不能用于全局变量的声明

变量名 := 表达式

package main
import "fmt"

// 全局变量
var m = 100

func main() {
	n := 10
	m := 200 // 此处声明局部变量 m
	fmt.Print(m,n)
}

7，匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量(anonymous variable).匿名变量用一个下划线 _ 表示。例如：

func getInfo() (int,stringi) {
	return 10,"张三"
}

实战如下：

package main

import "fmt"

// 封装一个方法(函数)
func getUserinfo() (string, int) {
	return "张三", 18
}

// var g = "全局变量"

// g1 := "全局变量 短变量声明法式 错误写法"

func main() {
	// g1 := "全局变量 短变量声明法式 错误写法"
	// fmt.Println(g)

	// fmt.Println(g1) // 全局变量 短变量声明法式 错误写法

	// fmt.Println("变量声明: var 变量名 类型 = 表达式")
	// 	var username string

	// 	fmt.Println(username)// 变量声明后没有赋值，默认值为变量类型的零值 即变量为空值
	// var username string = "张三"
	// fmt.Println(username)

	// var 1a stringconst	// 错误 变量名不能以数字开头
	// fmt.Printf("", var)

	// var m_ = "李四"	// 正确 变量名可以以下划线开头 不推荐使用
	// fmt.Println(m_)

	// var if = "李四"	// 错误 变量名不能使用关键字
	// fmt.Println(if)

	// go语言 变量的定义以及初始化值必须使用同一个类型
	// 第一种初始化变量的方式：
	// var username string
	// username = "李四"
	// fmt.Println(username)

	// 第二种初始化变量的方式：var 变量名 类型 = 值
	// var username string = "张三" // 推荐使用
	// fmt.Println(username)

	// 第三种初始化变量的方式：变量名 := 值	// 自动推导变量类型 使用简短赋值语句 :=
	// username := "王五"
	// fmt.Println(username)

	// 第四种初始化变量的方式：同时声明多个变量
	// var username = "李四"
	// var age = 18
	// var sex = "男"
	// fmt.Println(username, age, sex)

	// var username = "李四"
	// var age = 18
	// var sex = "男"
	// username = "张三" // 变量可以重新赋值
	// fmt.Println(username, age, sex)

	// 第五种初始化变量的方式：简短声明 := 变量值	// 只能在函数中定义局部变量
	// 一次声明多个变量
	/*
		1,一次定义多个变量 类型一致的变量
		var 变量名称，变量名称，变量名称 类型 = 变量值，变量值，变量值
		var (
			变量名称 类型
			变量名称 类型
			变量名称 类型
		)
	*/
	// 一次定义多个变量
	// var a1, a2 string
	// a1 = "aaa"
	// a2 = "aaaaaaaa"
	// fmt.Println(a1, a2) // aaa aaaaaaaaa

	//2,定义多个变量时，类型可以不同
	/*
		var (
			username string
			age      int
			sex      string
		)
		username = "张三"
		age = 18
		sex = "男"
		fmt.Println(username, age, sex)
	*/

	// 3,一次定义多个变量时，类型可以不同
	// var (
	// 	username string = "张三"
	// 	age      int    = 18
	// 	sex      string = "男"
	// )
	// fmt.Println(username, age, sex)

	// 4,定义多个变量时，类型可以不同
	// 简短声明 = 变量值   只能定义全局变量 不能定义局部变量
	// var (
	// 	username = "李四"
	// 	age      = 18
	// 	sex      = "男"
	// )
	// fmt.Println(username, age, sex)
	// fmt.Println("=========================")

	/*
		5，短变量声明法，在函数内部，可以使用更简略的 := 方式声明并初始化变量。
		注意：短变量只能用于声明局部变量，不能用于全局变量的声明
	*/
	// username := "王五"
	// fmt.Println(username)
	// // 打印 username 变量的类型
	// fmt.Printf("username 的类型是 %T\n", username)
	// fmt.Printf("类型：%T\n", 10)

	// 6,使用短变量一次声明多个变量，并初始化变量值
	// a, b, c := 12, 13, 20
	// fmt.Println(a, b, c)// 12 13 20

	// 7,使用短变量一次声明多个变量，类型可以不同
	// a, b, c := 12, 13, "c"
	// fmt.Println(a, b, c)                                   // 12 13 c
	// fmt.Printf("a 的类型: %T, b 的类型: %T, c 的类型: %T", a, b, c) // a 的类型: int, b 的类型: int, c 的类型: string

	/*
		匿名变量：在使用多重赋值时，如果想忽略某个值，可以使用匿名变量。(anonymous variable)

		匿名变量用户定义一个没有变量名的变量。匿名变量用 _ 符号表示，比如：
		func getUserinfo() (string, int) {
			return "张三", 18
		}
	*/
	// var username, age = getUserinfo()
	// fmt.Println(username, age) // 张三 18  能打印出来，表示我们可以调用getUserinfo()这个方法

	// 8,使用匿名变量忽略返回值
	// var username = getUserinfo()
	// fmt.Println(username) // 张三  报错

	// var username, _ = getUserinfo()
	// fmt.Println(username) // 张三

	// 9,匿名变量不占命名空间，不会分配内存，所以匿名变量之间不存在重复声明的问题
	var _, age = getUserinfo()
	fmt.Println(age) // 18
}

4，Go 语言中的常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。常量的声明和变量的声明非常类似，只是把var换成了 const,常量在定义的时候必须赋值。

1，使用 const 定义常量

const pi = 3.1415
const e = 2.7182

声明了pi和e这两个常量之后，在整个程序运行期间™的值都不能再发生变化了。

多个常量也可以一起声明：

const(
	pi = 3.14159
	e = 2.7182
)

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同，例如：

const(
	n1 = 100
	n2
	n3
)

打印 pi 的值

package main
import(
	"fmt"
	"math"
)
func main() {
	const pi=math.pi
	fmt.Println(pi)
}

2, const 常量结合 iota 的使用 (了解)

iota 是 golang 语言的常量计数器，只能在常量的表达式中使用。

iota 在 const 关键字出现时将被重置为0(const内部的第一行之前)，const中每新增一行常量声明将使 iota 计数一次(iota 可理解为const 语句块中的行索引)。

1），iota 只能在常量的表达式中使用。

fmt.Println(iota)
编译错误：undefined:iota

2) , 每次 const 出现时，都会让 iota 初始化为 0.【自增长】

const a = iota //a=0
const(
	b = iota //b=0
	c		 //c=1
)

3）const iota使用_跳过某些值。

const(
	n1 = iota //0
	n2
	-
	n4
)
fmt.Println(n1,n2,n4) 0 1 3

4) iota 声明中间插队

const(
	n1 = iota
	n2 = 100
	n3 = iota
	n4
)
const n5 = iota
fmt.Println(n1,n2,n3,n4,n5)//0 100 2 3

5) 多个 iota 定义在一行

const(
	a,b = iota + 1,iota + 2 // 1,2
	c,d
	e,f
)
fmt.Println(a,b c,d e,f)

5, Go 语言变量，常量命名规则

1，变量名称必须由数字，字母，下划线组成。

2，标识符开头不能是数字

3，标识符不能是保留字和关键字。

4，变量的名字是区分大小写的如：age和Age是不同的变量，在实际的运用中，也建议不要用一个单词大小写区分两个变量。

5，标识符(变量名称)一定要见名思意：变量名称建议用名词，方法名称建议用动词

6，变量命名一般采用驼峰式，当遇到特有名词(缩写或简称，如DNS)的时候，特有名词根据是否私钥全部大写或小写。

6，Go语言代码风格

1，代码每一行结束后不用写分号(;)

2, 运算符左右建议个加一个空格

var username string = "itying"

3, Go语言程序员推荐使用驼峰式命名

当名字有几个单词组成的时候优先使用大小写分隔

4，强制的代码风格

左括号必须紧接着语句不换行，这个特性刚开始会使开发者不习惯，但随着对GO语言的不断熟悉，就会发现风格统一让大家在阅读代码时把注意力集中到了解决问题上，而不是代码风格上

5, go fmt 主要用于格式化文档，让所有人的代码风格保存一

go fmt main.go

main.go

实践

package main

import (
	"fmt"
	"math"
)

// const iota = 10

func main() {
	const pi = math.Pi
	fmt.Println(pi)

	// 变量声明以后，可以多次赋值，但是不可以重复声明同一个变量
	// var username = "张三"
	// username = "李四"
	// username = "王五"
	// fmt.Println(username)

	// 1 . 常量声明：const 变量名 = 值

	// 常量声明以后，不可以重复赋值 const pi = 3.14
	// const pi = 3.1415926
	// fmt.Println(pi)

	// 变量声明和常量声明的区别：
	// 1.变量声明后，可以多次赋值；常量声明后，不可以重复赋值
	// 2.变量声明后，如果不赋值，则系统默认值为0值，例如int为0，string为空字符串""
	// 3.变量声明后，如果不赋值，则不能直接使用

	// 变量声明和常量声明的选择：
	// 1.如果需要被多次赋值，则使用变量；如果只使用一次，则使用常量
	// var num int = 10
	// fmt.Println(num)
	// const num2 = 10
	// fmt.Println(num2)
	// fmt.Println(num + num2)

	// 2. 一次可以声明多个常量，也可以同时声明多个不同类型的常量，例如：
	// const (
	// 	A = "A"
	// 	B = "B"
	// )
	// fmt.Println(A, B)

	// 3. const 同时声明多个常量，如果省略了值，则表示和上面一行声明的常量值相同，例如：
	// const (
	// 	n1 = 100
	// 	n2
	// 	n3
	// )
	// fmt.Println(n1, n2, n3) // 100 100 100

	/* 1. 常量声明中，如果需要使用到某个常量表达式中的值，则必须将该常量表达式写在一行中，例如：

	iota 是 golang 语言的常量计数器，只能在常量的表达式中使用。
	iota 在 const 关键字出现时将被重置为0(const内部的第一行之前)，
	const中每新增一行常量声明将使 iota 计数一次(iota 可理解为const 语句块中的行索引)。
	 每次 const 出现时，都会让 iota 初始化为 0.【自增长】
	 iota 主要用在一次定义常量组时，不需要写各组的值
	*/
	// const a = iota // a=0
	// const (
	// 	b = iota // b=0
	// 	c
	// 	d
	// )

	// fmt.Println(a)
	// fmt.Println(a, b, c, d) // 0 0 1 2
	// fmt.Println(iota)

	//2,每次 const 出现时，都会让 iota 初始化为 0.【自增长】
	// const (
	// 	n1 = iota // n1=0
	// 	n2
	// 	n3
	// 	n4
	// 	n5
	// )
	// fmt.Println(n1, n2, n3, n4, n5) // 0 1 2 3 4

	// 3, const  iota使用_跳过某些值。
	// const (
	// 	n1 = iota
	// 	_
	// 	n3
	// 	n4
	// )
	// fmt.Println(n1, n3, n4) // 0 2 3

	// 4) iota 声明中间插队
	// const (
	// 	n1 = iota
	// 	n2 = 100
	// 	n3 = iota
	// 	n4
	// )
	// fmt.Println(n1, n2, n3, n4) // 0 100 2 3

	// 5)  多个 iota 定义在一行
	// const (
	// 	a, b = iota + 1, iota + 2 // a=1,b=2
	// 	c, d                      // c=2,d=3
	// 	e, f                      // e=3,f=4
	// )
	// fmt.Println(a, b, c, d, e, f) // 1 2 2 3 3 4
	// fmt.Println(a, b)// 1 2
	// fmt.Println(c, d)// 2 3
	// fmt.Println(e, f)// 3 4

	//Go语言中，变量和常量命名规范：
	//1. 变量名必须以字母或下划线开头，大小写敏感
	//2. 变量名不能以数字开头，例如：age10
	//3. 变量名不能包含空格，例如：a b c
	//4. 变量名不能包含关键字，例如：var、const
	//5. 变量名不能包含特殊字符，例如：$、&等
	//6. 变量名要具有描述性，例如：username、password
	//7. 变量名要使用驼峰命名法，例如：UserName、Password
	//8. 变量名不要使用中文，例如：用户名、密码
	//9. 变量名不要使用拼音，例如：zhangsan、lisi
	//10. 变量名不要使用拼音和中文组合，例如：zhangSan、LiSi
	//11. 变量名要使用统一风格，例如：username、User_Name
	//12. 变量名不要过长，例如：user_name_of_good_friend
	//13. 变量名不要使用拼音缩写，例如：u、p
	//14. 变量名不要使用中文缩写，例如：u、p
	//15. 变量名不要使用数字，例如：user1、user2
	//16. 变量名不要使用下划线_，例如：user_name、password
	//17. 建议常量名全大写，例如：AGE、PASSWORD
	//18. 常量名不要使用中文，例如：年龄、密码

	// var age = 10
	// var Age = 20
	// fmt.Println(age, Age)

	// 在Go语言中，如果你将变量名封装成一个包，则变量名必须使用驼峰命名法
	// 小驼峰封装 私有 大驼峰封装 公有
	var maxAge = 10 // maxAge=10 小驼峰命名法	封装 私有
	var MaxAge = 20 // MaxAge=20 大驼峰命名法   封装 公有
	fmt.Println(maxAge, MaxAge)

	// go语言中代码风格：
	// 1. 使用tab缩进，不要使用空格
	// 2. 每行代码的长度不要超过150个字符
	// 3. 每行代码后面不要添加多余的空格
	// 4. 每行代码结束不要添加多余的;
	// 5. 代码块中，左括号{的位置通常放在函数名或者控制语句的末尾处，而不是开头
	// 6. 如果代码块中只有一行代码，则左括号{和右括号}可以写在同一行
	// 7. 不要使用多余的空行来缩进和分隔代码块
	// 8. 如果代码过长，可以使用换行来分隔
	// 9. 如果代码过长，可以使用括号()来分隔
	// 10. 如果代码过长，可以使用中括号[]来分隔
	// 11. 如果代码过长，可以使用花括号{}来分隔
	// 12. 如果代码过长，可以使用竖线|来分隔
	// 13. 如果代码过长，可以使用逗号,来分隔
	// 14. 如果代码过长，可以使用分号;来分隔
	// 15. 如果代码过长，可以使用空格来分隔
	// 16. 运算符前后要添加空格，例如：a = b + c
	// 17. 推荐使用单行注释，不要使用多行注释
	// 18. 推荐使用函数注释，不要使用包注释
	// 19. 推荐使用变量注释，不要使用常量注释
	// 20. 推荐使用结构体注释，不要使用接口注释
	// 21. 推荐使用方法注释，不要使用字段注释
	// 22. 注释内容应该使用完整句子，句子的开头第一个字母应该大写
	// 23. 注释内容应该使用英文，不要使用中文
	// 24. 注释内容应该使用英文句号，不要使用中文句号
	// 25. 注释内容应该使用英文感叹号，不要使用中文感叹号
	// 26. 注释内容应该使用英文问号，不要使用中文问号
	// 27. 注释内容应该使用英文逗号，不要使用中文逗号
	// 28. 注释内容应该使用英文分号，不要使用中文分号
	// 29. 注释内容应该使用英文冒号，不要使用中文冒号
	// 30. 注释内容应该使用英文省略号，不要使用中文省略号
	// 31. 注释内容应该使用英文双引号，不要使用中文双引号
	// 32. 注释内容应该使用英文单引号，不要使用中文单引号
	// 33. 注释内容应该使用英文括号，不要使用中文括号
	// 34. 注释内容应该使用英文反引号，不要使用中文反引号
	// 35. 注释内容应该使用英文中划线，不要使用中文中划线
	// 36. 注释内容应该使用英文等号，不要使用中文等号
	// 37. 注释内容应该使用英文加号，不要使用中文加号
	// 38. 注释内容应该使用英文减号，不要使用中文减号
	// 39. 注释内容应该使用英文星号，不要使用中文星号
	// 40. 注释内容应该使用英文斜线，不要使用中文斜线
	// 41. 注释内容应该使用英文反斜线，不要使用中文反斜线
	// 42. 注释内容应该使用英文点号，不要使用中文点号
	// 43. 推荐使用驼峰命名法，不要使用下划线_
	// 44. 当变量名、函数名、方法名等使用英文命名时，应该使用驼峰命名法
	// 45. 当常量名等使用英文命名时，应该使用全大写字母命名
	// 46. 当包名等使用英文命名时，应该使用小写字母命名
	// 47. 当接口名等使用英文命名时，应该使用驼峰命名法
	// 48. 当结构体名等使用英文命名时，应该使用驼峰命名法
	// 49. 当方法名等使用英文命名时，应该使用驼峰命名法
	// 50. 当字段名等使用英文命名时，应该使用驼峰命名法
}

Go 语言基本数据类型

1，Golang 数据类型介绍

2，整型

3，浮点型

4，布尔值

5，字符串

6，byte 和 rune 类型

7，修改字符串

查看全文

http://www.kler.cn/a/468397.html

在线机考|2024华为实习秋招春招编程题（最新）——第3题_个性化歌单推荐系统_300分（十一）

如何利用PHP爬虫按关键字搜索淘宝商品

REVERSE-COMPETITION-CCSSSC-2025

热备份路由HSRP及配置案例

Wireshark 具体某种协议的分析

如何利用人工智能算法优化知识分类和标签？

Python中使用正则表达式的场景

MOE怎样划分不同专家：K-Means聚类算法来实现将神经元特征聚类划分

【Python】super() 函数和 MRO 顺序的实例剖析

Python自动化小技巧27——代理IP变化爬虫

XGBoost 分类模型优化：超参数调优与性能提升的协同攻略

代码随想录D32-35 动态规划01-03 Python

（二）元问题和元指令：问GPT怎么问

【开源免费】基于SpringBoot+Vue.JS物资管理系统（JAVA毕业设计）

【Qt】将控件均匀分布到圆环上

业务连续性计划（BCP）是什么？

OneFlow和PyTorch在性能上有哪些区别？

C 实现植物大战僵尸（三）

git分支管理-创建分支、重命名分支、推送分支

我用AI学Android Jetpack Compose之Kotlin篇

PyTorch Geometric框架下图神经网络的可解释性机制：原理、实现与评估

拥抱时代--AI（3）

WSDM 2025 | 时间序列（time series）论文总结

linux定时执行脚本的方法

大模型高效推理综述

动态库dll与静态库lib编程4：MFC规则DLL讲解

1, Go 语言介绍

Go 即 Golang,是 Google公司2009年11月正式对外公开的一门编程语言。

GO语言不仅拥有静态编译语言的安全和高性能，而且又达到了动态语言开发速度和易维护性。有人形容Go语言：Go=C+Python,说明Go语言即有C语言程序的运行速度，又能达到Python语言的快速开发。

Go语言是非常有潜力的语言，是因为它的应用场景是目前互联网热门的几个领域，比如WEB开发，区块链开发，大型游戏服务端的开发，分布式/云计算开发。国内比较知名的

B站就是用Go语言开发的，像 Google,阿里，京东，百度，腾讯，小米，360d的很多应用也是使用Go语言开发的。

2，Go语言成功的项目

nsq: bitly开源的消息队列系统，性能非常高，目前他们每台处理数十亿条的消息。

docker: 基于lxc的一个虚拟打包工具，能够实现PAAS平台的组件

packer: 用来生成不同平台的镜像文件，例如VM,vbox,AWS等，作者是vagrant的作者

skynet: 分布式调度框架

Doozer：分布式同步工具，类似ZooKeeper

Heka: mazila 开源的日志处理系统

cbfs: couchbase 开源的分布式文件系统

tsuru: 开源的 PAAS 平台，和 SAE 实现的功能一模一样

groupcache: memcache 作者写的用于Google下载系统的缓存系统

god: 类似 redis 的缓存系统，但是支持分布式和扩展性

gor: 网络流量抓包和重放工具

3，哪些大公司在用 go 语言？

Google

这个不用多做介绍，作为开发Go语言的公司。当仁不让。Google基于Go有很多优秀的项目，比如： https://github.com/kubernetes/kubernetes,大家也可以在Github上 https://github.com/google/查看更多Google的Go开源项目。

Facebook

Facebook也有在用，为此他们还专门在Github上建立了一个开源组织facebookgo,大家可以通过 https://github.com/facebookgo 访问查看 facebook 开源的项目，比如著名的是平滑升级的grace.

腾讯

腾讯作为国内的大公司。还是敢于尝试的，尤其是Docker容器化这一块，他们在15年已经做了 docker 万台规模的实践，具体可以参考 http://www.infoq.com/cn/articles/tenent-millions-scale-docker-application-practice

百度

目前所知的百度的使用 是在运维这边，是百度运维的一个BFE下项目。负责前端流量的接入。他们的负责人在2016年有分享，大家可以看下这个

京东

京东云消息推送系统，云存储，以及京东商城等都要使用Go做开发。

小米

小米对Golang的支持，莫过于运维监控系统的开源，也就是 http://open-falcon.com/

此外。小米互娱，小米商城，小米视频，小米生态链等团队都在使用Golang.

360

360对Golang的使用也不少，一个是开源的日志搜索系统Poseidon,托管在Github上，https://github.com/Qihoo360/poseidon

4,Go语言前景

5，Go环境 win 环境搭建

说明： Go1.11版本之后无需手动配置环境变量，使用 go mod 管理项目，也不需要非得把项目放到 GOPATH指定目录下，你可以在你磁盘的任何位置心建一个项目。

Go1.13以后可以彻底不要 GOPATH了。

6 , Go 语言开发工具 Vscode配置

1， 下载安装 vscode

2, 汉化 vscode

3,vscode中安装Go语言插件

3, Go语言 vscode 插件安装失败解决方法

4，LiteIDE安装

LiteIDE是一款简单，开源，跨平台的 GoIDE

官网：

合作网站： www.itying.com(IT营)

作者专栏：

5，Go语言 定义变量 ，fmt包，Print,Println,Printf,Go语言注释

fmt包里面给我们提供了一些常见的打印数据的方法，比如：Print,Println,Printf,在我们实际开发中Println,Printf用的非常多。

Print和Println区别:

一次输入多个值的时候Println中间有空格Print没有

Print会自动换行，Prrint不会

Println和Printf区别

Printf是格式化输出，在很多场景下比Println更方便，举个例子：

1，Go语言定义变量

这里我们为了演示代码期间给大家先简单介绍一下变量，后面的教程还会详细讲解。

Golang中常见的变量定义方法如下：

Golang 中常见的变量定义方法如下：

1，var 定义变量

2, 类型推导方式定义变量

a 在函数内部，可以使用更简略的 := 方式声明并初始化变量。

注意：短变量只能用于声明局部变量，不能用于全局变量的声明

%d 是占位符，表示数字的十进制表示。Printf中的占位符与后面的数字变量一一对应。

更多的占位符参考：

3，Go语言中的注释

win下面 ctrl+/可以快速的注释一行，mac下面 command+/也可以快速的注释一行。

Go 变量，常量，变量命名规则

1，变量的来历

2，变量的类型

3，Go语言中变量的声明

4，Go语言中的常量

5，Go语言变量，常量命名规则

6，Go语言代码风格

1，变量的来历

2，变量类型

变量(Variable)的功能是存储数据。不同的变量保存的数据类型可能会不一样。经过半个多世纪的发展，编程语言已经基本形成了一套固定的类型，常见变量的数据类型有：整型，浮点型，布尔型等。

Go语言中的每一个变量都要自己的类型，并且变量必须经过声明才能开始使用。

3，GO语言中变量的声明

Go语言变量名由字母，数字，下划线组成，其中首个字符不能为数字。Go语言中关键字和保留字都不能用作变量名。

Go语言中的变量需要声明后才能使用，同一作用域内部不支持重复声明。并且Go语言的变量声明后必须使用。

目前所知的百度的使用是在运维这边，是百度运维的一个BFE下项目。负责前端流量的接入。他们的负责人在2016年有分享，大家可以看下这个

1，下载安装 vscode

5，Go语言定义变量，fmt包，Print,Println,Printf,Go语言注释

5，类型推导