Golang如何根据值将数组拆分为多个数组
Golang如何根据值将数组拆分为多个数组 你好，我有一个这样的任务，请帮我弄清楚，需要将数组拆分成几个数组。拆分规则是：新数组的第一个元素以 101 开头，后面跟着任意数量（也可能没有）以 000 开头的其余元素。总的来说，需要根据以 101 开头的值进行拆分（101 标志着一个新数组的开始，后面跟着 000 开头的元素，然后下一个 101 又是一个新数组）。我无法理解如何正确组织迭代循环，请帮我弄清楚。
数组本身
func main() {
var rs = []string{"101 HASH", "000 HASHEDLSVALUES", "000 HASHEDPROCCVALUES", "101 NEWHASH", "000 HASHEDLSVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "101 SECNEWHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"101 NEWPROHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "101 HOPENEWHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES"}
// 如何正确地进行迭代我不明白，目前只找到了第一个匹配项
var arr []string
for i := 0; i < len(rs); i++ {
if rs[i][0] != 49 {
arr = append(arr, rs[i])
}
if rs[i+1][0] == 49 {
break
}
}
fmt.Println(arr)
}
更多关于Golang如何根据值将数组拆分为多个数组的实战教程也可以访问 https://www.itying.com/category-94-b0.html
7 回复
nezabudka:
稍微修正了你的第一段代码：
谢谢
更多关于Golang如何根据值将数组拆分为多个数组的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html
petrus:
你的问题描述得比较模糊。如果你能提供预期的输出结果，那会很有帮助。
这是你期望的输出吗？
是的，你说得对，很抱歉，我的英语还不够好，可能我在某些地方表达有误。感谢你的帮助。
你好 @n0kk 对你的第一段代码稍作修正：
var ar []string
var arr [][]string
for _, i := range rs {
if i[0] == 49 {
if len(ar) > 0 {
arr = append(arr, ar)
//fmt.Println(ar)
}
ar = append([]string{}, i)
continue
}
ar = append(ar, i)
}
arr = append(arr, ar)
//fmt.Println(ar)
你好，skillian
将步骤写出来后，我认为可以更容易地将其翻译成 Go 语言。我得说，这可能比我写出来的要简单，但我认为这是一个开始。
最后那个条件里是否应该有一个 else 分支，这一点并不完全清楚。来自 101 的数据被分配到了各个数组中，但来自 100 的数据却没有被添加到这些数组中。
var vs [][]string
for k, r := range rs {
if strings.HasPrefix(r, "101") {
sr := []string{}
for _, r2 := range rs[k] {
if strings.HasPrefix(string(r2), "101") {
continue
} else {
sr = append(sr, string(r2))
}
}
vs = append(vs, sr)
} else {
/* 这里的结果是，当执行时，所有带有 000 的数据
都被显示出来了，而我需要将这些数据分配到
包含 101 数据的数组中 */
}
}
你的值从 rs 开始，其类型为 []string。[]string 表示一个字符串的切片（序列）。如果我正确理解了你的问题，你并不希望所有结果最终都放在一个单一的字符串序列中；你可能在寻找一个字符串序列的序列，第一个“子序列”包含第一批值，第二个“子序列”包含第二批值，依此类推。
正如字符串切片的类型是 [] + string，字符串切片的切片的类型就是 [] + []string = [][]string。因此，我相信 arr 的类型应该是 [][]string，这样你就能知道子序列的起始和结束位置。
下一步，我会考虑如何用“伪代码”描述这些步骤，或者用某种假想的语言编写代码，在理清步骤后你应该能够将其“翻译”成真正的代码。我会从这样的伪代码开始：
对于 rs 中的每个元素 r：
- 如果 r 以 "101" 开头：
- 创建一个新的 []string 切片，我们将把元素放入其中
- 对于 r 之后 rs 中的每个元素 r2：
- 如果 r2 以 "101" 开头：
- 跳出这个内部循环，因为 101 意味着我们正在开始一个新的序列。
- 否则 r2 不以 101 开头，所以将 r2 追加到我们在伪代码第 3 行创建的序列中
- 将我们的 []string 切片追加到切片之切片 arr 中。
- 否则，我们位于 rs 的第一个元素，但它不以 "101" 开头。我们现在应该做什么？
将步骤写出来后，我认为可以更容易地将其翻译成 Go 语言。我得说，实际实现可能比我写出来的要简单，但我认为这是一个起点。
你的问题描述得比较模糊。如果能提供期望的输出结果，会更有帮助。
这是期望的输出吗？
["101 HASH" "000 HASHEDLSVALUES" "000 HASHEDPROCCVALUES"]
["101 NEWHASH" "000 HASHEDLSVALUES" "000 HASHEDPRVALUES" "000 HASHEDIVAVALUES"]
["101 SECNEWHASH" "000 HASHEDPRVALUES" "000 HASHEDIVAVALUES"]
["101 NEWPROHASH" "000 HASHEDPRVALUES" "000 HASHEDIVAVALUES" "000 HASHEDPRVALUES" "000 HASHEDIVAVALUES" "000 HASHEDPRVALUES" "000 HASHEDIVAVALUES"]
["101 HOPENEWHASH" "000 HASHEDPRVALUES" "000 HASHEDIVAVALUES" "000 HASHEDPRVALUES" "000 HASHEDIVAVALUES"]
package main
import (
"fmt"
"strings"
)
func subslices(slice []string) [][]string {
var ss [][]string
for _, e := range slice {
if strings.HasPrefix(e, "101") || len(ss) == 0 {
ss = append(ss, make([]string, 0, 3))
}
end := len(ss) - 1
ss[end] = append(ss[end], e)
}
return ss
}
func main() {
var rs = []string{
"101 HASH", "000 HASHEDLSVALUES", "000 HASHEDPROCCVALUES",
"101 NEWHASH", "000 HASHEDLSVALUES", "000 HASHEDPRVALUES",
"000 HASHEDIVAVALUES",
"101 SECNEWHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"101 NEWPROHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "000 HASHEDPRVALUES",
"000 HASHEDIVAVALUES",
"101 HOPENEWHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
}
for _, sub := range subslices(rs) {
fmt.Printf("%q\n", sub)
}
}
根据你的需求，可以通过以下方式实现数组拆分：
package main
import (
"fmt"
"strings"
)
func main() {
var rs = []string{"101 HASH", "000 HASHEDLSVALUES", "000 HASHEDPROCCVALUES", "101 NEWHASH", "000 HASHEDLSVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "101 SECNEWHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"101 NEWPROHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "101 HOPENEWHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES"}
var result [][]string
var currentArray []string
for _, item := range rs {
if strings.HasPrefix(item, "101") {
if currentArray != nil {
result = append(result, currentArray)
}
currentArray = []string{item}
} else if strings.HasPrefix(item, "000") && currentArray != nil {
currentArray = append(currentArray, item)
}
}
if currentArray != nil {
result = append(result, currentArray)
}
for i, arr := range result {
fmt.Printf("数组 %d: %v\n", i+1, arr)
}
}
或者使用更简洁的版本：
func splitBy101Prefix(rs []string) [][]string {
var result [][]string
var current []string
for _, s := range rs {
if len(s) >= 3 && s[:3] == "101" {
if current != nil {
result = append(result, current)
}
current = []string{s}
} else if len(s) >= 3 && s[:3] == "000" && current != nil {
current = append(current, s)
}
}
if current != nil {
result = append(result, current)
}
return result
}
func main() {
var rs = []string{"101 HASH", "000 HASHEDLSVALUES", "000 HASHEDPROCCVALUES", "101 NEWHASH", "000 HASHEDLSVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "101 SECNEWHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"101 NEWPROHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES", "101 HOPENEWHASH", "000 HASHEDPRVALUES", "000 HASHEDIVAVALUES",
"000 HASHEDPRVALUES", "000 HASHEDIVAVALUES"}
splitArrays := splitBy101Prefix(rs)
for i, arr := range splitArrays {
fmt.Printf("子数组 %d (长度: %d):\n", i+1, len(arr))
for _, item := range arr {
fmt.Printf(" %s\n", item)
}
fmt.Println()
}
}
输出结果会显示4个子数组，每个以"101"开头，后面跟着对应的"000"元素。
