Le champ entier MySQL est renvoyé sous forme de chaîne en PHP

J'ai un champ de table dans une base de données MySQL:

userid INT(11)

Je l'appelle donc sur ma page avec cette requête:

"SELECT userid FROM DB WHERE name='john'"

Ensuite, pour gérer le résultat, je fais:

$row=$result->fetch_assoc();

$id=$row['userid'];

Maintenant si je fais:

echo gettype($id);

Je reçois une chaîne. Cela ne devrait-il pas être un entier?

Lorsque vous sélectionnez des données dans une base de données MySQL en utilisant PHP, le type de données sera toujours converti en chaîne. Vous pouvez le reconvertir en entier à l'aide du code suivant:

$id = (int) $row['userid'];

Ou en utilisant la fonction intval():

$id = intval($row['userid']);

Utilisez le mysqlnd (pilote natif) pour php.

Si vous êtes sur Ubuntu:

sudo apt-get install php5-mysqlnd
sudo service apache2 restart

Si vous êtes sur Centos:

sudo yum install php-mysqlnd
sudo service httpd restart

Le pilote natif renvoie les types entiers de manière appropriée.

Éditer:

Comme @Jeroen l'a souligné, cette méthode ne fonctionnera que pour PDO.
Comme @LarsMoelleken l'a souligné, cette méthode fonctionnera avec mysqli si vous définissez également l'option MYSQLI_OPT_INT_AND_FLOAT_NATIVE sur true.

Exemple:

$mysqli = mysqli_init();
$mysqli->options(MYSQLI_OPT_INT_AND_FLOAT_NATIVE, TRUE);

Solution la plus simple que j'ai trouvée:

Vous pouvez forcer json_encode à utiliser des nombres réels pour les valeurs qui ressemblent à des nombres:

json_encode($data, JSON_NUMERIC_CHECK) 

(depuis PHP 5.3.3).

Ou vous pouvez simplement convertir votre identifiant en un int.

$row = $result->fetch_assoc();
$id = (int) $row['userid'];

Ma solution consiste à transmettre le résultat de la requête $rset à obtenir un tableau assoc des données castées comme retour:

function cast_query_results($rs) {
    $fields = mysqli_fetch_fields($rs);
    $data = array();
    $types = array();
    foreach($fields as $field) {
        switch($field->type) {
            case 3:
                $types[$field->name] = 'int';
                break;
            case 4:
                $types[$field->name] = 'float';
                break;
            default:
                $types[$field->name] = 'string';
                break;
        }
    }
    while($row=mysqli_fetch_assoc($rs)) array_push($data,$row);
    for($i=0;$i<count($data);$i++) {
        foreach($types as $name => $type) {
            settype($data[$i][$name], $type);
        }
    }
    return $data;
}

Exemple d'utilisation:

$dbconn = mysqli_connect('localhost','user','passwd','tablename');
$rs = mysqli_query($dbconn, "SELECT * FROM Matches");
$matches = cast_query_results($rs);
// $matches is now a assoc array of rows properly casted to ints/floats/strings

Indépendamment du type de données défini dans vos tables, le pilote MySQL de PHP sert toujours les valeurs de ligne comme des chaînes.

Vous devez convertir votre identifiant en int.

$row = $result->fetch_assoc();
$id = (int) $row['userid'];

J'aime la réponse de Chad, en particulier lorsque les résultats de la requête seront transmis à javascript dans un navigateur. Javascript traite proprement les entités numériques comme des nombres, mais nécessite un travail supplémentaire pour traiter les entités numériques comme des chaînes. ie doit utiliser parseInt ou parseFloat sur eux.

En m'appuyant sur la solution de Chad, j'utilise ceci et c'est souvent exactement ce dont j'ai besoin et crée des structures qui peuvent être encodées en JSON pour une utilisation facile en javascript.

while ($row = $result->fetch_assoc()) {
    // convert numeric looking things to numbers for javascript
    foreach ($row as &$val) {
        if (is_numeric($val))
            $val = $val + 0;
    }
}

L'ajout d'une chaîne numérique à 0 produit un type numérique en PHP et identifie correctement le type afin que les nombres à virgule flottante ne soient pas tronqués en entiers.

Cela se produit lorsque PDO::ATTR_EMULATE_PREPARESest défini sur truesur la connexion.

Attention cependant, le paramétrer sur falseinterdit l'utilisation de paramètres plus d'une fois. Je pense que cela affecte également la qualité des messages d'erreur qui reviennent.

Vous pouvez le faire avec ...

1. mysql_fetch_field ()
2. mysqli_result :: fetch_field_direct ou
3. PDOStatement :: getColumnMeta ()

... selon l'extension que vous souhaitez utiliser. Le premier n'est pas recommandé car l'extension mysql est obsolète. Le troisième est encore expérimental.

Les commentaires sur ces hyperliens expliquent bien comment définir votre type d'une ancienne chaîne simple à son type d'origine dans la base de données.

Certains frameworks font également abstraction de cela (CodeIgniter fournit $this->db->field_data()).

Vous pouvez également faire des suppositions - comme faire une boucle sur vos lignes résultantes et utiliser is_numeric () sur chacune. Quelque chose comme:

foreach($result as &$row){
 foreach($row as &$value){
  if(is_numeric($value)){
   $value = (int) $value;
  }       
 }       
}

Cela transformerait tout ce qui ressemble à un nombre en un ... certainement pas parfait.

Dans mon projet, j'utilise généralement une fonction externe qui "filtre" les données récupérées mysql_fetch_assoc.

Vous pouvez renommer les champs de votre table afin de comprendre de manière intuitive quel type de données est stocké.

Par exemple, vous pouvez ajouter un suffixe spécial à chaque champ numérique: si useridc'est un, INT(11)vous pouvez le renommer userid_iou s'il s'agit d'un, UNSIGNED INT(11)vous pouvez le renommer userid_u. A ce stade, vous pouvez écrire une simple fonction PHP qui reçoit en entrée le tableau associatif (récupéré avec mysql_fetch_assoc), et appliquer le cast à la "valeur" stockée avec ces "clés" spéciales.

Si des instructions préparées sont utilisées, le type sera int le cas échéant. Ce code renvoie un tableau de lignes, où chaque ligne est un tableau associatif. Comme si fetch_assoc()était appelé pour toutes les lignes, mais avec des informations de type préservées.

function dbQuery($sql) {
    global $mysqli;

    $stmt = $mysqli->prepare($sql);
    $stmt->execute();
    $stmt->store_result();

    $meta = $stmt->result_metadata();
    $params = array();
    $row = array();

    while ($field = $meta->fetch_field()) {
      $params[] = &$row[$field->name];
    }

    call_user_func_array(array($stmt, 'bind_result'), $params);

    while ($stmt->fetch()) {
      $tmp = array();
      foreach ($row as $key => $val) {
        $tmp[$key] = $val;
      }
      $ret[] = $tmp;
    }

    $meta->free();
    $stmt->close();

    return $ret;
}

MySQL a des pilotes pour de nombreuses autres langues, la conversion des données en chaîne "standardise" les données et laisse à l'utilisateur le soin de taper des valeurs en int ou autres

Dans mon cas, l' mysqlnd.soextension avait été installée. MAIS je ne l'avais pas fait pdo_mysqlnd.so. Ainsi, le problème avait été résolu en remplaçant pdo_mysql.sopar pdo_mysqlnd.so.

J'aime la technique de mastermind , mais le codage peut être plus simple:

function cast_query_results($result): array
{
    if ($result === false)
      return null;

    $data = array();
    $fields = $result->fetch_fields();
    while ($row = $result->fetch_assoc()) {
      foreach ($fields as $field) {
        $fieldName = $field->name;
        $fieldValue = $row[$fieldName];
        if (!is_null($fieldValue))
            switch ($field->type) {
              case 3:
                $row[$fieldName] = (int)$fieldValue;
                break;
              case 4:
                $row[$fieldName] = (float)$fieldValue;
                break;
              // Add other type conversions as desired.
              // Strings are already strings, so don't need to be touched.
            }
      }
      array_push($data, $row);
    }

    return $data;
}

J'ai également ajouté la vérification des requêtes retournant false plutôt qu'un jeu de résultats.
Et vérifier une ligne avec un champ qui a une valeur nulle.
Et si le type souhaité est une chaîne, je ne perds pas de temps dessus - c'est déjà une chaîne.

Je ne prends pas la peine de l'utiliser dans la plupart des codes php; Je compte juste sur la conversion automatique de type de php. Mais si vous interrogez beaucoup de données, pour ensuite effectuer des calculs arithmétiques, il est judicieux de convertir en premier les types optimaux.