golang基础

基础语句

判断

if

if有两种用法

if 表达式; 条件和if 条件

else if只有一种

else if 条件

num := 10
if num2 := num * num; num2 > 90 {
    fmt.Println("num > 90")
    fmt.Println(num2)
}else if num2 >= 60 && num2 <= 90{
    fmt.Println("60 <= num <= 90")
    fmt.Println(num2)
}else{
    fmt.Println(num2)
}

switch

go的switch会比c、cpp灵活一点

比如说想对0-100的数进行不同的操作，c/cpp只能用if …else if…

go可以用switch这么写，我一度以为cpp也能这么写，但是不可以hh，cpp的case后面的条件只能放常量

num := 50
switch {
    case num >= 60 && num <=100:
    fmt.Println("op 1")
    case num >= 30 && num < 60:
    fmt.Println("op 2")
    case num >=0 && num < 30:
    fmt.Println("op 3")
}

switch还可以用来判断类型，以下应该是一种固定用法吧，当然case后面还可以自定义类型

func judgeType(num interface{}){
	switch num.(type){
	case int:
		fmt.Println(num, " is int")
	case string: 
		fmt.Println(num, " is string")
	}
}

循环

无限循环

for{
    
}

普通

for i:=0; i<100; i++{
    
}

类while

for 条件

for i<100{
    i++
}

for-range

熟悉python的话，这个类似python里的for key, value in enumerate(interator):

for-range可以对数组，切片，表，字符串，信道进行遍历的同时，获取当前遍历的元素的[索引/键]

var s string
s = "cgynbnb kkk"
for key, value := range s{
    fmt.Println(key, string(value))
}

break

按照正常的循环控制，break只能跳出一层循环，但是go的语法中，break可以设置标记，设置跳出哪一层的循环

b1:
for i=0; i<100; i++{
    b2:
    for j=0; j<100; j++{
        for k=0; k<100; k++{
            if i * j * k >= 10000{
                break b1
            }
            if k == 100{
                break b2
            }
        }
    }
}

continue

也可以进行标记

数据类型

channel

map

跟cpp、java中的map基本一样的使用，python中的字典

slice

set

集合类型是go不自带的，看了几篇文章，都是通过map[interface{}]struct{}进行实现，然后添加一些方法，来实现集合的包含，打印，比较等等。

自己也试着实现了一个，但是打印方法始终没有写好，翻了一下golang-set这个包，这边贴个代码，只能感慨确实了解的少了。其中threadUnsafeSet的声明就是type threadUnsafeSet map[interface{}]struct{}

func (set *threadUnsafeSet) String() string {
	items := make([]string, 0, len(*set))
	for elem := range *set {
		items = append(items, fmt.Sprintf("%v", elem))
	}
	return fmt.Sprintf("Set{%s}", strings.Join(items, ", "))
}

array

string

使用方法跟c++、java、python差不多。字符拼接类似java，官方推荐的是用strings.Builder，写个示例，到时候忘记了来康康：）

var builder strings.Builder
builder.WriteString("1")
builder.WriteString(" 2")
builder.WriteString(" 3")
fmt.Println(builder.String())

struct

方法

将函数变成方法，就是在函数名前面，写上传入类型

以下就是为Person添加了run方法

func (person *Person) run(){
	fmt.Println(person.name, "can run")
}

继承

将父结构体放在子结构体内，即可

底下代码里面定义了Male、Person，Male有showHair方法，Person有run方法。将Person放在Male中，在main函数里声明Male类型变量cgy，发现实例cgy可以调用Male的方法，也可以调用Person的方法。

type Person struct{
	name string
	age int
}

func (person *Person) run(){
	fmt.Println(person.name, "can run")
}

type Male struct{
	Person
	hair string
}

func (male *Male) showHair(){
	fmt.Println(male.name, "'s hair is ", male.hair)
}

func main(){
	cgy := &Male{
		Person: Person{name: "cgy", age: 19},
		hair: "black",
	}
	cgy.run()
	cgy.showHair()
}

interface

这篇文章写的挺详细了
文章链接

协程

粗浅的理解，差不多就是，在后边执行函数吧

package main

import (
	"fmt"
	"time"
)

var a int

func f(){
	for{
		fmt.Scanf("%d", &a)
		fmt.Println("here is:", a)
		time.Sleep(time.Second)
	}
}

func main() {
	go f()
	for{
		fmt.Println(a)
		time.Sleep(time.Second)
	}
}