go语言基础(1)

写在前面

本文更侧重java与go语法中的不同之处

适合有java基础，想学习go语言的人

测试代码可以用在线编译器：https://lightly.teamcode.com/

1、go与java写法异同

1、注释写法相同
2、go语句结束不需要分号 “ ；”

go语言不支持的一些东西：
1、go不支持泛型，只能用 interface{} 模拟
2、go不支持三元表达式
3、没有继承多态的面向对象、没有隐式的数值转换，没有构造函数和析构函数，没有运算符重载，没有默认参数，也没有继承，没有泛型，没有异常，没有宏，没有函数修饰，更没有线程局部存储。

2、变量、常量、iota

变量定义与赋值

var a1
var a = "hello"
var b string = "world"
var c,d int = 0,1
var h bool = true
e := "hello"                   // 等价于 var e string =  "hello" 
f,g := 123, "hello"            // 不带声明格式的只能在函数体中出现

常量

const b string = "abc"
const b = 1

const (
    Unknown = 0
    Female = 1
    Male = 2
)

// 函数必须是内置函数，否则编译不过
const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)

// 自动计数
const (
    a = iota
    b = iota
    c = iota
)
// 简写
const (
    a = iota
    b
    c
)

iota使用示例：

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

// 输出  0 1 2 ha ha 100 100 7 8


const (
    i=1<<iota
    j=3<<iota
    k
    l
)

func main1() {
    fmt.Println("i=",i)
    fmt.Println("j=",j)
    fmt.Println("k=",k)
    fmt.Println("l=",l)
}

// 输出 
// i= 1
// j= 6
// k= 12
// l= 24

3、if、switch、select、for、goto

if else

package main

import "fmt"

func main() {
   var a int = 10
   if a < 20 {
       /* 如果条件为 true 执行 */
       fmt.Printf("a 小于 20\n" )
   } else {
   	   fmt.Printf("a 不小于 20\n" )
   }
   fmt.Printf("a 的值为 : %d\n", a)
}

switch语句

package main

import "fmt"

func main() {
   var grade string = "B"
   var marks int = 90

   // 第一种
   switch marks {
      case 90: fmt.Printf("90")    
      case 80: fmt.Printf("80")    
      case 50,60,70 : fmt.Printf("50或60或70")    
      default: fmt.Printf("其他")      
   }

   // 第二种
   switch {
      case grade == "A" : fmt.Printf("优秀!\n" )    
      case grade == "B", grade == "C" : fmt.Printf("良好\n" )
      default: fmt.Printf("差\n" );
   }

   var x interface{}
   // switch 输出变量类型
   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("未知型")    
  }
}

使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。

package main

import "fmt"

func main() {

    switch {
    case false:
            fmt.Println("1")
            fallthrough
    case true:
            fmt.Println("2")
            fallthrough
   case false:
            fmt.Println("3")
    default:
            fmt.Println("默认")
    }
}

select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。

package main

import "fmt"

func main() {

	ch := make(chan int, 3)             // make为ch通道初始化一个值3
	for i := 0; i < 10; i++ {
		select {
		case ch <- i:                   // <- 符号表示把i的值写入到ch通道中
         fmt.Println("dddd:",i)
		case x := <-ch:                 // 把ch中的值读到x中
			fmt.Println(x)
		}
	}
}

go语言中也有continue、break关键字，另外还有goto

package main

import "fmt"

func main() {
   var a int = 10
   L: fmt.Printf("a的值为 : %d\n", a)
   for a < 20 {
      if a == 15 {
         a++
         goto L
      }else if a == 17{
         break
      }else{
         a++
         fmt.Printf("a的值为 : %d\n", a)
      }
   }  
}

4、函数、引用、闭包函数

函数定义

func 方法名(参数1, 参数2)  返回类型{
   函数体
}

例

package main

import "fmt"

func main() {
   /* 调用函数 */
   ret := max(100, 200)
   fmt.Printf( "最大值是 : %d\n", ret )
}

/* 函数返回两个数的最大值 */
func max((a, b int) int {
	if a>b {
		return a
	}else{
	    return b
	}
}

Go 函数可以返回多个值

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("hello", "world")
   fmt.Println(a, b)
}

引用

/* 定义交换值函数*/
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* 保持 x 地址上的值 */
   *x = *y      /* 将 y 值赋给 x */
   *y = temp    /* 将 temp 值赋给 y */
}

函数还可以这样声明

package main

import (
   "fmt"
   "math"
)

func main(){
   /* 声明函数变量 */
   getSquareRoot := func(x float64) float64 {
      return math.Sqrt(x)
   }

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

}

闭包函数

package main

import "fmt"

func getSequence() func() int {
   i:=0
   return func() int {
      i+=1
     return i  
   }
}

func main(){
   /* nextNumber 为一个函数，函数 i 为 0 */
   nextNumber := getSequence()  

   /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   
   /* 创建新的函数 nextNumber1，并查看结果 */
   nextNumber1 := getSequence()  
   fmt.Println(nextNumber1())
   fmt.Println(nextNumber1())
}