golang 实现网站静态化和生成网站地图

已于 2024-05-25 11:18:56 修改
阅读量245 收藏
点赞数 3
文章标签： golang 开发语言 后端
于 2024-05-25 11:16:23 首次发布
嘎嘎淘
本文链接：https://blog.csdn.net/zhang804633234/article/details/139194560
版权

go.mod

module main

go 1.22

require golang.org/x/net v0.25.0 // indirect

main.go

package main

import (
	"bufio"
	"fmt"
	"io/ioutil"
	"main/createMap"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"regexp"
	"strings"
)

var resourceCache map[string]bool
var cacheFilePath = "resourceCache.txt"
var websitePath = "website"

func main() {
	//生成txt地图
	createMap.CreateMap("http://127.0.0.1:9090/")
	//生成xml地图
	createMap.CreateMapXml("http://127.0.0.1:9090/")
	//静态化网站
	createStatic("http://127.0.0.1:9090/sitemap.xml", false, "C:\\Users\\Administrator\\Desktop\\website", "resourceCache11.txt")
}

// 移除缓存文件的方法
func removeCacheFile() {
	err := os.Remove(cacheFilePath)
	if err != nil {
		if os.IsNotExist(err) {
			fmt.Println("缓存文件不存在:", cacheFilePath)
		} else {
			fmt.Println("移除缓存文件时出错:", err)
		}
	} else {
		fmt.Println("缓存文件已移除:", cacheFilePath)
	}
}

/*
mapUrl 网站地图文件xml格式
onlyPage 是否是单页【为true时,mapUrl为单连接】
setWebsitePath 生成的网站地址路径 默认website
setcacheFilePath 缓存下载记录文件名 默认resourceCache.txt
*/
func createStatic(mapUrl string, onlyPage bool, setWebsitePath string, setcacheFilePath string) {
	cacheFilePath = setcacheFilePath
	websitePath = setWebsitePath
	//加载缓存文件
	loadCache()
	defer saveCache()
	var urls []string
	//单页
	if onlyPage {
		urls = append(urls, mapUrl)
	} else {
		//整站
		resp, err := http.Get(mapUrl)
		if err != nil {
			fmt.Println("获取网站地图时出错:", err)
			return
		}
		defer resp.Body.Close()

		sitemapBytes, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			fmt.Println("读取网站地图时出错:", err)
			return
		}

		sitemap := string(sitemapBytes)
		urls = extractURLsFromSitemap(sitemap)
	}

	for _, url := range urls {
		staticizePage(url)
	}

	fmt.Println("网站静态化完成。")
}

func extractURLsFromSitemap(sitemap string) []string {
	var urls []string
	startTag := "<loc>"
	endTag := "</loc>"

	startIdx := strings.Index(sitemap, startTag)
	for startIdx != -1 {
		endIdx := strings.Index(sitemap[startIdx:], endTag)
		if endIdx == -1 {
			break
		}
		endIdx += startIdx

		url := sitemap[startIdx+len(startTag) : endIdx]
		urls = append(urls, url)

		startIdx = strings.Index(sitemap[endIdx:], startTag)
		if startIdx != -1 {
			startIdx += endIdx
		}
	}

	return urls
}

func staticizePage(urlStr string) {
	resp, err := http.Get(urlStr)
	if err != nil {
		fmt.Println("获取页面", urlStr, "时出错:", err)
		return
	}
	defer resp.Body.Close()

	pageBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("读取页面", urlStr, "时出错:", err)
		return
	}

	u, err := url.Parse(urlStr)
	if err != nil {
		fmt.Println("解析URL时出错:", err)
		return
	}
	path := filepath.Join(websitePath, strings.TrimPrefix(u.Path, "/"))

	if !strings.HasSuffix(path, "/") {
		path = filepath.Dir(path)
	}

	err = os.MkdirAll(path, os.ModePerm)
	if err != nil {
		fmt.Println("为", urlStr, "创建目录时出错:", err)
		return
	}

	fileName := filepath.Base(u.Path)
	filePath := filepath.Join(path, fileName)
	err = ioutil.WriteFile(filePath, pageBytes, 0644)
	if err != nil {
		fmt.Println("为", urlStr, "写入静态文件时出错:", err)
		return
	}

	fmt.Println("页面已静态化:", urlStr)

	links := extractResourceLinks(pageBytes, u)

	for _, link := range links {
		saveResource(link, websitePath)
	}
}

func extractResourceLinks(pageBytes []byte, baseURL *url.URL) []string {
	var links []string

	imgPattern := regexp.MustCompile(`(?i)src=["']([^"']+)["']`)
	cssPattern := regexp.MustCompile(`(?i)href=["']([^"']+\.(css))["']`)
	jsPattern := regexp.MustCompile(`(?i)src=["']([^"']+\.(js))["']`)
	fontPattern := regexp.MustCompile(`(?i)url\(["']?([^"')]+)\.(woff2|woff|ttf|otf)["']?\)`)
	bgPattern := regexp.MustCompile(`(?i)background(?:-image)?:\s*url\(["']?([^"')]+)["']?\)`)

	imgMatches := imgPattern.FindAllSubmatch(pageBytes, -1)
	for _, match := range imgMatches {
		links = append(links, buildAbsoluteURL(string(match[1]), baseURL))
	}

	cssMatches := cssPattern.FindAllSubmatch(pageBytes, -1)
	for _, match := range cssMatches {
		links = append(links, buildAbsoluteURL(string(match[1]), baseURL))
	}

	jsMatches := jsPattern.FindAllSubmatch(pageBytes, -1)
	for _, match := range jsMatches {
		links = append(links, buildAbsoluteURL(string(match[1]), baseURL))
	}

	fontMatches := fontPattern.FindAllSubmatch(pageBytes, -1)
	for _, match := range fontMatches {
		links = append(links, buildAbsoluteURL(string(match[1]), baseURL))
	}
	bgMatches := bgPattern.FindAllSubmatch(pageBytes, -1)
	for _, match := range bgMatches {
		links = append(links, buildAbsoluteURL(string(match[1]), baseURL))
	}
	return links
}

func buildAbsoluteURL(link string, baseURL *url.URL) string {
	u, err := url.Parse(link)
	if err != nil {
		fmt.Println("解析URL时出错:", err)
		return ""
	}
	return baseURL.ResolveReference(u).String()
}

func saveResource(link, basePath string) {
	if resourceCache[link] {
		fmt.Println("资源已下载:", link)
		return
	}

	resp, err := http.Get(link)
	if err != nil {
		fmt.Println("获取资源", link, "时出错:", err)
		return
	}
	defer resp.Body.Close()

	resourceBytes, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("读取资源", link, "时出错:", err)
		return
	}

	u, err := url.Parse(link)
	if err != nil {
		fmt.Println("解析资源URL时出错:", err)
		return
	}

	var filePath string
	if strings.Contains(link, "uploadfile") {
		uploadfile := strings.Split(link, "url=")
		filePath = filepath.Join(basePath, uploadfile[1])
	} else {
		filePath = filepath.Join(basePath, u.Path)
	}

	dirPath := filepath.Dir(filePath)
	err = os.MkdirAll(dirPath, os.ModePerm)
	if err != nil {
		fmt.Println("为资源", link, "创建目录时出错:", err)
		return
	}

	err = ioutil.WriteFile(filePath, resourceBytes, 0644)
	if err != nil {
		fmt.Println("写入资源文件", filePath, "时出错:", err)
		return
	}

	resourceCache[link] = true
	appendCache(link)

	fmt.Println("资源已保存:", link)
	// 如果是CSS文件，提取并下载背景图资源
	if strings.HasSuffix(link, ".css") {
		fmt.Println("解析css背景文件")
		extractAndSaveCSSResources(resourceBytes, u)
		fmt.Println("解析css字体文件:")
		extractAndSaveCSSResources(resourceBytes, u)
	}
}

func extractAndSaveCSSResources(cssBytes []byte, baseURL *url.URL) {
	//backackground
	bgPattern := regexp.MustCompile(`(?i)url\(["']?([^"')]+)["']?\)`)
	matches := bgPattern.FindAllSubmatch(cssBytes, -1)
	for _, match := range matches {
		resourceURL := buildAbsoluteURL(string(match[1]), baseURL)
		saveResource(resourceURL, websitePath)
	}
	//fonts
	fontPattern := regexp.MustCompile(`(?i)url\(["']?([^"')]+)\.(woff2|woff|ttf|otf)["']?\)`)
	matchesFonts := fontPattern.FindAllSubmatch(cssBytes, -1)
	for _, match := range matchesFonts {
		fontURL := buildAbsoluteURL(string(match[1]), baseURL)
		saveResource(fontURL, websitePath)
	}
}
func loadCache() {
	resourceCache = make(map[string]bool)
	file, err := os.Open(cacheFilePath)
	if err != nil {
		if !os.IsNotExist(err) {
			fmt.Println("读取缓存文件时出错:", err)
		}
		return
	}
	defer file.Close()

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		resourceCache[scanner.Text()] = true
	}
	if err := scanner.Err(); err != nil {
		fmt.Println("扫描缓存文件时出错:", err)
	}
}

func appendCache(link string) {
	file, err := os.OpenFile(cacheFilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println("打开缓存文件时出错:", err)
		return
	}
	defer file.Close()

	_, err = file.WriteString(link + "\n")
	if err != nil {
		fmt.Println("写入缓存文件时出错:", err)
	}
}

func saveCache() {
	file, err := os.Create(cacheFilePath)
	if err != nil {
		fmt.Println("创建缓存文件时出错:", err)
		return
	}
	defer file.Close()

	writer := bufio.NewWriter(file)
	for link := range resourceCache {
		_, err := writer.WriteString(link + "\n")
		if err != nil {
			fmt.Println("写入缓存文件时出错:", err)
			return
		}
	}
	writer.Flush()
}

createMap/createMap.go

package createMap

import (
	"fmt"
	"golang.org/x/net/html"
	"net/http"
	"net/url"
	"os"
	"strings"
)

func CreateMap(url string) {
	// 指定要抓取的网站地址和最大深度
	websiteURL := url
	maxDepth := 1000

	// 抓取网站所有链接
	links := crawlSite(websiteURL, websiteURL, maxDepth)

	// 生成网站地图文件
	err := generateSitemap(links, "sitemap.txt")
	if err != nil {
		fmt.Println("Error generating sitemap:", err)
		return
	}

	fmt.Println("Sitemap generated successfully.")
}

// 抓取网站所有链接
func crawlSite(currentURL, rootURL string, maxDepth int) []string {
	var links []string
	visited := make(map[string]bool)
	crawl(currentURL, rootURL, 0, maxDepth, &links, visited)
	return links
}

// 递归爬取网站链接
func crawl(currentURL, rootURL string, depth, maxDepth int, links *[]string, visited map[string]bool) {
	// 检查深度是否超过最大深度
	if depth > maxDepth {
		return
	}

	// 发起 HTTP 请求获取网页内容
	resp, err := http.Get(currentURL)
	if err != nil {
		fmt.Println("Error fetching page", currentURL, ":", err)
		return
	}
	defer resp.Body.Close()

	// 解析 HTML 内容，提取链接
	tokens := html.NewTokenizer(resp.Body)
	for {
		tokenType := tokens.Next()
		if tokenType == html.ErrorToken {
			break
		}
		token := tokens.Token()
		if tokenType == html.StartTagToken && token.Data == "a" {
			for _, attr := range token.Attr {
				if attr.Key == "href" {
					// 解析链接，确保绝对路径
					link, err := resolveURL(attr.Val, rootURL)
					if err != nil {
						continue
					}

					// 排除包含 "#" 的链接
					if !strings.Contains(link, "#") {
						// 检查链接是否已经访问过且是否为同一域名下的链接
						if !visited[link] && isSameDomain(link, rootURL) {
							*links = append(*links, link)
							visited[link] = true
							// 递归爬取链接
							crawl(link, rootURL, depth+1, maxDepth, links, visited)
						}
					}
				}
			}
		}
	}
}

// 解析链接，确保绝对路径
func resolveURL(link, rootURL string) (string, error) {
	parsedURL, err := url.Parse(link)
	if err != nil {
		return "", err
	}
	baseURL, err := url.Parse(rootURL)
	if err != nil {
		return "", err
	}
	resolvedURL := baseURL.ResolveReference(parsedURL)
	return resolvedURL.String(), nil
}

// 判断链接是否为同一域名下的链接
func isSameDomain(link, rootURL string) bool {
	parsedLink, err := url.Parse(link)
	if err != nil {
		return false
	}
	parsedRootURL, err := url.Parse(rootURL)
	if err != nil {
		return false
	}
	return parsedLink.Host == parsedRootURL.Host
}

// 生成网站地图文件
func generateSitemap(links []string, filePath string) error {
	file, err := os.Create(filePath)
	if err != nil {
		return err
	}
	defer file.Close()

	for _, link := range links {
		// 写入地图文件
		_, err := fmt.Fprintln(file, link)
		if err != nil {
			return err
		}
	}

	return nil
}

createMap/createMapXml.go

package createMap

import (
	"encoding/xml"
	"fmt"
	"golang.org/x/net/html"
	"io/ioutil"
	"net/http"
	"net/url"
	"strings"
	"time"
)

// URLSet 结构用于表示网站地图中的 urlset
type URLSet struct {
	XMLName xml.Name `xml:"urlset"`
	Xmlns   string   `xml:"xmlns,attr"`
	URLs    []URL    `xml:"url"`
}

// URL 结构用于表示网站地图中的 url
type URL struct {
	Loc        string `xml:"loc"`
	Lastmod    string `xml:"lastmod"`
	Changefreq string `xml:"changefreq"`
	Priority   string `xml:"priority"`
}

func CreateMapXml(url string) {
	// 指定要抓取的网站地址和最大深度
	websiteURL := url
	maxDepth := 1000

	// 抓取网站所有链接
	links := crawlXmlSiteXml(websiteURL, websiteURL, maxDepth)

	// 生成网站地图文件
	err := generateSitemapXml(links, "sitemap.xml")
	if err != nil {
		fmt.Println("Error generating sitemap:", err)
		return
	}

	fmt.Println("Sitemap generated successfully.")
}

// 抓取网站所有链接
func crawlXmlSiteXml(currentURL, rootURL string, maxDepth int) []string {
	var links []string
	visited := make(map[string]bool)
	crawlXml(currentURL, rootURL, 0, maxDepth, &links, visited)
	return links
}

// 递归爬取网站链接
func crawlXml(currentURL, rootURL string, depth, maxDepth int, links *[]string, visited map[string]bool) {
	// 检查深度是否超过最大深度
	if depth > maxDepth {
		return
	}

	// 发起 HTTP 请求获取网页内容
	resp, err := http.Get(currentURL)
	if err != nil {
		fmt.Println("Error fetching page", currentURL, ":", err)
		return
	}
	defer resp.Body.Close()

	// 解析 HTML 内容，提取链接
	tokens := html.NewTokenizer(resp.Body)
	for {
		tokenType := tokens.Next()
		if tokenType == html.ErrorToken {
			break
		}
		token := tokens.Token()
		if tokenType == html.StartTagToken && token.Data == "a" {
			for _, attr := range token.Attr {
				if attr.Key == "href" {
					// 解析链接，确保绝对路径
					link, err := resolveURLXml(attr.Val, rootURL)
					if err != nil {
						continue
					}

					// 排除包含 "#" 的链接
					if !strings.Contains(link, "#") {
						// 检查链接是否已经访问过且是否为同一域名下的链接
						if !visited[link] && isSameDomainXml(link, rootURL) {
							*links = append(*links, link)
							visited[link] = true
							// 递归爬取链接
							crawlXml(link, rootURL, depth+1, maxDepth, links, visited)
						}
					}
				}
			}
		}
	}
}

// 解析链接，确保绝对路径
func resolveURLXml(link, rootURL string) (string, error) {
	parsedURL, err := url.Parse(link)
	if err != nil {
		return "", err
	}
	baseURL, err := url.Parse(rootURL)
	if err != nil {
		return "", err
	}
	resolvedURL := baseURL.ResolveReference(parsedURL)
	return resolvedURL.String(), nil
}

// 判断链接是否为同一域名下的链接
func isSameDomainXml(link, rootURL string) bool {
	parsedLink, err := url.Parse(link)
	if err != nil {
		return false
	}
	parsedRootURL, err := url.Parse(rootURL)
	if err != nil {
		return false
	}
	return parsedLink.Host == parsedRootURL.Host
}

// 生成网站地图文件
func generateSitemapXml(links []string, filePath string) error {
	var urls []URL

	for _, link := range links {
		urls = append(urls, URL{
			Loc:        link,
			Lastmod:    time.Now().Format("2006-01-02"),
			Changefreq: "always",
			Priority:   "1.0",
		})
	}

	urlSet := URLSet{
		Xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9",
		URLs:  urls,
	}

	xmlData, err := xml.MarshalIndent(urlSet, "", "    ")
	if err != nil {
		return err
	}

	err = ioutil.WriteFile(filePath, xmlData, 0644)
	if err != nil {
		return err
	}

	return nil
}

资源文件url网站地图-静态化网站

凄凉山谷的风 OL
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Golang面试题一（基础）
qq_22321199的专栏
04-14 988
CSP 理论最初由计算机科学家 Tony Hoare 在1978年提出，其核心思想是通过独立的并发实体（processes）通过严格的通信机制来协同工作，而不是直接共享内存。GoroutineGoroutine 是 Go 语言中实现并发编程的核心概念。它是一种轻量级的线程（或称协程），由Go 运行时（runtime）管理，而非操作系统直接调度。相比于传统的操作系统的线程，它是一种用户态线程，具有更低的创建和上下文切换开销，使得编写高并发、高性能的应用程序变得更加容易和高效。2.如何停止 Goroutine。
golang基础
weixin_44337108的博客
07-11 638
GOlang 基本知识 写在前面 语法、 标准库、第三方库、构件体系和工具链 GOlang 最主要的特性： 自动垃圾回收 更丰富的内置类型 函数多返回值 错误处理 匿名函数和闭包 类型和接口 并发编程 反射 语言交互性 为了简化设计，不支持函数重载和操作符重载 为了避免在 C/C++ 开发中的一些 Bug 和混乱，不支持隐式转换 Go 语言通过另一种途径实现面向对象设计（第 10-11 章）来放弃类和类型的继承 尽管在接口的使用方面（第 11 章）可以实现类似变体类型的功能，但本身不支持变体类型 不支持动
golang 返回html页面,golang在指定的路由返回静态html文件
weixin_28992423的博客
06-03 1051
如果所有静态文件位于同一树下，则可以使用http.FileServer：http.Handle("/s/", http.StripPrefix("/s/", http.FileServer(http.Dir("/path/to/static/files/"))))否则，将您想要的html文件预先加载到func init()中的地图中，然后根据请求的路径为fmt.Fprint创建一个处理程序。简单静...
Golang 开源项目2024年初盘点
jeansboy的专栏
01-02 1390
作为一名程序员， 我平时非常关注关于Go, Python, Java, C#和Javascript相关的一些开源项目， 这里我整理了一份目前最受欢迎的一些Golang开源项目
Golang笔记
怨行客
10-18 415
协程是用户态轻量级线程协程是线程调度的基本单位通常在函数前加上go关键字就能实现并发。一个Goroutine会以一个很小的栈启动2KB或4KB，当遇到栈空间不足时，栈会自动伸缩， 因此可以轻易实现成千上万个goroutine同时启动。
golang简介_Golang简介
weixin_26755331的博客
09-26 498
golang简介This post intends to be an introduction to the Go programming language, also known as Golang. 本文旨在对Go编程语言(也称为Golang)进行介绍。 免责声明 (Disclaimer) I’m not an expert in Go. In fact, I’ve started lea...
使用gridsome和strapi搭建静态站点
yhzzy的博客
10-27 724
文章内容输出来源：拉勾教育前端高薪训练营 什么是静态网站生成器 静态网站生成器是使用一系列配置、模板以及数据，生成静态HTML文件及相关资源的工具 这个功能也叫预渲染 生成的网站不需要类似PHP这样的服务器 只需要放在支持静态资源的Web Server或CDN上即可运行 静态网站的好处 省钱，不需要专业的服务器，只要能托管静态文件的空间即可 快速，不经过后端服务器的处理，只传输内容 安全，没有后端程序执行，自然会更安全 常见的静态网站生成器 Jekyll（Ruby） Hexo (Node) H.
Go语言自学系列 | 高效golang开发
COCO_gsta的博客
04-25 2057
视频来源：B站《golang入门到项目实战 [2021最新Go语言教程，没有废话，纯干货！持续更新中...]》 一边学习一边整理老师的课程内容及试验笔记，并与大家分享，侵权即删，谢谢支持！ 附上汇总贴：Go语言自学系列 | 汇总_COCOgsta的博客-CSDN博客 介绍 Go 是一种新语言。虽然它借鉴了现有语言的思想，但它具有不同寻常的特性，使有效的 Go 程序在特性上不同于用它的亲戚编写的程序。将 C++ 或 Java 程序直接翻译成 Go 不太可能产生令人满意的结果——Java 程序是用 Ja
Golang教程笔记
S_ZaiJiangHu的博客
03-21 821
第一个go程序 package main import "fmt" func main() { // notice { 不能在单独的行上 fmt.Println("Hello," + " World!") //当语句不在一行时 不需要行分隔符； go语言连接符为+ } 运行和编译 方法1：编译二进制文件执行 $ go build hello.go //命令行 $ ./hello //命令行 Hello, World! //结果 方法2： $ go run hello.go 第一行代码
golang 实现生成网站地图，和静态化网站功能
05-25
golang 实现生成网站地图，和静态化网站功能
avro-golang-compiler:golang 的 Avro 代码生成器
05-31
Avro C 绑定如果您使用带有嵌入记录的地图，请确保应用了此否则您将获得空指针异常用法使用 maven 使用以下命令构建包 mvn clean package dependency:copy-dependencies有一个静态java类可以用来生成golang代码。...
sitemap:用于去的站点地图生成器
06-01
标题 "sitemap:用于网站...通过学习以上知识，并结合提供的压缩包文件“sitemap-master”，开发者可以深入了解这个特定的Golang站点地图生成器的实现细节，对其进行定制、改进或者作为学习Go语言和网站优化的实践项目。
LaGrueCendree：像素艺术世界地图程序生成器
02-05
Go语言，又称为Golang，是由Google开发的一种静态类型、编译型、并发型且具有垃圾回收功能的编程语言，因其高效和简洁的语法而受到广大开发者的欢迎。通过运行这个命令，用户可以启动LaGrueCendree程序，并将生成的...
blog-generator：我的博客的静态博客生成器，网址为https：zupzup.org
02-04
产品特点清单网站地图生成器RSS订阅代码突出显示封存可配置的静态页面标签基于文件的配置安装go get github.com/zupzup/blog-generator使用和定制组态可以使用名为bloggen.yml的配置文件来配置该工具。 存储库中有一...
sitemap.xml生成（go语言版）
lsjweiyi的博客
06-25 314
遍历一个文件夹及其子目录下的html文件，生成sitemap.xml。
Go 语言特定指南
美味小鱼的杂货铺
06-25 846
本指南将向您展示如何使用 Docker 创建、测试和部署容器化的 Go 应用程序。
Java程序员学习Go开发Higress的WASM插件
最新发布
BothSavage
06-26 765
tinygo@0.32+go@1.19无法在macos arm架构下打包。升级go@1.21再次打包提示unsafe.SliceData requires go1.20 or later。后放弃macos+arm，采用ubuntu+amd64打包，ubuntu打包也必须使用tinygo@0.28.1。0.32.0在ubuntu仍然提示unsupported GOOS/GOARCH pair wasip1/wasm。
golang实现三数之和
03-31
以下是Golang实现三数之和的示例代码： ``` func threeSum(nums []int) [][]int { sort.Ints(nums) // 对数组进行排序 var result [][]int for i := 0; i < len(nums)-2; i++ { // 如果当前数字与前一个数字相同，则跳过 if i > 0 && nums[i] == nums[i-1] { continue } // 定义左右指针 left, right := i+1, len(nums)-1 for left < right { sum := nums[i] + nums[left] + nums[right] if sum == 0 { // 如果找到了符合条件的三元组，则将其添加到结果中 result = append(result, []int{nums[i], nums[left], nums[right]}) // 左右指针都需要移动，但不能重复 left++ for left < right && nums[left] == nums[left-1] { left++ } right-- for left < right && nums[right] == nums[right+1] { right-- } } else if sum < 0 { // 如果和小于0，则左指针向右移动 left++ } else { // 如果和大于0，则右指针向左移动 right-- } } } return result } ``` 使用方法： ``` nums := []int{-1, 0, 1, 2, -1, -4} result := threeSum(nums) fmt.Println(result) // [[-1 -1 2] [-1 0 1]] ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值