Hoe vergelijk ik twee strings in Perl?

Hoe vergelijk ik twee strings in Perl?

Ik ben Perl aan het leren, ik had deze basisvraag opgezocht hier op StackOverflow en vond geen goed antwoord, dus ik dacht ik vraag het.

Antwoord 1, autoriteit 100%

Zie perldoc perlop. Gebruik lt, gt, eq, neen cmpzoals van toepassing voor string vergelijkingen:

Binaire eqretourneert waar als het linkerargument stringwise gelijk is aan het rechterargument.

Binair neretourneert waar als het linkerargument stringwise niet gelijk is aan het rechterargument.

Binaire cmpretourneert -1, 0 of 1 afhankelijk van of het linkerargument stringwise kleiner is dan, gelijk aan of groter is dan het rechterargument.

Binaire ~~doet een smartmatch tussen zijn argumenten. …

lt, le, ge, gten cmpgebruiken de sortering (sorteer)volgorde gespecificeerd door de huidige locale als een legacy use locale (maar niet use locale ':not_characters') van kracht is. Zie perllocale. Combineer deze niet met Unicode, alleen met oudere binaire coderingen. De standaard Unicode::Collateen Unicode::Collate::Locale-modules bieden veel krachtigere oplossingen voor sorteerproblemen.

Antwoord 2, autoriteit 73%

• cmpVergelijk

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

• eqGelijk aan

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

• neNiet gelijk aan

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

• ltKleiner dan

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

• leKleiner dan of gelijk aan

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

• gtGroter dan

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

• geGroter dan of gelijk aan

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

Zie perldoc perlopvoor meer informatie.

( Ik vereenvoudig dit een beetje omdat alles behalve cmpeen waarde retourneert die zowel een lege tekenreeks is als een numerieke nulwaarde in plaats van 0, en een waarde die zowel de tekenreeks '1'als de numerieke waarde 1is. Dit zijn dezelfde waarden die u altijd krijgt van booleaanse operatoren in Perl. U zou eigenlijk alleen de geretourneerde waarden gebruiken voor booleaanse of numerieke bewerkingen, in welk geval het verschil er niet echt toe doet. )

Antwoord 3, autoriteit 9%

In aanvulling op de uitgebreide lijst van Sinan Ünür met stringvergelijkingsoperatoren, voegt Perl 5.10 de slimme match-operator toe.

De slimme match-operator vergelijkt twee items op basis van hun type. Zie de onderstaande grafiek voor het 5.10-gedrag (ik geloof dat dit gedrag enigszins verandert in 5.10.1):

perldoc perlsyn“Slimme matching in detail “:

Het gedrag van een slimme match hangt af van wat voor soort dingen de argumenten zijn. Het is altijd commutatief, d.w.z. $a ~~ $bgedraagt zich hetzelfde als $b ~~ $a. Het gedrag wordt bepaald door de volgende tabel: de eerste rij die van toepassing is, in willekeurige volgorde, bepaalt het wedstrijdgedrag.

$a $b Type overeenkomst Impliciete overeenkomstcode
 ====== ===== ===================== =============
 (overbelasting overtreft alles)
 Code[+] Code[+] referentiële gelijkheid $a == $b
 Elke code[+] scalaire sub waarheid $b−>($a)
 Hash Hash hash-sleutels identiek [sorteersleutels %$a]~~[sorteersleutels %$b]
 Hash Array hash slice bestaan grep {exists $a−>{$_}} @$b
 Hash Regex hash-sleutel grep grep /$b/, toetsen %$a
 Hash Elke hash-invoer bestaat $a−>{$b}
 Array Array-arrays zijn identiek[*]
 Array Regex-array grep grep /$b/, @$a
 Array Num array bevat nummer grep $_ == $b, @$a
 Array Elke array bevat string grep $_ eq $b, @$a
 Elke undef undefined !defined $a
 Elk Regex-patroon komt overeen met $a =~ /$b/
 Code() Code() resultaten zijn gelijk aan $a−>() eq $b−>()
 Elke Code() eenvoudige sluitingswaarheid $b−>() # negeer $a
 Num nuish[!] numerieke gelijkheid $a == $b
 Elke Str-tekenreeksgelijkheid $a eq $b
 Elke Num numerieke gelijkheid $a == $b
 Elke Elke tekenreeksgelijkheid $a eq $b
+ − dit moet een codereferentie zijn waarvan het prototype (indien aanwezig) niet "" is
(subs met een "" prototype worden behandeld door het item 'Code()' onderaan)
* dat wil zeggen, elk element komt overeen met het element van dezelfde index in de andere
reeks. Als er een kringverwijzing wordt gevonden, vallen we terug op referentiële
gelijkwaardigheid.
! − ofwel een reëel getal, of een tekenreeks die eruitziet als een getal

De “matching code” vertegenwoordigt natuurlijk niet de echte matching code: het is er alleen om de bedoelde betekenis uit te leggen. In tegenstelling tot grep, zal de smart match-operator kortsluiting maken wanneer hij maar kan.

Aangepaste matching via overbelasting
U kunt de manier wijzigen waarop een object wordt vergeleken door de operator ~~te overbelasten. Dit overtreft de gebruikelijke slimme match-semantiek. Zie overload.

Antwoord 4, autoriteit 5%

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

Perl heeft aparte tekenreeksvergelijkings- en numerieke vergelijkingsoperatoren om te helpen bij het losse typen in de taal. Lees perlopvoor alle verschillende operators.

Antwoord 5, autoriteit 4%

De voor de hand liggende subtekst van deze vraag is:

waarom kun je niet gewoon ==gebruiken om controleren of twee strings hetzelfde zijn?

Perl heeft geen verschillende datatypes voor tekst versus getallen. Ze worden beide vertegenwoordigd door het type “scalar”. Anders gezegd, strings zijngetallen if je gebruikt ze als zodanig.

if ( 4 == "4" ) { print "true"; } else { print "false"; }
true
if ( "4" == "4.0" ) { print "true"; } else { print "false"; }
true
print "3"+4
7

Aangezien tekst en cijfers niet worden onderscheiden door de taal, kunnen we de operator ==niet simpelweg overbelasten om in beide gevallen het juiste te doen. Daarom biedt Perl eqom waarden als tekst te vergelijken:

if ( "4" eq "4.0" ) { print "true"; } else { print "false"; }
false
if ( "4.0" eq "4.0" ) { print "true"; } else { print "false"; }
true

Kortom:

• Perl heeft geen datatype exclusief voor tekststrings
• gebruik ==of !=om twee operanden als getallen te vergelijken
• gebruik eqof neom twee operanden als tekst te vergelijken

Er zijn veel andere functies en operators die kunnen worden gebruikt om scalaire waarden te vergelijken, maar het onderscheid tussen deze twee vormen kennen is een belangrijke eerste stap.

Antwoord 6

En als je de verschillen tussen de twee strings wilt extraheren, kun je gebruiken String::Verschil.

Antwoord 7

Ik kwam op zoek naar een oplossing waarbij ik in perl kon vergelijken of A > B of Z < AA. Niets werkte hier betrouwbaar voor mij, dus kwam ik met mijn eigen oplossing. De truc is om aan elke letter een nummer toe te kennen

Bijvoorbeeld

A=1
B=2
C=3 and so on

Als het tijd is om te vergelijken als A > B krijg je de bijbehorende nummers en vergelijk je ze in dit geval 1 > 2

Hier is een werkende perl-code.

# header
use warnings;
use strict;
#create a hash of letters
my %my_hash_lookup;
my $letter_counter=0;
foreach my $letters ('A'..'ZZ')
{
    #print "$letters \n";
    $letter_counter++;
    my $key = $letters;
    my $keyValue = $letter_counter;
    $my_hash_lookup{$key}=$keyValue;
}
my $size = keys %my_hash_lookup;
print "hash size: $size ...\n";
#get number value of string letters
        my $my_hash_value1 = $my_hash_lookup{"A"};
        my $my_hash_value2 = $my_hash_lookup{"B"};
        if  ( (defined $my_hash_value1) && (defined $my_hash_value2))
        {
            if ($my_hash_value1 == $my_hash_value2)
            {
                #equal
            }
            elsif ($my_hash_value1 > $my_hash_value2)
            {
                #greater than
            }
            elsif ($my_hash_value1 < $my_hash_value2)
            {
                #less than
            }
        }