标签：Println src 语言 fmt 基础 go GoWork Go main

第01天 Go语言基础语法入门

1 初识GO语言

简介

Go是一门开放源码的编程语言，可容易构建，简单、可靠和高效的软件

历史

Go 语言是由谷歌的开发工程师(罗伯特·格瑞史莫、罗勃·派克、肯·汤普逊等)于 2007 年
开始设计，利用 20%的自由时间开发的实验项目，并于 2009 年以 BSD-style 授权（完全开
源）首次公开发布，于 2012 年正式发布

Go语言的版本:
https://go.dev/doc/devel/release
https://golang.google.cn/doc/devel/release.html

优势

开发者使用编程语言的三大分类（编译速度、开发难度、执行速度）
	执行速度快、编译速度慢（编译型）：C C++
	执行速度较慢、编译速度快（解释型）JAVA .NET
	执行速度慢、开发难度小（动态脚本）Python PHP
	
Go语言的三个条件做了平衡：易于开发、快速编译、高效执行

特性

静态类型并具有丰富的内置类型：bool byte rune int float string array slice map 泛型
函数多返回值
错误处理机制：使用defer panic recover定义标准的错误流程
语言层并发：使用关键字go将函数以Goroutine方式运行，使用CSP模型作为Goroutine的通信方式

面向对象：使用类型、组合、接口来实现面向对象思想
反射
CGO:用于调用C语言实现的模块
自动垃圾回收
静态编译
交叉编译
易于部署
基于BSD协议完全开放

应用领域

Go语言主要用于服务端开发，其定位是开发大型软件，常用于：
服务器编程：日志处理、虚拟机处理、文件系统、分布式系统等
网络编程：Web应用、API应用、下载应用等
内存数据库
云平台
机器学习
区块链

使用Go开发的项目
GO
Docker
Kubernetes
... ...

开源项目列表

https://github.com/golang/go/wiki/Projects

百科： http://github.com/golang/go/wiki

开源项目列表
编译工具的  Build Tools
缓存的 cache
云计算的 Cloud Computing
命令行工具的
压缩  Compression
并发的 Concurrency and Goroutines
配置的文件解析的  Configuration File Parsers
控制台的 Console User Interface
持续集成 Continuous Integration
加密的 Cryptocurrency
数据处理的 Data Processing
自己实现的一些堆栈等

日期处理
开发工具
文档处理 
Email处理

语言机器学习
日志监控

使用Go的大型公司

国外 Google Microsoft Amazon FaceBook
国内 阿里 腾讯 百度 京东、爱奇艺、小米、今日头条、滴滴、美团、饿了么、360、七牛、B 站、盛大、搜狗……

一些优秀的项目源码

如何学习

知识点分解
刻意练习
反馈
	主动反馈 看别人的代码
	被动反馈 codereview

总结 多写，多看，多问

2 开发环境搭建

Windows 安装

下载SDK
官网: https://golang.google.cn/dl/
go中文网：https://studygolang.com/dl

1 默认安装路径
	C:\Program Files\Go\bin
2 创建工作目录
	D:\GoWork\bin
	D:\GoWork\pkg
	D:\GoWork\src

2 配置环境变量
	推荐设置
	go env -w GO111MODULE=on
	go env -w GOPROXY=https://goproxy.cn,direct	
	go env -w GOPATH=D:\GoWork

	此电脑--属性 -- 高级系统设置 -- 环境变量
3 执行命令
	C:\Users\zhu>go version // 查看安装go的版本
	go version go1.19.9 windows/amd64
	C:\Users\zhu>go env

Linux安装

下载SDK
官网: https://golang.google.cn/dl/
go中文网：https://studygolang.com/dl

1 解压到/usr/local目录
	tar -xf go1.19.9.linux-amd64.tar.gz -C /usr/local

2 创建工作目录
	mkdir -p /root/{bin,pkg,src}
	
2 配置环境变量
cat > /etc/profile.d/go.sh <<OEF
if [[ "x" == "x${GOROOT}" ]]; then
    export GO111MODULE=on
    export GOPROXY=https://goproxy.cn,direct
    export GOROOT=/usr/local/go
    export GOPATH=${HOME}/go
    export PATH=${GOROOT}/bin:${GOPATH}/bin:${PATH}
fi
EOF

source /etc/profile.d/go.sh

3 执行命令
go version
go env

vscode开发环境搭建

下载vscode：https://code.visualstudio.com/

安装Vscode Go语言扩展

Go
Golang postfix
Outline Map

单词拼写检查: Code Spell Checker
快捷运行代码的插件: Code Runner
最好用Git工具没有之一: Gitlens
AI 代码生成: Tabnine AI Code

安装Vscode Go语言扩展需要的工具集

设置变量加速
	go env -w GOPROXY=https://goproxy.cn,direct
设置变量过后为了保证vscode能正常使用, 请重启vscode

1 打开命令面板: Shift + Ctrl + P
2 输入: Install/Update 搜索 Go扩展依赖工具安装命令
3 勾选所有选项, 点击确认，进行安装

安装失败处理

go install -v golang.org/x/tools/gopls@latest
go install -v honnef.co/go/tools/cmd/staticcheck@latest
go install -v github.com/go-delve/delve/cmd/dlv@latest
go install -v github.com/haya14busa/goplay/cmd/goplay@latest
go install -v github.com/josharian/impl@latest
go install -v github.com/fatih/gomodifytags@latest
go install -v github.com/cweill/gotests/gotests@latest
go install -v github.com/ramya-rao-a/go-outline@latest
go install -v github.com/uudashr/gopkgs/v2/cmd/gopkgs@latest

设置终端使用Git Shell

下载Git https://git-scm.com/downloads

1 Shift + Ctrl + ` 打开终端

2 打开终端的设置界面

3 点击 Git Bash即可

4 重启vscode, 可以看到默认打开Git Bash终端、也可选择其他终端

配置自动保存

file --> Auto ave
如果要配置自动保存的时间, 打开vscode的设置按钮, 搜索auto save

3 第一个程序

D:\GoWork\src\code\day01\helloworld.go

package main

import "fmt"

func main() {
	fmt.Println("Hello world!")
}

01 新建文件helloworld.go，并进行编辑
02 声明包名main
03 导入fmt包
04 定义main函数
05 使用fmt包的Println打印字符串helloworld到控制台
06 编译链接 go build helloworld.go
07 运行 helloworld.exe

go的几个工具

go build 
	go build helloworld.go 
	展示编译过程 -x 
	go build -x helloworld.go

	编译生成指定文件 -o
	go build -x -o hello.exe helloworld.go

	打印临时目录
	go build  --work helloworld.go
	WORK=C:\Users\zhu\AppData\Local\Temp\go-build2020755140


go run
	go run helloworld.go
	展示编译过程
	go run -x helloworld.go
	
	打印过程不执行 -n
	go run -n helloworld.go
	
go help 查看帮助


go fmt 格式化
	go fmt helloworld.go

注释

// 定义包main
package main // 定义包main

import "fmt" //导入标准包fmt

// 程序入口，main函数
func main(){
   /*
      我是一个注释
      这里调用fmt包下的Println函数打印内容到控制台
   */
   fmt.Println("Hello world") // 打印hello world到控制台
}

4 变量&作用域

变量-什么是变量

D:\GoWork\src\code\day01\vars.go

package main

import "fmt"

func main() {
	// 变量 给数据起一个名字
	var msg string = "hello world"
	fmt.Println(msg)
	// 其他代码
	fmt.Println(msg)
}

作用域

1 包级别，函数级别，块级别，子块级别

D:\GoWork\src\code\day01\block.go

package main

import "fmt"

// 包级别
var packageVar string = "package Var"

func main() {
	// 函数级别的
	var funcVar string = "func var"
	{
		// 块级别
		var blockVar string = "block var"
		{
			//子块级别
			var innerBlockVar string = "inner block var"
			fmt.Println(packageVar, funcVar, blockVar, innerBlockVar)
		}
		fmt.Println(packageVar, funcVar, blockVar)
	}
	fmt.Println(packageVar, funcVar)
}

/* 执行结果： 顺序执行
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run block.go
package Var func var block var inner block var
package Var func var block var
package Var func var
*/

2 父块不能用子级别的变量

D:\GoWork\src\code\day01\block.go

package main

import "fmt"

// 包级别
var packageVar string = "package Var"

func main() {
	// 函数级别的
	var funcVar string = "func var"
	{
		// 块级别
		var blockVar string = "block var"
		{
			//子块级别
			var innerBlockVar string = "inner block var"
			fmt.Println(packageVar, funcVar, blockVar, innerBlockVar)
		}
        // innerBlockVar 报错
		fmt.Println(packageVar, funcVar, blockVar,innerBlockVar)
	}
	fmt.Println(packageVar, funcVar)
}

3 先找自己，再找父模块的，没找到再向外找

D:\GoWork\src\code\day01\block2.go

package main

import "fmt"

// 包级别
var packageVar string = "package Var"

func main() {
	// 函数级别的
	var funcVar string = "func var"
	var packageVar string = "func package Var"
	{
		// 块级别
		var packageVar string = "block package Var"
		fmt.Println(packageVar)
	}
	fmt.Println(packageVar, funcVar)
}

/* 打印结果： 
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run block2.go
block package Var
func package Var func var
*/

4 作用域总结

包packageVar -- {函数级别funcVar -- {块级别 blockVar -- {子块级别 innerBlockVar}}}

1 代码块限定变量使用范围
2 子块可以覆盖父块中定义的变量

变量-声明

四种变量声明：

1 声明并赋值
	var name string = "bob"
2 先声明，后赋值(默认零值)。 
	var name string
3 不带类型的声明
	var name 		= "bob"
4 短声明
	name:			= "bob"

D:\GoWork\src\code\day01\vars2.go

package main

import "fmt"

func main() {
	// 1声明并赋值
	var name string = "bob"
	// 2 声明不初始化
	var zeroString string
	// 3 声明不指定类型,通过值推导
	var typeString = "bob"
	// 4 短声明（必须在函数内子块中使用）
	shortString := "bob"

	fmt.Println(name, zeroString, typeString, shortString)
	fmt.Printf("%#v,%#v,%#v,%#v", name, zeroString, typeString, shortString)
}

/* 打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run vars2.go
bob  bob bob
"bob","","bob","bob"
*/

多变量声明和单行生成多变量

D:\GoWork\src\code\day01\vars3.go

package main

import "fmt"

var version = "1.0"

func main() {
	var (
		name string = "bob"
		msg         = "hello world"
		desc string
	)

	x, y := "x", "y"
	fmt.Println(name, msg, desc, x, y)
}

/* 打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run vars3.go 
bob hello world  x y
*/

变量-赋值

赋值（更新变量的值）

D:\GoWork\src\code\day01\assign.go

package main

import "fmt"

func main() {
	var name string = "bob"
	fmt.Println(name)

	name="alice" // 更新变量的值（赋值）
	fmt.Println(name)
}

/* 打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run assign.go 
bob
alice
*/

块内赋值（不是定义，都更新）

D:\GoWork\src\code\day01\assign.go

package main

import "fmt"

func main() {
	var name string = "bob"
	fmt.Println(name)

	name = "alice" // 更新变量的值（赋值）
	fmt.Println(name)
	{
		// 不是定义
		name = "cc"
	}
	fmt.Println(name)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run assign.go 
bob
alice
cc
*/

块内定义（仅更新块内）

D:\GoWork\src\code\day01\assign1.go

package main

import "fmt"

func main() {
	var name string = "bob"
	fmt.Println(name)

	name = "alice" // 更新变量的值（赋值）
	fmt.Println(name)
	{
		// 块内定义
		name := "dd"
		fmt.Println(name)
	}
	fmt.Println(name)
}


/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run assign1.go 
bob
alice
dd
alice
*/

5 基本组成元素

标识符（变量的命名规范和匿名变量）

D:\GoWork\src\code\day01\name.go

package main

import "fmt"

func main() {
	/*
	   标识符：程序中定义的名字 变量名，常量名字，函数名字，自定义类型，接口，包名字
	   规范：
	      1. 必须满足:组成只能由非空的Unicode编码字符串、数字、下换线组成
	      2. 必须满足:必须以Unicode编码的字符串或下换线开头（不能以数字开头）
	      3. 必须满足:不能与go的关键字冲突（package，func，var... 25个）
	   建议：
	      1. AsciII编码（a-z,A-Z)/数字、下划线
	      2. 变量使用驼峰式
	         多个英文字母 my_name myName 驼峰
	      3. 与go内置的标识符不要冲突（string...)
	   说明：标识符区分大小写
	      my=""
	      My=""
	*/
	var my = "my"
	var My = "My"
	var 我的名字 = "bob"      // 可以，不建议用
	var _myName = "alice" //可以
	//var 0Name = "aa"   // 不可以
	//var package = "bb" // 不可以
	fmt.Println(my, My, 我的名字, _myName)
	
    // 关于匿名变量
	// var _,b,c = 100,"hello",true
}

运算符

算术运算符 + - * / % ++ --
关系运算符 >、 >=、 <、 <=、 ==、 !=
逻辑运算符 &&、 ||、 ！
位运算符 &、 |、 ^、 <<、 >>、 &^
赋值运算符 =、 +=、 -=、*=、 /=、 %=、&=、|=、^=、 <<=、 >>=
其他运算符 &(单目)、 *(单目)、 .(点)、 -(单目)、 ...、 <-

分隔符

小括号() 中括号[] 大括号{} 分号; 逗号,

Day01 下午

6 常量

声明

声明语句用于定义程序的各种实体对象，主要有：
声明变量的var
声明常量的const
声明函数的func
声明类型的type

常量声明

常量一旦定义不能修改
常量可以不使用

D:\GoWork\src\code\day01\const.go

package main

import "fmt"

func main() {
	const name string = "bob"
	fmt.Println(name)

	// name = "alice" // 常量一旦定义不能修改

	const msg = "msg" // 常量可以不使用

}

D:\GoWork\src\code\day01\const2.go

package main

import (
	"fmt"
)

func main() {
	const (
		A = "test"
		B // 使用前一个常量值
		C // 使用前一个常量值
		D = "testD"
		E
		F
	)
	fmt.Println(B, C)
	fmt.Println(E, F)

}

/* 打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run const2.go 
test test
testD testD
*/

枚举类型

D:\GoWork\src\code\day01\enum.go

package main

import (
	"fmt"
)

func main() {
	const (
		A = iota
		B
		C
		D
	)
	fmt.Println(A, B, C, D)
	const (
		Mon = iota
		Tue
		Wed
		Thu
		Fri
		Sat
		Sun
	)
	fmt.Println(Mon, Tue, Wed, Thu, Fri, Sat, Sun)
}

/* 打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run enum.go 
0 1 2 3
0 1 2 3 4 5 6
*/

打印类型print

D:\GoWork\src\code\day01\print.go

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var name = "bob"
	fmt.Println("*")
	fmt.Println(name) //打印变量加换行
	fmt.Println("*")
	fmt.Print(name) // 打印变量不加换行
	fmt.Println("*")

	fmt.Printf("%T,%v,%#v\n", name, name, name)
	fmt.Println(reflect.TypeOf(name))
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run print.go 
*
bob
*
bob*
string,bob,"bob"
string
*/

7 基础数据类型

布尔类型：用来表示真假 只有两个 真true 假false
数字类型: 
// int uint
// int8 int16
// uint8 uint16
// byte rune
// uintptr
浮点类型
// float32 float64 （非精确的存储）
复数类型
字符串

数组
切片
映射
自定类型

7.1 布尔类型

声明&零值&占位符%t

D:\GoWork\src\code\day01\bool.go

package main

import "fmt"

func main() {
	isGirl := false
	fmt.Printf("%T,%t\n", isGirl, isGirl)

	var bbb bool
	fmt.Printf("%t,%t\n", bbb, "bbb") //零值false，"bbb"是字符串%t提示不匹配
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run bool.go 
bool,false
false,%!t(string=bbb)

*/

逻辑运算

D:\GoWork\src\code\day01\bool1.go

package main

import "fmt"

func main() {
	// 逻辑运算
	a, b, c, d := true, true, false, false
	fmt.Println("a=true", "b=true", "c=false", "d=false")
	// 与: 左操作数与右操作数都为true，结果为true &&
	fmt.Println("a&&b:", a && b)
	fmt.Println("a&&c:", a && c)
	fmt.Println("c&&b:", c && b)
	fmt.Println("c&&d:", c && d)

	// 或: 左操作数与右操作数只要由一个为true，结果为true ||
	fmt.Println("a=true", "b=true", "c=false", "d=false")
	fmt.Println("a||b:", a || b)
	fmt.Println("a||c:", a || c)
	fmt.Println("c||b:", c || b)
	fmt.Println("c||d:", c || d)

	// 非: 取反 true=> false false=>true !
	fmt.Println("a=true",  "c=false")
	fmt.Println("!a:", !a)
	fmt.Println("!c:", !c)

}

/* 打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run bool1.go 
a=true b=true c=false d=false
a&&b: true
a&&c: false
c&&b: false
c&&d: false
a=true b=true c=false d=false
a||b: true
a||c: true
c||b: true
c||d: false
a=true c=false
!a: false
!c: true
*/

关系运算

D:\GoWork\src\code\day01\bool2.go

package main

import "fmt"

func main() {
	// 关系运算
	a, b, c := true, true, false
	fmt.Println("a=true", "b=true", "c=false")
	fmt.Println("true==true:", a == b)
	fmt.Println("true==false:", a == c)
	fmt.Println("true!=true:", a != b)
	fmt.Println("true!=false", a != c)
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run bool2.go 
a=true b=true c=false
true==true: true
true==false: false
true!=true: false
true!=false true
*/

7.2 数字类型

数字类型: 
// 有符号：int8 int16 int32(rune) int64 
// 无符号：uint8(byte) uint16 uint32 uint64 
// 与平台有关：int uint uintptr 用于存放指针

0 声明&零值&占位符%d、%b、%o、%x、%X、&默认推断类型int

D:\GoWork\src\code\day01\int.go

package main

import "fmt"

func main() {
	// 声明
	var age8 int8 = 31 // 字面量 10进制 8进制 16进制
	var age0 int       // 零值
	var age = 18       // 默认推断为int型

	fmt.Println("字面量 10进制 2进制 8进制 16进制:")
	fmt.Printf("%T,%d,%b,%o,%x,%X\n\n", age8, age8, age8, age8, age8, age8)

	fmt.Println("占位符,格式化对齐:")
	fmt.Printf("%-8d,\n%8d,\n%08d,\n\n", age8, age8, age8)

	fmt.Printf("零值:     %T %2d\n", age0, age0)
	fmt.Printf("推导类型：%T %d\n\n", age, age)

}



/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run int.go
字面量 10进制 2进制 8进制 16进制:
int8,31,11111,37,1f,1F

占位符,格式化对齐:
31      ,
      31,
00000031,

零值:     int  0
推导类型：int 18
*/

1 声明： 2进制 8进制 16进制数

D:\GoWork\src\code\day01\int1.go

package main

import "fmt"

func main() {
	// 声明2进制 8进制 16进制数
	var v2 int8 = 0b111
	var v8 int16 = 070
	var v16 int64 = 0x1f
	fmt.Printf("%T %v\n", v2, v2)
	fmt.Printf("%T %v\n", v8, v8)
	fmt.Printf("%T %v\n", v16, v16)
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run int1.go
int8 7
int16 56
int64 31
*/

2 算术运算

D:\GoWork\src\code\day01\int2.go

package main

import "fmt"

func main() {
	// 算术运算
	var a, b = 2, 4

	fmt.Println(a + b)
	fmt.Println(a - b)
	fmt.Println(a * b)
	fmt.Println(a / b)
	fmt.Println(a % b)

	a++
	fmt.Println(a)
	b--
	fmt.Println(b)

	// 除0异常
	// c, d := 2, 0
	//fmt.Println(c / d) //panic: runtime error: integer divide by zero
	//fmt.Println(c % d) //panic: runtime error: integer divide by zero
}

/*打印结果:
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run int2.go 
6
-2
8
0
2
3
3
*/

位运算

了解 D:\GoWork\src\code\day01\int2.go

package main

import "fmt"

func main() {

	/*
	   仅了解 位运算
	   7 => 0111
	   2 => 0010

	   按位与 &
	   按位或 |
	   取非 ^
	   右移位 >>
	   左移位 <<
	   and not &^
	*/
	fmt.Println("********************************")
	fmt.Println(7 & 2)
	fmt.Println(7 | 2)
	fmt.Println(^2)
	fmt.Println(7 >> 2)
	fmt.Println(7 << 2)
	fmt.Println(7 &^ 2) // 7 & -3  0000 0111 & 1111 1100 转换反码 与0000 0100
	fmt.Println(7 & 3)  // 7 & 3   0000 0111 & 1000 0011 转换反码 与0000 0011
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run int2.go
********************************
2
7
-3
1
28
5
3
*/

3 关系运算

D:\GoWork\src\code\day01\int3.go

package main

import "fmt"

func main() {
	// 关系运算
	a, b := 3, 3
	fmt.Println(a > b)
	fmt.Println(a < b)
	fmt.Println(a == b)
	fmt.Println(a != b)
	fmt.Println(a >= b)
	fmt.Println(a <= b)
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run int3.go 
false
false
true
false
true
true
*/

4 转换后再计算

D:\GoWork\src\code\day01\int4.go

package main

import "fmt"

func main() {
	var (
		i         = 1
		i32 int32 = 1
		i64 int64 = 1
	)
	// 类型转换type(value) int32(i) int64(i)  int(i32) int(i64)
	fmt.Println(i + int(i32))
	fmt.Println(i + int(i64))
	fmt.Println(int32(i) + i32)
	fmt.Println(int64(i) + i64)
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run int4.go 
2
2
2
2
*/

5 字节定义byte、rune&占位%U %c %q &%T打印int32

D:\GoWork\src\code\day01\int5.go

package main

import "fmt"

func main() {
	var (
		achar        byte = 'A'
		aint         byte = 65
		unicodePoint      = '中'
	)
	fmt.Println(achar, aint)
	fmt.Printf("%T %U %c,%q\n", unicodePoint, unicodePoint, unicodePoint, unicodePoint)
	fmt.Printf("%d %U %c,%q\n", achar, achar, achar, achar)
	fmt.Printf("%d %U %c,%q\n", aint, aint, aint, aint)
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run int5.go 
65 65
int32 U+4E2D 中,'中'
65 U+0041 A,'A'
65 U+0041 A,'A'
*/

6 赋值运算（参考浮点数赋值运算）

7.3 浮点类型

声明

// float32 float64 （非精确的存储）

D:\GoWork\src\code\day01\float.go
package main

import "fmt"

func main() {
	var height float32 = 1.68
	var heightType = 1.68
	var k = 1e3
	fmt.Printf("%T,%#v,%f\n", height, height, height)
	fmt.Printf("%T,%#v,%f\n", heightType, heightType, heightType)
	fmt.Println(k)
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run float.go 
float32,1.68,1.680000
float64,1.68,1.680000
1000
*/

算术运算

package main

import "fmt"

func main() {
	var (
		f1 = 1.2
		f2 = 2.36
	)
	fmt.Println(f1 + f2)
	fmt.Println(f1 - f2)
	fmt.Println(f1 * f2)
	fmt.Println(f1 / f2)

	f1++
	f2--
	fmt.Print(f1, f2)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run float1.go 
3.5599999999999996
-1.16
2.832
0.5084745762711864
2.2 1.3599999999999999
*/

decimal解决精度问题

D:\GoWork\src\code\day01\float2.go

package main

import (
	"fmt"

	"github.com/shopspring/decimal"
)

func main() {
	var (
		a = 1.1
		b = 2.34
	)

	c := decimal.NewFromFloat(a)
	d := decimal.NewFromFloat(b)
	//算术运算
	fmt.Println(c.Add(d), a+b)
	fmt.Println(c.Sub(d), a-b)
	fmt.Println(c.Mul(d), a*b)
	fmt.Println(c.Div(d), a/b)

	fmt.Println("--------------------------------")
	//float32 与 float64转换
	var aa float32
	aa = 9.99999
	bb := float64(aa)
	cc := decimal.NewFromFloat32(aa)
	fmt.Println(bb)
	fmt.Println(cc.Float64())

}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run float2.go 
3.44 3.44
-1.24 -1.2399999999999998
2.574 2.574
0.4700854700854701 0.47008547008547014
--------------------------------
9.999990463256836
9.99999 false
*/

关系运算

D:\GoWork\src\code\day01\float3.go

package main

import "fmt"

func main() {
	var (
		f1 = 1.2
		f2 = 2.36
	)
	fmt.Println(f1 > f2)
	fmt.Println(f1 >= f2)
	fmt.Println(f1 == f2)
	fmt.Println(f1 != f2)

}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run float3.go 
false
false
false
true
*/

赋值运算

D:\GoWork\src\code\day01\float4.go

package main

import "fmt"

func main() {
	var (
		f1 = 1.2
		f2 = 2.36
	)
	f1 += f2
	fmt.Println(f1)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run float4.go 
3.5599999999999996
*/

7.4 字符串

声明

D:\GoWork\src\code\day01\string.go

package main

import "fmt"

func main() {
	var msg ="我的名字\\n是bob"
	var msgRaw = `我的名字\n是alice`
	fmt.Printf("%T %s\n",msg,msg)
	fmt.Printf("%T %s\n",msgRaw,msgRaw)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run string.go 
string 我的名字\n是bob
string 我的名字\n是alice
*/

字符串连接+

D:\GoWork\src\code\day01\string1.go

package main

import "fmt"

func main() {
	var msg = "我的名字\\n是bob"
	var msgRaw = `我的名字\n是alice`
	fmt.Println(msg + msgRaw)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run string1.go 
我的名字\n是bob我的名字\n是alice
*/

关系运算

D:\GoWork\src\code\day01\string2.go

package main

import "fmt"

func main() {
	// 先比较第一位，再比较第二位
	fmt.Println("abc" > "acb")
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run string2.go
false
*/

赋值运算

D:\GoWork\src\code\day01\string3.go

package main

import "fmt"

func main() {
	var msg ="我的名字是bob"
	msg+=" -- by bob"
	fmt.Println(msg)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run string3.go
我的名字是bob -- by bob
*/

索引&切片&ascii &字节大小len()

D:\GoWork\src\code\day01\string4.go

package main

import "fmt"

func main() {
	msg := "abcdef"
	fmt.Printf("%T %#v %c\n", msg[0], msg[0], msg[0])
	fmt.Println(msg[1:3])
	fmt.Println(len(msg))

}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run string4.go
uint8 0x61 a
bc
6
*/

类型转换 - strconv

D:\GoWork\src\code\day01\string5.go

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var (
		intVal     = 65
		float64Val = 2.2
		stringVal  = "3.3"
	)
	// 整型转浮点，浮点转整型，整型转字符串
	fmt.Println(intVal, float64Val, stringVal)
	fmt.Printf("%T %#v\n", float64(intVal), float64(intVal))
	fmt.Printf("%T %#v\n", int(float64Val), int(float64Val))
	fmt.Println(string(intVal))
	// fmt.Println(string(float64Val)) //cannot convert float64Val (variable of type float64) to stringcompilerInvalidConversion
	fmt.Println(fmt.Sprintf("%#v\n", float64Val))

	// 字符串 <--> 整型（int）
	fmt.Println(strconv.Itoa(intVal))
	v, err := strconv.Atoi(stringVal)
	fmt.Println(v, err)

	// 字符串<--> float64
	vv, err := strconv.ParseFloat(stringVal, 64)
	fmt.Println(vv, err)

	fmt.Println(fmt.Sprintf("%#v\n", vv))
	fmt.Println(strconv.FormatFloat(vv, 'f', -1, 64))
	fmt.Println(strconv.FormatFloat(vv, 'f', -1, 32))
	fmt.Println(strconv.FormatFloat(vv, 'f', 10, 64))
	fmt.Println(strconv.FormatFloat(vv, 'f', 10, 32))

}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run string5.go
65 2.2 3.3
float64 65
int 2
A
2.2

65
0 strconv.Atoi: parsing "3.3": invalid syntax
3.3 <nil>
3.3

3.3
3.3
3.3000000000
3.2999999523
*/

7.5 指针

声明

*int

D:\GoWork\src\code\day01\pointer.go

package main

import "fmt"

func main() {
	// 零值 nil
	var (
		pointerInt  *int
		pointString *string
	)
	fmt.Printf("%T %#v\n", pointerInt, pointerInt)
	fmt.Printf("%T %#v\n", pointString, pointString)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run pointer.go
*int (*int)(nil)
*string (*string)(nil)
*/

赋值

&name

D:\GoWork\src\code\day01\pointer1.go

package main

import "fmt"

func main() {
	var pointerInt *int
	age:=32
	fmt.Printf("%T\n", age)
	pointerInt = &age
	fmt.Printf("%T\n", pointerInt)
	fmt.Printf("%v\n", pointerInt)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run pointer1.go
int
*int
0xc00001e0a8
*/

访问和修改指针

D:\GoWork\src\code\day01\pointer2.go

package main

import "fmt"

func main() {
	var pointerInt *int
	age := 32
	fmt.Printf("%T\n", age)
	pointerInt = &age
	fmt.Println(*pointerInt)
	*pointerInt = 33
	fmt.Println(*pointerInt)

}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run pointer2.go
int
32
33
*/

复制值变与不变

D:\GoWork\src\code\day01\pointer3.go

package main

import "fmt"

func main() {
	var pointerInt *int
	age := 32
	age2 := age
	pointerInt = &age
	fmt.Println(*pointerInt)
	*pointerInt = 33
	fmt.Println(age, age2)

}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run pointer3.go
32
33 32
*/

验证复制地址变量

D:\GoWork\src\code\day01\pointer4.go

package main

import "fmt"

func main() {
	var pointerInt *int
	age := 32
	age2 := age

	pointerInt = &age
	fmt.Println(&age,&age2,pointerInt)
	*pointerInt = 33
	fmt.Println(&age,&age2,pointerInt)


}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run pointer4.go
0xc0000a6058 0xc0000a6070 0xc0000a6058
0xc0000a6058 0xc0000a6070 0xc0000a6058
*/

指针的指针

取地址&name，取值*pointerInt

D:\GoWork\src\code\day01\pointer5.go

package main

import "fmt"

func main() {
	var (
		pointerString *string
	)
	pointerString = new(string)
	fmt.Printf("%#v,%#v\n", pointerString, *pointerString)
	pp := &pointerString
	fmt.Printf("%T\n", pp)
	**pp = "bob"
	fmt.Println(*pointerString)
	fmt.Println(**pp)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run pointer5.go
(*string)(0xc000058260),""
**string
bob
bob
*/

7.6 scan

输入年龄有误，第一个不能转换为int，会把后边的赋值给下个变量
方式1 用strconv转
方式2 确保输入的为int

D:\GoWork\src\code\day01\scan.go

package main

import "fmt"

func main() {
	name := ""
	fmt.Print("请输入你的名字:")
	fmt.Scan(&name)
	fmt.Println("你输入的名字是:", name)

	age := 0
	fmt.Print("请输入你的年龄:")
	fmt.Scan(&age)
	fmt.Println("你输入的年龄是:", age)

	msg := ""
	fmt.Print("请输入你的msg:")
	fmt.Scan(&msg)
	fmt.Println("你输入的msg是:", msg)
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run scan.go
请输入你的名字:bob
你输入的名字是: bob
请输入你的年龄:fds
你输入的年龄是: 0
请输入你的msg:你输入的msg是: ds
*/

8 流程控制

if 语法

if语法格式：

单分支
if 表达式{
	语句体
}

双分支
if 表达式{
	语句体
}else {
	语句体
}

多分支
if 表达式{
	语句体
}else if 表达式 {
	语句体
}else{
	语句体
}

最后的else不是必须的

if语法示例

D:\GoWork\src\code\day01\if.go

package main

import "fmt"

func main() {
	// 买10个包子
	// 如果有卖西瓜的，买一个西瓜
	fmt.Println("买10个包子")
	var y string
	fmt.Print("有没有卖西瓜的：")
	fmt.Scan(&y)
	fmt.Println("你输入的是：", y)
	if y == "yes" {
		fmt.Println("买一个西瓜")
	}

}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run if.go
买10个包子
有没有卖西瓜的：yes
你输入的是： yes
买一个西瓜
*/

if...else...语法示例

D:\GoWork\src\code\day01\if1.go

package main

import "fmt"

func main() {
	//如果有卖西瓜的买一个包子，否则买10个包子
	var y string
	fmt.Print("有没有卖西瓜的：")
	fmt.Scan(&y)
	fmt.Println("你输入的是：", y)
	if y == "yes" {
		fmt.Println("买1个包子")
	} else {
		fmt.Println("买10个包子")
	}
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run if1.go
有没有卖西瓜的：yes
你输入的是： yes
买1个包子
*/

if... else if... 语法示例

D:\GoWork\src\code\day01\if2.go

package main

import "fmt"

func main() {
	//在控制台输入分数
	//90及以上A
	//80及以上B
	//60及以上C
    //60及以下D

	var score float32
	fmt.Print("请输入分数：")
	fmt.Scan(&score)
	fmt.Println("你输入的分数是：", score)
	if score >= 90 {
		fmt.Println("A")
	} else if score >= 80{
		fmt.Println("B")
    } else if score >= 60 {
		fmt.Println("C")
	} else {
        fmt.Println("D")
	}
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run if2.go
请输入分数：91.5
你输入的分数是： 91.5
A
*/

switch语法

switch语法格式：

只做比对
switch 变量 {
case 具体值:
	语句A
case 值:
	语句B
case 值:
	语句C
default:
    ...
}

可以没有default语句块

switch语法示例

D:\GoWork\src\code\day01\switch.go

package main

import "fmt"

func main() {
	//如果有卖西瓜的买一个包子，否则买10个包子
	var y string
	fmt.Print("有没有卖西瓜的：")
	fmt.Scan(&y)
	fmt.Println("你输入的是：", y)

	switch y {
	case "yes","y","Y":
		fmt.Println("买1个包子")
	case "no","n","N":
		fmt.Println("买10个包子")
	default:
		fmt.Println("输入错误")
	}
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run switch.go
有没有卖西瓜的：yes
你输入的是： yes
买1个包子
*/

D:\GoWork\src\code\day01\switch1.go

package main

import "fmt"

func main() {
	var score float32
	fmt.Print("请输入分数：")
	fmt.Scanln(&score)
	fmt.Println("你输入的分数是：", score)

	switch {
	case score >= 90:
		fmt.Println("A")
	case score >= 80:
		fmt.Println("B")
	case score >= 60:
		fmt.Println("C")
	default:
		fmt.Println("D")
	}
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run switch1.go
请输入分数：90
你输入的分数是： 90
A
*/

if 和 switch 对比：

1、switch比if else更为简洁
2、执行效率更高
3、到底使用哪一个选择语句，代码环境有关，如果是范围取值，则使用if else语句更为快捷；如果是确定取值，则使用switch是更优方案。

for循环

循环格式: 四种写法

for 初始值;终止条件;步进 {
	循环体
}

初始值;
for 终止条件;{
	循环体
	步进
}


for k,v:=range  {
	循环体
}


for {
	死循环:
}

打印1-10

D:\GoWork\src\code\day01\for.go

package main

import "fmt"

func main() {
	// 在控制台打印1...10
	for index := 1; index <= 10; index++ {
		fmt.Println(index)
	}
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run for.go
1
2
3
4
5
6
7
8
9
10
*/

计算1--100和

D:\GoWork\src\code\day01\for1.go

package main

import "fmt"

func main() {
	// 计算1+2+3+...+100
	total:=0
	for index := 1; index <= 100; index++ {
		total += index
	}
	fmt.Println(total)
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run for1.go
5050
*/

打印1-10（模拟while ）

D:\GoWork\src\code\day01\for2.go

package main

import "fmt"

func main() {
	// 在控制台打印1...10
	var index = 1
	for index <= 10 {
		fmt.Println(index)
		index++
	}
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run for2.go
1
2
3
4
5
6
7
8
9
10
*/

break

退出循环

D:\GoWork\src\code\day01\break.go

package main

import "fmt"

func main() {
	for index := 1; index <= 10; index++ {
		if index == 5 {
			break // 循环结束
		}
		fmt.Println(index)
	}
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run break.go
1
2
3
4
*/

continue

跳过本次循环，继续下次循环

package main

import "fmt"

func main() {
	for index := 1; index <= 10; index++ {
		if index == 5 {
			continue //跳过本次循环，继续下次循环
		}
		fmt.Println(index)
	}
}

/*打印结果:
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run continue.go
1
2
3
4
6
7
8
9
10
*/

遍历打印字符

D:\GoWork\src\code\day01\chars.go

package main

import "fmt"

func main() {
	letters := "abcdefghi"
	for i := 0; i < len(letters); i++ {
		fmt.Println(letters[i])
	}
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run chars.go
97
98
99
100
101
102
103
104
105
*/

遍历打印中文

package main

import "fmt"

func main() {
	letters := "我爱中华人民共和国"
	for k, v := range letters {
		fmt.Printf("%T %#v,%T %#v %U ", k, k, v, v, v)
		fmt.Printf("%q,%c\n", v, v)
	}
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run chars1.go
int 0,int32 25105 U+6211 '我',我
int 3,int32 29233 U+7231 '爱',爱
int 6,int32 20013 U+4E2D '中',中
int 9,int32 21326 U+534E '华',华
int 12,int32 20154 U+4EBA '人',人
int 15,int32 27665 U+6C11 '民',民
int 18,int32 20849 U+5171 '共',共
int 21,int32 21644 U+548C '和',和
int 24,int32 22269 U+56FD '国',国

*/

死循环loop

D:\GoWork\src\code\day01\loop.go

package main

import "fmt"

func main() {
	var (
		index = 0
		total = 0
	)

	for {
		total += index
		index++
		if index > 100 {
			break
		}
	}
	fmt.Println(total)
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run loop.go
5050
*/

9 作业

1 打印乘法口诀

要求：对齐，

提示：print对齐

D:\GoWork\src\code\day01\homework.go

package main

import "fmt"

func main() {
	fmt.Printf("%3d]\n", 1)
	fmt.Printf("%3d]\n", 10000)
	fmt.Printf("%03d]\n", 1)
	fmt.Printf("%-0d]\n", 1)
}
/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run homework.go
  1]
10000]
001]
1]
*/

解答

D:\GoWork\src\code\day01\homework1.go

package main

import "fmt"

func main() {
	for i := 1; i < 10; i++ {
		for j := 1; j <= i; j++ {
			if j == 1 {
				fmt.Printf("%d*%d=%-2d", j, i, i*j)
			} else {
				fmt.Printf("%d*%d=%-2d ", j, i, i*j)
			}
		}
		fmt.Println()
	}
}

/*打印结果
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run homework1.go 
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6  3*3=9
1*4=4 2*4=8  3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
*/

2 猜数字游戏

提示：生成随机数

D:\GoWork\src\code\day01\homework2.go

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	rand.Seed(time.Now().Unix())
	fmt.Println(rand.Intn(10) % 3) // 0-2
	fmt.Println(rand.Intn(2))      // [0,2) 不包含2
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run homework2.go
1
0
*/

解答

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	for {
		rand.Seed(time.Now().Unix())
		num := rand.Intn(101)
		fmt.Println(num)
		//fmt.Println(num)
		var guess int
		i := 0
		for i < 5 {
			fmt.Print("请输入猜测数字[0-100]：")
			fmt.Scan(&guess)
			i++
			if guess > num {
				fmt.Println("猜的太大了，请猜小一点")
			} else if guess < num {
				fmt.Println("猜的太小了，请猜大一点")
			} else if guess == num {
				fmt.Printf("经过%d次，回答正确，你真棒！\n", i)
				break
			} else {
				fmt.Println("你太笨了，游戏结束！")
				break
			}
		}

		var game string
		fmt.Print("是否继续游戏[yes/no]")
		fmt.Scan(&game)
		if game == "yes" {
			continue
		} else {
			break
		}
	}
}

/*打印结果：
zhu@DESKTOP-3LCQABF MINGW64 /d/GoWork/src/code/day01
$ go run homework3.go
66
请输入猜测数字[0-100]：65
猜的太小了，请猜大一点
请输入猜测数字[0-100]：67
猜的太大了，请猜小一点
请输入猜测数字[0-100]：66
经过3次，回答正确，你真棒！
是否继续游戏[yes/no]yes
35
请输入猜测数字[0-100]：35
经过1次，回答正确，你真棒！
是否继续游戏[yes/no]no
*/

标签：Println,src,语言,fmt,基础,go,GoWork,Go,main
From： https://www.cnblogs.com/zhutao2014/p/17442013.html

Go语言基础-Go语言基础语法入门

第01天 Go语言基础语法入门

1 初识GO语言

简介

历史

优势

特性

应用领域

开源项目列表

使用Go的大型公司

一些优秀的项目源码

如何学习

2 开发环境搭建

Windows 安装

Linux安装

vscode开发环境搭建

安装Vscode Go语言扩展

安装Vscode Go语言扩展需要的工具集

设置终端使用Git Shell

配置自动保存

3 第一个程序

注释

4 变量&作用域

变量-什么是变量

作用域

变量-声明

四种变量声明：

多变量声明和单行生成多变量

变量-赋值

赋值（更新变量的值）

块内赋值（不是定义，都更新）

块内定义（仅更新块内）

5 基本组成元素

标识符（变量的命名规范和匿名变量）

运算符

分隔符

Day01 下午

6 常量

声明

常量声明

枚举类型

打印类型print

7 基础数据类型

7.1 布尔类型

声明&零值&占位符%t

逻辑运算

关系运算

7.2 数字类型

0 声明&零值&占位符%d、%b、%o、%x、%X、&默认推断类型int

1 声明： 2进制 8进制 16进制数

2 算术运算

位运算

3 关系运算

4 转换后再计算

5 字节定义byte、rune&占位%U %c %q &%T打印int32

6 赋值运算（参考浮点数赋值运算）

7.3 浮点类型

声明

算术运算

decimal解决精度问题

关系运算

赋值运算

7.4 字符串

声明

字符串连接+

关系运算

赋值运算

索引&切片&ascii &字节大小len()

类型转换 - strconv

7.5 指针

声明

赋值

访问和修改指针

复制值变与不变

验证复制地址变量

指针的指针

7.6 scan

8 流程控制

if 语法

if语法格式：