在Go中对切片/数组求和的多种方法

简介: 在Go中对切片/数组求和的多种方法

在这篇文章中,你将看到在 Golang 中获得一个给定 array/slice 的总和的多种方法,你可以使用多种方法来获得 Golang 中 array/slice 的总和,例如在数组的每个索引上进行迭代循环,或者你可以使用递归方法来获得 array/slice 的总和,这取决于开发者想要获得他们给定 array/slice 的总和。


这篇文章涵盖了如何在 Golang 中使用以下方法获得 array/slice 的总和。


  • 使用 for range
  • 使用 for(i:=0;i
  • 使用 for(while)
  • 使用递归函数
  • 使用变化函数


**1. **使用 for range


for index, value := range arr {
  // do whatever
}
package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    for idx, value := range arr {
        sum += value
        fmt.Printf("idx: %d, sum: %d\n", idx, sum)
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}


如果你尝试在你的机器上运行这段代码,你会在终端看到下面提到的输出:


$ go run main.go
How to get sum of slice/array using Golang…
idx: 0, sum: 1
idx: 1, sum: 3
idx: 2, sum: 6
idx: 3, sum: 10
idx: 4, sum: 15
idx: 5, sum: 21
idx: 6, sum: 28
idx: 7, sum: 36
idx: 8, sum: 45
idx: 9, sum: 55
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55


**2. **使用 for(i:=0;i


package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    for idx := 0; idx < len(arr); idx++ {
        sum += arr[idx]
        fmt.Printf("idx: %d, sum: %d\n", idx, sum)
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}


输出:


$ go run main.go
How to get sum of slice/array using Golang…
idx: 0, sum: 1
idx: 1, sum: 3
idx: 2, sum: 6
idx: 3, sum: 10
idx: 4, sum: 15
idx: 5, sum: 21
idx: 6, sum: 28
idx: 7, sum: 36
idx: 8, sum: 45
idx: 9, sum: 55
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55


**3. **使用 for(while)


在 Golang 中,你可以用多种方式使用 for 循环,其中之一是这样的,对于使用 for while,你不需要像我们在前面的例子中那样添加任何表达式来使其停止,你需要在 for 循环中添加条件,并且需要使用 break 关键字来在条件满足时退出循环。


为了更好地理解,让我们看看代码:


package main
import (
    "fmt"
)
func sum(arr []int) int {
    sum := 0
    idx := 0
    for {
        if idx > len(arr)-1 {
            break
        }
        sum += arr[idx]
        fmt.Printf("idx: %d, sum: %d\n", idx, sum)
        idx++
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}


正如你所看到的,在 sum 函数中,我们没有在 for 关键字旁边添加任何表达式,这就是为什么它的工作或行为像 while 循环( Golang 直接没有任何 while 关键字),在 for 循环中,你可以看到首先我们添加了 break 条件,为什么我们希望我们的程序在条件满足时立即脱离循环(以避免任何冲突或代码中断)。


在我们的条件之后,我们直接做我们的工作,这个函数是用来做和的,同时每次我们也在增加 idx 值,这样我们就可以访问给定 array/slice 的另一个索引值。


运行这段代码将产生以下输出:


$ go run main.go
How to get sum of slice/array using Golang…
idx: 0, sum: 1
idx: 1, sum: 3
idx: 2, sum: 6
idx: 3, sum: 10
idx: 4, sum: 15
idx: 5, sum: 21
idx: 6, sum: 28
idx: 7, sum: 36
idx: 8, sum: 45
idx: 9, sum: 55
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55


**4. **使用递归函数


在这个模块中,我们将使用递归函数来获取给定的 array/slice 的总和,那么使用递归来获取总和的方法是什么呢,很简单,我们需要修改我们的总和函数。

  • 添加两个函数参数,第一个是 slice/array,第二个是 length。
  • 在 sum 函数中,我们需要添加条件来检查第二个参数,即长度是否小于等于0,如果为真,则返回0。
  • 在 sum 函数内部调用 sum 函数的返回时间,所以它将直接返回它在内部进行的每次迭代的总和(递归)。


package main
import (
    "fmt"
)
func sum(arr []int,n int) int {
  if n <= 0 {
    return 0
  }
    return (sum(arr, n - 1) + arr[n - 1])
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr,len(arr))
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}


输出:


$ go run main.go
How to get sum of slice/array using Golang…
slice: [1 2 3 4 5 6 7 8 9 10]
sum of slice is: 55


5. 使用变化函数

你可以使用所有提到的方法来使用变化函数,但在这篇文章中我将使用 for(while) 循环。


在上述所有函数中,你也可以使用递归,但你可能需要一个额外的变量来先存储所有元素,然后再传递 arr 和 length,所以在所有期望递归的方法中最好使用变量。


package main
import (
    "fmt"
)
func sum(arr ...int) int {
    sum := 0
    idx := 0
    for {
        if idx > len(arr)-1 {
            break
        }
        sum += arr[idx]
        fmt.Printf("idx: %d, sum: %d\n", idx, sum)
        idx++
    }
    return sum
}
func main() {
    fmt.Println("How to get sum of slice/array using Golang...")
    // slice
    arr := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    result := sum(arr...)
    fmt.Printf("slice: %v\n", arr)
    fmt.Printf("sum of slice is: %d\n", result)
}


输出:


$ go run main.go 
How to get sum of slice/array using Golang… 
idx: 0, sum: 1 
idx: 1, sum: 3 
idx: 2, sum: 6 
idx: 3, sum: 10 
idx: 4, sum: 15 
idx: 5, sum: 21 
idx: 6, sum: 28 
idx: 7, sum: 36 
idx: 8, sum: 45 
idx: 9, sum: 55 
slice: [1 2 3 4 5 6 7 8 9 10] 
sum of slice is: 55
相关文章
|
29天前
|
存储 Go 索引
go语言中数组和切片
go语言中数组和切片
40 7
|
2月前
|
Go 索引
Go语言中,遍历数组或切片
在Go语言中,遍历数组或切片
49 6
|
3月前
|
存储 前端开发 Go
Go语言中的数组
在 Go 语言中,数组是一种固定长度的、相同类型元素的序列。数组声明时长度已确定,不可改变,支持多种初始化方式,如使用 `var` 关键字、短变量声明、省略号 `...` 推断长度等。数组内存布局连续,可通过索引高效访问。遍历数组常用 `for` 循环和 `range` 关键字。
|
28天前
|
存储 Go 索引
go语言中的数组(Array)
go语言中的数组(Array)
106 67
|
1月前
|
Go 索引
go语言for遍历数组或切片
go语言for遍历数组或切片
101 62
|
2月前
|
Go 索引
go语言遍历数组和切片
go语言遍历数组和切片
22 2
|
2月前
|
存储 Go
|
2月前
|
Java Go 数据处理
go语言使用切片而非数组
【10月更文挑战第18天】
16 1
|
2月前
|
Go
|
3月前
|
存储 安全 Go
Go语言切片:从入门到精通的深度探索###
本文深入浅出地剖析了Go语言中切片(Slice)这一核心概念,从其定义、内部结构、基本操作到高级特性与最佳实践,为读者提供了一个全面而深入的理解。通过对比数组,揭示切片的灵活性与高效性,并探讨其在并发编程中的应用优势。本文旨在帮助开发者更好地掌握切片,提升Go语言编程技能。 ###