评论盖楼、多层菜单，递归讲解（2024版）go语言

小锟哥哥

发布于 2024-01-26 15:41:04

870

发布于 2024-01-26 15:41:04

文章被收录于专栏：GoLang全栈GoLang全栈

递归是一种强大的编程技巧，用于处理具有层次结构的数据，如多层菜单和评论盖楼。在本文中，我们将深入讨论 Go 语言中递归的实现，结合多层菜单和评论盖楼的数据结构，演示前端拿到数据后的处理方法，并关注递归的安全性及其处理方法。

友情提示：本篇文章代码较多，可以放IDE里面细细分析，可能单单看一遍不太容易理解哦。

第一章：递归的基本概念

1.1 递归的定义

递归是一种在函数内部调用自身的编程技巧，通过将问题分解为更小规模的相似子问题来解决。

1.2 递归的基本结构

在 Go 中，递归函数通常包括两部分：

基线条件（Base Case）： 递归调用停止的条件。
递归条件： 问题规模减小，递归调用自身。

package main

import "fmt"

// 递归函数示例
func countDown(n int) {
    // 基线条件
    if n <= 0 {
        return
    }

    // 递归条件
    fmt.Println(n)
    countDown(n - 1)
}

func main() {
    countDown(5)
}

第二章：多层菜单及评论盖楼数据结构的设计

2.1 多层菜单结构定义

设计一个多层菜单结构，每个菜单项包含名称和可能的子菜单项。

package main

import "fmt"

// 菜单项结构
type MenuItem struct {
    Name     string
    Children []MenuItem
}

// 打印菜单项
func printMenu(menuItem MenuItem, indent string) {
    fmt.Println(indent + menuItem.Name)

    // 递归打印子菜单项
    for _, child := range menuItem.Children {
        printMenu(child, indent+"  ")
    }
}

func main() {
    // 构建多层菜单
    menu := MenuItem{
        Name: "Root",
        Children: []MenuItem{
            {
                Name: "Item 1",
                Children: []MenuItem{
                    {Name: "Item 1.1"},
                    {Name: "Item 1.2"},
                },
            },
            {
                Name: "Item 2",
                Children: []MenuItem{
                    {Name: "Item 2.1"},
                    {Name: "Item 2.2"},
                },
            },
        },
    }

    // 打印菜单
    printMenu(menu, "")
}

2.2 评论盖楼数据结构定义

设计一个评论盖楼的数据结构，每个评论包含内容和可能的子评论。

goCopy code
package main

import "fmt"

// 评论结构
type Comment struct {
    Content  string
    Replies  []Comment
}

// 打印评论
func printComment(comment Comment, indent string) {
    fmt.Println(indent + comment.Content)

    // 递归打印子评论
    for _, reply := range comment.Replies {
        printComment(reply, indent+"  ")
    }
}

func main() {
    // 构建评论盖楼
    rootComment := Comment{
        Content: "Root Comment",
        Replies: []Comment{
            {Content: "Reply 1"},
            {Content: "Reply 2"},
            {
                Content: "Reply 3",
                Replies: []Comment{
                    {Content: "Reply 3.1"},
                    {Content: "Reply 3.2"},
                },
            },
        },
    }

    // 打印评论
    printComment(rootComment, "")
}

第三章：前端处理多层菜单及评论盖楼数据

3.1 前端接收数据

前端通过 API 获取多层菜单及评论盖楼数据，通常是 JSON 格式的数据。

多层菜单数据：

{
  "name": "Root",
  "children": [
    {
      "name": "Item 1",
      "children": [
        {"name": "Item 1.1"},
        {"name": "Item 1.2"}
      ]
    },
    {
      "name": "Item 2",
      "children": [
        {"name": "Item 2.1"},
        {"name": "Item 2.2"}
      ]
    }
  ]
}

评论盖楼数据：

{
  "content": "Root Comment",
  "replies": [
    {"content": "Reply 1"},
    {"content": "Reply 2"},
    {
      "content": "Reply 3",
      "replies": [
        {"content": "Reply 3.1"},
        {"content": "Reply 3.2"}
      ]
    }
  ]
}

3.2 前端递归处理数据

前端通过递归方式处理多层菜单及评论盖楼数据，展示或操作每个菜单项或评论。

// 处理多层菜单数据
function renderMenu(menuItem, indent) {
    console.log(indent + menuItem.name);

    // 递归渲染子菜单项
    menuItem.children.forEach(child => {
        renderMenu(child, indent + '  ');
    });
}

// 前端获取的多层菜单数据
const menuData = {
    "name": "Root",
    "children": [
        {
            "name": "Item 1",
            "children": [
                {"name": "Item 1.1"},
                {"name": "Item 1.2"}
            ]
        },
        {
            "name": "Item 2",
            "children": [
                {"name": "Item 2.1"},
                {"name": "Item 2.2"}
            ]
        }
    ]
};

// 前端渲染多层菜单
renderMenu(menuData, '');

// 处理评论盖楼数据
function renderComments(comment, indent) {
    console.log(indent + comment.content);

    // 递归渲染子评论
    comment.replies.forEach(reply => {
        renderComments(reply, indent + '  ');
    });
}

// 前端获取的评论盖楼数据
const commentData = {
    "content": "Root Comment",
    "replies": [
        {"content": "Reply 1"},
        {"content": "Reply 2"},
        {
            "content": "Reply 3",
            "replies": [
                {"content": "Reply 3.1"},
                {"content": "Reply 3.2"}
            ]
        }
    ]
};

// 前端渲染评论盖楼
renderComments(commentData, '');

第四章：递归的安全性

4.1 递归调用深度

递归调用深度过大可能导致栈溢出，因此在实际应用中需要注意递归调用深度的限制。

4.2 输入验证

在递归函数中对输入进行验证，确保输入符合预期，避免不必要的错误。

package main

import (
 "errors"
 "fmt"
)

// 验证输入是否为正整数
func validateInput(n int) error {
 if n <= 0 {
  return errors.New("输入必须为正整数")
 }
 return nil
}

// 递归函数示例
func countDown(n int) {
 // 基线条件
 if err := validateInput(n); err != nil {
  fmt.Println("错误:", err)
  return
 }

 fmt.Println(n)

 // 递归条件
 countDown(n - 1)
}

func main() {
 countDown(5)
}