¿Cómo puedo saber si una variable tiene un valor numérico en Perl?

¿Existe una forma sencilla en Perl que me permita determinar si una variable dada es numérica? Algo parecido a:

if (is_number($x))
{ ... }

sería ideal. Sin -wduda, se prefiere una técnica que no arroje advertencias cuando se usa el interruptor.

Use Scalar::Util::looks_like_number()que usa la función looks_like_number () de la API interna de Perl C, que es probablemente la forma más eficiente de hacer esto. Tenga en cuenta que las cadenas "inf" e "infinity" se tratan como números.

Ejemplo:

#!/usr/bin/perl

use warnings;
use strict;

use Scalar::Util qw(looks_like_number);

my @exprs = qw(1 5.25 0.001 1.3e8 foo bar 1dd inf infinity);

foreach my $expr (@exprs) {
    print "$expr is", looks_like_number($expr) ? '' : ' not', " a number\n";
}

Da esta salida:

1 is a number
5.25 is a number
0.001 is a number
1.3e8 is a number
foo is not a number
bar is not a number
1dd is not a number
inf is a number
infinity is a number

Ver también:

• perldoc Scalar :: Util
• perldoc perlapi paralooks_like_number

Consulte el módulo CPAN Regexp :: Common . Creo que hace exactamente lo que necesitas y maneja todos los casos extremos (por ejemplo, números reales, notación científica, etc.). p.ej

use Regexp::Common;
if ($var =~ /$RE{num}{real}/) { print q{a number}; }

La pregunta original era cómo saber si una variable era numérica, no si "tiene un valor numérico".

Hay algunos operadores que tienen modos de operación separados para operandos numéricos y de cadena, donde "numérico" significa cualquier cosa que originalmente era un número o que alguna vez se usó en un contexto numérico (p. Ej. $x = "123"; 0+$x, En , antes de la adición, $xes una cadena, luego se considera numérico).

Una forma de saberlo es esta:

if ( length( do { no warnings "numeric"; $x & "" } ) ) {
    print "$x is numeric\n";
}

Si la función bit a bit está habilitada, eso hace que &solo sea un operador numérico y agrega un &.operador de cadena separado , debe deshabilitarlo:

if ( length( do { no if $] >= 5.022, "feature", "bitwise"; no warnings "numeric"; $x & "" } ) ) {
    print "$x is numeric\n";
}

(bit a bit está disponible en perl 5.022 y superior, y está habilitado de forma predeterminada si usted use 5.028;o superior).

Una respuesta simple (y tal vez simplista) a la pregunta es que el contenido de $xnumérico es el siguiente:

if ($x  eq  $x+0) { .... }

Hace una comparación textual del original $xcon el $xconvertido a un valor numérico.

Por lo general, la validación de números se realiza con expresiones regulares. Este código determinará si algo es numérico y también buscará variables indefinidas para no generar advertencias:

sub is_integer {
   defined $_[0] && $_[0] =~ /^[+-]?\d+$/;
}

sub is_float {
   defined $_[0] && $_[0] =~ /^[+-]?\d+(\.\d+)?$/;
}

Aquí hay material de lectura que debería consultar.

No es perfecto, pero puedes usar una expresión regular:

sub isnumber 
{
    shift =~ /^-?\d+\.?\d*$/;
}

No creo que haya nada incorporado para hacerlo. Para obtener más información de lo que nunca quiso ver sobre el tema, consulte Perlmonks sobre detección de números

Se puede encontrar una expresión regular un poco más robusta en Regexp :: Common .

Parece que quiere saber si Perl cree que una variable es numérica. Aquí hay una función que atrapa esa advertencia:

sub is_number{
  my $n = shift;
  my $ret = 1;
  $SIG{"__WARN__"} = sub {$ret = 0};
  eval { my $x = $n + 1 };
  return $ret
}

Otra opción es desactivar la advertencia localmente:

{
  no warnings "numeric"; # Ignore "isn't numeric" warning
  ...                    # Use a variable that might not be numeric
}

Tenga en cuenta que las variables no numéricas se convertirán silenciosamente a 0, que es probablemente lo que deseaba de todos modos.

rexep no perfecto ... esto es:

use Try::Tiny;

sub is_numeric {
  my ($x) = @_;
  my $numeric = 1;
  try {
    use warnings FATAL => qw/numeric/;
    0 + $x;
  }
  catch {
    $numeric = 0;
  };
  return $numeric;
}

Prueba esto:

If (($x !~ /\D/) && ($x ne "")) { ... }

Aunque encontré esto interesante

if ( $value + 0 eq $value) {
    # A number
    push @args, $value;
} else {
    # A string
    push @args, "'$value'";
}

Personalmente, creo que el camino a seguir es confiar en el contexto interno de Perl para que la solución sea a prueba de balas. Una buena expresión regular podría coincidir con todos los valores numéricos válidos y ninguno de los no numéricos (o viceversa), pero como hay una forma de emplear la misma lógica que usa el intérprete, debería ser más seguro confiar en eso directamente.

Como tiendo a ejecutar mis scripts -w, tuve que combinar la idea de comparar el resultado de "valor más cero" con el valor original con el no warningsenfoque basado en @ysth:

do { 
    no warnings "numeric";
    if ($x + 0 ne $x) { return "not numeric"; } else { return "numeric"; }
}

Puede usar expresiones regulares para determinar si $ foo es un número (o no).

Eche un vistazo aquí: ¿Cómo puedo determinar si un escalar es un número?

if (definido $ x && $ x! ~ m / \ D /) {} o $ x = 0 if! $ x; si ($ x! ~ m / \ D /) {}

Esta es una ligera variación de la respuesta de Veekay, pero déjeme explicar mi razonamiento para el cambio.

La realización de una expresión regular en un valor indefinido provocará un mensaje de error y hará que el código salga en muchos, si no en la mayoría de los entornos. Probar si el valor está definido o establecer un caso predeterminado como hice en el ejemplo alternativo antes de ejecutar la expresión guardará, como mínimo, su registro de errores.