go 基础语法

时间有限，简单记一些常用的，麻烦的不写了

定义变量：可以连续定义，也可以单个定义

var a int    int类型

var a="ds"   默认string类型

a:="string"  ：=前面不可以有var

上面三种属于等价的

连续定义

var x1,x2,x3 int =1,2,3

name1,name2,name3:="mu","bai","xu"

基本数据类型

int int16，int32,int64  double float 32,64 complex具体含义百度

循环

for init；condition;desc/incr{

}

上面这种和c++的for循环一样，只不过没括号

还有一种类似于while的

for condition{

}

eg： condition：a<b  ||a>b

无限循环

for true{

}

switch：

和c++的主要区别就是没有break

type-switch

Type Switch

switch 语句还可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。

Type Switch 语法格式如下：

switch x.(type){
    case type:
       statement(s);      
    case type:
       statement(s); 
    /* 你可以定义任意个数的case */
    default: /* 可选 */
       statement(s);
}

package main

import "fmt"

func main() {
   var x interface{}
     
   switch i := x.(type) {
      case nil:      
         fmt.Printf(" x 的类型 :%T",i)                
      case int:      
         fmt.Printf("x 是 int 型")                       
      case float64:
         fmt.Printf("x 是 float64 型")           
      case func(int) float64:
         fmt.Printf("x 是 func(int) 型")                      
      case bool, string:
         fmt.Printf("x 是 bool 或 string 型" )       
      default:
         fmt.Printf("未知型")     
   }   
}

select 语句类似于 switch 语句，但是select会随机执行一个可运行的case。如果没有case可运行，它将阻塞，直到有case可运行。

以下描述了 select 语句的语法：

• 每个case都必须是一个通信
• 所有channel表达式都会被求值
• 所有被发送的表达式都会被求值
• 如果任意某个通信可以进行，它就执行；其他被忽略。
• 如果有多个case都可以运行，Select会随机公平地选出一个执行。其他不会执行。 
  否则：
  1. 如果有default子句，则执行该语句。
  2. 如果没有default字句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值

条件：

break，contonie，goto都是和c/里面的类似

function：

函数的返回值可以有一个二两或者多个，中间用逗号隔开就可以，return x,y,z

return的值接的时候就是

func function(a,b,c int) int{

　　return a,b,c

}

x,y,z=function(a,b,c)

package main
import "fmt"

func max(a,b int) int{
    var result int
    if a>b{
        result=a
    }else{
        result=b
    }
    
    return result
}

func main(){
    var re int
    
    re=max(14,6)
    fmt.Println(re)
}

 函数可以作为值

  getSquareRoot := func(x float64) float64 {
      return math.Sqrt(x)
   }

   /* 使用函数 */
   fmt.Println(getSquareRoot(9))

内置方法

get（）  len()都属于circle的内置方法

package main
import (
    "fmt"
)
type circle struct{
         x,y int
}
func main(){
    var c circle
    c.x=4
    c.y=51
    var ret int
    ret=c.get()
    fmt.Println(ret)
    ret=c.len()
    fmt.Println(ret)
}

func (c circle) len() int {
    return c.x+c.y
}


func (c circle) get() int{
      return c.x * c.y
}

range:

package main
import "fmt"
func main() {
    //这是我们使用range去求一个slice的和。使用数组跟这个很类似
    nums := []int{2, 3, 4}
    sum := 0
    for i, num := range nums {
        fmt.Println(i)
        sum += num
    }
    fmt.Println("sum:", sum)
    //在数组上使用range将传入index和值两个变量。
    //上面那个例子我们不需要使用该元素的序号，
    //所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    //range也可以用在map的键值对上。
    kvs := map[int]string{1: "apple", 2: "banana"}
    for k, v := range kvs {
        fmt.Printf("%d -> %s
", k, v)
    }
    //range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

map

使用range map的时候可以返回两个值，第一个key第二个value

package main

import "fmt"

func main() {
   var Map map[string]string
   /* 创建集合 */
    Map = make(map[string]string)
   
   Map["France"] = "Paris"
   Map["Italy"] = "Rome"
   Map["Japan"] = "Tokyo"
   Map["India"] = "New Delhi"
   
   
   for country ,value:= range Map {
   
       fmt.Println(country,value)
   }
   
 
   captial, ok := Map["United States"]
   /* 如果 ok 是 true, 则存在，否则不存在 */
   if(ok){
      fmt.Println("Capital of United States is", captial)  
   }else {
      fmt.Println("Capital of United States is not present") 
   }
}

 delete(map,"France");
通过delete我们可以删除指定map的key的value