go语言基础(1)

清疚 2023-10-08 16:38 18阅读 0赞

#### 文章目录 ####

*  写在前面
 *  1、go与java写法异同
 *  2、变量、常量、iota
 *  3、if、switch、select、for、goto
 *  4、函数、引用、闭包函数

## 写在前面 ##

本文更侧重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())
    }