go语言-基础元素与结构的使用

go基础元素与结构的使用，快速上手

编译go文件

java 复制代码

编译为可执行文件
go build +文件名.go

运行文件
./文件名

输入/输出

引用fmt库（关于输入输出的库）

输入

scanf 按照给定的格式依次读取数据（包括非法数据），不能换行输入（如果要换行需要在前面加一个scanln吸收掉回车符，就像c语言中的getchar）
scan 比scanf高级，依次读取数据，遇到回车会忽略，可以换行输入（如果要先用了scan输入，再用scanf输入的话，需要在中间加一个scanln）
scanln 类似scan，但是遇到换行（回车）立马结束输入，如果要换行输入必须用多个scanln

go 复制代码

package main
import (
	"fmt"
)
func main() {
	var a int
	var b string
	fmt.Printf("place input a: ")
	fmt.Scanf("%d  %s", &a, &b)
	i := 0
	for i < a {
		fmt.Println(i)
		i++
	}
	fmt.Println(b)
}

输出

print与println与printf

Print: 输出到控制台(不接受任何格式化，它等价于对每一个操作数都应用 %v)

go 复制代码

fmt.Print(str)

Println: 输出到控制台并换行

go 复制代码

fmt.Println(tmp)

Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量（不可以输出整形变量和整形等）

如果是使用"Print"或"Println"函数的话**，可以不需要格式化字符串。**也就是说"Print"或"Println"是已经封装好的printf，他们会帮你自动格式化这些函数会针对数据类型自动作转换。

Print函数默认将每个参数以"%v"格式输出，

Println函数则是在"Print"函数的输出基础上增加一个换

printf中的使用的格式化字符串

%v	按值的本来值输出
%+v	在 %v 基础上，对结构体字段名和值进行展开
%#v	输出 Go 语言语法格式的值
%T	输出 Go 语言语法格式的类型和值
%%	输出 % 本体
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%d	整型以十进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%U	Unicode 字符
%f	浮点数
%p	指针，十六进制方式显示

选择结构

if-else

go 复制代码

if condition1 {
    // do something 
} else if condition2 {
    // do something else    
} else {
    // catch-all or default
}

实例使用

go 复制代码

package main
import "fmt"
func main() {
	var a int = 100
	if a > 100 {
		fmt.Printf("a > 100")
	} else if a >= 50 && a <= 100 {
		fmt.Printf("a > 50 and a < 100")
	} else {
		fmt.Printf("a is nonono !!!")
	}
}

switch case

go 复制代码

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

go中的switch case 相对于 c++中的switch case 来说，

1、变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。前花括号 { 必须和 switch 关键字在同一行。

2、可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。

3、（ Go 语言使用快速的查找算法来测试 switch 条件与 case 分支的匹配情况，直到算法匹配到某个 case 或者进入 default 条件为止。）一旦成功地匹配到某个分支，在执行完相应代码后就会退出，整个 switch 代码块不需要特别使用 break 语句来表示结束。

实例代码：

go 复制代码

package main
import (
	"fmt"
)
func main() {
	var a int
	for true {
		fmt.Printf("place input a: ")
		fmt.Scanf("%d", &a)
		switch a {
		case 1, 5, 6, 7:
			fmt.Println("this is 1")
		case 2:
			fmt.Println("this is 2")
		case 3:
			fmt.Println("this is 3")
		case 4:
			fmt.Println("exit")
			return
		default:
			fmt.Println("this is not 1,2,3,4")
		}
	}
}

循环结构

go中只用一个循环关键字，for，没有while，而是使用for进行通吃。

for有四种写法，对应着不同的使用：

类c/c++中的for：

go 复制代码

for init; condition; post { }

实例代码：

go 复制代码

package main
import (
	"fmt"
)
func main() {
	var a int
	fmt.Printf("place input a: ")
	fmt.Scanf("%d", &a)
	for i := 0; i < a; i++ {
		fmt.Println(i, "\n")
	}
}

类c/c++中的while语句：

go 复制代码

for condition { }

实例代码：

go 复制代码

package main
import (
	"fmt"
)
func main() {
	var a int
	fmt.Printf("place input a: ")
	fmt.Scanf("%d", &a)
	i := 0
	for i < a {
		fmt.Println(i, "\n")
		i++
	}

}

类似while(1)

go 复制代码

for {}

for true{
}

这样将直接执行一个死循环
range 格式(主要应用在切片上，下面切片会具体讲)

go 复制代码

for key, value := range oldMap {
    newMap[key] = value
}

数组

下面是一些示例，说明在Go语言中如何声明和使用数组：

（1）声明和初始化一个数组：

go 复制代码

var a [5]int        // 声明一个长度为5的int类型数组 
a = [5]int{1, 2, 3}  // 将前三个元素初始化为1、2、3，后两个元素默认为0
b := [5]int{1, 2, 3, 4, 5} //直接初始化并赋值

（2）访问数组元素：

go 复制代码

x := a[0]    // 访问第一个元素   
a[2] = 10    // 修改第三个元素

（3）循环遍历数组：

go 复制代码

func sum(a [5]int) int {
    s := 0
    for i := 0; i < len(a); i++ {
        s += a[i]
    }
    return s
 }
x := sum([5]int{1, 2, 3, 4, 5})

（4）数组作为函数参数传递:

go 复制代码

func sum(a [5]int) int {
    s := 0
    for i := 0; i < len(a); i++ {
        s += a[i]
    }
    return s
 }
x := sum([5]int{1, 2, 3, 4, 5})

（5）多维数组：

go 复制代码

var a [3][3]int     // 声明一个3x3的二维数组*    
a[0][0] = 1         // 访问第一个元素*

函数

声明格式：

go 复制代码

func functionName(parameter1 type, parameter2 type) returnType {
    // 函数体
}

函数声明：关键字 func
functionName 代表是函数的名称，函数名由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内，函数名称不能重名。

parameter1 和 parameter2 代表是函数的参数，type 是参数的类型。参数由参数变量和参数变量的类型组成，参数变量可以省略，可以有一个参数，也可以有多个，也可以没有；多个参数之间使用,分隔；多个参数时参数变量要么全写，要么全省略；如果多个相邻参数的类型是一样的，可以只保留同一类型最后一个参数的声明

不同参数的使用

(1) 单个参数：

go 复制代码

func functionName**(parameterName parameterType) {
 // 函数体
}

这是函数接受单个参数的基本形式。parameterName是参数的名称，parameterType是参数的类型。

(2) 多个参数：

go 复制代码

func functionName(parameter1Name parameter1Type, parameter2Name parameter2Type) {
 // 函数体
}

如果函数需要接受多个参数，可以在函数声明中依次列出参数的名称和类型。

(3) 可变参数（Variadic parameters）：

go 复制代码

func functionName(parameterName ...parameterType) {
 // 函数体
}

可变参数允许函数接受不定数量的参数。在参数类型之前使用...来指示可变参数的形式。在函数体内，可变参数被当作切片类型来处理。

(4) 参数命名和类型省略：

go 复制代码

func functionName(parameter1, parameter2 int) {
 // 函数体
}

在函数定义中，如果多个参数具有相同的类型，可以省略参数类型，并在最后一个参数上指定类型。这种情况下，所有的参数都将具有相同的类型。

(5) 匿名参数：

go 复制代码

func functionName(int, string) {
 // 函数体
}

在函数定义中，如果不需要使用参数的值，可以将参数名称省略，只保留参数类型。这种形式的参数被称为匿名参数。

returnType 是函数的返回值类型。返回值由返回值变量和其变量类型组成，返回值变量可以省略，可以有一个返回值，也可以有多个，也可以没有；多个返回值必须用()包裹，并用,分隔；多个返回值时返回值变量要么全写，要么全省略。下面列举返回类型的不同定义方式：

不同返回值的使用

(1) 单个返回值：

go 复制代码

func functionName() returnType {
 // 函数体
 return value
}

这是函数返回单个值的基本形式。returnType是返回值的类型，value是要返回的具体值。

（2）多个返回值：

go 复制代码

func functionName() (returnType1, returnType2) {
 // 函数体
 return value1, value2
}

如果函数需要返回多个值，可以在函数声明中使用括号将多个返回值类型括起来，并在函数体内使用逗号分隔返回的具体值。

（3 命名返回值：

go 复制代码

func functionName() (returnValue1 returnType1, returnValue2 returnType2) {
 // 函数体
 returnValue1 = value1
 returnValue2 = value2
 return}

可以为返回值命名，通过在函数声明中为返回值指定名称和类型。在函数体内，可以直接为这些命名返回值赋值，并在最后使用return关键字返回结果。

（4）空返回值：

如果函数没有返回值，可以省略返回值的类型和具体值，只使用return关键字。

go 复制代码

func functionName() {
 // 函数体
 return}

结构体

结构体的基本方法：

go 复制代码

type MyStruct struct {
    // 结构体字段
    Field1 Type1
    变量名 + 类型
    // ...
}

基本的赋值操作

使用 var 声明变量

go 复制代码

var p1 people
p1.Name = "zq"
p1.Age = 18
p1.Address = "杭州"

使用语法糖定义变量

go 复制代码

p2 := people{
    Name: "zq",
    Age:   20,
    Address: "北京",
//变量 + ： + 数据
}

初始化结构体

go 复制代码

初始化一个结构体实例（一个结构体字面量：struct-literal）的更简短和惯用的方式如下：

    ms := &struct1{10, 15.5, "Chris"}
    // 此时ms的类型是 *struct1
或者：

    var ms struct1
    ms = struct1{10, 15.5, "Chris"}

实际应用

go 复制代码

package main
import "fmt"
type struct1 struct {
    i1  int
    f1  float32
    str string
}
func main() {
    ms := new(struct1)
    ms.i1 = 10
    ms.f1 = 15.5
    ms.str= "Chris"

    fmt.Printf("The int is: %d\n", ms.i1)
    fmt.Printf("The float is: %f\n", ms.f1)
    fmt.Printf("The string is: %s\n", ms.str)
    fmt.Println(ms)
}

切片

切片就类似与c++中的STL中vector,是一个动态数组，它长度是不固定的，可以追加元素，在追加时可能使切片的容量增大，但是需要注意的是切片是引用类型，例如：当你将一个切片赋值给另一个切片时，它们将引用同一个底层数组。如果一个切片被修改，另一个引用该底层数组的切片也会受到影响。

切片的声明

直接声明切片：

go 复制代码

var slice []T

T 是切片中元素的类型。例如，[]int 表示一个整数类型的切片，[]string 表示一个字符串类型的切片。
使用make来进行声明指定类型，长度，与容量

go 复制代码

var slice1 []type = make([]type, len，capacity)

也可以简写为
slice := make([]T, length, capacity)

对切片的基本操作

对于访问与修改元素

可以使用索引访问切片中的元素：
go 复制代码
```
a := slice[4]
```
也可以使用索引修改切片中的元素：
go 复制代码
```
slice[4] = 87
```

获取切片的长度（元素个数）：

go 复制代码

length := len(slice)

获取切片的容量（底层数组可容纳的元素个数）：

go 复制代码

capacity := cap(slice)

切片的切割：

获取原切片的一个子切片：

go 复制代码

newSlice := slice[start:end]  // 包含 start 索引，不包含 end 索引

myslice := slice[1: 5]   //得到slice[1],slice[2],slice[3],slice[4]

如果省略 start，则表示从切片的开头开始切割：

go 复制代码

newSlice := slice[:end]  // 从开头切割到 end 索引（不包含 end）

如果省略 end，则表示从切片的 start 索引开始切割到末尾：

go 复制代码

newSlice := slice[start:]  // 从 start 索引开始切割到末尾

切片的追加：

使用 append() 函数向切片末尾追加一个或多个元素：

go 复制代码

slice = append(slice, element1, element2, ...)

切片的复制：

使用 copy() 函数将一个切片的内容复制到另一个切片：

go 复制代码

copy(destSlice, srcSlice)

遍历切片：

使用 for range 循环遍历切片中的元素：

go 复制代码

for index, value := range slice {
    // 使用 index 和 value
    }

index 是一个整数类型的变量，用于表示当前元素的索引。

value 是切片中当前元素的值。

slice 是要遍历的切片。

在每次循环中，会自动得到下一个索引与值，给予index与value，这样我们就能对其进行操作了

对于其是直接赋值给了index与value的因此如果我们直接对value进行修改是不会对我们的value的值发送改变的。

如果我们要直接进行修改,直接通过索引访问到指定的元素即可

go 复制代码

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}

    for index := range numbers {
        if index == 0 {
            numbers[index] = 10
        }
    }

    fmt.Println(numbers)
}

参考

Go 语言切片(Slice) | 菜鸟教程 (runoob.com)