Como faço para converter uma string em um número em PHP?

Eu quero converter esses tipos de valores, '3', '2.34', '0.234343', etc, para um número. Em JavaScript, podemos usar Number(), mas existe algum método semelhante disponível em PHP?

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

Você normalmente não precisa fazer isso, pois o PHP coagirá o tipo para você na maioria das circunstâncias. Para situações em que você deseja converter explicitamente o tipo, lançou -lo:

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

Existem algumas maneiras de fazer isso:

1. Transmitir as strings para tipos de dados numéricos primitivos:

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

2. Execute operações matemáticas nas seqüências de caracteres:

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

3. Use intval()ou floatval():

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

4. Use settype().

Para evitar problemas, tente intval($var) . Alguns exemplos:

<?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
?>

Em qualquer idioma (de tipo fraco), você sempre pode converter uma string em um número adicionando zero a ela.

No entanto, há muito pouco sentido nisso, pois o PHP fará isso automaticamente no momento do uso dessa variável e será convertido para uma string de qualquer maneira no momento da saída.

Observe que você pode manter os números pontilhados como seqüências de caracteres, porque após a conversão para flutuação, ela pode ser alterada imprevisivelmente, devido à natureza dos números flutuantes.

Você pode usar:

(int)(your value);

Ou você pode usar:

intval(string)

Se você deseja obter um float para $value = '0.4', mas int for $value = '4', você pode escrever:

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

Está um pouco sujo, mas funciona.

Você sempre pode adicionar zero a ele!

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

Em vez de escolher entre converter stringpara intou float, você pode simplesmente adicionar um 0a ele, e o PHP converterá automaticamente o resultado em um 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;

No PHP, você pode usar intval(string) or floatval(string)funções para converter seqüências de caracteres em números.

Sim, existe um método semelhante no PHP, mas é tão pouco conhecido que você raramente ouvirá sobre ele. É um operador aritmético chamado " identidade ", conforme descrito aqui:

Operadores aritméticos

Para converter uma sequência numérica em um número, faça o seguinte:

$a = +$a;

Apenas uma pequena nota para as respostas que podem ser úteis e seguras em alguns casos. Convém verificar se a string realmente contém um valor numérico válido primeiro e somente depois convertê-lo em um tipo numérico (por exemplo, se você precisar manipular dados provenientes de um banco de dados que converte ints em strings). Você pode usar is_numeric()e depois floatval():

$a = "whatever"; // any variable

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

Aqui está a função que alcança o que você está procurando. Primeiro, verificamos se o valor pode ser entendido como um número; nesse caso, o transformamos em int e float. Se int e float forem os mesmos (por exemplo, 5 == 5.0), retornaremos o valor int. Se int e float não forem os mesmos (por exemplo, 5! = 5,3), assumimos que você precisa da precisão do float e retornamos esse valor. Se o valor não for numérico, lançamos um aviso e retornamos 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;
    }
}

Descobri que no JavaScript uma maneira simples de converter uma string em um número é multiplicá-la por 1. Ele resolve o problema de concatenação, porque o símbolo "+" tem vários usos em JavaScript, enquanto o símbolo "*" é puramente para multiplicação matemática.

Com base no que eu vi aqui sobre o PHP automaticamente querer interpretar uma string contendo dígitos como um número (e os comentários sobre a adição, já que no PHP o "+" é apenas para adição matemática), esse truque de multiplicação funciona muito bem para PHP também.

Eu testei e funciona ... Embora, dependendo de como você adquiriu a string, você pode aplicar a função trim () a ela, antes de multiplicar por 1.

Aqui está uma função que escrevi para simplificar as coisas para mim:

Ele também retorna versões abreviadas de booleano, inteiro, duplo e 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;
    }
}

O tipo de chamada com parseNumeric definido como true converterá seqüências numéricas antes de verificar o tipo.

Portanto:

type ("5", true) retornará int

type ("3.7", true) retornará float

type ("500") retornará string

Apenas tome cuidado, pois esse é um tipo de método de verificação falsa e sua variável real ainda será uma string. Você precisará converter a variável real para o tipo correto, se necessário. Eu só precisava verificar se o banco de dados deveria carregar um ID ou um alias de item, sem causar efeitos inesperados, pois ele será analisado como uma string no tempo de execução.

Editar

Se você deseja detectar se objetos são funções, adicione este caso ao comutador:

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

Além da resposta de Boykodev, sugiro o seguinte:

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

$a = "10";

$b = (int)$a;

Você pode usar isso para converter uma string em um int no PHP .

Simplesmente você pode escrever assim:

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

Apenas multiplique o número por 1 para que a string seja convertida em número do tipo.

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

Você pode usar:

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

Mas a melhor solução é usar:

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

Ou

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

Você pode alterar o tipo de dados da seguinte maneira

$number = "1.234";

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

settype($number , "float");

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

Por razões históricas, "double" é retornado em caso de flutuação.

Documentação PHP

Todas as sugestões perdem o tipo numérico.

Isso me parece uma prática recomendada:

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 fará isso por você dentro de limites

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

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

Há uma maneira:

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

Usar is_*não funcionará, pois o variableé um:string .

Usando a combinação de json_encode()e, em seguida, json_decode()ele é convertido em sua forma "verdadeira". Se é verdade, stringentão seria errado.

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

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

Saída: string(2) "Me" int(0) float(0)

Eu recebi a pergunta "digamos que você estava escrevendo a função interna para converter um número inteiro em uma string no PHP, como você escreveria essa função" em uma entrevista de programação. Aqui está uma solução.

$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);

Eu tenho lido as respostas e não vi ninguém mencionar a maior ressalva na conversão de números do PHP.

A resposta mais votada sugere fazer o seguinte:

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

Isso é brilhante. PHP faz casting direto. Mas e se fizermos o seguinte?

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

O PHP considera válidas essas conversões?

Aparentemente sim .

O PHP lê a string até encontrar o primeiro caractere não numérico para o tipo necessário. Significando que para números inteiros, os caracteres numéricos são [0-9]. Como resultado, ele lê 3, como está no intervalo de [0-9] caracteres, continua lendo. Lê .e para por aí, pois não está no intervalo [0-9].

O mesmo aconteceria se você jogasse para flutuar ou dobrar. O PHP leria 3, então ., então 1, então 4, e parava, ipois não é um caractere numérico flutuante válido.

Como resultado, "million" >= 1000000avalia como falso, mas "1000000million" >= 1000000avalia como true.

Veja também:

https://www.php.net/manual/en/language.operators.comparison.php como as conversões são feitas ao comparar

https://www.php.net/manual/en/language.types.string.php#language.types.string.conversion como as strings são convertidas nos respectivos números

Se você não souber antecipadamente se possui um número flutuante ou um número inteiro
e se a sequência pode conter caracteres especiais (como espaço, €, etc),
e se pode conter mais de 1 ponto ou vírgula,
você pode usá-lo função:

// 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;
}

Abordagem diferente:

1. Coloque tudo em uma matriz / matriz associativa.
2. json_encode($your_array, JSON_NUMERIC_CHECK); opcionalmente decodificá-lo de volta
3. ?
4. Lucro!