Rust技术问题：结构体属性访问权限与爬虫空Vec排查

在Rust中，结构体的字段默认是**私有（private）**的，只有定义该结构体的模块内部能访问，外部模块无法直接读取或修改。解决这个问题有两种常见方案，你可以根据场景选择：

方案1：将字段设为公开（pub） #

如果字段不需要额外的访问控制（比如简单的字符串、数字类型），直接用pub修饰字段即可让外部模块直接访问：

// 定义公开字段的结构体
pub struct CrawlerConfig {
    pub user_agent: String,
    pub max_depth: u32,
}

// 外部模块可以直接读写字段
fn main() {
    let mut config = CrawlerConfig {
        user_agent: "MyRustCrawler/1.0".to_string(),
        max_depth: 3,
    };
    println!("User-Agent: {}", config.user_agent);
    config.max_depth = 5;
}

方案2：提供Getter/Setter方法 #

如果需要对字段的访问做额外控制（比如只读、修改时验证合法性），可以保留字段私有，通过公开的方法暴露访问接口：

pub struct CrawlerConfig {
    user_agent: String,
    max_depth: u32,
}

impl CrawlerConfig {
    // Getter：只读访问user_agent
    pub fn user_agent(&self) -> &str {
        &self.user_agent
    }

    // Getter：只读访问max_depth
    pub fn max_depth(&self) -> u32 {
        self.max_depth
    }

    // Setter：修改max_depth时做合法性校验
    pub fn set_max_depth(&mut self, new_depth: u32) -> Result<(), String> {
        if new_depth > 10 {
            return Err("Max depth cannot exceed 10".to_string());
        }
        self.max_depth = new_depth;
        Ok(())
    }
}

// 外部模块通过方法访问字段
fn main() {
    let mut config = CrawlerConfig {
        user_agent: "MyRustCrawler/1.0".to_string(),
        max_depth: 3,
    };
    println!("User-Agent: {}", config.user_agent());
    // 合法修改
    config.set_max_depth(5).unwrap();
    // 非法修改会返回错误
    assert!(config.set_max_depth(15).is_err());
}

先直接给结论：你的问题大概率和生命周期无关——因为你返回的是Vec<String>（拥有所有权的类型），函数里的<'a>生命周期参数其实是多余的（Rust会自动推导参数引用的生命周期，且返回值和这些引用没有关联），可以直接删掉。

空向量的常见原因集中在HTML解析、URL提取或过滤逻辑上，按以下步骤排查：

1. 检查HTML解析是否成功 #

确保你正确使用html5ever解析了HTML，没有忽略解析错误。比如：

// 错误示例：忽略了解析失败的情况
let dom = parse_document(RcDom::default(), Default::default())
    .from_utf8()
    .read_from(&mut raw_html.as_bytes())
    .unwrap(); // 如果解析失败，unwrap会panic，但如果是静默失败（比如返回空DOM），就会导致后续无URL可提取

// 正确做法：显式处理错误，确认DOM有效
let dom = parse_document(RcDom::default(), Default::default())
    .from_utf8()
    .read_from(&mut raw_html.as_bytes())
    .expect("Failed to parse HTML document");

如果解析失败（比如HTML格式异常、编码错误），DOM会是空的，自然提取不到URL。

2. 检查DOM遍历逻辑是否正确 #

html5ever的RcDom需要递归遍历所有子节点才能找到所有<a>标签，常见错误包括：

• 只遍历了根节点的直接子节点，漏掉了深层嵌套的<a>；
• 判断标签名时用了大写（html5ever返回的标签名是小写的，比如"a"而不是"A"）；
• 没有正确提取href属性（属性名也是小写的"href"）。

参考正确的遍历逻辑：

use html5ever::{parse_document, rcdom::RcDom};
use markup5ever_rcdom::NodeData;
use url::Url;

fn find_urls_in_html(original_url: &Url, raw_html: String, fetched_cache: &[String]) -> Vec<String> {
    let dom = parse_document(RcDom::default(), Default::default())
        .from_utf8()
        .read_from(&mut raw_html.as_bytes())
        .expect("Failed to parse HTML");

    let mut urls = Vec::new();

    // 递归遍历所有DOM节点
    fn traverse(node: &RcDom, base_url: &Url, cache: &[String], result: &mut Vec<String>) {
        match &node.data {
            NodeData::Element { attrs, name, .. } => {
                // 只处理<a>标签
                if name.local == *"a" {
                    // 遍历所有属性找href
                    for attr in attrs.iter() {
                        if attr.name.local == *"href" {
                            let href = attr.value.as_ref();
                            // 解析相对URL为绝对URL
                            if let Ok(absolute_url) = base_url.join(href) {
                                let url_str = absolute_url.to_string();
                                // 过滤已抓取的URL
                                if !cache.contains(&url_str) {
                                    result.push(url_str);
                                }
                            }
                        }
                    }
                }
            }
            _ => {}
        }

        // 递归遍历子节点
        for child in node.children.borrow().iter() {
            traverse(child, base_url, cache, result);
        }
    }

    traverse(&dom.document, original_url, fetched_cache, &mut urls);
    urls
}

3. 检查URL过滤逻辑 #

如果fetched_cache里包含了所有提取到的URL（比如缓存初始化错误、判断条件反向），也会导致返回空向量。可以临时注释掉过滤逻辑，看是否能提取到URL，以此验证：

// 临时注释过滤逻辑，测试是否有URL被提取
// if !cache.contains(&url_str) {
    result.push(url_str);
// }

4. 检查相对URL解析 #

如果original_url是无效的，或者href是无法解析的相对路径（比如javascript:void(0)），base_url.join(href)会返回错误，导致该URL被跳过。可以在解析后打印错误日志，确认是否有解析失败的情况：

match base_url.join(href) {
    Ok(absolute_url) => {
        let url_str = absolute_url.to_string();
        if !cache.contains(&url_str) {
            result.push(url_str);
        }
    }
    Err(e) => {
        eprintln!("Failed to parse href '{}': {}", href, e);
    }
}

内容的提问来源于stack exchange，提问作者thatlittlegit