Go简单了解

0.一直很好奇,go是不是像传说中的速度快,解决了多线程问题,快速进行了解了解,和java进行对比,他是怎么解决语言发展的问题的…,所有语言都是差不多的,只是熟练程度不同而已
1.go图标是土拨鼠,2009发行

docker使用go,解决了并发问题
google facebook 腾讯 百度 七牛云 京东 小米使用go开发
可以简单的开发web服务,不需要很多框架.区块链以太坊,嵌入式

2.特点

1.语法简单 只有i++ 没有括号
2.支持并发 不用多线程了
3.垃圾回收

3.环境

1. go1.16 安装包
   cmd: go version

2. 配置环境变量
   GOROOT安装路径 \bin
   GOPATH代码依赖 创建文件夹 bin pkg src

   go evc

3. 开发工具 goland

4.代码

package main //相当于默认的包
import "fmt" //工具类 
func main(){   //定义方法
       fmt.PrintLn("Hello World")   //没有分号
 }
//font size调整字体
//开发工具报错
     cmd: go env -w GO111MODULE=off

5.代码1(js语法)

   var name string ="aaa"  //小写的
   //多个变量定义简单
    var name1,bb string 
    name= "aaa"
    //初始化并定义,自动推导
         name :="aaa"
         age :=10
   var(   //定义多个变量
               name string
               age int
      )

   fmt.Printf("%T,%p",name,&age) //查看类型,查看地址
  
   var a int =100
   var a int =300
   a,b = b,a //变量交换,区别于其他语言

   //定义函数
       func test() (int,int){ //返回值
           return 100,200
       }
    
        a,_: =test() //没有类了 接收匿名变量,不占用内存空间,也不分配内存,会丢弃
       //必须要使用,不然报错
      //全局变量,函数外,
  //常量
          const URL string="aaa"
          const a,b,c =3,14,"aaa",false
  //iota  常量计数器计算 会自动+1 不定义的话,可以对数组遍历,用得不多
         const(
          a =iota  //0
          b          //1
           c="aaa"    //给标号2
           d             //3
      )

5.数据类型(好像js啊,又像java一样强类型)

       var flag bool =true //默认false
   //整形
       var age int64 =19 
        var age uint64 =19  //无符号
         //32可能会精度丢失
       var money float64=3.14 //%f打印 默认6位小数 ,%.1f保留一位小数并且4四舍五入
         var age byte =19  
         var aa string ="" +"xxx" // %s ,%d 打印ASCIII码,中文打印GBK
   //类型转换
       c: =float64(a)  //int转float64 ,java使用(float)强制转换和隐式 ,这里没有优先级,
       d:=int(f)
   //但是使用 float64转float32会丢失

6.关系运算符 && || == !

   if !(a&&b){  //去括号
        
    }else{

    }
   //位运算 用于二进制加密解密,安全   ^异或: 不同为1  >> <<
      var a uint=60
       var a uint=13
           a & b                          //看二进制%b
    // &^可以清空特点的位 比如 1010 &^ 0011 = 1000 如果b为0取a的值,不是就取0,这个代码是清空了a的后两位, b代表清空哪里

7.其他运算符 & 和指针

  var a int *

8.输入

 var x int
 var y float64
fmt.ScanLn(&x,&y)

9.语法 没有小括号

 if a>20 && b<20 {
 }else if a>30 && b<20{

 } else{

 }

  switch score{ //?
      case 90:
      case 50,60,70:
          fallthrough //穿透到后面的
      default:
            break //停止穿透

     for i:=1 ;i<=10;i++{
            
     }
          //无限循环
         for{

         }

  }

10.字符串

     str:="aaa"
     len(str)   
 fmt.Printf("aaa",str[2]) //ascill码
      fmt.Printf("%c",str[2])
   for i,v:=range str{
         //下标和值
   }
   str[2]= 'a' //错误的,不能转,是int

11.函数

add(1,2)
func add(a,b int)(int) {
      c:=a+b
      return c
  }
func add() {
     
  }
func add() int {
      return 10
  }
func add()(string,string ){
      return "aa","bb"
  }

//要放在最后可变参数,只能一个
func add(nums ...int) int {
        len(nums)
       nums[0]
      return 10
 }

12.值传递 基础类型,arr struct

 arr1:=[4]int{1,2,3,4}
       
func update(arr2 [4] int){
  //值传递,复制一份,不改原数据
  fmt.Println("aaa",arr2[1])
  arr2[1]=10
}

//引用传递(值变化,传入地址) 切片(可扩容的数组) map chan
   s1: =[]int{1,2,3,4}

func aa(s2 []int)

13.作用域 就近原则

   for b:=1; b<=10
      fmt.PrintLn(b) //报错,只能循环使用

14.递归函数, 有就出结果,没有死循环
15.defer推迟执行函数最后执行,多个逆序执行 1cba

defer func1("a")
   func1("1")
defer func1("b")
defer func1("c")
  //关闭操作,写日志

16.函数的类型是 func()

  fmt.Printf("%T",f1) //如果有返回值也不一样
  //函数类型的变量
  var f5 func(int,int)
   f5=f1
  f5(1,2) //地址一样
  f2:=f1
  //匿名函数
  f3:=func(){
   }
  f3()
   //执行
   func(){
   }()
    f3:=func(a int,b int) int {
              return a+b
    }  //返回值 
  f3(1,2)
   //支持函数里面传函数(高阶函数)
   //回调函数(被调用的) 
func main(){
   oper(10,20,func()(int){})
}


func oper(a,b int ,fun func(int,int) int) int{
   return 10

})
   

17.函数闭包 不推荐使用可读性差(函数里面定义函数 内层操作外层变量,创建的函数的值不会被销毁,只有复制另外一个函数才重新创建)

func main(){
    r1:=aa()//1
   r1:=aa() //2
   r2:=aa()//1 创建新函数

} 

func aa()func () int{ //返回函数
     a:=1
   func1:= func bb(){
          return a++
    }
     return func1
}

18.go语言的面向对象是使用结构体指针实现的(c语言使用比较友好)

type Person struct {
    name string
    age  int
}

func (p *Person) SayHello() {
    fmt.Printf("Hello, my name is %s and I'm %d years old.\n", p.name, p.age)
}
19.没有继承和多态,实现不一样
go

```java

```java
type Animal struct {
    name string
}

func (a *Animal) Speak() {
    fmt.Println("I'm an animal.")
}

type Dog struct {
    Animal // 嵌入Animal类型
    breed  string
}

func main() {
    d := Dog{
        Animal: Animal{name: "Buddy"},
        breed:  "Labrador",
    }
    d.Speak() // 调用嵌入类型Animal的方法
    fmt.Println(d.name) // 访问嵌入类型Animal的字段
}

19.总结

1. 对比java语法确实简化许多,但是那个类型我写着好别扭, var a int64 可能写java写习惯了…
2. 解决多线程问题, 直接写个 go 函数名就解决了,java需要写多线程
3. 继承和多态还是java 比较简洁,用指针看起来不大舒服…
4. go开发结束代码没有 ; 号,可能我觉得他的作用还是很大的, 如果我要复制代码会格式变化,没有分号可能可读性比较弱
5. go语言用在docker,但是生态还没有java好,可发掘的潜力比较大