学习go 简单版

本文章对有java、c基础，想要快速学习go的童鞋们快速入门go

因为最近java比较卷，想要学学go

接下来，上火车咯

结构

package main

import "fmt" //用来输出、接受值

同一目录不要有一样的函数名

• 不用括号

  • for后面不用括号

    • for i:=0 ; i<n ; i++{}

  • switch后面不用括号

    • switch true {}

  • if后面不用括号

    • if true{}

• 变量没有隐式转换，只能显式地去转换

  • b:= int("123")

• 一定要有花括号

  • if a==1 {return true}

变量赋值

• 先名称后类型

  • var b string = "1"

• 直接隐式赋值、自动识别类型、重点不能用在全局变量

  • b:=1

uint、uint8、uint16、uint32、uint64

其他自己查

if

• if true{}

• if b:=1 ; n<=10{} 神奇，感觉哪里都能定义变量

switch

case自带break

如果想要贯通直接 fallthrough ，少用

循环

一个for走天下

str := "abcdefg"
for i,v := str{
    //下标
    fmt.Pringln(i)
    //值
    fmt.Pringln(v)
    
}

函数

定义值的数据类型都在后面，注意返回值的括号

func add(a string,b int) (int,string){
    return b,a
}

可变参数

在函数中的形参，上实例

main(){
    a:=getSum(1,2,3,4,5,6,7,8)
    b:=getSum(1,2,5,6,7,8)
    
}
​
func getSum(nums ...int) (int){
    sum :=0
    for i:=0 ; i< len(nums) ; i++{
        sum+=nums[i]
    }
    return sum
}

扩展说明：

• 形参只能有一个可变参数

• 可变参数前可以有几个不同于可变参数类型的参数

形参传递值指向

• 数组

  • 规定个数

  • //这里指定了数组的个数
    func update(arr [4]int){
        arr[0]=100
    }
    //没有效，因为传递的只是拷贝数组，因为指定数组个数，才是拷贝数组

  • 不规定个数

  • func add(arr []int){
        arr[0]=100
    }
    //值被改了，传递的是引用类型，也就是指针

delay延迟函数

函数可以添加多个defer语句，当函数执行到最后，这些defer语句会按照逆序执行，就像栈，先进后出，看实例

func test(){
    f("1")
    f("2")
    defer f("3")
    defer f("4")
    f("5")
}
func f(s string ){
    fmt.Println(s)
}
​
//输出结果，12543

函数探索

输出一下函数名，输出了一个内存地址

使用一个函数赋值给另一个变量，然后调用新的变量，可以知道，函数也是一个变量

f1()
f2:=f1
f2()
​
func f1(){
    fmt.Println("你好")
}

• 匿名函数

  • 我感觉我学到了javascript

  • func main(){
        f3 := func(){
            fmt.Println("你好")
        }
        f3()
    }

• 匿名函数自己调用自己

  • 注意这里有很多元素

  • 匿名函数，形参、返回值、自己调自己

  • func main(){
        a,b := 1,2
        c := func(a,b int)(int){
            fmt.Println("你好")
        }(a,b)
    }

• 因为这里的函数可以是一个变量，想想，是不是可以将函数变成参数进行套娃

  • func add(a,b int) int{
        return a+b
    }
    func sum(a,b int, fun func(int,int) int) int{
        r:= fun(a,b)
        return r
    }
    ​
    func main(){
        r:=sum(1,2,add)
        fmt.Println(r)
    }

  • 还可以传递一个匿名函数

  • func sum(a,b int, fun func(int,int) int) int{
        r:= fun(a,b)
        return r
    }
    ​
    func main(){
        r:=sum(1,2,func (a int,b int) int{
            if(b==0){
                fmt.Println("除数不能为0")
                return 0
            }
            return a/b
        })
        fmt.Println(r)
    }

闭包结构

一个函数（该函数返回一个匿名函数）里有一个匿名函数，函数返回的就是这个内部函数，而这个内部函数是操作外函数的局部变量的，在main函数中，将外函数变量赋值给一个变量，然后调用发现这个局部变量存在内存中没有另外新建额外的函数；此时外函数给另一个函数变量进一步的指向，此时是又新建一个局部函数的内存，可以说是并发，此时两个指向的函数变量都可以任意执行自己的内存，献上实例

func main() {
    r1 := increment()
​
    v := r1()
    ///这里比较正常
    fmt.Println(v)
    fmt.Println(r1())
    fmt.Println(r1())
    fmt.Println(r1())
​
    r2 := increment()
    fmt.Println(r2())
    fmt.Println(r1())
    fmt.Println(r2())
​
}
​
func increment() func() int {
    i := 0
    fun := func() int {
        i++
        return i
    }
    return fun
}
​

这里还有很多没有讲完，比如类咋搞、map咋搞，以后再更新吧，（有机会的话）

实例

1、递归

func dfs(n int) (int){
    if n==1 {
        return 1
    }
    return dfs(n-1)+n
}

这里献上一题力扣的算法题目

var p *ListNode;
func isPalindrome(head *ListNode) bool {
    p=head;    
    return dfs(head);
}
func dfs(node *ListNode) bool {
    if(node==nil){
        return true
    }
    if(!dfs(node.Next)){
        return false
    }
    if(node.Val == p.Val){
        p=p.Next
        return true
    }
    return false
}

写的很java，可以使用一下刚刚讲的匿名函数

func isPalindrome(head *ListNode) bool {
    p := head
    var rc func(*ListNode) bool
    rc = func(curnode *ListNode) bool {
        if curnode != nil {
            if !rc(curnode.Next) {
                return false
            }
            if curnode.Val != p.Val {
                return false
            }
            p = p.Next
        }
        return true
    }
    return rc(head)
}

写了之后，只能说go也是有他自己的特色的

接下来会编写一些算法为自己学习加油~~~~