关于go:goquery的认识使用源码分析及实现原理

转载于：https://scriptrunz.com/zh-cn/…

goquery 是什么

goquery 是用 Go 实现的一个相似于 jQuery 的库，它封装了 Go 规范库 net/html 和 CSS 库 cascadia，提供了与 jQuery 相近的接口。

Go 驰名的爬虫框架 colly 就是基于 goquery 实现的。

goquery 能用来干什么

goquery 提供了与 jQuery 相近的接口，能够对爬取到的 HTML 进行过滤以取得本人想要的数据。

goquery quick start

Document 是 goquery 包的外围类之一，创立一个 Document 是应用 goquery 的第一步：

type Document struct {
    *Selection
    Url      *url.URL
    rootNode *html.Node
}

func NewDocumentFromNode(root *html.Node) *Document 
func NewDocument(url string) (*Document, error)
func NewDocumentFromReader(r io.Reader) (*Document, error)
func NewDocumentFromResponse(res *http.Response) (*Document, error)

通过源码能够晓得 Document 继承了 Selection（先不论 Selection 是什么），除此之外最重要的是rootNode，它是 HTML 的根节点，Url这个字段作用不大，在应用NewDocument和NewDocumentFromResponse时会对该字段赋值。

领有Document类后，咱们就能够利用从Selection类继承的Find函数来取得本人想要的数据，比方咱们想拿到

func TestFind(t *testing.T) {
    html := `<body>
                <div>DIV1</div>
                <div>DIV2</div>
                <span>SPAN</span>
            </body>
            `
    
    dom, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Fatalln(err)
    }

    dom.Find("div").Each(func(i int, selection *goquery.Selection) {
        fmt.Println(selection.Text())
    })
}
------------运行后果--------------
=== RUN   TestFind
DIV1
DIV2

玩转goquery.Find()

goquery 提供了大量的函数，集体认为最重要的是Find函数，把它用好了能力疾速从大量文本中筛选出咱们想要的数据，上面这一章次要展现应用Find函数的各种姿态：

查找多个标签

应用,逗号找出多个标签：

func TestMultiFind(t *testing.T) {
    html := `<body>
                <div>DIV1</div>
                <div>DIV2</div>
                <span>SPAN</span>
            </body>
            `

    dom, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Fatalln(err)
    }

    dom.Find("div,span").Each(func(i int, selection *goquery.Selection) {
        fmt.Println(selection.Text())
    })
}
------------运行后果--------------
=== RUN   TestMultiFind
DIV1
DIV2
SPAN

Id 选择器

应用#代表 Id 选择器。

func TestFind_IdSelector(t *testing.T) {
    html := `<body>
                <div id="div1">DIV1</div>
                <div>DIV2</div>
                <span>SPAN</span>
            </body>
            `

    dom, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Fatalln(err)
    }

    dom.Find("#div1").Each(func(i int, selection *goquery.Selection) {
        fmt.Println(selection.Text())
    })
}
------------运行后果--------------
=== RUN   TestFind_IdSelector
DIV1

Class 选择器

应用.代表 Class 选择器。

func TestFind_ClassSelector(t *testing.T) {
    html := `<body>
                <div>DIV1</div>
                <div class="name">DIV2</div>
                <span>SPAN</span>
            </body>
            `

    dom, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Fatalln(err)
    }

    dom.Find(".name").Each(func(i int, selection *goquery.Selection) {
        fmt.Println(selection.Text())
    })
}
------------运行后果--------------
=== RUN   TestFind_ClassSelector
DIV2

属性选择器

应用[]代表属性选择器。

func TestFind_AttributeSelector(t *testing.T) {
    html := `<body>
                <div>DIV1</div>
                <div lang="zh">DIV2</div>
                <span>SPAN</span>
            </body>
            `

    dom, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Fatalln(err)
    }

    dom.Find("div[lang]").Each(func(i int, selection *goquery.Selection) {
        fmt.Println(selection.Text())
    })
}
------------运行后果--------------
=== RUN   TestFind_AttributeSelector
DIV2

属性选择器也反对表达式过滤，比方：

func TestFind_AttributeSelector_2(t *testing.T) {
    html := `<body>
                <div>DIV1</div>
                <div lang="zh">DIV2</div>
                <div lang="en">DIV3</div>
                <span>SPAN</span>
            </body>
            `

    dom, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Fatalln(err)
    }

    dom.Find("div[lang=zh]").Each(func(i int, selection *goquery.Selection) {
        fmt.Println(selection.Text())
    })
}
------------运行后果--------------
=== RUN   TestFind_AttributeSelector_2
DIV2

选择器	阐明
Find(“div[lang]”)	筛选含有lang属性的div元素
Find(“div[lang=zh]”)	筛选lang属性为zh的div元素
Find(“div[lang!=zh]”)	筛选lang属性不等于zh的div元素
Find(“div[lang¦=zh]”)	筛选lang属性为zh或者zh-结尾的div元素
Find(“div[lang*=zh]”)	筛选lang属性蕴含zh这个字符串的div元素
Find(“div[lang~=zh]”)	筛选lang属性蕴含zh这个单词的div元素，单词以空格离开的
Find(“div[lang$=zh]”)	筛选lang属性以zh结尾的div元素，辨别大小写
Find(“div[lang^=zh]”)	筛选lang属性以zh结尾的div元素，辨别大小写

当然也能够将多个属性筛选器组合，比方：Find("div[id][lang=zh]")

子节点选择器

应用>代表子节点选择器。

func TestFind_ChildrenSelector(t *testing.T) {
    html := `<body>
                <div>DIV1</div>
                <div>DIV2</div>
                <span>SPAN</span>
            </body>
            `

    dom, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Fatalln(err)
    }

    dom.Find("body>span").Each(func(i int, selection *goquery.Selection) {
        fmt.Println(selection.Text())
    })
}
------------运行后果--------------
=== RUN   TestFind_ChildrenSelector
SPAN

此外+示意相邻，～示意共有(父节点雷同即为true)

内容过滤器

过滤文本

应用:contains($text)来过滤字符串。

func TestFind_ContentFilter_Contains(t *testing.T) {
    html := `<body>
                <div>DIV1</div>
                <div>DIV2</div>
                <span>SPAN</span>
            </body>
            `

    dom, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Fatalln(err)
    }

    dom.Find("div:contains(V2)").Each(func(i int, selection *goquery.Selection) {
        fmt.Println(selection.Text())
    })
}
------------运行后果--------------
=== RUN   TestFind_ContentFilter_Contains
DIV2

过滤节点

func TestFind_ContentFilter_Has(t *testing.T) {
    html := `<body>
                <span>SPAN1</span>
                <span>
                    SPAN2
                    <div>DIV</div>
                </span>
            </body>
            `

    dom, err := goquery.NewDocumentFromReader(strings.NewReader(html))
    if err != nil {
        log.Fatalln(err)
    }

    dom.Find("span:has(div)").Each(func(i int, selection *goquery.Selection) {
        fmt.Println(selection.Text())
    })
}
------------运行后果--------------
=== RUN   TestFind_ContentFilter_Has
SPAN2
DIV

此外，还有:first-child、:first-of-type过滤器别离能够筛选出第一个子节点、第一个同类型的子节点。

相应的:last-child、:last-of-type、:nth-child(n)、:nth-of-type(n)用法相似，不做过多解释。

goquery 源码剖析

Find函数 是 goquery 最外围的函数：

func (s *Selection) Find(selector string) *Selection {
    return pushStack(s, findWithMatcher(s.Nodes, compileMatcher(selector)))
}

Find函数 的性能由pushStack函数实现：

func pushStack(fromSel *Selection, nodes []*html.Node) *Selection {
    result := &Selection{nodes, fromSel.document, fromSel}
    return result
}

该函数就是拿着nodes参数去创立一个新的 Selection 类，构建一个 Selection 链表。

无论是函数命名pushStack，还是 Selection 类的字段都能够证实下面的判断：

type Selection struct {
    Nodes    []*html.Node
    document *Document
    prevSel  *Selection // 上一个节点的地址
}

当初焦点来到了pushStack函数的nodes参数，nodes参数是什么间接决定了咱们构建了一个怎么的链表、决定了Find函数的最终返回值，这就须要咱们钻研下findWithMatcher函数的实现：

func findWithMatcher(nodes []*html.Node, m Matcher) []*html.Node {
    return mapNodes(nodes, func(i int, n *html.Node) (result []*html.Node) {
        for c := n.FirstChild; c != nil; c = c.NextSibling {
            if c.Type == html.ElementNode {
                result = append(result, m.MatchAll(c)...)
            }
        }
        return
    })
}

findWithMatcher函数 的性能由mapNodes函数实现：

func mapNodes(nodes []*html.Node, f func(int, *html.Node) []*html.Node) (result []*html.Node) {
    set := make(map[*html.Node]bool)
    for i, n := range nodes {
        if vals := f(i, n); len(vals) > 0 {
            result = appendWithoutDuplicates(result, vals, set)
        }
    }
    return result
}

mapNodes函数把参数f的返回值[]*html.Node做去重解决，所以重点在于这个参数f func(int, *html.Node) []*html.Node的实现：

func(i int, n *html.Node) (result []*html.Node) {
    for c := n.FirstChild; c != nil; c = c.NextSibling {
        if c.Type == html.ElementNode {
            result = append(result, m.MatchAll(c)...)
        }
    }
    return
}![img.png](img.png)

函数遍历html.Node节点，并利用MatchAll函数筛选出想要的数据

type Matcher interface {
    Match(*html.Node) bool
    MatchAll(*html.Node) []*html.Node
    Filter([]*html.Node) []*html.Node
}

func compileMatcher(s string) Matcher {
    cs, err := cascadia.Compile(s)
    if err != nil {
        return invalidMatcher{}
    }
    return cs
}

MatchAll函数由Matcher接口定义，而compileMatcher(s string)恰好通过利用cascadia库返回一个Matcher实现类，其参数s就是咱们上文提到的匹配规定，比方dom.Find("div")

图解源码

应用Find函数时，goquery 做了什么：

总结

本文次要介绍了 goquery 最外围的Find函数的用法及其源码实现，其实除了Find函数，goquery 还提供了大量的函数帮忙咱们过滤数据，因为函数泛滥且没那么重要，自己就没有持续钻研，当前有机会再深入研究下。

关于go:goquery的认识使用源码分析及实现原理

goquery 是什么

goquery 能用来干什么

goquery quick start

玩转goquery.Find()

查找多个标签

Id 选择器

Class 选择器

属性选择器

子节点选择器

内容过滤器

过滤文本

过滤节点

goquery 源码剖析

图解源码

总结

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于go:goquery的认识使用源码分析及实现原理

goquery 是什么

goquery 能用来干什么

goquery quick start

玩转goquery.Find()

查找多个标签

Id 选择器

Class 选择器

属性选择器

子节点选择器

内容过滤器

过滤文本

过滤节点

goquery 源码剖析

图解源码

总结

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复