Come faccio a convertire una stringa in un numero in PHP?

Voglio convertire questi tipi di valori, '3', '2.34', '0.234343', ecc per un numero. In JavaScript possiamo usare Number(), ma esiste un metodo simile disponibile in PHP?

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

In genere non è necessario farlo, poiché PHP forzerà il tipo per te nella maggior parte dei casi. Per le situazioni in cui desideri convertire esplicitamente il tipo, esegui il cast :

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

Ci sono alcuni modi per farlo:

1. Trasmetti le stringhe a tipi di dati primitivi numerici:

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

2. Esegui operazioni matematiche sulle stringhe:

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

3. Usa intval()o floatval():

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

4. Usa settype().

Per evitare problemi, prova intval($var). Qualche esempio:

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

In qualunque linguaggio (tipicamente impreciso) puoi sempre lanciare una stringa su un numero aggiungendo uno zero ad esso.

Tuttavia, ha molto poco senso in quanto PHP lo farà automaticamente al momento dell'utilizzo di questa variabile, e verrà comunque trasmesso su una stringa al momento dell'output.

Tieni presente che potresti voler mantenere i numeri tratteggiati come stringhe, perché dopo il lancio per fluttuare potrebbe essere cambiato in modo imprevedibile, a causa della natura dei numeri fluttuanti.

Puoi usare:

(int)(your value);

Oppure puoi usare:

intval(string)

Se vuoi ottenere un float per $value = '0.4', ma int per $value = '4', puoi scrivere:

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

È un po 'sporco, ma funziona.

Puoi sempre aggiungere zero ad esso!

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

Invece di dover scegliere se convertire stringin into float, puoi semplicemente aggiungerne uno 0e PHP convertirà automaticamente il risultato in un tipo numerico.

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

In PHP puoi usare le intval(string) or floatval(string)funzioni per convertire stringhe in numeri.

Sì, esiste un metodo simile in PHP, ma è così poco noto che raramente ne sentirai parlare. È un operatore aritmetico chiamato " identità ", come descritto qui:

Operatori aritmetici

Per convertire una stringa numerica in un numero, procedi come segue:

$a = +$a;

Solo una piccola nota alle risposte che possono essere utili e più sicure in alcuni casi. Potresti voler verificare se la stringa contiene prima un valore numerico valido e solo successivamente convertirlo in un tipo numerico (ad esempio se devi manipolare i dati provenienti da un db che converte ints in stringhe). È possibile utilizzare is_numeric()e quindi floatval():

$a = "whatever"; // any variable

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

Ecco la funzione che realizza ciò che stai cercando. Per prima cosa controlliamo se il valore può essere compreso come un numero, in tal caso lo trasformiamo in un int e un float. Se int e float sono uguali (ad es. 5 == 5.0), restituiamo il valore int. Se int e float non sono uguali (ad es. 5! = 5.3) allora assumiamo che tu abbia bisogno della precisione del float e restituisca quel valore. Se il valore non è numerico, lanciamo un avviso e restituiamo null.

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

Ho scoperto che in JavaScript un modo semplice per convertire una stringa in un numero è moltiplicarlo per 1. Risolve il problema di concatenazione, perché il simbolo "+" ha molteplici usi in JavaScript, mentre il simbolo "*" è puramente per moltiplicazione matematica.

Sulla base di ciò che ho visto qui in merito al fatto che PHP è automaticamente disposto a interpretare una stringa contenente cifre come un numero (e i commenti sull'aggiunta, poiché in PHP il "+" è puramente per l'aggiunta matematica), questo trucco moltiplica funziona perfettamente anche per PHP.

L'ho testato e funziona ... Anche se a seconda di come hai acquisito la stringa, potresti voler applicare la funzione trim () prima di moltiplicare per 1.

Ecco una funzione che ho scritto per semplificare le cose da solo:

Restituisce anche versioni abbreviate di booleano, intero, doppio e reale.

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

La chiamata del tipo con parseNumeric impostato su true convertirà le stringhe numeriche prima di controllare il tipo.

Così:

type ("5", true) restituirà int

type ("3.7", true) restituirà float

digitare ("500") restituirà la stringa

Fai solo attenzione poiché si tratta di una sorta di metodo di controllo falso e la tua variabile effettiva sarà comunque una stringa. Sarà necessario convertire la variabile effettiva nel tipo corretto, se necessario. Ne avevo solo bisogno per verificare se il database dovesse caricare un id o un alias di elemento, quindi non avere effetti imprevisti poiché verrà comunque analizzato come stringa in fase di esecuzione.

modificare

Se desideri rilevare se gli oggetti sono funzioni aggiungi questo caso allo switch:

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

Oltre alla risposta di Boykodev, suggerisco questo:

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

$a = "10";

$b = (int)$a;

Puoi usarlo per convertire una stringa in un int in PHP .

Semplicemente puoi scrivere così:

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

Moltiplica il numero solo per 1 in modo che la stringa venga convertita nel tipo numero.

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

Puoi usare:

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

Ma la soluzione migliore è usare:

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;

È possibile modificare il tipo di dati come segue

$number = "1.234";

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

settype($number , "float");

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

Per motivi storici "double" viene restituito in caso di float.

Documentazione PHP

Tutti i suggerimenti perdono il tipo numerico.

Questa mi sembra una buona pratica:

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 farà per te entro certi limiti

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

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

C'è un modo:

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

Utilizzando is_*non funziona, dal momento che la variableè una: string.

Utilizzando la combinazione di json_encode()e quindi json_decode()viene convertito nella sua forma "vera". Se è un vero, stringallora avrebbe prodotto un errore.

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

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

Uscita: string(2) "Me" int(0) float(0)

Ho avuto la domanda "diciamo che stavi scrivendo la funzione integrata per trasmettere un numero intero a una stringa in PHP, come scriveresti quella funzione" in un'intervista di programmazione. Ecco una soluzione

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

Ho letto le risposte e non ho visto nessuno menzionare il più grande avvertimento nella conversione numerica di PHP.

La risposta più votata suggerisce di fare quanto segue:

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

È geniale. PHP dirige il casting. E se avessimo fatto quanto segue?

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

PHP considera tali conversioni valide?

A quanto pare sì .

PHP legge la stringa fino a quando non trova il primo carattere non numerico per il tipo richiesto. Ciò significa che per i numeri interi, i caratteri numerici sono [0-9]. Di conseguenza, legge 3, poiché si trova nell'intervallo di caratteri [0-9], continua a leggere. Legge .e si ferma lì poiché non è compreso nell'intervallo [0-9].

Lo stesso accadrebbe se si lanciasse per float o double. PHP leggerebbe 3, quindi ., quindi 1, quindi 4, e si fermerebbe a ipoiché non è un carattere numerico float valido.

Di conseguenza, "million" >= 1000000restituisce false, ma "1000000million" >= 1000000valuta true.

Guarda anche:

https://www.php.net/manual/en/language.operators.comparison.php come vengono eseguite le conversioni durante il confronto

https://www.php.net/manual/en/language.types.string.php#language.types.string.conversion come le stringhe vengono convertite in rispettivi numeri

Se non sai in anticipo se hai un float o un numero intero
e se la stringa può contenere caratteri speciali (come spazio, €, ecc.)
E se può contenere più di 1 punto o virgola,
puoi usare questo funzione:

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

Approccio diverso:

1. Inserire tutto in un array / array associativo.
2. json_encode($your_array, JSON_NUMERIC_CHECK); eventualmente decodificarlo indietro
3. ?
4. Profitto!