Como eu comparo duas strings no Perl?

Como eu comparo duas strings no Perl?

Estou aprendendo Perl, tive essa pergunta básica pesquisada aqui no StackOverflow e não encontrei uma boa resposta, então pensei em perguntar.

Veja perldoc perlop . Use lt, gt, eq, ne, e cmpconforme apropriado para comparações de strings:

Binário eqretorna true se o argumento da esquerda for igual a string ao argumento da direita.

Binário neretorna true se o argumento da esquerda não for igual ao da direita.

Binário cmpretorna -1, 0 ou 1, dependendo se o argumento esquerdo é menor que, igual a ou maior que o argumento direito.

Binário ~~faz uma correspondência inteligente entre seus argumentos. ...

lt, le, ge, gtE cmpusar a ordem de agrupamento (ordenação) especificado pelo local atual, se uma localidade uso legado (mas não use locale ':not_characters') está em vigor. Veja perllocale . Não os misture com Unicode, apenas com codificações binárias herdadas. Os módulos Unicode :: Collate e Unicode :: Collate :: Locale padrão oferecem soluções muito mais poderosas para problemas de agrupamento.

• cmp Comparar

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

• eq Igual a

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

• ne Diferente de

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

• lt Menor que

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

• le Menos que ou igual a

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

• gt Maior que

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

• ge Melhor que ou igual a

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

Veja perldoc perloppara mais informações.

(Estou simplificando isso um pouco, pois todos cmpretornam um valor que é uma sequência vazia e um valor numericamente zero em vez de 0e um valor que é a sequência '1'e o valor numérico 1. Esses são os mesmos valores que você irá sempre obtenha operadores booleanos em Perl. Você realmente deve usar apenas os valores de retorno para operações numéricas ou booleanas; nesse caso, a diferença não importa.)

Além da lista abrangente da Sinan Ünür de operadores de comparação de strings, o Perl 5.10 adiciona o operador de correspondência inteligente.

O operador de correspondência inteligente compara dois itens com base em seu tipo. Veja o gráfico abaixo para o comportamento 5.10 (acredito que esse comportamento esteja mudando um pouco no 5.10.1):

perldoc perlsyn"Correspondência inteligente em detalhes" :

O comportamento de uma correspondência inteligente depende de que tipo de argumento são seus argumentos. É sempre comutativo, ou seja, $a ~~ $bcomporta-se da mesma forma que $b ~~ $a. O comportamento é determinado pela seguinte tabela: a primeira linha que se aplica, em qualquer ordem, determina o comportamento da correspondência.

  $ a $ b Tipo de código de correspondência implícito de correspondência
  ====== ===== ===================== =============
  (sobrecarregar supera tudo)

  Código [+] Código [+] igualdade referencial $ a == $ b   
  Qualquer código [+] sub-verdade escalar $ b -> ($ a)   

  Hash Hash hash keys idênticas [chaves de classificação% $ a] ~~ [chaves de classificação% $ b]
  Grep de existência de fatia de hash de matriz de hash {existe $ a -> {$ _}} @ $ b
  Chave de hash Regex de hash grep grep / $ b /, chaves% $ a
  Hash Existe qualquer entrada de hash $ a -> {$ b}

  Matriz Matrizes da matriz são idênticas [*]
  Matriz Regex matriz grep grep / $ b /, @ $ a
  Matriz Num array contém o número grep $ _ == $ b, @ $ a 
  Matriz Qualquer matriz contém a string grep $ _ eq $ b, @ $ a 

  Qualquer undef undefined! Definiu $ a
  Qualquer padrão Regex corresponde a $ a = ~ / $ b / 
  Os resultados do código () são iguais a $ a -> () eq $ b -> ()
  Qualquer código () simples fechamento verdade $ b -> () # ignorando $ a
  Num numish [!] Igualdade numérica $ a == $ b   
  Qualquer igualdade de string Str $ a eq $ b   
  Qualquer igualdade numérica numérica $ a == $ b   

  Qualquer Qualquer igualdade de string $ a eq $ b   

+ - deve ser uma referência de código cujo protótipo (se presente) não seja ""
(os subs com "" um protótipo são tratados pela entrada 'Code ()' abaixo) 
* - ou seja, cada elemento corresponde ao elemento do mesmo índice no outro
array. Se uma referência circular for encontrada, voltaremos ao referencial
igualdade.   
! - um número real ou uma string que se parece com um número

O "código correspondente" não representa o código correspondente real, é claro: está lá apenas para explicar o significado pretendido. Ao contrário do grep, o operador de partida inteligente irá causar um curto-circuito sempre que possível.

Correspondência personalizada via sobrecarga Você pode alterar a maneira como um objeto é correspondido sobrecarregando o ~~operador. Isso supera a semântica usual de correspondência inteligente. Veja overload.

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

O Perl possui operadores separados de comparação de caracteres e de comparação numérica para ajudar na digitação solta no idioma. Você deve ler perlop para todos os diferentes operadores.

O subtexto óbvio desta pergunta é:

por que você não pode simplesmente usar ==para verificar se duas strings são iguais?

O Perl não possui tipos de dados distintos para texto versus números. Ambos são representados pelo tipo "escalar" . Em outras palavras, cadeias são números se você as usar como tal .

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

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

print "3"+4
7

Como texto e números não são diferenciados pelo idioma, não podemos simplesmente sobrecarregar o ==operador para fazer a coisa certa nos dois casos. Portanto, o Perl fornece eqpara comparar valores como texto:

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

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

Em resumo:

• O Perl não possui um tipo de dados exclusivamente para cadeias de texto
• use ==ou !=, para comparar dois operandos como números
• use eqou nepara comparar dois operandos como texto

Existem muitas outras funções e operadores que podem ser usados ​​para comparar valores escalares, mas conhecer a distinção entre essas duas formas é um primeiro passo importante.

E se você deseja extrair as diferenças entre as duas strings, pode usar String :: Diff .