Go 中的关键字

在编程语言中，关键字是具有特殊含义的预定义单词。关键字由编程语言预先保留以执行某些预定义的操作。关键字也称为保留字或保留名称。这些单词不允许用作标识符，否则将发生会导致程序执行中断的编译时错误。
Go 编程语言中有 25 个关键字。它们如下

这些关键字可以根据其用法分为四类

让我们一一学习…

    声明关键字

声明关键字用于声明 Go 编程语言的各种元素。

• const

  在 Go 编程语言中，"const" 关键字用于声明常量值。一旦值被声明为常量值，就不能更改或重新分配新值。

  
  const CONST_NAME type = value
  
  

  
  const C
  

  打印常量变量值的示例程序

  
  
  package main
  import ("fmt")
  
  func main() {
    const A int= 1
    const B = 2
  
    fmt.Println(A)
    fmt.Println(B)
  }
  
  

  输出

  
  1
  2
  

• var

  在 Go 编程语言中，"var" 关键字用于声明变量。变量用于将值存储在计算机内存位置中。

  语法

  
  var variable_name type = value
  
  

  
  variable_name := value
  
  

  打印变量值的示例程序

  
  package main
  import ("fmt")
  
  func main() {
    var variable_1 string = "Hello" 
    var variable_2 = "World" 
    a := 5 
  
    fmt.Println(variable_1)
    fmt.Println(variable_2)
    fmt.Println(a)
  }
  
  

  输出

  
  Hello
  World
  5
  

• func

  在 Go 编程语言中，"func" 关键字用于创建（或声明）函数。在程序中，函数是执行某些特定任务的代码块。函数内的代码仅在调用函数时执行。

  语法

  
  func FunctionName() {
   //codes of statements of the function
  }
  
  

  使用函数打印消息的示例程序

  
  package main
  import ("fmt")
  
  func Fun_Msg() {
    fmt.Println(" This is a message from the function ! ")
  }
  
  func main() {
    Fun_Msg() 
  }
  
  

  输出

  
  This is a message from the function !
  

• type

  在 Go 编程语言中，"type" 关键字用于创建新类型，例如 struct（结构）、interface、pointer 等。

  语法

  
  type type_name existing_type or type_definition
  
  

  使用 struct 打印个人详细信息的示例程序

  
  package main
  import ("fmt")
  
  type Person struct {
    name string
    age int
  }
  
  func main() {
    var p1 Person
    
    p1.name = "Mary"
    p1.age = 30
  
    fmt.Println("Name: ", p1.name)
    fmt.Println("Age: ", p1.age)
  
  }
  
  

  输出

  
  Name: Mary
  Age: 30
  

  注意：在 Go 编程语言中，struct 或 structure 用于将不同类型的数据项/值组合成一个类型。

• package

  在 Go 编程语言中，"package" 关键字用于声明一个包。包用于将大型程序的相关功能组合成单个单元。使用包可以更轻松地维护和理解程序。Go 程序必须具有 "main" 包，否则它将无法编译。
  语法

  
  package package_name
  

  
   package main
  
  

• import

  在 Go 编程语言中，"import" 关键字用于将各种包链接到程序中。
  语法

  
  Import “package_name”
  
  

  示例

  
   import “fmt”
   import “ost”
  
  

复合关键字

复合类型关键字用于表示复合类型。

• chan

  在 Go 编程语言中，"chan" 关键字用于定义通道。通道是用于在 goroutines 之间通信的介质。
  语法

      
  var channel_name chan type
  
     

  示例

      
  package main
  import "fmt"
  func main() {
    
      var my_channel chan int
      fmt.Println("Value of channel: ", my_channel)
      fmt.Printf("Type of channel: %T ", my_channel)
  }  
  
     

  输出

      
  Value of channel: 
  Type of channel: chan int
  
     

• interface

  在 Go 编程语言中，"interface" 关键字用于表示一组方法签名。
  语法

      
  type name_of_interface interface{
  //methods
  }
  
     

  示例

      
  package main
  import "fmt"
  type square interface {
      sarea() float64
      sperimeter() float64
  }
  type myvalue struct {
      side float64
  }
  func (m myvalue) sarea() float64 {
      return m.side*m.side
  }
  func (m myvalue) sperimeter() float64 {
      return 4*m.side
  }
  func main() { 
      var s square
      s = myvalue{2}
      fmt.Println("Area of square :", s.sarea())
      fmt.Println("Perimeter of square:", s.sperimeter())
  }
  
     

  输出

      
  Area of square :4
  Perimeter of square:8
  
     

• map

  在 Go 编程语言中，"map" 关键字用于定义 map 类型。map 是无序键值对的集合。Map 用于执行查找、更新、删除和检索值。

      
  var map_variable = map[key_type]value_type{key1:value1, key2:value2,……..}
     

  示例

      
  package main
  import ("fmt")
  
  func main() {
    var m = map[string]string{"Name": "Joy", "breed": "Siberian Husky", "age": "2021"}
    fmt.Printf("m\t%v\n", m)
  }  

  输出

  m map[{Name: Joy age: 2021 breed: Siberian Husky]
     

• struct

  在 Go 编程语言中，"struct" 关键字用于声明结构。结构用于将不同数据类型的项/成员的集合存储在单个变量中。
  语法

      
  type struct_name struct {
    member1 datatype;
    member2 datatype;
    member3 datatype;
    member4 datatype;
   ..........
  }
  
     

  示例

      
  package main
  import ("fmt")
  
  type Employee struct {
    name string
    age int
    salary int
  }
  
  func main() {
    var emp1 Employee
    var emp2 Employee
  
    emp1.name = "Alex"
    emp1.age = 30
    emp1.salary = 10000
  
    emp2.name = "Mary"
    emp2.age = 50
    emp2.salary = 12000
  
    fmt.Println("Name: ", emp1.name)
    fmt.Println("Age: ", emp1.age)
    fmt.Println("Salary: ", emp1.salary)
    
    fmt.Println("Name: ", emp2.name)
    fmt.Println("Age: ", emp2.age)
    fmt.Println("Salary: ", emp2.salary)
  }
  
     

  输出

      
  Name: Alex
  Age:30
  Salary:10000
  Name: Mary
  Age:50
  Salary:12000
  
     

控制流

这些关键字用于控制代码的流程。它也称为决策制定，意味着代码块是根据给定条件执行的。

• if

  当给定条件为真时，"if" 关键字用于执行代码块，如果给定条件为假，则代码块将不会执行。
  语法

  
  if condition {
   //codes to be executed if the condition is true
  }
  
  

  打印两个数中较大数的示例程序

  
  package main
  import ("fmt")
  
  func main() {
    a := 10
    b := 2
    if a>b {
      fmt.Println(" The largest number is", a)
    }
  }
  
  

  输出

  
  The largest number is 10
  

• else

  当给定条件为假时，"else" 关键字与 "if" 关键字一起使用以执行另一个代码块。

  语法

  
  if condition {
   //codes to be executed if the condition is true
  } else {
  // codes to be executed if the condition is false
  }
  
  

  打印两个数中较大数的示例程序

  
  package main
  import ("fmt")
  
  func main() {
    a := 3
    b := 6
    if a>b {
      fmt.Println(" The largest number is", a)
    } else {
     fmt.Println(" The largest number is", b)
    }
  }
  
  

  输出

  
  The largest number is 6
  

• for

  "for" 关键字用于重复执行代码块，每次使用不同的值。
  语法

  
  for initialization; condition; increment/decrement {
   // codes to be executed
  }
  
  

  打印到 10 的数字的示例程序

  
  package main
  import ("fmt")
  
  func main() {
    for i:=1; i <= 10; i++ {
      fmt.Println(i)
    }
  }
  
  

  输出

  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  

• continue

  "continue" 关键字与 "for" 关键字一起使用以跳过迭代，然后继续循环中的下一个迭代。

  打印到 5 的数字并跳过一个数字的示例程序

  
  package main
  import ("fmt")
  
  func main() {
    for i:=1; i <= 5; i++ {
      if i == 2 {
        continue
      }
      fmt.Println(i)
    }
  }
  
  

  输出

  
  1
  3
  4
  5
  

• break

  "break" 关键字用于终止循环。终止循环后，将执行其余代码。

  打印到 10 的数字并在 5 之后终止循环的示例程序

  
  package main
  import ("fmt")
  
  func main() {
  
    for i:=1; i <= 10; i++ {
      if i == 6 {
        break
      }
      fmt.Println(i)
    }
  }
  
  

  输出

  
  1
  2
  3
  4
  5
  

• goto

  "goto" 关键字在函数中使用，用于在没有任何条件的情况下跳转到带标签的语句。
  语法

  
  label: statements
  …..
  ….
  goto label
  
  

  示例

  
  package main
  import "fmt"
  func main() { 
     a := 1
     LABEL: for a <= 5 {
        if a == 2 {
           a = a + 1
           goto LABEL
        }
        fmt.Printf("value of a = %d\n", a)
        a++     
     }  
  }
  
  

  输出

  
  Output:
  value of a = 1
  value of a = 3
  value of a = 4
  value of a = 5
  

• switch

  "switch" 关键字用于从多个代码块中执行一个代码块。

• case

  "case" 关键字与 "switch" 语句一起使用。在 switch 语句中，将表达式与多个 case 值进行比较。如果此表达式与 case 值匹配，则将执行与 case 关联的代码。
  语法

  
  switch expression {
   case a:
    // code of block
   case b:
    // code of block
   case c:
    // code of block
   ……………
  }
  
  

  打印月份名称的示例程序

  
  package main
  import ("fmt")
  
  func main() {
    
    month := 2
  
    switch month {
    case 1:
      fmt.Println("January")
    case 2:
      fmt.Println("February")
    case 3:
      fmt.Println("March")
    case 4:
      fmt.Println("April")
    case 5:
      fmt.Println("May")
    case 6:
      fmt.Println("June")
    case 7:
      fmt.Println("July")
    case 8:
      fmt.Println("August")
    case 9:
      fmt.Println("September")
    case 10:
      fmt.Println("October")
    case 11:
      fmt.Println("November")
    case 12:
      fmt.Println("December")  
    }
  }
  
  

  输出

  
  February
  

• default

  "default" 关键字与 "switch" 语句一起使用，用于在未找到 case 匹配时执行代码块。此关键字是可选的。
  语法

  
  switch expression {
   case a:
    // code of block
   case b:
    // code of block
   case c:
    // code of block
   ……………
  default:
   // code of block
  }
  
  

  示例程序

  
  package main
  import ("fmt")
  
  func main() {
    var day int= 8
  
    switch day {
    case 1:
      fmt.Println("Monday")
    case 2:
      fmt.Println("Tuesday")
    case 3:
      fmt.Println("Wednesday")
    case 4:
      fmt.Println("Thursday")
    case 5:
      fmt.Println("Friday")
    case 6:
      fmt.Println("Saturday")
    case 7:
      fmt.Println("Sunday")
    default:
      fmt.Println("Invalid")
    }
  }
  
  

  输出

  
  Invalid
  

• fallthrough

  "fallthrough" 关键字在 switch case 块内使用。它用于在表达式匹配当前 case 时将程序控制转移到下一个 case。

  示例程序

  
  package main
  import ("fmt")
  
  func main() {
    var day int= 5
  
    switch day {
    case 1:
      fmt.Println("Monday")
    case 2:
      fmt.Println("Tuesday")
    case 3:
      fmt.Println("Wednesday")
    case 4:
      fmt.Println("Thursday")
    case 5:
      fmt.Println("Friday")
      fallthrough
    case 6:
      fmt.Println("Saturday")
      fallthrough
    case 7:
      fmt.Println("Sunday")
    }
  }
  
  

  输出

  
  Friday
  Saturday
  Sunday
  

• range

  在 Go 编程语言中，"range" 关键字用于不同类型的数据结构以迭代所有元素。range 主要用于循环。

  示例程序

  
  package main
  import "fmt"
  func main() {
      even := [5]int{2, 4, 6, 8, 10}
      for i, item := range even {
          fmt.Printf("even[%d] = %d \n", i, item)
      }
  }
  
  

  输出

  
  even[0] = 2 
  even[1] = 4
  even[2] = 6
  even[3] = 8
  even[4] = 10
  

• return

  在 Go 编程语言中，"return" 关键字用于返回变量值。

• select

  在 Go 编程语言中，"select" 关键字用于多通道操作。select 语句类似于 switch 语句。
  语法

  
  select {
      case case1:
          // case 1...
      case case2:
          // case 2...
      case case3:
          // case 3...
      case case4:
          // case 4...
      default:
                  // default case...
  }
  
  

  示例程序

  
  package main
  import ("fmt")
   
  func g1(chanel chan int) {
      chanel <- 10
  }
   
  func g2(chanel chan int) {
      chanel <- 30
  }
   
  func main() {
   
      chanel1 := make(chan int)
      chanel2 := make(chan int)
   
      go g1(chanel1)
      go g1(chanel2)
   
      select {
      case v1 := <-chanel1:
          fmt.Println("Got: ", v1)
      case v2 := <-chanel2:
          fmt.Println("Got: ", v2)
      }
  }
  
  

  输出

  
  Got: 10
  

函数修饰符

函数修饰符关键字用于修改函数调用。

• defer

  在 Go 编程语言中，"defer" 关键字用于延迟函数或方法的执行，直到外部函数返回。
  语法

  
  //function
  defer func func_name(parameter_list Type)return_type{
  // Code
  }
  
  // Method
  defer func (receiver Type) method_name(parameter_list){
  // Code
  }
  
  defer func (parameter_list)(return_type){
  // code
  }()
  
  

  示例程序

  
  package main
  import "fmt"
  func mul(x, y int) int {
      r := x * y
      fmt.Println("Result: ", r)
      return 0
  }
  func show() {
      fmt.Println("Hello world")
  }
  func main() {
      mul(2, 5)
      defer mul(4, 3)
      show()
  }
  
  

  输出

  
  Result: 10
  Hello world
  Result: 12
  

• go

  在 Go 编程语言中，"go" 关键字用于创建 goroutines。
  语法

  
  func function_name(){
  // statements
  }
  go function_name()
  
  

  示例程序

  
  package main
  import "fmt"
    
  func display(s string) {
      for i := 0; i < 5; i++ {
          fmt.Println(s)
      }
  }
  func main() {
      go display("Welcome")
      display("hello")
  }
  
  

  输出

  
  hello
  hello
  hello
  hello
  hello