Parsing 将字符串解析为整数

所以我试图在字符串中找到一个模式，并将其转换为整数

首先，我查找字符串：

let haystack = "HTTP/1.1 200\r\n";
let needle = "HTTP/1.";

let http_location = haystack.rfind(needle);
if (http_location.is_some()) {

现在我已经找到了，我可以想出两种方法来获得数字状态。要么：

    let mut temp_str = haystack.char_at(http_location.unwrap());
    let status = String::from_str(temp_str);
}

或：

不幸的是，它们都不受欢迎（而且可能是错误的）。目前正确的做法是什么

此外，这一部分在文体上是否正确

let http_location = haystack.rfind(needle);
if (http_location.is_some())

---

句法分析是一个广泛而多样的话题。有简单的解析工具，也有高性能的解析工具和介于两者之间的一系列工具

fn main() {
    let haystack = "HTTP/1.1 200\r\n";
    let needle = "HTTP/1.";

    let z: Option<u8> = haystack.rfind(needle).and_then(|pt| {
        let after_match = &haystack[(pt + needle.len())..];
        after_match.splitn(2, " ").next()
    }).and_then(|val| {
        val.parse().ok()
    });

    println!("{:?}", z)
}

您将看到，我们有相同类型的故障模式，但结构有点不同

或者可能是使用

结果
和
的版本，试试看：

#[derive(Debug,Copy,Clone,PartialEq)]
enum Error {
    StartNotFound,
    NotANumber,
}

fn parse_it(haystack: &str) -> Result<u8, Error> {
    let needle = "HTTP/1.";
    let pt = try!(haystack.rfind(needle).ok_or(Error::StartNotFound));
    let after_match = &haystack[(pt + needle.len())..];
    let val = after_match.splitn(2, " ").next().unwrap();
    val.parse().map_err(|_| Error::NotANumber)
}

fn main() {
    println!("{:?}", parse_it("HTTP/1.1 200\r\n"));
    println!("{:?}", parse_it("HTTP/1"));
    println!("{:?}", parse_it("HTTP/1.cow"));
}

#[派生（调试、复制、克隆、部分Q）]
枚举错误{
StartNotFound，
编号，
}
fn解析它（haystack:&str）->结果{
让needle=“HTTP/1。”；
让pt=try！（haystack.rfind（needle.ok）或（Error:：StartNotFound））；
让我们在匹配后进行测试=&haystack[（pt+needle.len（））…]；
设val=after_match.splitn（2，“”）.next（）.unwrap（）；
val.parse（）.map_err（| | Error:：NotANumber）
}
fn main（）{
println！（“{：？}”，解析它（“HTTP/1.1200\r\n”）；
println！（“{：？}”，解析它（“HTTP/1”）；
println！（“{：？}”，解析它（“HTTP/1.cow”）；
}
在“生产”中是否应该这样写锈迹？它看起来非常简洁，似乎是作者在远离代码一段时间后很难理解的东西。无论如何，你能解释一下“.and_then（）”的函数和语法是什么吗？我觉得自己像是正式的文档，因为它假定我有一些函数式编程的知识，而我却没有。@andreyg beauty在旁观者的眼里，我想！您当然可以使用更多的
match
语句重写它，或者从
选项升级到
结果，然后使用
试试宏。我添加了这个和一个正则表达式示例。我不能代表整个Rust社区说话，但您肯定应该编写您能够理解的代码！每个人都知道调试的难度是编写程序的两倍。因此，如果您在编写它时尽可能聪明，您将如何调试它-
extern crate regex;

use regex::Regex;

fn main() {
    let haystack = "HTTP/1.1 200\r\n";

    let re = Regex::new(r"HTTP/1.(\d) (\d+)\r\n").unwrap();
    let captures = re.captures(haystack).unwrap();
    let version: Option<u8> = captures.at(1).and_then(|version| version.parse().ok());
    let status: Option<u8> = captures.at(2).and_then(|version| version.parse().ok());

    assert_eq!(Some(1), version);
    assert_eq!(Some(200), status);

    println!("Version: {:?}, Status: {:?}", version, status);
}

#[derive(Debug,Copy,Clone,PartialEq)]
enum Error {
    StartNotFound,
    NotANumber,
}

fn parse_it(haystack: &str) -> Result<u8, Error> {
    let needle = "HTTP/1.";
    let pt = try!(haystack.rfind(needle).ok_or(Error::StartNotFound));
    let after_match = &haystack[(pt + needle.len())..];
    let val = after_match.splitn(2, " ").next().unwrap();
    val.parse().map_err(|_| Error::NotANumber)
}

fn main() {
    println!("{:?}", parse_it("HTTP/1.1 200\r\n"));
    println!("{:?}", parse_it("HTTP/1"));
    println!("{:?}", parse_it("HTTP/1.cow"));
}