Golang 语句、函数、可见性规则

﹏ヽ暗。殇╰゛Y 2022-10-11 03:37 6阅读 0赞

### 目录 ###

*   *   *  语句
         *   *  if
             *  switch
             *  for
         *  函数
         *   *  函数的定义、使用
             *  返回值名称
             *  参数个数可变的函数
             *  函数作为参数
             *  函数闭包
         *  可见性规则

### 语句 ###

#### if ####

var a = 1
    
    if a > 0 { 
    	fmt.Println("a>0")
    } else if a == 0 { 
    	fmt.Println("a==0")
    } else { 
    	fmt.Println("a<0")
    }
    
    
    //在条件中可以声明赋值，但不能用var，只能用:=，声明的变量的作用域是当前if语句中
    if b := 1; b > 0 { 
    	fmt.Println("b>0")
    } else if b == 0 { 
    	fmt.Println("b==0")
    } else { 
    	fmt.Println("b<0")
    }

#### switch ####

func f1(a, b int, operator string) { 
    	switch operator { 
    	case "+":
    		fmt.Printf("%d%s%d=%d\n", a, operator, b, a+b)
    	case "-":
    		fmt.Printf("%d%s%d=%d\n", a, operator, b, a-b)
    	case "*":
    		fmt.Printf("%d%s%d=%d\n", a, operator, b, a*b)
    	case "/":
    		fmt.Printf("%d%s%d=%d\n", a, operator, b, a/b)
    	default:
    		//panic(fmt.Sprintf("不支持的运算符：%s", operator))
    		panic("不支持的运算符：" + operator)
    	}
    }
    
    
    func f2(score int) { 
    	switch { 
    	case score >= 80 && score <= 100:
    		fmt.Println("优秀")
    	case score >= 60 && score < 80:
    		fmt.Println("良好")
    	case score >= 0 && score < 60:
    		fmt.Println("不及格")
    	default:
    		//panic(fmt.Sprintf("不合法的分数值：%d", score))
    		panic("不合法的分数值：" + strconv.Itoa(score))
    	}
    }

*  case会自动加上break，不用手动加
 *  switch后可以有表达式，也可以没有
 *  case中可以写条件，可以写多个条件，作用类似于if语句

#### for ####

for i := 0; i < 10; i++ { 
    	fmt.Println(i)
    }
    
    
    arr := []string{ "a", "b", "c", "d"}
    
    //遍历数组，有2个变量时，第一个是下标，第二个是元素值
    for index, value := range arr { 
    	fmt.Println(index, value)
    }
    
    //如果不使用其中某个变量，可写成_
    for _, value := range arr { 
    	fmt.Println(value)
    }
    
    //如果只有一个变量，则为下标
    for index := range arr { 
    	fmt.Println(index)
    }
    
    
    //初始值、循环条件、变量变化表达式均可缺省，全部缺省时为无限循环
    for { 
    	fmt.Println("ok")
    }

*  golang中没有while循环，while循环可以转换为for，使用for即可
 *  内建容器都可以用for range遍历

### 函数 ###

#### 函数的定义、使用 ####

*  golang的参数、变量声明都是变量名在前，类型在后
 *  golang函数的返回值类型放在最后，形参没有默认值

//无返回值时不用写返回值类型
    func f1(name string, age int) { 
    	fmt.Printf("执行f1，name=%s，age=%d\n", name, age)
    }
    
    
    //如果参数类型相同，可以合写成 参数名1,参数名2 类型
    func f2(a, b int, operator string) int { 
    	switch operator { 
    	case "+":
    		return a + b
    	case "-":
    		return a - b
    	case "*":
    		return a * b
    	case "/":
    		return a / b
    	default:
    		panic("不支持的运算符：" + operator)
    	}
    }
    
    
    //可以有多个返回值，返回值类型放在()中
    func f3(a, b int) (int, int) { 
    	return b, a
    }
    
    
    func main() { 
    	f1("chy", 20)
    
    	result := f2(10, 20, "+")
    	fmt.Printf("f2()返回的值：%d\n", result)
    
    	a, b := f3(10, 20)
    	fmt.Printf("f3()返回的值：%d\t%d\n", a, b)
    }

#### 返回值名称 ####

/* 可以给返回值起名字，这样Ctrl+ALt+V补全时会使用对应的变量名来接收 不建议这样做，到处都是变量名，看起来有些混乱，如果要用，尽量只用在简单的函数上 */
    func f1(a, b int) (sum, diff int) { 
    	return a + b, a - b
    }
    
    func main() { 
    	sum, diff := f1(100, 10)
    	fmt.Println(sum, diff)
    }

#### 参数个数可变的函数 ####

//参数个数可变的函数，使用数组接受参数
    func sum(values ...int) int { 
    	sum := 0
    	for _, value := range values { 
    		sum += value
    	}
    	return sum
    }
    
    func main() { 
    	sum := sum(1, 2, 3, 4)
    	fmt.Println(sum)
    }

#### 函数作为参数 ####

//函数可以作为参数。此处oper代表函数名，func(int, int) int是函数原型
    func apply(oper func(int, int) int, a, b int) int { 
    	return oper(a, b)
    }
    
    func main() { 
    	result := apply(func(a int, b int) int { 
    		return a + b
    	}, 10, 20)
    	fmt.Println(result)
    }

#### 函数闭包 ####

闭包：返回值是函数，返回函数中使用的局部变量也会保存在内存中

//func(int) int是函数原型，返回值类型是这种类型的函数
    func adder() func(int) int { 
    	sum := 0
    	//返回的函数中包含了变量sum，sum随返回的函数一起被保存在内存中
    	return func(a int) int { 
    		sum += a
    		return sum
    	}
    }
    
    func main() { 
    	//用一个变量保存addr()返回的函数，可以把f做函数名来调用返回的函数
    	f := adder()
    	for i := 1; i < 10; i++ { 
    		fmt.Printf("0+...+%d=%d\n", i, f(i))
    	}
    }

*  i=1时，第一次调用f(i)，sum=0+1=1，sum=1随函数被保存在内存中
 *  i=2时，第二次调用f(i)，sum=1+2=3 ，sum使用的是被保存在内存中的值，不是初始值

### 可见性规则 ###

与其它语言的标识符命名规则不同，golang的标识命名有特殊含义，标识着可见性，不能随便大小写。

如果常量名、变量名、结构体名、函数名等

*  以小写开头，则只在当前包中可见，可在当前中直接使用
 *  以大写开头，则是公共变量，在其它包中可见，可导入使用

假设有一个目录D:/gopath/demo，GOPATH是D:/gopath，demo是项目根目录，demo下有2个包：package1、main  
   
package1

var Name = "chy"
    
    func F() { 
    	fmt.Println("正在执行F()...")
    }
    
    //内部字段名也要大写，不然不能访问、操作内部字段
    type Node struct { 
    	Value     int
    	Pre, Next *Node
    }

main

import (
    	"fmt"
    	//导入时取GOPATH后面的路径，直到包名
    	"demo/package1"
    )
    
    func main() { 
    	//通过包名来引用
    	fmt.Println(package1.Name)
    	package1.F()
    
    	head := package1.Node{ Value: 10}
    	fmt.Println(head.Value)
    	fmt.Println(head.Pre)
    }

导包时会先将import中的包的相对路径拼接在GOROOT后面，看存不存在，如果不存在，再拼接到GOPATH后面，看存不存在。

官方推荐把所有的golang项目、第三方库都放在GOPATH的src目录下。