Quand l'opérateur de vaisseau spatial utilisé en dehors d'une sorte?

Question

Ceci est une question des meilleures pratiques.

Je ne l'ai vu à l'opérateur de vaisseau spatial Perl (<=>) utilisé dans les routines de tri numérique. Mais il semble utile dans d'autres situations. Je ne peux pas penser à une utilisation pratique.

Quelqu'un peut-il me donner un exemple de quand il pourrait être utilisé en dehors d'une sorte Perl?

Answer 1

J'écris un système de contrôle pour robot de Joe qui veut aller au robot de Mary et la recharger. Ils se déplacent le long des points entiers sur la ligne. Joe commence à j $ et peut marcher 1 mètre dans toutes les directions par unité de temps. Marie se tient toujours à $ m et ne peut pas bouger - elle a besoin d'une bonne recharge! Le programme de contrôle ressemblerait que:

while ($m != $j) {
    $j += ($m <=> $j);
}

Answer 2

L'opérateur <=> serait utile pour un algorithme de recherche binaire . La plupart des langages de programmation ne sont pas un opérateur qui fait une comparaison à trois voies qui rend nécessaire de faire deux comparaisons par itération. Avec <=> vous pouvez le faire seul.

sub binary_search {
    my $value = shift;
    my $array = shift;
    my $low   = 0;
    my $high  = $#$array;

    while ($low <= $high) {
        my $mid = $low + int(($high - $low) / 2);

        given ($array->[$mid] <=> $value) {
            when (-1) { $low  = $mid + 1 }
            when ( 1) { $high = $mid - 1 }
            when ( 0) { return $mid      }
        }
    }

    return;
}

Answer 3

Dans toute sorte de méthode de comparaison. Par exemple, vous pourriez avoir un objet complexe, mais a encore un « ordre » défini, vous pouvez donc définir une fonction de comparaison pour elle (que vous ne faites Vous à utiliser dans une méthode de tri, bien qu'il serait être à portée de main):

package Foo;

# ... other stuff...

# Note: this is a class function, not a method
sub cmp
{
    my $object1 = shift;
    my $object2 = shift;

    my $compare1 = sprintf("%04d%04d%04d", $object1->{field1}, $object1->{field2}, $object1->{field3});
    my $compare2 = sprintf("%04d%04d%04d", $object2->{field1}, $object2->{field2}, $object2->{field3});
    return $compare1 <=> $compare2;
}

Ceci est un exemple tout à fait artificiel bien sûr. Cependant, je trouve presque dans le code source de mon entreprise exactement ce qui précède, pour comparer les objets utilisés pour contenir des informations de date et l'heure.

Un autre usage que je peux penser est pour l'analyse statistique - si une valeur est exécutée de manière répétée à une liste de valeurs, vous pouvez dire si la valeur est supérieure ou inférieure à la médiane arithmétique de l'ensemble:

use List::Util qw(sum);
# $result will be
#   -1 if value is lower than the median of @setOfValues,
#    1 if value is higher than the median of @setOfValues,
#    0 if value is equal to the median
my $result = sum(map { $value <=> $_ } @setOfValues);

Voici une autre, de wikipedia : « Si les deux arguments ne peuvent pas être comparés (par exemple l'un d'eux est NaN), l'opérateur retourne undef « . à-dire que vous pouvez déterminer si deux nombres sont aa nombre à la fois, bien que personnellement je vais pour le moins cryptique Scalar :: Util :: looks_like_number.