¿Cómo convierto una cadena a un número en PHP?

Quiero convertir estos tipos de valores, '3', '2.34', '0.234343', etc, para un número. En JavaScript podemos usar Number(), pero ¿hay algún método similar disponible en PHP?

Input             Output
'2'               2
'2.34'            2.34
'0.3454545'       0.3454545

Por lo general, no necesita hacer esto, ya que PHP forzará el tipo por usted en la mayoría de las circunstancias. Para situaciones en las que desea convertir explícitamente el tipo, transmítalo :

$num = "3.14";
$int = (int)$num;
$float = (float)$num;

Hay algunas formas de hacerlo:

1. Convierta las cadenas en tipos de datos primitivos numéricos:

   $num = (int) "10";
   $num = (double) "10.12"; // same as (float) "10.12";

2. Realice operaciones matemáticas en las cadenas:

   $num = "10" + 1;
   $num = floor("10.1");

3. Usar intval()o floatval():

   $num = intval("10");
   $num = floatval("10.1");

4. Uso settype().

Para evitar problemas intente intval($var). Algunos ejemplos:

<?php
echo intval(42);                      // 42
echo intval(4.2);                     // 4
echo intval('42');                    // 42
echo intval('+42');                   // 42
echo intval('-42');                   // -42
echo intval(042);                     // 34 (octal as starts with zero)
echo intval('042');                   // 42
echo intval(1e10);                    // 1410065408
echo intval('1e10');                  // 1
echo intval(0x1A);                    // 26 (hex as starts with 0x)
echo intval(42000000);                // 42000000
echo intval(420000000000000000000);   // 0
echo intval('420000000000000000000'); // 2147483647
echo intval(42, 8);                   // 42
echo intval('42', 8);                 // 34
echo intval(array());                 // 0
echo intval(array('foo', 'bar'));     // 1
?>

En cualquier lenguaje (tipeado) siempre puede convertir una cadena a un número agregando un cero.

Sin embargo, tiene muy poco sentido en esto, ya que PHP lo hará automáticamente al momento de usar esta variable, y de todos modos se convertirá en una cadena al momento de la salida.

Tenga en cuenta que es posible que desee mantener los números punteados como cadenas, porque después de emitir para flotar puede cambiar de forma impredecible, debido a la naturaleza de los números flotantes.

Puedes usar:

(int)(your value);

O puedes usar:

intval(string)

Si quieres obtener un float para $value = '0.4', pero int para $value = '4', puedes escribir:

$number = ($value == (int) $value) ? (int) $value : (float) $value;

Está un poco sucio, pero funciona.

¡Siempre puedes agregarle cero!

Input             Output
'2' + 0           2 (int)
'2.34' + 0        2.34 (float)
'0.3454545' + 0   0.3454545 (float)

En lugar de tener que elegir si desea convertir el stringa into float, simplemente puede añadir una 0a ella, y PHP convertirá automáticamente el resultado a un tipo numérico.

// Being sure the string is actually a number
if (is_numeric($string))
    $number = $string + 0;
else // Let the number be 0 if the string is not a number
    $number = 0;

En PHP puedes usar intval(string) or floatval(string)funciones para convertir cadenas en números.

Sí, hay un método similar en PHP, pero es tan poco conocido que rara vez lo escuchará. Es un operador aritmético llamado " identidad ", como se describe aquí:

Operadores Aritméticos

Para convertir una cadena numérica en un número, haga lo siguiente:

$a = +$a;

Solo una pequeña nota a las respuestas que puede ser útil y más segura en algunos casos. Es posible que desee verificar si la cadena realmente contiene un valor numérico válido primero y solo luego convertirlo a un tipo numérico (por ejemplo, si tiene que manipular los datos que provienen de una base de datos que convierte ints en cadenas). Puede usar is_numeric()y luego floatval():

$a = "whatever"; // any variable

if (is_numeric($a)) 
    var_dump(floatval($a)); // type is float
else 
    var_dump($a); // any type

Aquí está la función que logra lo que está buscando. Primero verificamos si el valor puede entenderse como un número, si es así lo convertimos en un int y un flotante. Si int y float son iguales (p. Ej., 5 == 5.0) entonces devolvemos el valor int. Si int y float no son lo mismo (por ejemplo, 5! = 5.3), entonces asumimos que necesita la precisión del float y devolver ese valor. Si el valor no es numérico, lanzamos una advertencia y devolvemos nulo.

function toNumber($val) {
    if (is_numeric($val)) {
        $int = (int)$val;
        $float = (float)$val;

        $val = ($int == $float) ? $int : $float;
        return $val;
    } else {
        trigger_error("Cannot cast $val to a number", E_USER_WARNING);
        return null;
    }
}

Descubrí que en JavaScript una manera simple de convertir una cadena en un número es multiplicarla por 1. Resuelve el problema de concatenación, porque el símbolo "+" tiene múltiples usos en JavaScript, mientras que el símbolo "*" es puramente para multiplicación matemática

Basado en lo que he visto aquí con respecto a que PHP está dispuesto a interpretar automáticamente una cadena que contiene dígitos como un número (y los comentarios sobre la suma, ya que en PHP el "+" es puramente para la suma matemática), este truco de multiplicación funciona bien para PHP, también.

Lo he probado y funciona ... Aunque dependiendo de cómo adquirió la cadena, es posible que desee aplicarle la función trim (), antes de multiplicar por 1.

Aquí hay una función que escribí para simplificar las cosas para mí:

También devuelve versiones abreviadas de boolean, integer, double y real.

function type($mixed, $parseNumeric = false)
{        
    if ($parseNumeric && is_numeric($mixed)) {
        //Set type to relevant numeric format
        $mixed += 0;
    }
    $t = gettype($mixed);
    switch($t) {
        case 'boolean': return 'bool'; //shorthand
        case 'integer': return 'int';  //shorthand
        case 'double': case 'real': return 'float'; //equivalent for all intents and purposes
        default: return $t;
    }
}

El tipo de llamada con parseNumeric establecido en verdadero convertirá cadenas numéricas antes de verificar el tipo.

Así:

tipo ("5", verdadero) devolverá int

tipo ("3.7", verdadero) devolverá flotante

type ("500") devolverá una cadena

Solo tenga cuidado ya que este es un tipo de método de verificación falsa y su variable real seguirá siendo una cadena. Necesitará convertir la variable real al tipo correcto si es necesario. Solo lo necesitaba para verificar si la base de datos debería cargar una identificación o alias de elemento, por lo que no tiene ningún efecto inesperado, ya que de todos modos se analizará como una cadena en tiempo de ejecución.

Editar

Si desea detectar si los objetos son funciones, agregue este caso al conmutador:

case 'object': return is_callable($mixed)?'function':'object';

Además de la respuesta de Boykodev, sugiero esto:

Input             Output
'2' * 1           2 (int)
'2.34' * 1        2.34 (float)
'0.3454545' * 1   0.3454545 (float)

$a = "10";

$b = (int)$a;

Puede usar esto para convertir una cadena a un int en PHP .

Simplemente puedes escribir así:

<?php
    $data = ["1","2","3","4","5"];
    echo json_encode($data, JSON_NUMERIC_CHECK);
?>

Solo multiplique el número por 1 para que la cadena se convierta en número de tipo.

//String value
$string = "5.1"
if(is_numeric($string)){
  $numeric_string = $string*1;
}

Puedes usar:

((int) $var)   ( but in big number it return 2147483647 :-) )

Pero la mejor solución es usar:

if (is_numeric($var))
    $var = (isset($var)) ? $var : 0;
else
    $var = 0;

O

if (is_numeric($var))
    $var = (trim($var) == '') ? 0 : $var;
else
    $var = 0;

Puede cambiar el tipo de datos de la siguiente manera

$number = "1.234";

echo gettype ($number) . "\n"; //Returns string

settype($number , "float");

echo gettype ($number) . "\n"; //Returns float

Por razones históricas, se devuelve "doble" en caso de flotación.

Documentación PHP

Todas las sugerencias pierden el tipo numérico.

Esto me parece una mejor práctica:

function str2num($s){
// Returns a num or FALSE
    $return_value =  !is_numeric($s) ? false :               (intval($s)==floatval($s)) ? intval($s) :floatval($s);
    print "\nret=$return_value type=".gettype($return_value)."\n";
}

PHP lo hará por ti dentro de los límites

<?php
   $str = "3.148";
   $num = $str;

   printf("%f\n", $num);
?>

Hay una manera:

$value = json_decode(json_encode($value, JSON_NUMERIC_CHECK|JSON_PRESERVE_ZERO_FRACTION|JSON_UNESCAPED_SLASHES), true);

Usar is_*no funcionará, ya que variablees un:string .

Usando la combinación de json_encode()y luego json_decode()se convierte a su forma "verdadera". Si es cierto, stringentonces saldría mal.

$num = "Me";
$int = (int)$num;
$float = (float)$num;

var_dump($num, $int, $float);

Saldrá: string(2) "Me" int(0) float(0)

Recibí la pregunta "digamos que estaba escribiendo la función incorporada para convertir un número entero en una cadena en PHP, ¿cómo escribiría esa función" en una entrevista de programación. Aquí hay una solución.

$nums = ["0","1","2","3","4","5","6","7","8","9"];
$int = 15939; 
$string = ""; 
while ($int) { 
    $string .= $nums[$int % 10]; 
    $int = (int)($int / 10); 
} 
$result = strrev($string);

He estado leyendo las respuestas y no vi a nadie mencionar la mayor advertencia en la conversión de números de PHP.

La respuesta más votada sugiere hacer lo siguiente:

$str = "3.14"
$intstr = (int)$str // now it's a number equal to 3

Eso es brillante. PHP hace casting directo. Pero, ¿y si hiciéramos lo siguiente?

$str = "3.14is_trash"
$intstr = (int)$str

¿PHP considera válidas tales conversiones?

Aparentemente si .

PHP lee la cadena hasta que encuentra el primer carácter no numérico para el tipo requerido. Lo que significa que para los enteros, los caracteres numéricos son [0-9]. Como resultado, se lee 3, ya que está en el rango de caracteres [0-9], continúa leyendo. Lee. y se detiene allí ya que no está en el rango [0-9].

Lo mismo sucedería si lanzaras para flotar o duplicar. PHP leería 3, luego ., luego 1, luego 4, y se detendría iya que no es un carácter numérico flotante válido.

Como resultado, se "million" >= 1000000evalúa como falso, pero se "1000000million" >= 1000000evalúa como true.

Ver también:

https://www.php.net/manual/en/language.operators.comparison.php cómo se realizan las conversiones al comparar

https://www.php.net/manual/en/language.types.string.php#language.types.string.conversion cómo las cadenas se convierten en números respectivos

Si no sabe de antemano si tiene un flotante o un entero,
y si la cadena puede contener caracteres especiales (como espacio, €, etc.),
y si puede contener más de 1 punto o coma,
puede usar esto función:

// This function strip spaces and other characters from a string and return a number.
// It works for integer and float.
// It expect decimal delimiter to be either a '.' or ','
// Note: everything after an eventual 2nd decimal delimiter will be removed.
function stringToNumber($string) {
    // return 0 if the string contains no number at all or is not a string:
    if (!is_string($string) || !preg_match('/\d/', $string)) {
        return 0;
    } 

    // Replace all ',' with '.':
    $workingString = str_replace(',', '.', $string);

    // Keep only number and '.':
    $workingString = preg_replace("/[^0-9.]+/", "", $workingString);

    // Split the integer part and the decimal part,
    // (and eventually a third part if there are more 
    //     than 1 decimal delimiter in the string):
    $explodedString = explode('.', $workingString, 3);

    if ($explodedString[0] === '') {
        // No number was present before the first decimal delimiter, 
        // so we assume it was meant to be a 0:
        $explodedString[0] = '0';
    } 

    if (sizeof($explodedString) === 1) {
        // No decimal delimiter was present in the string,
        // create a string representing an integer:
        $workingString = $explodedString[0];
    } else {
        // A decimal delimiter was present,
        // create a string representing a float:
        $workingString = $explodedString[0] . '.' .  $explodedString[1];
    }

    // Create a number from this now non-ambiguous string:
    $number = $workingString * 1;

    return $number;
}

Enfoque diferente:

1. Empújalo todo en una matriz / matriz asociativa.
2. json_encode($your_array, JSON_NUMERIC_CHECK); opcionalmente decodificar de nuevo
3. ?
4. ¡Lucro!