go基础

本文已参与周末学习计划，点击链接查看详情：juejin.cn/post/696572…

go环境安装（windows）

安装地址：golang.google.cn/dl/

傻瓜式安装，安装完应该会自动配置环境变量

安装完检查下环境变量是否配置成功，若没有配置成功则手动配置，基本跟java环境配置相同

go version  // 在cmd窗口下输入该命令会显示当前go版本

hello world

go编辑器 goland 或者vscode

package main    // 定义包 main为包的主程序

import "fmt"    // 导入go标准库fmt

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


go run <filename>.go  // 运行程序命令  使用goland可配置启动配置 点击启动即可

go的语言结构

包声明 package
引入包 import
函数 func main()
变量
语句 & 表达式
注释

go的关键字

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 数据类型

布尔（true or false）
```
var b bool = true
```

数字类型 (整形 int 浮点型 float32 float64)

整形

序号	类型和描述
1	uint8 无符号 8 位整型 (0 到 255)
2	uint16 无符号 16 位整型 (0 到 65535)
3	uint32 无符号 32 位整型 (0 到 4294967295)
4	uint64 无符号 64 位整型 (0 到 18446744073709551615)
5	int8 有符号 8 位整型 (-128 到 127)
6	int16 有符号 16 位整型 (-32768 到 32767)
7	int32 有符号 32 位整型 (-2147483648 到 2147483647)
8	int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)

浮点型

序号	类型和描述
1	float32 IEEE-754 32位浮点型数
2	float64 IEEE-754 64位浮点型数
3	complex64 32 位实数和虚数
4	complex128 64 位实数和虚数

其他数字类型

序号	类型和描述
1	byte 类似 uint8
2	rune 类似 int32
3	uint 32 或 64 位
4	int 与 uint 一样大小
5	uintptr 无符号整型，用于存放一个指针

字符串类型
派生类型
- 指针类型（pointer）
- 数组类型
- 结构体（struct）
- Channel
- 函数
- 切换
- 接口（interface）
- Map

go语言变量

变量名定义规则由字母、数字、下划线组成，首字母不能为数字

在go中定义一个变量必须使用，否则会编译报错

在导入包中或者接受函数返回值，若不想使用可以使用 _ 接收表示被抛弃

// 自己定义类型
// 声明变量一般使用var    若定义声明没有初始化  则变量默认为零值
var a int
// 一次声明多个变量
var a, b int

var a string = '123'
var a, b int = 1, 2




// 根据值自定判断类型
var a = 1
var b = true


// 使用var的简写  ：=
// 使用：= 若已经声明过了会产生编译报错  不能重复声明
// 类型由编译器推断
// 只能写在函数中
var a = 1
a := 1 // 会报错


func main() {
  a := 1
}

// 
a := 1
// 相等于
var a int
a = 1


// 这种写法声明多个变量   一般用于声明全局变量
var(
	a int
	b string
)

零值

int  0
bool false
string ""


下面的类型零值都为nil
*int
[]int
map[string] int
chan int
func(string) int
error  // error是接口

值类型和引用类型

值类型（int float bool string）存储在栈中（和js很像）
引用类型

引用类型存储的是一个内存地址（指针），通过内存地址访问数据

同一个引用类型的指针可以是在连续的内存中，也可以分散在内存中

r2 = r1 引用类型之间的赋值，只是引用地址被赋值

go常量

const a int = 1
const b string = "123"

// 常量可以用作枚举
const (
	Man = 0
	woMan = 1
)

iota 特殊常量可以被编译器修改的常量

// iota 在新的一行被使用时 值会自动+1
const (
	a = iota  // 0
	b = iota  // 1
	c = iota  // 2
)

// 简写 b c 会自动+1
const (
	a = iota
	b
	c
)

实例

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

运算符

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
其他运算符

算术运算符

运算符	描述
+	相加
-	相减
*	相乘
/	相除
%	求余
++	自增
--	自减

2.关系运算符

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

3.逻辑运算符

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

位运算（不会，看不懂）

赋值运算符

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

6.其他运算符

运算符	描述	实例
&	返回变量存储地址	&a; 将给出变量的实际地址。
*	指针变量。	*a; 是一个指针变量

运算符优先级

优先级	运算符
5	* / % << >> & &^
4	+ - \| ^
3	== != < <= > >=
2	&&
1	\|\|

go 条件语句

if
```
var a int  = 10
if a < 20 {
	
}
```

if else

var a int  = 10
if a < 8 {
	
} else {
	
}

switch

switch 不要要加break 匹配到后自动停止

如果匹配到后需要执行后面的可以使用fallthrough

switch 可以在一个case中匹配多个值

var a int = 50
switch a {
  case 90: 
  case 80:
  case 50,60,70:
  default: 
}

Type switch

var x interface {}
switch i := x.(type) {
	case int: 
	case nil:
	case float64:
	default
}

fallthrough

使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

func main() {

    switch {
    case false:
            fmt.Println("1、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("2、case 条件语句为 true")
            fallthrough
    case false:
            fmt.Println("3、case 条件语句为 false")
            fallthrough
    case true:
            fmt.Println("4、case 条件语句为 true")
    case false:
            fmt.Println("5、case 条件语句为 false")
            fallthrough
    default:
            fmt.Println("6、默认 case")
    }
}

select

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。

select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。
```
var c1, c2 chan int
var i1, i2 int

select {
  case i1 = <-c1:
  	fmt.Printf(i1)
  case c2 <- i2:
  	fmt.Printf(c2)
  default: 
  	fmt.Printf('')
}
```

go 循环

普通for

func main() {
	sum := 0
	for(i := 0; i<= 10; i++) {
		sum += i
	}
}

// 省略写法
func main() {
	sum := 1
	for ; sum <= 10 {
		sum += sum
	}
}

func main() {
	sum := 1
	for sum <= 10 {
		sum += sum
	}
}

// 无限循环 类似java的for(;;)
func main() {
	sum := 1
	for {
		sum += sum
	}
}

for range 可以对字符串数组切片等输出

func main() {
	strings := []string{"vue", "react"}
	for i,v := range strings {
		fmt.Printf(i, v)
		// i 是索引 v是值
	}
}

go循环控制语句

break 中断for循环或switch
continue 跳出本次循环进行下一轮循环
goto 将控制转移到被标记的语句

go 函数

函数定义形式

func function_name( [parameter list] ) [return_types] {
   函数体
}

func max(num1, num2 int) (int, int) {
	return num1, num2
}

函数传参

值传递调用函数将参数复制一份到函数中
引用传递将参数的地址传递到函数中，改变参数影响实际参数

// 值传递
func max(num1, num2 int) (int, int) {
	return num1, num2
}
func main() {
	max(1, 2)
}

// 引用传递
func max(x *int, y *int) {
	var a int
	a = *x
	*x = *y
	*y = a
}
func main() {
	var a int = 100
	var b int = 200
	max(a,b)
}

go方法

Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。

定义方法结构

func (variable_name variable_data_type) function_name() [return_type]{
   /* 函数体*/
}

package main

import (
   "fmt"  
)

/* 定义结构体 */
type Circle struct {
  radius float64
}

func main() {
  var c1 Circle
  c1.radius = 10.00
  fmt.Println("圆的面积 = ", c1.getArea())
}

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

数组

声明数组数组长度固定

var arrayList [10] int    // 声明长度为10的数组

// 初始化
arrList := [10]int{1,2,3,4}   // 初始化一个长度为10的数组

// 不确定长度
arrList := [...]int{}    // 使用...代替长度 编译器自动推断

// 指定索引初始化
arrList := [5]int{1:100, 3:100}  // 将索引为1 和 3的元素初始化

/*
	{} 中的元素个数不能超过指定的长度
*/

// 访问数组元素通过下标访问
arrList[0]

Go基础入门 | 周末学习