Go语言零基础——变量、数据类型、运算符及流程控制|青训营

立德博学
99 阅读6分钟

一、变量

变量是程序中存储数据的容器，在Go语言中使用前需要先声明。声明变量的基本语法如下：

var 变量名 数据类型

例如，声明一个整数类型的变量：

var num int

上述代码声明了一个名为num的变量，类型为int。

变量声明后，我们可以给变量赋初始值。例如：

var num int = 10

在Go语言中，同一类型的变量可以同时声明多个，例如：

var a, b, c int

可以在声明多个变量的同时进行赋值,=前面的变量与=后面的值一一对应

var num,name,n = 25,"judy",6.5

也可以使用括号进行多个变量的声明和赋值

	var (
		age  = 99
		name = "tom"
	)

如果不写变量的类型，将根据=后面的值进行自动判断变量的类型

var num = "tom"

我们也可以通过:=简短声明的方式创建并初始化变量：

message := "Hello, World!"

在简短声明中，Go语言会自动推断变量的类型。

二、数据类型

Go语言提供了丰富的内置数据类型，其中包括整型、浮点型、布尔型、字符串和复合数据类型等。

image.png

1. 整型

在Go语言中，整数类型有多种，包括有符号和无符号类型。常用的整数类型有int、int8、int16、int32、int64、uint、uint8、uint16、uint32和uint64。

有符号整数类型 image.png 无符号整数类型 image.png 其它整数类型 image.png 示例：声明一个名为age的int类型变量并赋值

var age int = 28

2. 浮点型

浮点型表示带小数点的数值，常用的浮点型有float32和float64。

image.png

var pi float64 = 3.14

3. 布尔型

布尔型表示逻辑值，只有两个取值：true和false。

var isTrue bool = true

4. 字符串

字符串是一系列字符组成的序列，用双引号或反引号括起来。

var message string = "Hello, Go!"

5. 复合数据类型

Go语言中还有一些复合数据类型，例如数组、切片、映射和结构体等。

var numbers [5]int  // 数组
var names []string  // 切片
var scores map[string]int  // 映射
type Person struct {
    Name string
    Age int
}  // 结构体

三、类型转换

在Go语言中，不同类型之间的赋值需要进行类型转换。类型转换的基本语法如下：

目标类型(表达式)

例如，将一个整数转换为浮点数：

var num int = 10
var result float64 = float64(num)

需要注意的是，只能在相互兼容的类型之间进行转换。

四、运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

image.png

算术运算符

在Go语言中，常用的算术运算符有加法+、减法-、乘法*、除法/、取余%、自增++、自减--。例如：

var a, b int = 10, 5
var sum int = a + b    // 加法
var diff int = a - b   // 减法
var product int = a * b // 乘法
var quotient float64 = float64(a) / float64(b)  // 除法
var remainder int = a % b   // 取余
var result int = a++   // 相当于 result = a + 1

与Java不同的是，go语言中，自增/减运算符只能书写在变量的后面，不能写在变量的前面，--a、++a是错误的写法

关系运算符

关系运算符用于比较两个值的关系，返回布尔值true或false。常用的关系运算符有等于==、不等于!=、大于>、小于<、大于等于>=和小于等于<=。例如：

var a, b int = 10, 5
var isEqual bool = a == b         // 等于
var isNotEqual bool = a != b      // 不等于
var isGreater bool = a > b        // 大于
var isLess bool = a < b           // 小于
var isGreaterOrEqual bool = a >= b  // 大于等于
var isLessOrEqual bool = a <= b     // 小于等于

逻辑运算符

逻辑运算符用于组合多个条件，返回布尔值true或false。常用的逻辑运算符有逻辑与&&、逻辑或||和逻辑非!。例如：

var a, b int = 10, 5
var resultAnd bool = (a > 0) && (b < 10)  // 逻辑与
var resultOr bool = (a > 0) || (b < 10)    // 逻辑或
var resultNot bool = !(a > b)              // 逻辑非

赋值运算符

赋值运算符用于给变量赋值。常用的赋值运算符有=、+=、-=、*=、/=、%=等。例如：

var a int = 10
var b int = 5
a += b   // 等价于 a = a + b

其他运算符

&运算符：&操作符用于获取变量的内存地址，即取地址操作。它返回一个指向变量的指针

例如：

x := 10
p := &x // p指向变量x的内存地址

在上述示例中，变量x的内存地址可以通过&x来获取，然后将其赋值给变量p，此时p就成为指向x的指针。

*运算符： *运算符用于解引用指针，即获取指针指向的值。它可以应用于指针类型的变量。

例如：

x := 10
p := &x // p指向变量x的内存地址

fmt.Println(*p) // 输出：10

在上述示例中，通过*p可以获取指针p指向的值，即变量x的值。

除了解引用指针，*操作符还可以用于定义指针类型的变量。例如：

var p *int // 定义一个指向int类型的指针变量p

在上述示例中，p是一个指向int类型的指针变量。

需要注意的是，Go语言中的指针操作相对较为安全，不支持指针的运算和指针偏移。这是为了避免出现悬垂指针和非法内存访问的情况，从而提高代码的安全性和可靠性。

五、流程控制

流程控制是编程中非常重要的概念，它允许程序根据不同的条件执行不同的代码块。在Go语言中，我们可以使用条件语句和循环语句来实现流程控制。

条件语句

条件语句用于根据给定的条件执行相应的代码块。在Go语言中，常用的条件语句有if语句和switch语句。

if语句

if语句用于执行条件为真的代码块，如果条件为假，则跳过该代码块。基本语法如下：

if 条件 {
    // 代码块
} else if 条件 {
    // 代码块
} else {
    // 代码块
}

例如：

var num int = 10

if num > 0 {
    fmt.Println("num是正数")
} else if num < 0 {
    fmt.Println("num是负数")
} else {
    fmt.Println("num是零")
}

switch语句

switch语句用于根据不同的条件执行不同的代码块。基本语法如下：

switch 表达式 {
case 条件1:
    // 代码块1
case 条件2:
    // 代码块2
...
default:
    // 默认代码块
}

例如：

var grade string = "A"

switch grade {
case "A":
    fmt.Println("优秀")
case "B":
    fmt.Println("良好")
case "C":
    fmt.Println("及格")
default:
    fmt.Println("不及格")
}

循环语句

循环语句用于重复执行一段代码，直到满足特定条件为止。在Go语言中，常用的循环语句有for循环和range循环。

for循环

for循环用于重复执行一段代码，直到循环条件为假。基本语法有以下三种形式：

// 形式1：初始化语句; 循环条件; 后续语句
for 初始化语句; 循环条件; 后续语句 {
    // 代码块
}

// 形式2：循环条件
for 循环条件 {
    // 代码块
}

// 形式3：无限循环
for {
    // 代码块
    if 循环条件 {
        break   // 通过break语句跳出循环
    }
}

例如：

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

j := 0
for j < 5 {
    fmt.Println(j)
    j++
}

k := 0
for {
    fmt.Println(k)
    k++
    if k >= 5 {
        break
    }
}

range循环

range循环用于遍历数组、切片、映射、字符串等数据结构。基本语法如下：

for 索引, 值 := range 数据结构 {
    // 代码块
}

例如：

numbers := []int{1, 2, 3, 4, 5}

for index, value := range numbers {
    fmt.Printf("索引：%d，值：%d\n", index, value)
}

scores := map[string]int{"Alice": 90, "Bob": 80, "Cindy": 70}

for key, value := range scores {
    fmt.Printf("姓名：%s，分数：%d\n", key, value)
}

控制流程语句

在流程控制中，还有一些特殊的语句用于改变代码的执行顺序。

break语句

break语句用于跳出循环，终止当前的循环体。

for i := 0; i < 10; i++ {
    if i == 5 {
        break  // 跳出循环
    }
    fmt.Println(i)
}

continue语句

continue语句用于跳过当前循环体中剩余的代码，进入下一次循环迭代。

for i := 0; i < 10; i++ {
    if i%2 == 0 {
        continue  // 跳过当前循环迭代
    }
    fmt.Println(i)
}
avatar
文章
阅读
粉丝