Go基础（二）

最新推荐文章于 2024-05-17 10:04:07 发布

晶凌玄夜

最新推荐文章于 2024-05-17 10:04:07 发布

阅读量432

点赞数

分类专栏： Go 文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/weixin_43755544/article/details/122949468

版权

Go 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

循环语句

for循环

一般for循环的三种形式。Go语言中没有while循环。

package main

import "fmt"

func main() {
        //第一种
        for i := 0; i <= 10; i++ {
               
        }
        //第二种，类似while循环
        for ; sum <= 10; {
                sum += sum
        }
        //第二种也可以这种形式
        for sum <= 10 {
                sum += sum
        }
        //第三种，无限for循环
        for {
            sum++ // 无限循环下去
        }
}

For-each range 循环。这种格式的循环可以对字符串、数组、切片等进行迭代输出元素：

package main
import "fmt"

func main() {
        strings := []string{"google", "runoob"}
        for i, s := range strings {
                fmt.Println(i, s)
        }

        numbers := [6]int{1, 2, 3, 5}
        for i,x:= range numbers {
                fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
        }  
}

控制语句

break

用于循环语句中跳出循环，并开始执行循环之后的语句。
break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
在多重循环中，可以用标号 label 标出想 break 的循环。

continue

Go 语言的 continue 语句有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。

goto

Go 语言的 goto 语句可以无条件地转移到过程中指定的行。
goto 语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。
但是，在结构化程序设计中一般不主张使用 goto 语句，以免造成程序流程的混乱，使理解和调试程序都产生困难。强烈不建议使用

函数

函数定义格式如下:

func function_name( [parameter list] ) [return_types] {
函数体
}

func：函数由 func 开始声明
function_name：函数名称，参数列表和返回值类型构成了函数签名。
parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
函数体：函数定义的代码集合。

示例：

/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
   /* 声明局部变量 */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result
}

函数返回多个值

示例：

package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}

func main() {
   a, b := swap("Google", "Runoob")
   fmt.Println(a, b)
}
输出结果：
Runoob Google

闭包函数

o 语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。

package main

import "fmt"

func getSequence() func() int {
   i:=0
   return func() int {
      i+=1
     return i  
   }
}

func main(){
   /* nextNumber 为一个函数，函数 i 为 0 */
   nextNumber := getSequence()  

   /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   
   /* 创建新的函数 nextNumber1，并查看结果 */
   nextNumber1 := getSequence()  
   fmt.Println(nextNumber1())
   fmt.Println(nextNumber1())
}
输出结果：
1
2
3
1
2

Go函数方法

Go 没有面向对象，而我们知道常见的 Java、C++ 等语言中，实现类的方法做法都是编译器隐式的给函数加一个 this 指针，而在 Go 里，这个 this 指针需要明确的申明出来，其实和其它语言并没有很大的区别。
示例：

package main

import (
   "fmt"  
)

/* 定义结构体 */
type Circle struct {
  radius float64
}

func main() {
  var c1 Circle
  c1.radius = 10.00
  fmt.Println("圆的面积 = ", c1.getArea())
}

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
  //c.radius 即为 Circle 类型对象中的属性
  return 3.14 * c.radius * c.radius
}

Go 语言变量作用域

局部变量：在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。
全局变量：在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。

Go语言数组

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。结构如下：
在这里插入图片描述

数组声明和初始化

声明

var variable_name [SIZE] variable_type
//例
var balance [10] float32

初始化

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
//或者
balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

//数组长度不确定
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
//或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

//如果设置了数组的长度，我们还可以通过指定下标来初始化元素
balance := [5]float32{1:2.0,3:7.0}

多维数组

声明

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type
//例
var threedim [5][10][4]int

初始化
go对格式有一定要求

//第一种方式
var a = [3][4]int {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}}

//第二种方式，}符号另起一行，但需要添加,符号
a := [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11},   /* 第三行索引为 2 */
}

//第三种方式，}在同一行
a := [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11}}   /* 第三行索引为 2 */

//go中各数组长度可以不相等
    // 创建空的二维数组
    animals := [][]string{}

    // 创建三一维数组，各数组长度不同
    row1 := []string{"fish", "shark", "eel"}
    row2 := []string{"bird"}
    row3 := []string{"lizard", "salamander"}

    // 使用 append() 函数将一维数组添加到二维数组中
    animals = append(animals, row1)
    animals = append(animals, row2)
    animals = append(animals, row3)

数组传参

//形参设定数组大小
void myFunction(param [10]int)
{
.
}
//形参未设定数组大小
void myFunction(param []int)
{
.
}

Go语言切片

定义和初始化

定义

var identifier []type
var slice1 []type = make([]type, len)
//也可以简写为
slice1 := make([]type, len)
//也可以指定容量，其中 capacity 为可选参数
make([]T, length, capacity)

初始化

//直接初始化切片，[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3，其 cap=len=3。
s :=[] int {1,2,3 } 

//初始化切片 s，是数组 arr 的引用。
s := arr[:] 

//将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片
s := arr[startIndex:endIndex] 

//默认 endIndex 时将表示一直到arr的最后一个元素。
s := arr[:endIndex]

//默认 startIndex 时将表示从 arr 的第一个元素开始。
s := arr[:endIndex] 

//通过切片 s 初始化切片 s1
s1 := s[startIndex:endIndex] 

//通过内置函数 make() 初始化切片s，[]int 标识为其元素类型为 int 的切片。
s :=make([]int,len,cap)

Go语言Map

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

定义和初始化：

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

//示例
package main

import "fmt"

func main() {
    var countryCapitalMap map[string]string /*创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap [ "France" ] = "巴黎"
    countryCapitalMap [ "Italy" ] = "罗马"
    countryCapitalMap [ "Japan" ] = "东京"
    countryCapitalMap [ "India " ] = "新德里"

    /*使用键输出地图值 */
    for country := range countryCapitalMap {
        fmt.Println(country, "首都是", countryCapitalMap [country])
    }

    /*查看元素在集合中是否存在 */
    capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(capital) */
    /*fmt.Println(ok) */
    if (ok) {
        fmt.Println("American 的首都是", capital)
    } else {
        fmt.Println("American 的首都不存在")
    }
}

Go 语言接口

Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

实例：

package main

import (
    "fmt"
)

type Phone interface {
    call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iPhone IPhone) call() {
    fmt.Println("I am iPhone, I can call you!")
}

func main() {
    var phone Phone

    phone = new(NokiaPhone)
    phone.call()

    phone = new(IPhone)
    phone.call()

}

Go 错误处理

Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
error类型是一个接口类型，这是它的定义：

type error interface {
    Error() string
}

实例：

package main

import (
    "fmt"
)

// 定义一个 DivideError 结构
type DivideError struct {
    dividee int
    divider int
}

// 实现 `error` 接口
func (de *DivideError) Error() string {
    strFormat := `
    Cannot proceed, the divider is zero.
    dividee: %d
    divider: 0
`
    return fmt.Sprintf(strFormat, de.dividee)
}

// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
    if varDivider == 0 {
            dData := DivideError{
                    dividee: varDividee,
                    divider: varDivider,
            }
            errorMsg = dData.Error()
            return
    } else {
            return varDividee / varDivider, ""
    }

}

func main() {

    // 正常情况
    if result, errorMsg := Divide(100, 10); errorMsg == "" {
            fmt.Println("100/10 = ", result)
    }
    // 当除数为零的时候会返回错误信息
    if _, errorMsg := Divide(100, 0); errorMsg != "" {
            fmt.Println("errorMsg is: ", errorMsg)
    }

}

晶凌玄夜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Go基础（二）

文章目录循环语句for循环控制语句breakcontinuegoto函数函数返回多个值闭包函数Go函数方法Go 语言变量作用域Go语言数组数组声明和初始化多维数组数组传参Go语言切片定义和初始化Go语言MapGo 语言接口Go 错误处理循环语句for循环一般for循环的三种形式。Go语言中没有while循环。package mainimport "fmt"func main() { //第一种 for i := 0; i <= 10; i++ {
复制链接

扫一扫