O campo inteiro do MySQL é retornado como string no PHP

Eu tenho um campo de tabela em um banco de dados MySQL:

userid INT(11)

Então, eu estou chamando para a minha página com esta consulta:

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

Então, para lidar com o resultado, eu faço:

$row=$result->fetch_assoc();

$id=$row['userid'];

Agora se eu fizer:

echo gettype($id);

Eu recebo uma corda. Não deveria ser um número inteiro?

Quando você seleciona dados de um banco de dados MySQL usando PHP, o tipo de dados sempre será convertido em uma string. Você pode convertê-lo novamente em um número inteiro usando o seguinte código:

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

Ou usando a função intval():

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

Use o mysqlnd (driver nativo) para php.

Se você estiver no Ubuntu:

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

Se você estiver no Centos:

sudo yum install php-mysqlnd
sudo service httpd restart

O driver nativo retorna tipos inteiros adequadamente.

Editar:

Como o @Jeroen apontou, esse método só funciona imediatamente para a DOP.
Como o @LarsMoelleken apontou, este método funcionará com o mysqli se você também definir a opção MYSQLI_OPT_INT_AND_FLOAT_NATIVE como true.

Exemplo:

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

Solução mais fácil que encontrei:

Você pode forçar o json_encode a usar números reais para valores parecidos com números:

json_encode($data, JSON_NUMERIC_CHECK) 

(desde o PHP 5.3.3).

Ou você pode simplesmente converter seu ID para um int.

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

Minha solução é passar o resultado da consulta $rse obter uma matriz assoc dos dados convertidos como o retorno:

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

Exemplo de uso:

$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

Não. Independentemente do tipo de dado definido em suas tabelas, o driver MySQL do PHP sempre serve valores de linha como strings.

Você precisa converter seu ID para um int.

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

Eu gosto da resposta do Chade, especialmente quando os resultados da consulta serão repassados ​​para javascript em um navegador. O Javascript lida de maneira limpa com entidades semelhantes numéricas como números, mas requer trabalho extra para lidar com entidades semelhantes numéricas como seqüências de caracteres. ou seja, deve usar parseInt ou parseFloat neles.

Com base na solução do Chade, eu uso isso e geralmente é exatamente o que eu preciso e cria estruturas que podem ser codificadas em JSON para facilitar o manuseio em 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;
    }
}

Adicionar uma sequência numérica a 0 produz um tipo numérico no PHP e identifica corretamente o tipo para que os números de ponto flutuante não sejam truncados em números inteiros.

Isso acontece quando PDO::ATTR_EMULATE_PREPARESestá definido como truena conexão.

Cuidado, porém, configurá-lo para falsenão permitir o uso de parâmetros mais de uma vez. Acredito que isso também afeta a qualidade das mensagens de erro retornadas.

Você pode fazer isso com ...

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

... dependendo da extensão que você deseja usar. O primeiro não é recomendado porque a extensão mysql está obsoleta. O terceiro ainda é experimental.

Os comentários nesses hiperlinks explicam como definir seu tipo de uma seqüência antiga simples para seu tipo original no banco de dados.

Algumas estruturas também abstraem isso (o CodeIgniter fornece $this->db->field_data()).

Você também pode adivinhar - como percorrer as linhas resultantes e usar is_numeric () em cada uma. Algo como:

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

Isso transformaria qualquer coisa que parecesse um número em um ... definitivamente não é perfeito.

No meu projeto, geralmente uso uma função externa que "filtra" os dados recuperados mysql_fetch_assoc.

Você pode renomear campos na sua tabela para que seja intuitivo entender qual tipo de dados está armazenado.

Por exemplo, você pode adicionar um sufixo especial a cada campo numérico: se useridfor um, INT(11)você pode renomeá-lo userid_iou, se for, UNSIGNED INT(11)você pode renomear userid_u. Nesse ponto, você pode escrever uma função PHP simples que receba como entrada a matriz associativa (recuperada com mysql_fetch_assoc) e aplicar a conversão ao "valor" armazenado com essas "chaves" especiais.

Se declarações preparadas forem usadas, o tipo será int, quando apropriado. Esse código retorna uma matriz de linhas, onde cada linha é uma matriz associativa. Como se fetch_assoc()fosse chamado para todas as linhas, mas com informações de tipo preservadas.

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

O MySQL possui drivers para muitas outras linguagens, converter dados em string "padroniza" dados e deixa ao usuário digitar valores de conversão para int ou outros

No meu caso, a mysqlnd.soextensão foi instalada. MAS eu não tinha pdo_mysqlnd.so. Portanto, o problema foi resolvido substituindo-o pdo_mysql.sopor pdo_mysqlnd.so.

Eu gosto da técnica do idealizador , mas a codificação pode ser mais simples:

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

Também adicionei a verificação de consultas retornando false em vez de um conjunto de resultados.
E verificando uma linha com um campo que tenha um valor nulo.
E se o tipo desejado é uma string, não perco tempo com ela - já é uma string.

Eu não me incomodo em usar isso na maioria dos códigos php; Eu apenas confio na conversão automática de tipos do php. Mas, se você estiver consultando muitos dados, para realizar cálculos aritméticos, é sensato converter os tipos ideais no início.