likes
comments
collection
share

Golang语法一览（上）

作者站长头像
站长
· 阅读数 3

安装 Go 的方法可以自行查阅相关资料，通过命令 go version 查看 go 版本。

如果使用的是 VS Code，推荐安装插件：Go

Golang语法一览（上）

然后设置goMod状态：

go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct

如果不设置，将无法正常安装插件，插件很好用，可看函数定义、可格式化代码。

零、依赖管理

在 go 中使用 gomod 文件进行依赖管理，类似于 node 中的 package.json 文件。

  1. 初始化gomod文件
go mod init github.com/knight174/hello

Golang语法一览（上）

  1. 安装依赖
go mod tidy
  1. 创建第一个go程序
// main.go
package main

func main () {
	println("Hello, World!")
}
  1. 编译
go build main.go
# go build .

生成一个二进制文件：

Golang语法一览（上）

  1. 运行
./main

Golang语法一览（上）

一、变量、常量

package main

import "fmt" // 引入包

func main() {
  // This is a comment.
  println("Hello, World!")
  
  var zero int
  fmt.Println(zero) // 默认值 0
  
  var a int = 1       // 声明并赋值一个变量
  var b, c int = 2, 3 // 声明并赋值多个变量
  fmt.Println(a, b, c)

  // 用括号来组合声明多个变量
  var (
    a1     int = 1
    b1, c1 int = 2, 3
  )
  fmt.Println(a1, b1, c1)

  // 使用:=来声明并赋值变量（只能在函数内部使用）
  d := 4
  e, f := 5, 6
  fmt.Println(d, e, f)
  
  // 声明并赋值变量
  const G = 7
  fmt.Println(d, e, f)

  // 声明枚举常量并初始化
  const (
    A0 = iota // 0
    A1        // 1
    A2        // 2
  )
  fmt.Println(A0, A1, A2)
  
  const (
    B0 = iota + 1 // 1
    B1            // 2
    B2            // 3
  )
  fmt.Println(B0, B1, B2)

  const (
    C0 = iota // 1
    _         // 2
    C2        // 3
    C3        // 4
  )
  fmt.Println(C0, C2, C3)
}

  • 使用 import 引入包

  • 不写类型会自动推断（与TS类似）

  • iota表示枚举，从0开始，只能用于const常量

  • 使用:=声明赋值的变量只能用在函数内部，用var或const声明的变量可以放在函数外部去声明

    package main

import 'fmt'

var a = 1 // ✅
const E = 4 // ✅

d := 3 // ❌

func main() {
  var b = 1 // ✅
  c := 2 // ✅
  const F = 5 // ✅
  fmt.Println(b, c, F)
}

二、函数

package main

import "fmt"

// 函数
func add(a int, b int) int {
	return a + b
}

func main() {
  fmt.Println(add(1, 2))

  // 匿名函数
  var add2 = func(a int, b int) int {
    return a + b
  }
  fmt.Println(add2(1, 2))

  add3 := func(a int, b int) int {
    return a + b
  }
  fmt.Println(add3(1, 2))

  // 立即执行函数
  result := func(a int, b int) int {
    return a + b
  }(1, 2)
  fmt.Println(result)

  // 返回两个值
  swap := func(a, b string) (string, string) {
    return b, a
  }
  a, b := swap("hello", "world")
  fmt.Println(a, b)

  // 可变参数函数
  sum := func(nums ...int) int {
    total := 0
    for _, num := range nums {
      total += num
    }
    return total
  }
  fmt.Println(sum(1, 2, 3, 4, 5))

  nums := []int{1, 2, 3, 4, 5}
  fmt.Println(sum(nums...))
}
  • func 开头定义的函数只能放在函数外面
  • 函数可以返回多个值

三、if、switch

if 语句

// if 语句
num := 9
if num < 0 {
  println(num, "is negative")
} else if num < 10 {
  println(num, "has 1 digit")
} else {
  println(num, "has multiple digits")
}

// 上面代码等价于下面，if 中可以同时使用两个表达式
if num2 := 9; num2 < 0 {
  println(num2, "is negative")
} else if num2 < 10 {
  println(num2, "has 1 digit")
} else {
  println(num2, "has multiple digits")
}
  • if 或 else if 可以接多个表达式
  • 条件语句上不用写括号

switch 语句

// switch 语句
switch num {
case 1:
	println("one")
case 2:
	println("two")
case 3:
	println("three")
default:
	println("more")
}

// 多个条件用逗号隔开
switch time.Now().Weekday() {
case time.Saturday, time.Sunday:
	println("it's the weekend")
default:
	println("it's a weekday")
}

// fallthrough 语句，漏斗
switch num {
case 1:
	println("one")
	fallthrough
case 2:
	println("two")
	fallthrough
case 3:
	println("three")
default:
	println("more")
}
  • 断点时不用写break
  • case语句中，多个条件用逗号分隔
  • 使用 fallthrough 继续执行下一个条件

四、for

for j := 1; j <= 10; j++ {
  println(j)
}

i := 1
for i <= 10 {
  println(i)
  i++
}

// while 循环，k大于3时退出循环
k := 1
for {
  if k > 3 {
    break
  }
  fmt.Println("loop", k)
  k++
}

// 无限循环
// for {
//   println("loop")
// }
  • for + 0 个表达式，相当于 JS 的 while(true)
  • for + 1 个表达式，相当于 JS 的 while(condition)
  • for + 2 个表达式，相当于 JS 的 for 循环

总结

以上是 Go 语言的基础语法，包括变量、函数、分支语句、循环语句，它们是大多数编程语言的基本构成。下篇将介绍 Go 语言中的数据类型，它与 JS 这种动态弱类型语言还是有所不同的，但又与 TS 有相似之处。