Go 菜鸟学习笔记-快速入门（上）

1.简介和hello world

1. go特性
   接受了函数式编程的一些想法，支持匿名函数与闭包
   接受了以Erlang语言为代表的面向消息编程思想，支持goroutine和通道
   推荐使用消息而不是共享内存来进行并发编程
   有丰富的内置类型，支持函数多返回值，类型和接口，反射
   自动垃圾回收，错误处理
   Go 语言是一种静态类型的编程语言

2. 优点和用途
   并行、内存管理、数组安全、编译迅速
   用于高性能分布式系统领域，被设计成一门应用于搭载 Web 服务器的系统编程语言。

3. hello world示例

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

4. Go 的安装
   Go语言环境安装
   goland常用配置

2. Go 语言基本结构

• 包声明
• 引入包
• 函数
• 变量
• 语句 & 表达式
• 注释

package main   //第一行指明这个文件属于哪个包

import "fmt"  //这个程序需要使用 那些 包

func main() {
      //main 函数是每一个`可执行程序所必须包含的`
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}

1.基础语法与数据类型

基础语法

1. Go标记
   Go 程序可以由多个标记组成，可以是关键字，标识符，常量，字符串，符号
   eg：fmt.Println("Hello, World!") 由6个标记组成： fmt . Println ( "Hello,World!" )

2. 标识符
   标识符用来命名变量、类型等程序实体，由字母，数字，下划线组成
   第一个字符必须是字母或下划线而不能是数字。

3. 关键字
   下面列举了 Go 代码中会使用到的 25 个关键字或保留字：

break	default	func	interface	select
	case	defer	go	map	struct
	chan	else	goto	package	switch
	const	fallthrough	if	range	type
	continue	for	import	return	var

除了以上介绍的这些关键字，Go 语言还有 36 个预定义标识符：

append	bool	byte	cap	close	complex	complex64	complex128	uint16
	copy	false	float32	float64	imag	int	int8	int16	uint32
	int32	int64	iota	len	make	new	nil	panic	uint64
	print	println	real	recover	string	true	uint	uint8	uintptr

4.字符串格式化

package main

import (
    "fmt"
)

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)
}

结果为：Code=123&endDate=2020-12-31

其它格式化字符串：fmt.Sprintf 格式化字符串

---

数据类型

首先明确一点，为什么有数据类型？

数据类型的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。

1. 布尔型：只可以是常量 true 或者 false
2. 数字类型：整型 int 和浮点型 float32、float64，支持整形，浮点型，复数
3. 字符串类型 ：一串字符序列，字符串的字节使用UTF-8编码
4. 派生类型：包括 指针类型（Pointer），数组，结构化类型（struct），函数类型，Channel类型，切片类型，接口类型（interface），Map类型

2. 变量和常量

变量的来源

变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。

1.变量的定义

var a string = "you will"
//或：
var b, c int = 1,2

2.变量的声明

第一种：指定变量类型，如果没有初始化，则变量默认为零值。其中
数值类型（包括 complex64/128）–>0
布尔类型 —> false
字符串类型 ---->""(空字符串)
其他几种类型 ---->nil

var a *int   					//引用类型
var a []int   					//数组类型
var a map[string] int   		 //map类型
var a chan int   			 //channel 类型
var a func(string) int 		 //函数类型
var a error					 // error 是接口

第二种：根据值自行判定变量类型

var d = true  //可以根据值推断 变量d 为 bool 类型

第三种：省略var 使用 :=（用于局部变量的声明）

intVal := 1   

特殊的变量使用：
1.空白标识符 _ ：用于你并不需要使用从一个函数得到的所有返回值
空白标识符 _ 被用于抛弃值，如值 5 在：_, b = 5, 7 中被抛弃。
2.并行赋值：用于当一个函数返回多个返回值时
val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)
3.变量值交换：a, b = b, a

变量的作用域（和Java没有区别）

• 函数内定义的变量称为局部变量
• 函数外定义的变量称为全局变量
• 函数定义中的变量称为形式变量

---

常量的定义

在程序运行时，不会被修改的量
常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

声明方式
显式类型定义： const b string = “abc”
隐式类型定义： const b = “abc” （编译器可以根据变量的值来推断其类型）

可用于枚举

const (
    Unknown = 0
    Female = 1
    Male = 2
)
//数字 0、1 和 2 分别代表未知性别、女性和男性。

特殊常量：iota
iota，特殊常量，可以认为是一个可以被编译器修改的常量
iota 可用于枚举值

const (
    a = iota
    b = iota
    c = iota
)
//第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1

---

值类型和引用类型(重点)

引用：
go中的值类型和引用类型
go中的基本类型，引用类型，结构类型

1.最本质的区别
值类型：内存中变量存储的是具体的值 比如： var num int num存放的是具体的int值
但是变量在内存中的地址可以通过 &num 来获取
引用类型：变量直接存放的就是一个地址值，这个地址值指向的空间存的才是值。
eg: var ptr *int =&num

2.基本类型
有 数值、浮点、字符串、布尔、数组 及 错误 类型和结构体struct
值类型的变量的
值当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝：存储在栈中。

3.引用类型
有切片(slice)、字典(map)、接口(interface)、函数(func) 以及 通道(chan)
引用类型变量存储的地址（也就是通过指针访问类型里面的数据），通常真正的值在堆上分配

如果 r1 的值被改变了，那么这个值的所有引用都会指向被修改后的内容，在这个例子中，r2 也会受到影响。

运算符

• 算术运算符 + - * /
• 关系运算符 > < != ==
• 逻辑运算符 && || !
• 位运算符 & | ^
• 赋值运算符 = += %=
• 其他运算符 & *
  &:返回变量存储地址,&a 将给出变量的实际地址。
  *:指针变量 ,*a 是一个指针变量

分支语句：if、switch、select

if 语句

package main

import "fmt"

func main() {
   
   /* 局部变量定义 */
   var a int = 100;
 
   /* 判断布尔表达式 */
   if a < 20 {
   
       /* 如果条件为 true 则执行以下语句 */
       fmt.Printf("a 小于 20\n" );
   } else {
   
       /* 如果条件为 false 则执行以下语句 */
       fmt.Printf("a 不小于 20\n" );
   }
   fmt.Printf("a 的值为 : %d\n", a);

}

switch语句：用于基于不同条件执行不同动作

package main

import "fmt"

func main() {
   
   /* 定义局部变量 */
   var grade string = "B"
   var marks int = 90

   switch marks {
   
      case 90: grade = "A"
      case 80: grade = "B"
      case 50,60,70 : grade = "C"
      default: grade = "D"  
   }

   switch {
   
      case grade == "A" :
         fmt.Printf("优秀!\n" )    
      case grade == "B", grade == "C" :
         fmt.Printf("良好\n" )      
      case grade == "D" :
         fmt.Printf("及格\n" )      
      case grade == "F":
         fmt.Printf("不及格\n" )
      default:
         fmt.Printf("差\n" );
   }
   fmt.Printf("你的等级是 %s\n", grade );      
}

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

语法如下：

select {
   
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s);
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}

语法说明：

• 每个 case 都必须是一个通信
• 所有 channel 表达式都会被求值
• 所有被发送的表达式都会被求值
• 如果任意某个通信可以进行，它就执行，其他被忽略。
• 如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。
  否则：
  如果有 default 子句，则执行该语句。
  如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值

package main

import "fmt"

func main() {
   
   var c1, c2, c3 chan