go语法基础文档

Posted 2022-12-04 水月情缘雪飞飞

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了go语法基础文档相关的知识，希望对你有一定的参考价值。

go语法基础文档

一：变量和作用域

1.变量声明

1.第一种，指定变量类型，声明后若不赋值，使用默认值

/* 单个变量声明 */
var v_name v_type
    v_name = value

    // 示例
    var a int
    a = 10


/* 类型相同多个变量声明 （非全局变量）*/
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

    // 示例
    var a, b int
    var c string
    a, b, c = 5, 7, "abc"

2.根据值自行判定变量类型

/* 单个变量声明 */
var v_name = value

    // 示例
    var a = 18
    var b = false


/* 多个变量声明，自动判断类型 */
var vname1, vname2, vname3 = v1, v2, v3

    // 示例
    var a, b, c = 5, 7, "abc"

3.省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误

/* 单个变量声明 */
v_name := value

    // 示例
    a := 19


/* 多个变量声明，自动判断类型 */
vname1, vname2, vname3 := v1, v2, v3 

    // 示例
    a,b,c := 19,false,"string"

2.并行或同时赋值(两个变量的类型必须是相同)

a := 5
b := 7

// 并行计算
a, b = b, a
fmt.Println("a=", a, " b=", b)

// 结果
// a= 7  b= 5

3.空白标识符(抛弃值) _

// 值 5 被抛弃
_, b = 5, 7

//不适用 err 则可以写为 vval,_ = func1()
val, err = Func1(var1)。

二：常量

声明：

const identifier [type] = value

1.显示定义

 const b string = "abc"

2.隐式类型定义

 const b = "abc"

3.多个常量的声明

const c_name1, c_name2 = value1, value2

// 示例
const a,b = 1,"string"
fmt.Println("a=", a, " b=", b)

4.枚举

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

5.常量函数表达式（函数必须是内置函数： len(), cap(), unsafe.Sizeof() ）

const (
    a = "abc"
    b = len(a)
    c = unsafe.Sizeof(a)
)
fmt.Println(a, b, c)
// 结果： abc 3 16

6.iota 特殊常量，可以认为是一个可以被编译器修改的常量。

const (
    a = iota
    b = iota
    c = iota
)
fmt.Println(a, b, c)
// 结果 0 1 2

const (
    a = iota
    b
    c
)
fmt.Println(a, b, c)
// 结果 0 1 2


const (
    a = iota       // 0
    b = 18         // 独立值 iota += 1
    c = "一个string" // 独立值 iota += 1
    d              // "一个string"
    e              // "一个string"
    f = iota       //恢复计数 iota += 1
    g              // iota += 1
)
fmt.Println(a, b, c, d, e, f, g)
// 结果： 0 18 一个string 一个string 一个string 5 6


/* 左移 << 表示左移 */
const (
    a = 1 << iota
    b = 3 << iota
    c
    d
)
fmt.Println(a, b, c, d)
// 结果：  1 6 12 24

三：运算符

参考文档

四：条件语句

1.if 语句

if 布尔表达式 
 else if 布尔表达式 
 else 


// 示例
var a int = 10
if a < 20 
    fmt.Printf("a 小于 20\\n" )

2.switch 语句

switch

switch var1 
    case val1:
        ...
    case val2:
        ...
    default:
        ...


// 示例
var a int = 10
switch a 
case 1: // a == 1

case 10: // a == 20

default: // 默认值

Type Switch：判断某个 interface 变量中实际存储的变量类型

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


// 示例
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("未知型")

3.select 语句

参考文档

select 
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s); 
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);


// 示例
var c1, c2, c3 chan int
var i1, i2 int
select 
case i1 = <-c1:
    fmt.Printf("received ", i1, " from c1\\n")
case c2 <- i2:
    fmt.Printf("sent ", i2, " to c2\\n")
case i3, ok := (<-c3): // same as: i3, ok := <-c3
    if ok 
        fmt.Printf("received ", i3, " from c3\\n")
     else 
        fmt.Printf("c3 is closed\\n")
    
default:
    fmt.Printf("no communication\\n")

五：循环语句

1.for init; condition; post

// 示例
for a := 0; a < 3; a++ 
    fmt.Println(a)

// 结果 0 1 2

2.for condition

// 示例 1
var a, b int = 0, 3
for a < b 
    a++
    fmt.Println(a)

// 结果 1 2 3

// 示例2：无限循环
var i int = 0
for true 
    i++

3.for

备注：for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环

// 示例
var list = [3]int1, 2, 3
for key, value := range list 
    fmt.Println("key=", key, "value=", value)


/*
结果
key= 0 value= 1
key= 1 value= 2
key= 2 value= 3
*/

4.循环控制语句

break 语句经常用于中断当前 for 循环或跳出 switch 语句
continue 语句跳过当前循环的剩余语句，然后继续进行下一轮循环。
goto 语句将控制转移到被标记的语句。参考连接

  /* 定义局部变量 */
  var a int = 10

  /* 循环 */
  LOOP: for a < 20 
     if a == 15 
        /* 跳过迭代 */
        a = a + 1
        goto LOOP
     
     fmt.Printf("a的值为 : %d\\n", a)
     a++

六：函数

主函数：main 函数必须存在

func main()

声明：

func 函数名( [函数参数...] ) [返回类型] 
    函数体

1.函数参数

1.值传递

// 示例1：
max(1,30)
func max(num1, num2 int) int 
    /* 定义局部变量 */
    var result int
    if (num1 > num2) 
        result = num1
     else 
        result = num2
    
    return result


// 示例2：多类型接收与多类型声明返回
func function(a []int, b int, c bool, d map[int][]int) (list []int, data int, err error) 
    return


// 示例3：多类型接收与多类型返回
func function(a []int, b int, c bool, d map[int][]int) ([]int, int, error) 
    // 未声明变量，需要函数里声明，return 返回具体的变量
    var list = []int
    var data int
    var err error

    return list, data, err

2.引用传递

/* 定义局部变量 */
func man
    var a int = 100
    var b int= 200

    fmt.Printf("交换前，a 的值 : %d\\n", a )
    fmt.Printf("交换前，b 的值 : %d\\n", b )

    /* 调用 swap() 函数
    * &a 指向 a 指针，a 变量的地址
    * &b 指向 b 指针，b 变量的地址
    */
    swap(&a, &b)

    fmt.Printf("交换后，a 的值 : %d\\n", a )
    fmt.Printf("交换后，b 的值 : %d\\n", b )

func swap(x *int, y *int) 
    var temp int
    temp = *x    /* 保存 x 地址上的值 */
    *x = *y      /* 将 y 值赋给 x */
    *y = temp    /* 将 temp 值赋给 y */

/*
执行结果:
交换前，a 的值 : 100
交换前，b 的值 : 200
交换后，a 的值 : 200
交换后，b 的值 : 100
*/

2.函数用法

1.函数作为值

/* 声明函数变量 */
getSquareRoot := func(x float64) float64 
    // 开平方根
    return math.Sqrt(x)

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

2.闭包

匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。

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())

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

3.函数方法（类）

/* 定义结构体 */
type Circle struct 
  radius float64

func main() 
  var c1 Circle
  c1.radius = 10.00
  fmt.Println("圆的面积 = ", c1.getArea())

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius

七：数组

声明：

var variable_name [SIZE] variable_type

初始化数组

1.固定长度数组

备注：

[] 设定数组个数
是数组元素
数组中中的元素个数不能大于 [] 中的数字

var a [10]int
var b [10] int
var c = []int1, 2, 3, 4, 5, 6

2.无限长度数组

备注：

忽略 [] 中的数字不设置数组大小，根据元素的个数来设置数组的大小

var a []int
var b [] int
var c = []int1, 2, 3, 4, 5, 6

访问数组元素

备注：

数组元素可以通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为 0，第二个索引为 1，以此类推

1.一维数组

var n [3]int /* n 是一个长度为 3 的数组 */
fmt.Println(len(n))

var length = len(n) // 数组的长度为3

/* 为数组 n 初始化元素 */
for i := 0; i < length; i++ 
  n[i] = i + 100 /* 设置元素为 i + 100 */


/* 数组元素读取 */
for i := 0; i < length; i++ 
  fmt.Println(i, n[i])

/*
执行结果：
3
0 100
1 101
2 102
*/

2.多维数组

var threedim [3][4][5]int
fmt.Println(threedim)
/*
执行结果：
[
    [
        [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]
    ] 
    [
        [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]
    ] 
    [
        [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]
    ]
]
*/

// 赋值
array[0][1][1] = 10
// 读取
fmt.Println(array[0][1][1])

3.函数传递数组

1.方式一：形参设定数组大小

void myFunction(param [10]int)

2.方式二：形参未设定数组大小

void myFunction(param []int)

示例：

func function(arr []int, data [5]int)

八：指针

指针：一个指针变量指向了一个值的内存地址
声明：

var var_name *var-type

var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

1.指针使用

定义指针变量。
为指针变量赋值。
访问指针变量中指向地址的值。

  // 定义指针变量
  var a int = 20
  var b *int

  // 赋值
  b = &a /* 指针变量的存储地址 */
  
  fmt.Printf("a 变量的地址是: %x\\n", &a)

  /* 指针变量的存储地址 */
  fmt.Printf("b 变量储存的指针地址: %x\\n", b)

  /* 使用指针访问值 */
  fmt.Printf("*b 变量的值: %d\\n", *b)

2.空指针

当一个指针被定义后没有分配到任何变量时，它的值为 nil，nil 指针也称为空指针

var ptr *int

fmt.Printf("ptr 的值为 : %x\\n", ptr)

if (ptr == nil) 
  fmt.Println("ptr = nil")

/*
执行结果：
ptr 的值为 : 0
ptr = nil
*/

3.指针数组

a := []int10, 100, 200
var i int
var ptr [3]*int;
for i = 0; i < 3; i++ 
  ptr[i] = &ago语言基础之格式化输出
 golang Go：Newton的平方根方法
 Go语言基础语法（一）
 go语言语法(基础语法篇)
 每天一点Go语言——Go语言语法基础及基本数据类型
 从零开始——GO语言基础语法

go语法基础文档

go语法基础文档

一：变量和作用域

1.变量声明

2.并行 或 同时 赋值(两个变量的类型必须是相同)

3.空白标识符(抛弃值) _

二：常量

1.显示定义

2.隐式类型定义

3.多个常量的声明

4.枚举

5.常量函数表达式 （函数必须是内置函数： len(), cap(), unsafe.Sizeof() ）

6.iota 特殊常量，可以认为是一个可以被编译器修改的常量。

三：运算符

四：条件语句

1.if 语句

2.switch 语句

switch

Type Switch：判断某个 interface 变量中实际存储的变量类型

3.select 语句

五：循环语句

1.for init; condition; post

2.for condition

3.for

4.循环控制语句

六：函数

1.函数参数

1.值传递

2.引用传递

2.函数用法

1.函数作为值

2.闭包

3.函数方法（类）

七：数组

初始化数组

1.固定长度数组

2.无限长度数组

访问数组元素

1.一维数组

2.多维数组

3.函数传递数组

八：指针

1.指针使用

2.空指针

3.指针数组

2.并行或同时赋值(两个变量的类型必须是相同)

5.常量函数表达式（函数必须是内置函数： len(), cap(), unsafe.Sizeof() ）