Bina perangkak serentak berprestasi tinggi menggunakan Go dan Goroutines

Gunakan Go dan Goroutines untuk membina perangkak serentak berprestasi tinggi

Dalam era Internet hari ini, maklumat semakin meletup dan sejumlah besar kandungan web tersedia untuk kami semak imbas. Bagi pembangun, mendapatkan maklumat ini dan menjalankan analisis lanjut adalah tugas penting. Dan crawler ialah alat yang digunakan untuk mencapai matlamat ini. Artikel ini akan memperkenalkan cara menggunakan bahasa Go dan Goroutines untuk membina perangkak serentak berprestasi tinggi.

Bahasa Go ialah bahasa pengaturcaraan sumber terbuka yang dibangunkan oleh Google. Ia terkenal dengan sintaks minimalis dan prestasi yang berkuasa. Goroutines ialah benang ringan dalam bahasa Go yang boleh digunakan untuk melaksanakan operasi serentak.

Sebelum kita mula menulis perangkak, kita perlu menyediakan dua perpustakaan yang diperlukan: net/http dan golang.org/x/net/html. Yang pertama digunakan untuk menghantar permintaan HTTP dan menerima respons HTTP, dan yang terakhir digunakan untuk menghuraikan dokumen HTML. net/http和golang.org/x/net/html。前者用于发送HTTP请求和接收HTTP响应，后者用于解析HTML文档。

下面是一个简单的示例，演示了如何使用Go和Goroutines来编写一个并发爬虫：

package main

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

func main() {
    urls := []string{
        "https://www.example.com/page1",
        "https://www.example.com/page2",
        "https://www.example.com/page3",
    }

    results := make(chan string)

    for _, url := range urls {
        go func(url string) {
            body, err := fetch(url)
            if err != nil {
                fmt.Println(err)
                return
            }

            links := extractLinks(body)
            for _, link := range links {
                results <- link
            }
        }(url)
    }

    for i := 0; i < len(urls); i++ {
        fmt.Println(<-results)
    }
}

func fetch(url string) (string, error) {
    resp, err := http.Get(url)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return "", err
    }

    return string(body), nil
}

func extractLinks(body string) []string {
    links := []string{}
    doc, err := html.Parse(strings.NewReader(body))
    if err != nil {
        return links
    }

    var extract func(*html.Node)
    extract = func(n *html.Node) {
        if n.Type == html.ElementNode && n.Data == "a" {
            for _, attr := range n.Attr {
                if attr.Key == "href" {
                    links = append(links, attr.Val)
                    break
                }
            }
        }

        for c := n.FirstChild; c != nil; c = c.NextSibling {
            extract(c)
        }
    }

    extract(doc)
    return links
}

在上面的代码中，我们首先定义了一个urls数组，其中包含了我们要爬取的网页URL。然后，我们创建了一个results通道，用于存放爬取结果。

接下来，我们使用for循环迭代urls数组中的每个URL。在每次循环中，我们都使用go关键字来创建一个Goroutine，去并发地爬取指定的URL。在Goroutine中，我们首先调用fetch函数来发送HTTP请求并获取响应的HTML内容。之后，我们根据HTML内容调用extractLinks函数，提取其中的链接，并将它们发送到results通道中。

最后，我们使用一个for循环来从results

Berikut ialah contoh mudah yang menunjukkan cara menggunakan Go dan Goroutines untuk menulis perangkak serentak:

rrreee

Dalam kod di atas, kami mula-mula mentakrifkan tatasusunan url yang mengandungi URL web kami halaman untuk dirangkak. Kemudian, kami mencipta saluran results untuk menyimpan hasil merangkak.

Seterusnya, kami menggunakan gelung for untuk mengulang setiap URL dalam tatasusunan url. Dalam setiap gelung, kami menggunakan kata kunci go untuk mencipta Goroutine untuk merangkak URL yang ditentukan secara serentak. Dalam Goroutine, kami mula-mula memanggil fungsi fetch untuk menghantar permintaan HTTP dan mendapatkan kandungan HTML respons. Selepas itu, kami memanggil fungsi extractLinks berdasarkan kandungan HTML, mengekstrak pautan dan menghantarnya ke saluran results. 🎜🎜Akhir sekali, kami menggunakan gelung for untuk menerima hasil rangkak daripada saluran results dan mencetaknya. 🎜🎜Dengan menggunakan Goroutines, kami boleh menghantar berbilang permintaan HTTP serentak, dengan itu meningkatkan prestasi perangkak. Selain itu, operasi intensif IO seperti permintaan HTTP dan penghuraian HTML boleh dikendalikan dengan cekap menggunakan Goroutines. 🎜🎜Ringkasnya, artikel ini memperkenalkan cara menggunakan bahasa Go dan Goroutines untuk membina perangkak serentak berprestasi tinggi. Dengan menggunakan mekanisme konkurensi dengan betul, kita boleh mendapatkan dan menganalisis maklumat di Internet dengan lebih cekap. Saya harap pembaca dapat memahami dan menguasai cara menggunakan bahasa Go untuk menulis perangkak serentak berprestasi tinggi melalui kandungan artikel ini. 🎜

Atas ialah kandungan terperinci Bina perangkak serentak berprestasi tinggi menggunakan Go dan Goroutines. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!