Go 语言入门指南

Go 语言入门指南

学一门语言先看看helloworld吧，感觉go结合了好多语言的方式，写起来一会像python一会像c++，java差不多。反正语法挺奇特

package main

import "fmt"

func main() {
	fmt.Println("HelloWorld")
}

go语言特点：

高性能、高并发

语法简单，学习曲线平缓

丰富的标准库

完善的工具链

静态链接

快速编译

跨平台

垃圾回收

首先听到老师说 go语言编译贼快，1秒钟左右，我（c++选手）听到简直大吃一惊啊，真神奇

基础语法

首先go是强类型语言，每一个变量都有自己的变量类型，常见的有：字符串，整数，浮点型，布尔类型，另外go中也有指针（只不过用法就是解引用和取地址）

go语言中字符串是内置类型，可通过加号直接拼接，也同时能用等于号比较俩个字符串

下面是变量声明及其定义

var name string // 声明
var name string = "name" //声明并赋初值
var name = "name" //自动推导类型为string

name := "name" //也可以省略var 和类型直接自动推导
/*其他类型同上几乎差不多*/

分支结构

if - else :

go 中的if - else和其他语言差不多，有些细节需要注意

if true{ // 花括号必须加
	...
}else{ //else必须位于这里
    
}
// if - else if 
if true{
	...
}else if true{
	...
}else{
	...	
}

switch-case

switch 中 可以放 变量，常量 ，字符串， case中也可以放表达式，用起来很是方便

switch v{
	case 1 , 2 : // 可以并列 ， 然后没有break
	case 3:
	default:
} 
switch {
	case  retInt() == v: //表达式
		...
	case  v == 2:
		...
	default:
		...
	} 

循环结构

go 语言中只有一个for

for{	//类似 while(true)死循环
	...
}
for i < 10{ //类似while(i < 10)
	...
}
for i:=0; i < 10; i++{ //正常for循环，三个表达式也可以省略，但是分号得在昂
	...
}

数组

数组的话和其他语言类似，具有编号且长度确定的元素序列

var a[5] int //声明一个长度为5的int型数组
b := [5]int{1,2,3,4,5} //声明并定义
c := [...]int{1,2,3,4,5}//不想写括号里的5也可以写...来根据后面初始化的数量赋值
var twoD [2][3]int//二维数组

切片

go语言中一般很少用数组，用切片更方便一些

切片可以任意更改长度

	s := make([]string, 3) //创建一个切片 初始长度为3
	s[0] = "a"
	s[1] = "b"
	s[2] = "c"
	s = append(s, "d") //数组不能用这个方法
	fmt.Println(s) // [a b 3 d] 

切片也可以这样声明，一开始总搞混切片和数组，其实就是切片方括号没值而已，数组有值

	var s  []string //切片也可以这样声明
	s = append(s, "a")
	s = append(s, "b")
	fmt.Println(s) // [a b]

现在解释一一下为什么s = append(s, “a”)还需要在重新给s赋值呢，虽然切片可以动态变长，其实切片底层是维护了一个数组的，也就是说他初始上就是个数组，只不过有一定大小，如果你append添加元素没有超过数组，那没事，但是超过数组大小，他就会重新弄一个更大的数组然后把值拷贝进去，最后把地址返回出来，所以你得让他重新等于s。（对于c++同学应该是类似与vector的东东）

对切片可以有cap方法查看其底层数组大小 ， len方法是真实元素个数
	var s []string
	s = append(s, "a")
	s = append(s, "b")
	s = append(s, "c")
	fmt.Println(s)
	fmt.Println(cap(s)) // 4 
	fmt.Println(len(s)) // 3

切片遍历时也可以像python的切片一样
	s[0:len(s)]  // 这样使用
	// 数组也可以 只不过数组一这样用返回的类型也就是切片类型了

map

这个map和其他语言的hashmap、字典差不多

	m := make(map[string]int , 3)//key是string value是int  初始大小设置为3								 	//也可以不设置
	m["name"] = 2
	fmt.Println(m["name"])
	delete(m , "name")//在m中删除key为name的

range

下面来介绍range。对于一个 slice（切片） 或者一个 map 的话，我们可以用 range 来快速遍历，这样代码能够更加简洁。 range 遍历的时候，对于数组会返回两个值，第一个是索引，第二个是对应位置的值。如果我们不需要索引的话，我们可以用下划线来忽略。

	nums := []int{2, 3, 4}
	sum := 0
	for i, num := range nums { //返回数组的 下标 和值
		sum += num
		if num == 2 {
			fmt.Println("index:", i, "num:", num) // index: 0 num: 2
		}	
	}
	fmt.Println(sum) // 9
	m := map[string]string{"a": "A", "b": "B"}
	for k, v := range m {  //返回key和value
		fmt.Println(k, v) // a A; b B
	}
	for k := range m {//返回key
		fmt.Println("key", k) // key a; key b
	}

函数

这个是 Golang 里面一个简单的实现两个变量相加的函数。 Golang 和其他很多语言不一样的是，变量类型是后置的。Golang 里面的函数原生支持返回多个值。在实际的业务逻辑代码里面几乎所有的函数都返回两个值，第一个是真正的返回结果，第二个值是一个错误信息。

func add(a  int , b int) int ,err {//a int , b int == a , b int俩种方式都一样
	return a + b		//后面的是返回值
}
func add(a , b int)(int , error){ //可返回多个值
	return a + b , nil
}

func Tmp(a , b int){
	func() int {//还可以在函数内部定义一个匿名函数，类似别的语言lambda函数
		return 5
	}()//加上（）表示直接调用
}

结构体

type student struct { //定义方式 type + 名字 + struct
	name string //小写变量名相当于私有，只有自己包的才可以访问，
	Age  int //大写变量名相当于公有 ， 外面包也可以访问
}
	stus := []student{ 
		{name: "小王子", Age: 18}, //可以指定变量成员赋值
		{name: "大王八", Age: 9000},
		{name: "娜扎", Age: 23},
	}

结构体函数

相比其他语言，结构体成员函数是在外面定义的

type person struct {
	name, city string
	age        int8
}
//	(接收者变量 接收者类型) 方法名(参数列表) (返回参数)
//	不可修改成员的值
// 方法与函数的区别是，函数不属于任何类型，方法属于特定的类型。
func (p person) Dream() { 
	fmt.Printf("%s的梦想是学好Go语言！\n", p.name)
}
// 可修改成员的值
func (p *person) SetAge(newAge int8) {
	p.age = newAge
}

简单语法结构就介绍这么多了，剩下的太多了慢慢介绍