go 基本语法(简单案例)

！注： go中 对变量申明很是严格，申明了，在没有使用的情况下，也会产生编译错误
1.行分隔符
一行就是代码，无；分割，如果需要在一行展示，需要以；分割，否则编译出错

	fmt.Println("hello world")
	fmt.Println(111)
	fmt.Println("hello world");fmt.Println(111)

2.标识符
标识符就是常量或者func命名方式：
不能使用关键字，数字开头，运算符 如：case(关键字)，1ab（数字开头无效字符），a+b(编译不通过)之类的来命名；也不允许使用预定义标识符 如 byte bool等

3.关键字
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

4.预定义标识符
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

5.go语言中的空格
go语言中的空格 为了提高代码的阅读性个规范，通常两个变量之间必须要有空格隔开，在if条件中是为了提高阅读性，在常量赋值中，没有空格隔开，编译出错。

const a int = 10
const b string = "ccc"

func main() {
	var c int = 11
	if c < a {
		fmt.Print("a<10")
	} else {
		fmt.Print("a>10")
	}
}

6.格式化字符串
Go 语言中使用 fmt.Sprintf 或 fmt.Printf 格式化字符串并赋值给新串：

Sprintf 根据格式化参数生成格式化的字符串并返回该字符串。
Printf 根据格式化参数生成格式化的字符串并写入标准输出。
等同于 java中string.format()

    // %d 表示整型数字，%s 表示字符串
	var tempCode = 1234
	var endDate = "2023-12-24"
	var url = "Code=%d&endDate=%s"
	fmt.Println(fmt.Printf(url, tempCode, endDate))
	var target_url = fmt.Sprintf(url, tempCode, endDate)
	fmt.Println(target_url)

7.变量
go语言中变量同一个func中具有唯一性
只能申明一次
申明变量使用 var申明

var tempA, tempB, tempC int = 1, 2, 3 //申明同一种类型的变量可以采用这种方式
	fmt.Println(tempA)
	fmt.Println(tempB)
	fmt.Println(tempC)

先申明多个变量，在统一赋值

var tempA, tempB, tempC int //申明同一种类型的变量可以采用这种方式
	var stringVla string
	tempA, tempB, tempC, stringVla = 1, 2, 3, "测试字符串"
	fmt.Println(tempA)
	fmt.Println(tempB)
	fmt.Println(tempC)
	fmt.Println(stringVla)

重复申明

var intVal int
	intVal := 1

	intVal1 := 10
	fmt.Println(intVal + intVal1)

go中 对变量申明很是严格
申明了，在没有使用的情况下，也会产生编译错误

函数调用

	//cc := "测试"
	var testStr string = "测试"

	v1, v2, v3 := disposeData(9, 1, testStr)
	fmt.Print(v1, v2, v3)
}

func disposeData(d int, d1 int, c1 string) (int, int, string) {
	a, b, c := 1+d, 2+d1, "参数"+c1
	return a, b, c
}

8.常量
go中常量以 const(a,b,c)这种格式进行来命名常量
普通常量

	const (
		a = "常量测试"
		b = len(a)
		c = unsafe.Sizeof(a)
	)

常量元素自动+1(iota)

	// 在const常量中，使用iota进行计算，它后面的的值都会依次+1
	const (
		a = iota
		b
		c
	)
	fmt.Print(a, b, c)

9.语言运算符
这里和传统很多语言中的一样就 不写代码实例了
运算符 描述 实例

==	检查两个值是否相等，如果相等返回 True 否则返回 False。	(A == B) 为 False
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。	(A != B) 为 True
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False。	(A > B) 为 False
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False。	(A < B) 为 True
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。	(A >= B) 为 False
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。	(A <= B) 为 True

逻辑运算符

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

赋值运算符

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

其他运算符

&	返回变量存储地址	&a; 将给出变量的实际地址。
*	指针变量。	*a; 是一个指针变量 int  4

运算符优先级
由高到低

5	* / % << >> & &^
4	+ - | ^
3	== != < <= > >=
2	&&
1	||

10.语言条件语句
if if-else 嵌套if switch selct
if语句

	var a int = 10
	//var b int = 12
	if a < 10 {
		fmt.Print("a<10")
	}

if-else

	var a int = 10
	//var b int = 12
	if a < 10 {
		fmt.Print("a<10")
	}else {
		fmt.Print("a>10")
		
	}```
嵌套if

```bash
	var a int = 10
	var b int = 12
	if a == 10 {
		fmt.Println("a<10")
		if b > 10 {
			fmt.Println("b>10")
		}
	}

switch
等于某个值走某一项

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
接收到某个值走某一个

   c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        time.Sleep(1 * time.Second)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(2 * time.Second)
        c2 <- "two"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1) // 获取到c1的值执行
        case msg2 := <-c2:
            fmt.Println("received", msg2) // 获取到c2的值执行
        }
    } 

11.循环语句
这里的循环分为for，for-each 循环两种
for循环

sum := 0
	for {
		sum++          // 无限循环
		if sum == 10 { // 增加条件跳出循环
			fmt.Print(sum + 1)
			break
		}
	}

for-each循环
array数组循环

// for-each
	//数组
	strings := []string{"abc", "ABC"}
	for i, s := range strings {
		fmt.Println(i, s) //rang==java总的 each strings 数组名 i元素index，s元素value index从0开始

	}

map集合循环

// map集合
	map1 := make(map[int]string) //定义一个int(key) string(value)类型的map集合
	map1[1] = "a"
	map1[2] = "b"
	map1[3] = "c"
	map1[4] = "d"

	// 取出map集合中kv
	for i, s := range map1 {
		fmt.Println(i, s)
	}

	// 读取map集合中的k
	for i := range map1 {
		fmt.Println(i)
	}

	// 读取map集合中的v
	for _, s := range map1 {
		fmt.Println(s)
	}

map集合和array数组结合使用测试

// map集合
	map1 := make(map[int]int)                        //定义一个int(key) string(value)类型的map集合
	tempInts := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //创建一个集合并赋值
	//var arr []int // 创建一个空数组
	if !reflect.ValueOf(tempInts).IsNil() {
		for i, tempInt := range tempInts {
			map1[i] = tempInt
		}
	} else {
		fmt.Println("集合为空！")
	}

	// 取出map集合中kv
	if len(map1) > 0 {
		for i, s := range map1 {
			fmt.Println(i, s)
		}
	}

在循环体当中通常还有一些控制语句

break 语句	经常用于中断当前 for 循环或跳出 switch 语句
continue 语句	跳过当前循环的剩余语句，然后继续进行下一轮循环。
goto 语句	将控制转移到被标记的语句。

用到最多的通常为上面两个
12.函数
函数也叫方法
一个函数当中扩了传参的参数，有些情况还包括了返回参数

	// 函数调用
	var maxVal = maxVal(10, 12)
	fmt.Println(maxVal)

	// 返回多个参数
	v1, v2, v3 := disposeData(1, 2, "测试")
	fmt.Println(v1, v2, v3)
}

// 返回最大值，类型为int型
func maxVal(val1, val2 int) int {
	var res int
	if val1 > val2 {
		res = val1
	} else {
		res = val2
	}
	return res
}

// 返回多个参数
func disposeData(d int, d1 int, c1 string) (int, int, string) {
	a, b, c := 1+d, 2+d1, "参数"+c1
	return a, b, c
}

13.变量
变量分为全局变量和局部变量两种；通常函数内的变量为局部变量，函数外为全局变量

package main

import "fmt"

/* 声明全局变量 */
var g int

func main() {

   /* 声明局部变量 */
   var a, b int

   /* 初始化参数 */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("结果： a = %d, b = %d and g = %d\n", a, b, g)
}

14.数组

// 数组语法格式为
var arrayName [size]dataType

// 初始化数组
var arr1[10] int

//初始化数组并赋值,两种都可以，根据自己需求选择
var numbers = [5]int{1, 2, 3, 4, 5}
tempInts := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 

具体操作不在这写了，循环操作那里有

15.指针
指针:go中的指针就是实体中的某个属性，有指针名称，指针名称，指针地址；除了这个以外，还有空指针的概念
这个通常用于校验一个数据是否为空时使用。
指针使用流程：

1.定义指针变量。
2.为指针变量赋值。
3.访问指针变量中指向地址的值。
4.在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。

	// 指针
	var name *string //指向string类型
	var age *int     //指向int型
	var i int = 20
	var tempAge *int
	tempAge = &i // 指向变量存储地址
	fmt.Println(name, age, tempAge)

空指针

if(ptr != nil)     // ptr 不是空指针 
if(ptr == nil)    // ptr 是空指针

16.结构体
这个结构和java中的实体对象一样，只有赋值和取值方式有所区别

type Books struct {
	title   string
	author  string
	subject string
	book_id int
}

// 创建一个新的结构体
	fmt.Println(Books{"go", "fetter", "go教程", 1111})
	// k-v形式结构
	fmt.Println(Books{title: "go", author: "fetter", subject: "go教程", book_id: 1111})
	// 忽略某个字段
	fmt.Println(Books{title: "go", author: "fetter", subject: "go教程"})
	// 使用对象接收并获取单个字段
	book := Books{title: "go", author: "fetter", subject: "go教程", book_id: 1234}
	fmt.Println(book.book_id)

17.切片
切片等元素截取，拼接

	// 切片 数组元素截取，拼接
	//s := arr[startIndex:endIndex]// 开始位置，结束位置；开始位置包括本身，结束位置到结束的前一位
	numbers := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}
	printSlice(numbers)
	// 打印原始切片
	fmt.Println("numbers ==", numbers)

	//打印子切片从索引1(包含) 到索引4(不包含)
	fmt.Println("numbers[1:4] ==", numbers[1:4])

	// 默认下限为 0
	fmt.Println("numbers[:3] ==", numbers[:3])

	// 默认上限为 len(s)
	fmt.Println("numbers[4:] ==", numbers[4:])

	//append 数组元素追加
	// 追加一个10
	numbers = append(numbers, 10)
	fmt.Println(numbers)

	// 追加两个元素
	numbers = append(numbers, 10, 12)
	fmt.Println(numbers)

}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}

18.语言范围range
Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。
具体的操作上面有这里不做实例了

19.map集合
map是一个k-v集合，增加删除查询都是基于k来做的

// 创建一个集合
	var currentMap = make(map[int]string)

	currentMap[1] = "a"
	currentMap[2] = "b"
	currentMap[3] = "c"

	// 遍历集合
	if len(currentMap) > 0 {
		fmt.Println("取出集合k-v")
		// 取出集合中的k-v
		for i, s := range currentMap {
			fmt.Println(i, s)
		}
		fmt.Println("取出集合k")
		// 取出集合中的k
		for i := range currentMap {
			fmt.Println(i)
		}
		fmt.Println("取出集合v")
		// 取出集合中的v
		for _, s := range currentMap {
			fmt.Println(s)
		}

	}
	// 删除集合元素
	// 根据key删除
	fmt.Println("源集合", currentMap)
	delete(currentMap, 1)
	fmt.Println("删除后集合", currentMap)

20.类型转换
一种类型转为另一种类型

	// 类型转换
	// int转float
	var a int = 10
	var b float64 = float64(a)
	fmt.Println("int转float64", b)

	//string转int
	var str string = "10"
	var num int
	num, _ = strconv.Atoi(str)
	fmt.Println("string转int", num)

	//int转string
	num1 := 1234
	strVlue := strconv.Itoa(num1)
	fmt.Printf("整数 %d  转换为字符串为：'%s'\n", num1, strVlue)

21.接口 interface

	// go变量 对象在前，类型在后
	var phone Phone

	// java 类型在前，对象在后
	//private Object object

	phone = new(NokiaPhone)
	phone.call()
}

type Phone interface {
	call()
}

type NokiaPhone struct {
}

// 实现了Phone中的call()接口
func (nokiaPhone NokiaPhone) call() {
	fmt.Println("I m nokiaPhone , I call you phone")
}

22.异常处理
异常处理有捕获异常，返回响应前端，也有自己处理，这里直接打印了。

type error interface {
    Error() string
}
func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
}