什么是最简单的链式比较方法,产生第一个不相等的方法？

Question

对于具有可以比较的多个成员的结构或者sort_by回调,将数据与优先级进行比较是很常见的.

// Example of sorting a: Vec<[f64; 2]>, sort first by y, then x,
xy_coords.sort_by(
    |co_a, co_b| {
        let ord = co_a[1].cmp(&co_b[1]);
        if ord != std::cmp::Ordering::Equal {
            ord
        } else {
            co_a[0].cmp(&co_b[0])
        }
    }
);

是否有更简单的方法来执行多个cmp函数,其中只返回第一个不相等的结果？

Answer 1

执行多个cmp函数,其中只返回第一个不相等的结果

这基本上Ord是如何为元组定义的.创建一个函数,将您的类型转换为元组并比较它们:

fn main() {
    let mut xy_coords = vec![[1, 0], [-1, -1], [0, 1]];

    fn sort_key(coord: &[i32; 2]) -> (i32, i32) {
        (coord[1], coord[0])
    }

    xy_coords.sort_by(|a, b| {
        sort_key(a).cmp(&sort_key(b))
    });
}

由于这是常见的,因此有一种方法:

xy_coords.sort_by_key(sort_key);

这对你的情况没有帮助,因为浮点没有实现Ord.

许多可能性之一是杀死该程序NaN:

xy_coords.sort_by(|a, b| {
    sort_key(a).partial_cmp(&sort_key(b)).expect("Don't know how to handle NaN")
});

也可以看看

• 在浮点数向量上使用max_by_key
• 如何在Vec of Floats上进行二进制搜索？

有时您可能不想创建一个大元组来比较将被忽略的值,因为较高优先级的值会提前退出比较.

从Guava'sComparisonChain窃取页面,我们可以创建一个小型构建器,允许我们使用闭包来避免额外的工作:

use std::cmp::Ordering;

struct OrdBuilder<T> {
    a: T,
    b: T,
    ordering: Ordering,
}

impl<T> OrdBuilder<T> {
    fn new(a: T, b: T) -> OrdBuilder<T> {
        OrdBuilder {
            a: a,
            b: b,
            ordering: Ordering::Equal,
        }
    }

    fn compare_with<F, V>(mut self, mut f: F) -> OrdBuilder<T>
        where F: for <'a> FnMut(&'a T) -> V,
              V: Ord,
    {
        if self.ordering == Ordering::Equal {
            self.ordering = f(&self.a).cmp(&f(&self.b));
        }
        self
    }

    fn finish(self) -> Ordering {
        self.ordering
    }
}

这可以像

struct Thing {
    a: u8,
}

impl Thing {
    fn b(&self) -> u8 {
        println!("I'm slow!");
        42
    }
}

fn main() {
    let a = Thing { a: 0 };
    let b = Thing { a: 1 };

    let res = OrdBuilder::new(&a, &b)
        .compare_with(|x| x.a)
        .compare_with(|x| x.b())
        .finish();

    println!("{:?}", res);
}