Syntax 什么';这是链接比较的最直接的方法,产生第一个非相等项?
对于具有多个可比较成员的结构,或者对于Syntax 什么';这是链接比较的最直接的方法,产生第一个非相等项?,syntax,comparison,rust,Syntax,Comparison,Rust,对于具有多个可比较成员的结构,或者对于sort\u 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 {
sort\u 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])
}
}
);
//排序a的示例:Vec,先按y排序,然后按x排序,
xy_坐标。排序依据(
|co_a,co_b|{
设ord=co_a[1].cmp(&co_b[1]);
如果ord!=std::cmp::Ordering::Equal{
作战需求
}否则{
co_a[0]。cmp(&co_b[0])
}
}
);
是否有更直接的方法来执行多个cmp
函数,其中只返回第一个不相等的结果
执行多个cmp函数,其中仅返回第一个不相等的结果
这就是元组的基本定义。创建一个函数,将您的类型转换为元组并比较:
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);
这对你的案子没有帮助,因为
多种可能性之一是在NaN
上终止程序:
xy_coords.sort_by(|a, b| {
sort_key(a).partial_cmp(&sort_key(b)).expect("Don't know how to handle NaN")
});
另见
有时,您可能不想创建一个大元组来比较将被忽略的值,因为更高优先级的值将提前退出比较 从中窃取一个页面,我们可以制作一个小型构建器,允许我们使用闭包来避免额外的工作:
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
}
}
这个答案对于问题中的例子很好,但不能直接回答问题。有时,您可能不想创建一个大元组来比较将被忽略的值,因为更高优先级的值将提前退出比较。基本上-有时避免创建用于比较的元组是合理的,问题中的方法仍然适用。@ideasman42没有直接解决问题-如果问题对性能或避免创建内容有任何评论,这可能是正确的。问题很清楚:什么是链接比较的最直接方式,产生第一个不相等项?答案非常直接。你不能因为第一次没有正确地陈述什么对你来说是重要的,就追溯改变问题的精神。我应该把这说得更清楚,我感谢你的回答。这个问题确实需要一种“执行多个cmp函数的方法”,我对这方面特别感兴趣——一种在闭包控制下保持比较逻辑的方法(在本例中)。否则我会问一个关于比较的更一般性的问题。
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);
}