在靠近用户的地方部署容器

本工程教育（EngEd）计划由科支持。

在全球范围内即时部署容器。Section是经济实惠、简单而强大的。

免费开始吧。

Golang - 编程基础知识

2020年8月6日

主题。
语言

Go是一种静态类型的程序化编程语言，其语法类似于C语言。在上一篇文章中，我们了解了Go的历史、其目的和安装。在这篇文章中，我们将探讨基本的编程概念，如变量、输入/输出、数组等。在我们开始编写程序之前，有几个概念需要牢记在心。

Go工作区

Go程序通常被保存在同一个工作区。一个工作区可能包含来自版本控制系统（如Git）的多个存储库。

这些存储库可以包含多个软件包。根据文档，Go 程序被组织成包。一个包是同一目录下的程序的集合，它们被编译在一起。

一个资源库包含一个或多个模块。一个模块是相关 Go 包的集合，它们被一起发布。一个 Go 代码库通常只包含一个模块，位于代码库的根部。

程序结构

Go程序具有以下结构。

package main

import "fmt"

func main() {
  
   fmt.Println("Hello, World!")
}

包声明。这是该程序的第一行，定义了当前包的名称名称。Package main，告诉Go，这是运行程序的起点。我们可以使用package关键字来定义程序中的包。
导入。导入语句告诉Go编译器要包括该特定包中定义的文件。在上面的例子中，我们导入的是fmt 包，该包在Go中实现了I/O功能。我们可以使用import关键字将一个特定的包导入我们的程序中。
**函数。**一个函数是一组执行特定任务的语句。主函数定义了程序的开始和结束。主函数是必须在主包中定义的。Go会自动执行主函数中的所有内容，当程序到达终点时就会退出。func关键字是用来定义函数的。

go run 命令可以用来运行go程序。该命令在终端或命令提示符上编译并执行程序。

将本教程中的所有例子复制并粘贴到一个文件中，给该文件起个名字，然后在终端上使用go run <file name> 命令运行它。

go run

组件

变量

变量是用来存储信息的，可以在程序中引用或操作。在Go中，每个变量都有一个特定的类型，它决定了变量的属性，如在内存中占用的大小、允许的操作等。数据类型的完整列表可以在这里找到。变量只能以字母或下划线开头，可以包含字母 "a-z "或 "A-Z "或数字0-9或下划线。

package main

import (
    "fmt"
)

func main() {
    var a, b int = 1, 2
    
    var c = a + b
    fmt.Println(c)

    d := 10
    fmt.Println(d)

    e := "hello"
    fmt.Println(e)
}

用户可以使用var关键字来定义单个或多个变量。可以在一行中声明多个变量，如果在没有类型的情况下初始化变量，Go会推断出变量的类型。已声明但未初始化的变量会自动初始化为零。:= 操作符是一种速记方法，在同一行中声明和初始化一个变量，编译器会自动识别变量的类型。在上面的例子中，d 和e 是用速记操作符声明的。

操作符是特殊的符号，它告诉Go对变量进行特定的数学运算。

声明变量的结构是。

var variable_name data_type(optional) = value(optional)

variable_name := value (shorthand)

关键词

关键词是由程序保留的词，因为它们有特殊的含义，用于某些内部操作。关键词是保留的，不能在程序中作为标识符使用。

Go中共有25个关键词。 go keywords

标识符

标识符是用户在程序中定义的各种组件的名称。一个标识符可以是一个变量、函数、常量、语句等的名称。

常量

常量是固定的值，只需初始化一次，在程序中的任何地方都不会被改变。const关键字用于在Go中声明一个或多个常量变量。

package main

import (
    "fmt"
)

func main() {
    const a = 100
    fmt.Println(a)

    const s string = "hello" 
    fmt.Println(s)
}

在上面的代码中，我们声明a 是一个常量。如果我们试图改变a 的值或者给它分配一个新的值，编译器会抛出一个错误。声明常量变量的结构是。

const variable_name data_type (optional) = value (optional)

条件式和控制流

条件语句是根据某些条件执行特定动作的功能，这些条件评价为真或假。请看下面的例子。

package main

import (
    "fmt"
)

func main() {

    if 3%2 == 0 {
        fmt.Println("7 is even")
    } else {
        fmt.Println("7 is odd")
    }

    if 5 > 3 {
        fmt.Println("5 is greater")
    } else if 5 < 3 {
        fmt.Println("5 is equal to three")
    } else{
        fmt.Println("5 is less than 3")
    }

}

if是一个关键字，它检查一个表达式，看它是真还是假。如果表达式评估为真，那么大括号内的语句将被执行。如果表达式是假的，则执行else部分所包含的语句。例如，if 3%2 == 0 评估为false ，因为3不能被2整除，else部分中的print语句被执行。同样地，由于5大于3，if 5 > 3 ，评估为true ，if内的打印语句被执行。

一个用户可以执行多个if-else语句，这些语句从上往下执行。只要其中一个条件为真，与之相关的语句就会被执行。这就形成了一个 "阶梯"，也叫if-else阶梯。

control flow
条件语句的基本结构。

if condition1 {
    statements executed when condition1 is true
} else if condition2 {
    statements executed when condition2 is true and condition1 is false
.
.
.
} else {
    statements executed when none of the conditions are true
}

一个if 语句可以在没有相应的else 语句的情况下使用，而一个else 语句必须总是在一个if 语句之后。else 语句不能在没有相应的if 。

if condition {
    statements
}

一个if-else块可以 "嵌套 "在另一个if-else块中，如下所示。

if condition1 {
    statements

    if condition2 {
        statements
    } else {
        statements
    }
}

循环

循环是一组重复的指令，直到满足某个条件。当用户想多次执行一个语句块时，可以使用循环。

package main

import (
    "fmt"
)

func main() {

    for i := 0; i <= 10; i++ {
        fmt.Println(i)
    }
}

一个for循环会按照指定的次数执行大括号内的所有语句。在上面的例子中，for 循环打印了从0到10的所有数字。for 循环的结构如下。

for variable declaration; condition; operation {
    statements
}

(while loop)
for condition {
    statements
}

循环只执行到条件得到满足为止。在上面的例子中，我们声明并初始化一个名为i 的变量为0，然后执行for循环，直到i 达到10的数值。递增运算符 (++) 被用来在循环的每一次迭代后递增i 的值。

Go没有while循环。然而，for循环可以作为Go中的while循环。

package main

import (
    "fmt"
)

func main() {

    i := 0
    for i <= 10 {
        fmt.Println(i)
        i++
    }
}

把它放在一起

让我们用上述概念来编写一个程序，将1到100的所有偶数相加，并打印出结果。

package main

import (
    "fmt"
)

func main() {
   
    var sum int = 0

    for i := 1; i <= 100; i++ {
  
        if i % 2 == 0 {
            sum = sum + i
        }
    }
    fmt.Println(sum)
}