Comment comparer deux chaînes en Perl?

Question

Comment comparer deux chaînes en Perl?

J'apprends Perl, j'ai eu cette question de base sur StackOverflow et je n'ai trouvé aucune bonne réponse.

Answer 1

Voir perloc perlop . Utilisez lt , gt , eq , ne (merci Tuckster ) et cmp selon le cas.

Answer 2

• cmp Comparer

  'a' cmp 'b' # -1
  'b' cmp 'a' #  1
  'a' cmp 'a' #  0
  

• eq Égal à

  'a' eq  'b' #  0
  'b' eq  'a' #  0
  'a' eq  'a' #  1
  

• ne Non-Égal à

  'a' ne  'b' #  1
  'b' ne  'a' #  1
  'a' ne  'a' #  0
  

• lt Moins de

  'a' lt  'b' #  1
  'b' lt  'a' #  0
  'a' lt  'a' #  0
  

• le Inférieur ou égal à

  'a' le  'b' #  1
  'b' le  'a' #  0
  'a' le  'a' #  1
  

• gt De plus que

  'a' gt  'b' #  0
  'b' gt  'a' #  1
  'a' gt  'a' #  0
  

• ge Supérieure ou égale à

  'a' ge  'b' #  0
  'b' ge  'a' #  1
  'a' ge  'a' #  1
  

Voir perldoc perlop pour plus d'informations.

Answer 3

En plus de Sinan Ünür liste complète de la chaîne des opérateurs de comparaison, Perl 5.10 ajoute la smart opérateur de match.

Le smart match opérateur compare deux éléments en fonction de leur type. Voir le tableau ci-dessous pour les 5.10 comportement (je crois que ce comportement est en train de changer légèrement en 5.10.1):

perldoc perlsyn "Smart matching dans le détail":

Le comportement d'un smart match dépend de quel type de chose de ses arguments. Il est toujours commutative, c'est à dire $a ~~ $b a le même comportement que $b ~~ $a . Le comportement est déterminé par le tableau suivant: la première ligne qui s'applique, dans l'ordre, détermine le match de comportement.

 $a, $b Type de Match Implicite de Code Correspondant
 ====== ===== ===================== =============
 (surcharge l'emporte sur tout)

 Code [+] [+] référentiel de l'égalité $a == $b 
 Le Code[+] scalaire sous la vérité $b−>($a) 

 De hachage Hachage hachage clés identiques [trier les touches %$a]~~[trier les touches %$b]
 Hachage Tableau de hachage tranche existence grep {il existe $a−>{$_}} @$b
 Hachage de la Regex de la clé de hachage grep grep /$b/, keys %$un
 Hachage de hachage entrée existence existe $a−>{$b}

 Array Array tableaux sont identiques[*]
 Tableau Regex tableau grep grep /$b/, @$un
 Tableau Num tableau contient le nombre grep ($_ == $b @$un 
 Array un tableau contenant des chaînes grep ($_ eq $b @$un 

 Tout le fnud pas défini !définis $a
 Toute expression régulière pattern match $a =~ /$b/ 
 (Code) Code() les résultats sont égaux $a−>() eq $b−>()
 Aucun Code() simple fermeture de la vérité, $b−>() # ignorant $un
 Num numish[!] numérique de l'égalité $a == $b 
 Toute chaîne Str égalité $un eq $b 
 Tout Num numérique de l'égalité $a == $b 

 Toute la chaîne de l'égalité $un eq $b 

+ − ce doit être un code de référence dont le prototype (si présent) n'est pas ""
(sous-marins avec un " prototype sont traitées par le Code '()' entrée plus bas) 
* − qui est, chaque élément correspond à l'élément de même indice dans l'autre
tableau. Si une référence circulaire est trouvé, nous retombons à référentielle 
de l'égalité. 
! − soit un nombre réel ou une chaîne de caractères qui ressemble à un numéro de

Le "code de correspondance" ne représente pas le vrai code correspondant, bien sûr: il est juste là pour expliquer le sens. Contrairement à grep, la smart match, l'opérateur en court-circuit à chaque fois qu'il le peut.

De correspondance personnalisée via la surcharge Vous pouvez modifier la façon dont un objet est compensée par la surcharge de l' ~~ de l'opérateur. Cela l'emporte sur l'habitude smart match de la sémantique. Voir overload.

Answer 4

 print "Matched!\n" if ($str1 eq $str2)
 

Perl a des opérateurs de comparaison de chaînes et de comparaison de chaînes séparés pour aider à taper librement la langue. Vous devriez lire perlop pour tous les différents opérateurs.

Answer 5

Et si vous souhaitez extraire les différences entre les deux chaînes, vous pouvez utiliser String :: Diff .