Go语言开发笔记

go 语言学习之路

第一章 go语言

简介

Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。

Go是从2007年末由Robert Griesemer, Rob Pike, Ken Thompson主持开发，后来还加入了Ian Lance Taylor, Russ Cox等人，并最终于2009年11月开源，在2012年早些时候发布了Go 1稳定版本。现在Go的开发已经是完全开放的，并且拥有一个活跃的社区。

go语言的特色

• 简洁、快速、安全
• 并行、有趣、开源
• 内存管理、数组安全、编译迅速

go语言安装

不会就百度

第一个程序

package main
// 指定包
func main() {  //程序入口
	print("Hello,World")  //输出
}

运行方式：

• go 文件—》 go build 编译为 .exe -----》运行----》 结果
• • go build hello.go
• go 文件----》 go run ----》 结果
• • go run hello.go

fmt包

fmt 包主要提供格式化输出，输入的函数

转义字符

\t  缩进 一个制表符
\n 换行符
\\  一个\
\" 一个“
\r 一个回车	

//实现格式化动作 （和c语言类似）
%d	十进制整数
%x,%X	大小写方式显示十六进制整数
%o	八进制整数
%b	二进制整数
%f,%g,%e	浮点数
%t	布尔值
%c	字符
%s	字符串
%q	带双引号字符串
%v	内置格式内容
%T	类型
%p	内存地址
%%	字符%

//举例
fmt.Printf("面积为 : %d", area)

案例

格式化字符串

func main() {
   // %d 表示整型数字，%s 表示字符串
    var stockcode=123
    var enddate="2020-12-31"
    var url="Code=%d&endDate=%s"
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)
}

格式化字符串

func main() {
   // %d 表示整型数字，%s 表示字符串
    var stockcode=123
    var enddate="2020-12-31"
    var url="Code=%d&endDate=%s"
    var target_url=fmt.Sprintf(url,stockcode,enddate)
    fmt.Println(target_url)
}

第二章 语言结构

一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ;
变量声明语法：
var 变量名 = 数值
Go 语言中变量的声明必须使用空格隔开

var i int
i = 1
fmt.Println("i=",i) //使用方法

字符串拼接："str"+"str"
变量的使用方式：
1、指定变量类型，声明后若不赋值，将会使用默认值
2、类型推导根据值自行判断变量类型
3、省略var :=i (变量名不应该是声明过的)

变量使用的注意事项：
变量名由字母、数字、下划线组成，其中首个字符不能为数字
变量在同一作用域的数值可以在同一类型范围内变化
在同一区域内不能重名
变量的三要素：变量 = 变量名+数据类型+数据值

package main

import "fmt"

// var name = "zs"
// var n = 1
// var a = 2
// 一次性声明
var (
	name = "zs"
	n    = 1
	a    = 2
)

func main() {
	//var i int
	//name := "zhag"
	//fmt.Println("Hello,", name, "i=", i)
	//
	//多变量声明  1
	//var n1, n2, n3 int
	//fmt.Println("n1", n1, n2, n3)

	//多变量声明  2
	//var n, str, a = 100, "s", 5
	//fmt.Println(n, str, a)

	//多变量声明  3
	//n, str, a := 100, "s", 5
	//fmt.Println(n, str, a)

	//全局变量（在函数外部的变量为全局变量）
	fmt.Println(name, a, n)
}

数据类型

数据类型：
基本数据类型：

• 数值型
• • 整数类型
• • 浮点类型
• 字符型
• 布尔型
• 字符串
  派生/复杂数据类型：
• 指针
• 数组
• 结构体
• 管道
• 函数
• 切片
• 接口
• map

基本数据类型

所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值

var i int = 1

可以通过 &i 来获取变量 i 的内存地址

复杂数据类型

常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：
const 变量名 类型 = 数据值
类型可以省略
多个常量声明：const v1,v2=v,v3

func main() {
   const LENGTH int = 10
   const WIDTH int = 5  
   var area int
   const a, b, c = 1, false, "str" //多重赋值

   area = LENGTH * WIDTH
   fmt.Printf("面积为 : %d", area)
   println()
   println(a, b, c)  
}

常量还可以用作枚举
语法：
const (
v1 = v
v2 = v
)

实例

package main

import (
   "fmt"
   "unsafe"
)

/*
1、获取i的内存地址
2、const常量所有使用方法
*/
//const 的枚举用法
const (
   a = "abcdef"
   b = len(a)
   c = unsafe.Sizeof(a) //返回数据类型的大小
   // 那为什么会是16呢
   /*
   			只返回数据类型的大小，不管引用数据的大小，string类型不是直接存的数据，而是一个结构体，用指针指向实际数据地址
   		type StringHeader struct {
   		        Data uintptr
   		        Len  int
   		}
   	在64位系统上uintptr int都是8字节，加起来就16了。
   */
)

func main() {
   var i int = 0
   fmt.Println(&i) //0xc00001c088
   fmt.Println(a)
   fmt.Println(b)
   fmt.Println(c)
}

iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。
iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。
iota 可以用作枚举

const (
a = iota
b = iota
c = iota 
)
/*
第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写  
const(
a = iota
b
c
)
*/

案例

package main

import "fmt"

const (
	a = iota //0
	b        //1
	c        //2
	d = "ha" // 3
	e        //4
	f        //5
	g = 100  //6
	h = iota //100   h = iota 时恢复计数 此时 h = 7
	i
)

func main() {
	fmt.Println(a, b, c, d, e, f, g, h, i)
}

案例二

package main

import "fmt"

const (
	// << 表示左移的意思
	i = 1 << iota
	j = 3 << iota //1 6
	k
	l
)

func main() {
	/*
		i=1：左移 0 位，不变仍为 1。
		j=3：左移 1 位，变为二进制 110，即 6。
		k=3：左移 2 位，变为二进制 1100，即 12。
		l=3：左移 3 位，变为二进制 11000，即 24。
	*/
	fmt.Println(i, j, k, l)
}

####算术运算符
go语言中的内置运算符

算术运算符

符号	含义
+	加法运算
-	减法运算
*	乘法运算
/	除法运算
%	求余运算
++	自增运算
–	自减运算

关系运算符

符号	含义
==	检查两个值是否相等，如果相等返回 True 否则返回 False。
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False。
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False。
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

逻辑运算符

符号	含义
&&	逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False。
ιι	逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。
!	逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。

位运算符

符号	含义
&	按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。
ι	按位或运算"ι"是双目运算符。 其功能是参与运算的两数各对应的二进位相或
^	按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。
<<	左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。 其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0。
>>	右移运算符">>“是双目运算符。右移n位就是除以2的n次方。 其功能是把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。

赋值运算符

符号	含义
=	简单的赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值
<<=	左移后赋值
>>=	右移后赋值
&=	按位与后赋值
^=	按位异或后赋值
ι=	按位或后赋值

其他运算符

符号	含义
&	返回变量存储地址	&a; 将给出变量的实际地址.
*	指针变量。	*a; 是一个指针变量

获取用户终端输入

通过键盘获取到用户输入的内容
案例1：

package main

import (
	"fmt"
)

func main() {
	var name string
	var age int
	var salary int
	var isPass bool

	fmt.Println("请输入用户名")
	fmt.Scanln(&name)
	fmt.Println("请输入年龄")
	fmt.Scanln(&age)
	fmt.Println("请输入月薪")
	fmt.Scanln(&salary)
	fmt.Println("是否通过考试")
	fmt.Scanln(&isPass)

	fmt.Println("名字是 ", name, "\n 年龄是 ", age, " \n 月薪是 ", salary, " \n  考试情况 ", isPass, "\n ")
}

案例2：

package main

import "fmt"

func main() {
	var name string
	var age int
	var salary float32
	var isPass bool

	fmt.Println("请输入姓名，年龄，工资，是否通过考试。（使用空格分隔开）")
	fmt.Scanf("%s %d %f %t", &name, &age, &salary, &isPass) //这种方式对于格式要求比较严格
}

第三章 流程控制

分支语句

go语言中分支语句有

• if
• if…else
• if 嵌套

package main

const (
	a = iota
	b
	c
)

func main() {
	if a == 0 {
		println("a", 0)
	}
	if b == 1 {
		println("b", 1)
	}
	if c == 2 {
		println("c", c)
	}
	if c == 3 {
		println("c==3?", c == 3)
	}
}

• switch

package main

func main() {
	const str = "xm"
	switch str {
	case "xm":
		println("我是小明")
		break
	case "xh":
		println("我是小红")
		break
	case "xg":
		println("我是小刚")
		break
	default:
		println("我也不知道我姓名是什么")
	}
}

• select 语句
  注意：go语言中没有三目运算
  由于go语言中的if、if…else、switch等语句与Java相识所以这部分语句将不做为主要学习目标

select 语句

select 是 go 语句中的一个控制结构，类似与switch语句。select 语句只能用于通道操作，每个 case 必须是一个通道操作，要么是发送要么是接收。
select 随机执行一个可执行的case。
如果没有case可执行，它将阻塞，直到case执行。
一个默认的子句应该总是可运行的。

循环结构

package main

import (
	"fmt"
)

func main() {
	for i := 0; i < 10; i++ { //i :=1  定义i=1  且推断i的数据类型
		fmt.Println("我爱你第", i, "遍")
	}
}