Il campo intero MySQL viene restituito come stringa in PHP

Ho un campo tabella in un database MySQL:

userid INT(11)

Quindi lo sto chiamando alla mia pagina con questa query:

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

Quindi per gestire il risultato faccio:

$row=$result->fetch_assoc();

$id=$row['userid'];

Ora se lo faccio:

echo gettype($id);

Ricevo una stringa. Non dovrebbe essere un numero intero?

Quando selezioni i dati da un database MySQL utilizzando PHP, il tipo di dati verrà sempre convertito in una stringa. Puoi riconvertirlo in un numero intero usando il seguente codice:

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

O usando la funzione intval():

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

Usa mysqlnd (driver nativo) per php.

Se sei su Ubuntu:

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

Se sei su Centos:

sudo yum install php-mysqlnd
sudo service httpd restart

Il driver nativo restituisce i tipi interi in modo appropriato.

Modificare:

Come ha sottolineato @Jeroen, questo metodo funzionerà immediatamente per PDO.
Come ha sottolineato @LarsMoelleken, questo metodo funzionerà con mysqli se imposti anche l'opzione MYSQLI_OPT_INT_AND_FLOAT_NATIVE su true.

Esempio:

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

La soluzione più semplice che ho trovato:

Puoi forzare json_encode a usare numeri reali per valori che sembrano numeri:

json_encode($data, JSON_NUMERIC_CHECK) 

(dal PHP 5.3.3).

Oppure potresti semplicemente trasmettere il tuo ID a un int.

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

La mia soluzione è passare il risultato della query $rse ottenere un array assoc dei dati castati come ritorno:

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

Esempio di utilizzo:

$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

No. Indipendentemente dal tipo di dati definito nelle tabelle, il driver MySQL di PHP serve sempre i valori delle righe come stringhe.

Devi trasmettere il tuo ID a un int.

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

Mi piace la risposta di Chad, soprattutto quando i risultati della query verranno passati a javascript in un browser. Javascript gestisce in modo pulito entità come numeri come numeri, ma richiede ulteriore lavoro per gestire entità come numeri come stringhe. cioè deve usare parseInt o parseFloat su di essi.

Basandomi sulla soluzione di Chad, lo uso ed è spesso esattamente ciò di cui ho bisogno e crea strutture che possono essere codificate in JSON per una facile gestione in 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'aggiunta di una stringa numerica a 0 produce un tipo numerico in PHP e identifica correttamente il tipo in modo che i numeri in virgola mobile non vengano troncati in numeri interi.

Questo succede quando PDO::ATTR_EMULATE_PREPARESè impostato sutrue su sulla connessione.

Attento, impostandolo su falsenon consente l'uso dei parametri più di una volta. Credo che influisca anche sulla qualità dei messaggi di errore che ritornano.

Puoi farlo con ...

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

... a seconda dell'estensione che si desidera utilizzare. Il primo non è raccomandato perché l'estensione mysql è obsoleta. Il terzo è ancora sperimentale.

I commenti a questi collegamenti ipertestuali fanno un buon lavoro nel spiegare come impostare il tipo da una semplice stringa vecchia al suo tipo originale nel database.

Alcuni framework astraggono anche questo (fornisce CodeIgniter $this->db->field_data()).

Potresti anche fare congetture - come scorrere le righe risultanti e usare is_numeric () su ciascuna. Qualcosa di simile a:

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

Ciò trasformerebbe tutto ciò che sembra un numero in uno ... sicuramente non perfetto.

Nel mio progetto di solito utilizzo una funzione esterna con cui "filtra" i dati recuperati mysql_fetch_assoc .

È possibile rinominare i campi nella tabella in modo che sia intuitivo capire quale tipo di dati è archiviato.

Ad esempio, puoi aggiungere un suffisso speciale a ciascun campo numerico: se useridè un INT(11)puoi rinominarlo userid_io se è un UNSIGNED INT(11)puoi rinominarlo userid_u. A questo punto, puoi scrivere una semplice funzione PHP che riceve come input l'array associativo (recuperato con mysql_fetch_assoc) e applicare il casting al "valore" memorizzato con quegli speciali "tasti".

Se vengono utilizzate istruzioni preparate, il tipo sarà int dove appropriato. Questo codice restituisce una matrice di righe, in cui ogni riga è una matrice associativa. Come se fetch_assoc()fosse stato chiamato per tutte le righe, ma con informazioni sul tipo conservate.

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 ha driver per molte altre lingue, convertendo i dati in string "standardizza" i dati e lascia all'utente la digitazione di valori in int o altri

Nel mio caso l' mysqlnd.soestensione era stata installata. MA non l'ho fatto pdo_mysqlnd.so. Quindi, il problema era stato risolto sostituendolo pdo_mysql.socon pdo_mysqlnd.so.

Mi piace la tecnica di mastermind , ma la codifica può essere più semplice:

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

Ho anche aggiunto il controllo della query restituendo false anziché un set di risultati.
E controllando una riga con un campo che ha un valore nullo.
E se il tipo desiderato è una stringa, non ci spreco tempo, è già una stringa.

Non mi preoccupo di usare questo nella maggior parte del codice php; Mi baso solo sulla conversione automatica del tipo di php. Ma se si eseguono query su molti dati, per eseguire calcoli aritmetici, è sensato eseguire il cast dei tipi ottimali in anticipo.