Comment convertir une chaîne en nombre en PHP?

Je veux convertir ces types de valeurs, '3', '2.34', '0.234343', etc. à un certain nombre. En JavaScript, nous pouvons utiliser Number(), mais existe-t-il une méthode similaire disponible en PHP?

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

Vous n'avez généralement pas besoin de le faire, car PHP contraindra le type pour vous dans la plupart des circonstances. Pour les situations où vous ne voulez convertir explicitement le type, coulé il:

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

Il y a plusieurs façons de le faire:

1. Convertissez les chaînes en types de données primitifs numériques:

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

2. Effectuer des opérations mathématiques sur les chaînes:

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

3. Utilisez intval()ou floatval():

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

4. Utilisez settype().

Pour éviter les problèmes, essayez intval($var). Quelques exemples:

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

Dans n'importe quelle langue (typiquement lâche), vous pouvez toujours convertir une chaîne en un nombre en y ajoutant un zéro.

Cependant, cela n'a pas beaucoup de sens car PHP le fera automatiquement au moment de l'utilisation de cette variable, et il sera de toute façon converti en chaîne au moment de la sortie.

Notez que vous souhaiterez peut-être conserver les nombres en pointillés sous forme de chaînes, car après la conversion en flottant, il peut être modifié de manière imprévisible, en raison de la nature des nombres flottants.

Vous pouvez utiliser:

(int)(your value);

Ou vous pouvez utiliser:

intval(string)

Si vous voulez obtenir un flottant pour $value = '0.4', mais int pour $value = '4', vous pouvez écrire:

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

C'est un peu sale, mais ça marche.

Vous pouvez toujours y ajouter zéro!

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

Au lieu d'avoir à choisir de convertir le stringen intou float, vous pouvez simplement y ajouter un 0, et PHP convertira automatiquement le résultat en type numérique.

// 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, vous pouvez utiliser des intval(string) or floatval(string)fonctions pour convertir des chaînes en nombres.

Oui, il existe une méthode similaire en PHP, mais elle est si peu connue que vous en entendrez rarement parler. Il s'agit d'un opérateur arithmétique appelé " identité ", comme décrit ici:

Opérateurs aritmétiques

Pour convertir une chaîne numérique en nombre, procédez comme suit:

$a = +$a;

Juste une petite note aux réponses qui peuvent être utiles et plus sûres dans certains cas. Vous voudrez peut-être vérifier si la chaîne contient réellement une valeur numérique valide en premier et ensuite la convertir en un type numérique (par exemple si vous devez manipuler des données provenant d'une base de données qui convertit les entiers en chaînes). Vous pouvez utiliser is_numeric()puis floatval():

$a = "whatever"; // any variable

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

Voici la fonction qui permet d'atteindre ce que vous recherchez. Nous vérifions d'abord si la valeur peut être comprise comme un nombre, si c'est le cas, nous la transformons en int et en float. Si int et float sont identiques (par exemple, 5 == 5.0), nous renvoyons la valeur int. Si int et float ne sont pas identiques (par exemple, 5! = 5.3), nous supposons que vous avez besoin de la précision du float et renvoyez cette valeur. Si la valeur n'est pas numérique, nous lançons un avertissement et retournons 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;
    }
}

J'ai trouvé qu'en JavaScript, un moyen simple de convertir une chaîne en nombre est de la multiplier par 1. Cela résout le problème de concaténation, car le symbole "+" a plusieurs utilisations en JavaScript, tandis que le symbole "*" est purement pour la multiplication mathématique.

Sur la base de ce que j'ai vu ici concernant PHP étant automatiquement disposé à interpréter une chaîne contenant des chiffres comme un nombre (et les commentaires sur l'ajout, car en PHP le "+" est purement pour l'addition mathématique), cette astuce de multiplication fonctionne très bien pour PHP, également.

Je l'ai testé et cela fonctionne ... Bien que selon la façon dont vous avez acquis la chaîne, vous souhaitiez peut-être lui appliquer la fonction trim (), avant de multiplier par 1.

Voici une fonction que j'ai écrite pour me simplifier les choses:

Il renvoie également des versions abrégées de booléen, entier, double et réel.

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

L'appel de type avec parseNumeric défini sur true convertira les chaînes numériques avant de vérifier le type.

Donc:

type ("5", true) renverra int

type ("3.7", true) renverra float

type ("500") renverra une chaîne

Faites juste attention car c'est une sorte de méthode de fausse vérification et votre variable réelle sera toujours une chaîne. Vous devrez convertir la variable réelle au type correct si nécessaire. J'en avais juste besoin pour vérifier si la base de données doit charger un identifiant ou un alias d'élément, n'ayant donc aucun effet inattendu car il sera de toute façon analysé en tant que chaîne au moment de l'exécution.

Éditer

Si vous souhaitez détecter si les objets sont des fonctions, ajoutez ce cas au commutateur:

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

En plus de la réponse de Boykodev, je suggère ceci:

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

$a = "10";

$b = (int)$a;

Vous pouvez l'utiliser pour convertir une chaîne en entier en PHP .

Vous pouvez simplement écrire comme ceci:

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

Multipliez uniquement le nombre par 1 pour que la chaîne soit convertie en type nombre.

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

Vous pouvez utiliser:

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

Mais la meilleure solution est d'utiliser:

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;

Vous pouvez modifier le type de données comme suit

$number = "1.234";

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

settype($number , "float");

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

Pour des raisons historiques, "double" est retourné en cas de flottement.

Documentation PHP

Toutes les suggestions perdent le type numérique.

Cela me semble une meilleure pratique:

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 le fera pour vous dans certaines limites

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

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

Il y a un moyen:

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

L' utilisation is_*ne fonctionnera pas, car le variableest un: string.

En utilisant la combinaison de json_encode()puis json_decode()il est converti en sa forme "vraie". Si c'est un vrai, stringcela donnerait un mauvais résultat.

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

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

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

J'ai eu la question "disons que vous écriviez la fonction intégrée pour convertir un entier en une chaîne en PHP, comment écririez-vous cette fonction" dans une interview de programmation. Voici une solution.

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

J'ai lu les réponses et je n'ai vu personne mentionner la plus grande mise en garde dans la conversion des nombres PHP.

La réponse la plus votée suggère de faire ce qui suit:

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

C'est brillant. PHP fait du casting direct. Et si nous faisions ce qui suit?

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

PHP considère-t-il que ces conversions sont valides?

Apparemment oui .

PHP lit la chaîne jusqu'à ce qu'il trouve le premier caractère non numérique du type requis. Cela signifie que pour les entiers, les caractères numériques sont [0-9]. En conséquence, il lit 3, puisqu'il est dans la plage de caractères [0-9], il continue la lecture. Lit .et s'arrête là car il n'est pas dans la plage [0-9].

La même chose se produirait si vous deviez lancer pour flotter ou doubler. PHP lirait 3, puis ., puis 1, puis 4s'arrêterait icar ce n'est pas un caractère numérique flottant valide.

Par conséquent, "million" >= 1000000évalue à faux, mais "1000000million" >= 1000000évalue à true.

Voir également:

https://www.php.net/manual/en/language.operators.comparison.php comment les conversions sont effectuées lors de la comparaison

https://www.php.net/manual/en/language.types.string.php#language.types.string.conversion comment les chaînes sont converties en nombres respectifs

Si vous ne savez pas à l'avance si vous avez un flottant ou un entier,
et si la chaîne peut contenir des caractères spéciaux (comme l'espace, €, etc.),
et si elle peut contenir plus d'un point ou une virgule,
vous pouvez utiliser ceci une fonction:

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

Une approche différente:

1. Poussez le tout dans un tableau / tableau associatif.
2. json_encode($your_array, JSON_NUMERIC_CHECK); éventuellement le décoder
3. ?
4. Profit!