¿Cómo comparo dos cadenas en Perl?

¿Cómo comparo dos cadenas en Perl?

Estoy aprendiendo Perl, tuve esta pregunta básica buscada aquí en StackOverflow y no encontré una buena respuesta, así que pensé en preguntar.

Ver perldoc perlop . Use lt , gt , eq , ne y cmp según corresponda para las comparaciones de cadenas:

Binary eq devuelve true si el argumento de la izquierda es stringwise igual al argumento de la derecha.

Binario ne devuelve verdadero si el argumento de la izquierda es de cadena no es igual al argumento de la derecha.

El cmp binario devuelve -1, 0 o 1, dependiendo de si el argumento de la izquierda es cadena menos, igual o mayor que el argumento de la derecha.

Binary ~~ hace una SmartCatch entre sus argumentos. …

lt , le , ge , gt y cmp usan el orden de intercalación (clasificación) especificado por la configuración regional actual si una configuración regional de uso heredada (pero no use locale ':not_characters' ) está en vigor. Ver perllocale . No mezcle estos con Unicode, solo con codificaciones binarias heredadas. Los módulos estándar Unicode :: Collate y Unicode :: Collate :: Locale ofrecen soluciones mucho más potentes a problemas de intercalación.

  • 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 No igual a

     'a' ne 'b' # 1 'b' ne 'a' # 1 'a' ne 'a' # 0 
  • Menos de

     'a' lt 'b' # 1 'b' lt 'a' # 0 'a' lt 'a' # 0 
  • le Menor que o igual a

     'a' le 'b' # 1 'b' le 'a' # 0 'a' le 'a' # 1 
  • gt Mayor que

     'a' gt 'b' # 0 'b' gt 'a' # 1 'a' gt 'a' # 0 
  • ge Mayor o igual a

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

Ver perldoc perlop para más información.

(Estoy simplificando esto un poco, ya que todos menos cmp devuelven un valor que es tanto una cadena vacía como un valor numérico cero en lugar de 0 , y un valor que es tanto la cadena '1' como el valor numérico 1 . son los mismos valores que siempre obtendrás de operadores booleanos en Perl. En realidad, solo deberías estar utilizando los valores de retorno para operaciones booleanas o numéricas, en cuyo caso la diferencia en realidad no importa).

Además de la completa lista de operadores de comparación de cadenas de Sinan Ünür, Perl 5.10 agrega el operador de coincidencia inteligente.

El operador de coincidencia inteligente compara dos elementos según su tipo. Consulte la tabla siguiente para conocer el comportamiento de 5.10 (creo que este comportamiento está cambiando ligeramente en 5.10.1):

perldoc perlsyn “Smart matching en detalle” :

El comportamiento de una coincidencia inteligente depende de qué tipo de cosa sean sus argumentos. Siempre es conmutativa, es decir, $a ~~ $b comporta igual que $b ~~ $a . El comportamiento está determinado por la siguiente tabla: la primera fila que se aplica, en cualquier orden, determina el comportamiento de coincidencia.

   $ a $ b Tipo de coincidencia Código de coincidencia implícita
   =========== ===============================
   (la sobrecarga lo supera todo)

   Código [+] Código [+] igualdad referencial $ a == $ b   
   Cualquier código [+] escalar sub verdad $ b -> ($ a)   

   Hash Hash hash keys idénticas [claves de clasificación% $ a] ~~ [claves de clasificación% $ b]
   Hash Array hash slice existence grep {existe $ a -> {$ _}} @ $ b
   Hash Regex tecla hash grep grep / $ b /, teclas% $ a
   Hash Cualquier existencia de entrada hash existe $ a -> {$ b}

   Array Array Array son idénticos [*]
   Array Regex array grep grep / $ b /, @ $ a
   La matriz Array Num contiene el número grep $ _ == $ b, @ $ a 
   Array Cualquier array contiene string grep $ _ eq $ b, @ $ a 

   Cualquier undef undefined! Define $ a
   Cualquier patrón Regex coincide con $ a = ~ / $ b / 
   Los resultados de Code () Code () son iguales $ a -> () eq $ b -> ()
   Cualquier código () cierre simple verdad $ b -> () # ignorando $ a
   Num numish [!] Igualdad numérica $ a == $ b   
   Cualquier Str string igualdad $ a eq $ b   
   Cualquier Num igualdad numérica $ a == $ b   

   Cualquiera Cualquier cadena de igualdad $ a eq $ b   

 + - debe ser una referencia de código cuyo prototipo (si está presente) no es ""
 (los subs con un prototipo "" se tratan con la entrada 'Código ()' más abajo) 
 * - es decir, cada elemento coincide con el elemento del mismo índice en el otro
 formación.  Si se encuentra una referencia circular, volvemos a referencia 
 igualdad.   
 !  - un número real o una cadena que se parece a un número

El “código coincidente” no representa el código de coincidencia real, por supuesto: está allí para explicar el significado previsto. A diferencia de grep, el operador de coincidencia inteligente se cortocircuitará siempre que sea posible.

Coincidencia personalizada mediante sobrecarga Puede cambiar la forma en que se combina un objeto al sobrecargar el operador ~~ . Esto supera la semántica de coincidencia inteligente habitual. Ver overload .

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

Perl tiene operadores de comparación numérica y de comparación de cadenas independientes para ayudar con la escritura suelta en el idioma. Debería leer perlop para todos los operadores diferentes.

El subtexto obvio de esta pregunta es:

¿Por qué no puedes simplemente usar == para verificar si dos cadenas son iguales?

Perl no tiene tipos de datos distintos para texto vs. números. Ambos están representados por el tipo “escalar” . Dicho de otra manera, las cadenas son números si los usa como tales .

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

Dado que el texto y los números no se diferencian por el idioma, no podemos simplemente sobrecargar al operador == para hacer lo correcto en ambos casos. Por lo tanto, Perl proporciona eq para 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 

En breve:

  • Perl no tiene un tipo de datos exclusivo para cadenas de texto
  • use == o != , para comparar dos operandos como números
  • use eq o ne , para comparar dos operandos como texto

Hay muchas otras funciones y operadores que se pueden usar para comparar valores escalares, pero conocer la distinción entre estas dos formas es un primer paso importante.

Y si desea extraer las diferencias entre las dos cadenas, puede usar String :: Diff .

    Intereting Posts