perl | Comparando escalares

Prerrequisito: Escalares en Perl

Perl tiene dos tipos de conjuntos de operadores de comparación. Al igual que otros operadores matemáticos, en lugar de realizar operaciones, estos operadores comparan escalares. Hay dos tipos de conjuntos de operadores de comparación de Perl. 

Uno es para valores escalares numéricos y el otro es para valores escalares de string . Ambos tipos se ilustran en la siguiente tabla: 

Explicaciones para los operadores de comparación numéricos y escalares de strings anteriores: 

• == y eq : este operador se utiliza para comprobar la igualdad. En el siguiente código, las salidas de los códigos después de usar == y eq se comparan y muestran cómo funciona de manera diferente para los escalares numéricos y de string.
  Ejemplo 1: 

# Perl program to illustrate
# == operator
   
# taking two numeric scalars
$x = 5;
$y = 5;
   
# using "==" operator
if($x == $y)
{
    print "== works with numeric value!";
}

Producción: 

== works with numeric value!

Ejemplo 2:

# Perl program to illustrate
# == and eq operator
   
# string scalar
$str = "geekforgeeks";
   
if($str == "GEEKSFORGEEKS")
{
    print "== doesn't work with string values!";
   
}
   
# comparing with capital string
if($str eq "GEEKSFORGEEKS")
{
    print "eq works with string values!";
}

Producción: 

== doesn't work with string values!

Explicación: en el resultado del ejemplo 2, la declaración de última impresión no se ejecutará porque $str y GEEKSFORGEEKS no son iguales. Además, los códigos ASCII de ‘g’ y ‘G’ son diferentes. Por lo tanto, == funciona bien para valores numéricos pero falla en el caso de valores de string y eq funciona bien solo para escalares de string.

• != y ne
  En el siguiente código hay una comparación de resultados después de usar != y ne y se muestra cuál funciona correctamente para strings y cuál funciona correctamente para valores escalares numéricos.
  Ejemplo 1:

# Perl program to demonstrate the 
# != operator
   
# numeric scalars
$x = 5;
$y = 10;
   
# using != operator
if($x != $y)
{
    print "!= works with numeric value!";
}

Producción: 

!= works with numeric value!

Ejemplo 2:

# Perl program to demonstrate the 
# != and ne operator
   
# string scalar
$str = "geekforgeeks";
   
# using != operator
if($str != "GEEKSFORGEEKS")
{
    print "\n!= doesn't work with string values!";
   
}
   
# comparing with capital string
if($str ne "GEEKSFORGEEKS")
{
    print"ne works with string values!";
}

Producción: 

ne works with string values!

Explicación: En el segundo ejemplo, la primera declaración de impresión no se ejecutará porque != convierte ambas strings a 0. Por lo tanto, != funciona bien para valores numéricos pero falla en el caso de valores de string y ne funciona bien para escalares de string.

• (> o gt) y (< o lt)
  En los códigos a continuación, compararemos las salidas después de usar (> o gt) y (< o lt) y veremos cuál funciona correctamente para strings y cuál funciona correctamente para escalar numérico valores.
  Ejemplo 1:

# Perl program to demonstrate the 
# (> or gt) And (< or lt)
# operator
   
# numeric scalars
$x = 4;
$y = 5;
   
# using (> or gt) And (< or lt)
if(($x < $y) and ($x lt $y) )
{
    print "< and lt works with numeric value!";
}
   
if(($y > $x) and ($y gt $x) )
{
    print "\n> and gt works with numeric value!";
}

Producción: 

< and lt works with numeric value!
> and gt works with numeric value!

Ejemplo 2:

# Perl program to demonstrate the 
# (> or gt) And (< or lt)
# operator
   
# string scalar
$str = "geekforgeeks";
   
if($str < "GEEKSFORGEEKS")
{
    print "< doesn't work with string values!";
}
   
# comparing with capital string
if($str lt "GEEKSFORGEEKSZZZ")
{
    print"lt works with string values!";
}
   
# comparing with capital string
if($str gt "GEEKSFORGEEKSZZZ")
{
    print"gt works with string values!";
}
   
# comparing with capital string
if($str lt "kEEKSFORGEEKS")
{
    print"\nlt works with string values!";
}

Producción: 

gt works with string values!
lt works with string values!

Explicación: El código anterior nos dice algunas cosas interesantes sobre cómo funciona Perl con strings. El resultado del primer ejemplo es muy obvio ya que tanto los operadores de string como los numéricos tratan a los escalares numéricos de la misma manera. 
Pero en la segunda Salida, el “lt” no se comportó como esperábamos. Digamos que el operador «lt» de Perl no distingue entre mayúsculas y minúsculas, pero incluso ponemos «ZZZ» después de eso e incluso en ese caso $str no es menor que la string entre comillas y la siguiente salida mostró que era mayor. Este punto puede quedar claro en la segunda línea de la salida del segundo ejemplo. 
El operador de string de Perl solo comprueba primero el primer carácter de String y compara los códigos ASCII. Dado que las letras mayúsculas son lo primero en la tabla ASCII. El compilador de Perl hizo coincidir la primera letra y luego hizo coincidir el resto.

• (>= o ge) y (<= o le) 
  Estos operadores también funcionan en los valores ASCII que se verifican en el caso de los operadores de strings. El valor se comprueba en el caso de operadores numéricos.
  Ejemplo:

# Perl program to demonstrate the 
# (>= or ge) And (<= or le)
# operator
   
# numeric scalars
$x = 5;
$y = 10;
   
if(($x <= $y) and ($y >= $x))
{
    print "<= and>= works";
}
   
# string scalar
$str= "geeksforgeeks";
   
if (($str le "keeksforgeeks") and ($str ge "feeksforgeeks"))
{
    print "\nle and ge works!";
}

Producción: 

<= and>= works
le and ge works!

Puntos importantes para recordar:

• El operador numérico siempre convertirá valores de string a 0. Cuando comparamos dos escalares de string con operadores numéricos como ==, >= o <=, entonces siempre convertirá los escalares a 0 o 0.0. Ya que no son de cuerda. Y por lo tanto será cierto en el caso de ==, >= o <= como se muestra en el siguiente ejemplo: 

# Perl program to illustrate 
# above point
   
# numeric scalars
$x = "BBB";
$y = "aaa";
   
if (($x == $y and ($x <= $y) and ($x >= $y)))
{
    print "True";
}

Producción: 

True

Explicación: en el código anterior, «aaa» es menor que BBB en todos los aspectos (en minúsculas y también ASCII de a es mayor que B), pero aún así ambas strings serán iguales ya que el operador de comparación numérica convirtió la string en 0. 

• El operador de string no compara valores numéricos, sino que compara sus valores ASCII. Los operadores de strings comparan valores ASCII para valores numéricos. En el siguiente ejemplo, «9 gt 17» es verdadero pero «17 gt 9» dará el resultado como falso. 

# Perl program to illustrate 
# above point
   
# numeric scalar
$x = 9;
$y = 17;
   
if ($x gt $y)
{
    print "True";
}

Producción: 

True