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

2011-12-16 php casting type-conversion

Voglio convertire questi tipi di valori, '3' , '2.34' , '0.234343' , ecc. In 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

Answers

PHP lo farà per te entro certi limiti

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

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

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

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() .

$a = "10";

$b = (int)$a;

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

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;

Puoi usare:

(int)(your value);

Oppure puoi usare:

intval(string)

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 in virgola mobile potrebbe essere cambiato in modo imprevedibile, a causa della natura dei numeri in virgola mobile.

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

È 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

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;

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 si desidera rilevare se gli oggetti sono funzioni, aggiungere questo caso allo switch:

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

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 riguardo al fatto che PHP è automaticamente disposto a interpretare una stringa contenente una cifra 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.

Per evitare problemi, provare 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
?>

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.

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

Invece di dover scegliere se convertire la string in int o float , puoi semplicemente aggiungere uno 0 ad essa e 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;

Approccio diverso:

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

Ecco la funzione che realizza ciò che stai cercando. Innanzitutto 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;
    }
}

Puoi sempre aggiungere zero ad esso!

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

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)

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

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;

Semplicemente puoi scrivere così:

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

C'è un modo:

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

L'uso di is_* non funzionerà, poiché la variable è una: string .

Utilizzando la combinazione di json_encode() e quindi json_decode() viene convertito nella sua forma "vera". Se si tratta di una string vera, verrà generato in modo errato.

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

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

Produrrà: string(2) "Me" int(0) float(0)

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é è compreso nell'intervallo di caratteri [0-9], continua a leggere. Legge . e si ferma lì poiché non è nell'intervallo [0-9].

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

Di conseguenza, "million" >= 1000000 "1000000million" >= 1000000 false, ma "1000000million" >= 1000000 "million" >= 1000000 "1000000million" >= 1000000 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

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

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

Related