fetch_object

mysqli_fetch_object() lee la siguiente fila de un conjunto de resultados MySQLi y la devuelve como un PHP object cuyas propiedades tienen el nombre de las columnas de tu consulta. Es el equivalente orientado a objetos de mysqli_fetch_assoc() y mysqli_fetch_array(): en lugar de escribir $row['name'] escribes $row->name.

Este capítulo cubre la firma de la función, cómo acceder a las columnas, cómo hidratar filas en tus propias clases, el manejo de errores y cuándo usarla frente a los fetchers basados en arrays.

Sintaxis

mysqli_fetch_object(
    mysqli_result $result,
    string $class = "stdClass",
    array $constructor_args = []
): object|null|false

En el estilo orientado a objetos la misma llamada es $result->fetch_object().

Valor de retorno:

• Un object relleno con las columnas de la fila cuando hay una fila disponible.
• null cuando no hay más filas (esto es lo que termina el bucle while).
• false en caso de fallo.

Uso básico

Llama a la función en un bucle while. Cada iteración avanza el puntero interno de filas una posición hasta que se devuelve null:

<?php
$mysqli = mysqli_connect("localhost", "username", "password", "database");

$result = mysqli_query($mysqli, "SELECT name, email FROM users");

if ($result) {
    while ($row = mysqli_fetch_object($result)) {
        printf("%s (%s)\n", $row->name, $row->email);
    }
    mysqli_free_result($result);
}

mysqli_close($mysqli);
?>

Cada $row es un object stdClass, por lo que sus propiedades coinciden con los nombres de las columnas seleccionadas (o sus alias). Si una columna no existe en la fila obtendrás un aviso y null, así que selecciona siempre las columnas que vayas a leer.

Importante — nombres de columnas, no posiciones. Como el object está indexado por nombre, SELECT * y SELECT name, email se comportan de forma diferente en cuanto al orden. Prefiere nombrar las columnas de forma explícita para que un cambio de esquema no pueda romper el acceso a las propiedades.

Hidratar filas en tu propia clase

La verdadera ventaja de mysqli_fetch_object() sobre los fetchers de array es que puede construir instancias de tu clase. Pasa el nombre de la clase como segundo argumento:

<?php
class User
{
    public string $name;
    public string $email;

    public function greet(): string
    {
        return "Hi, I'm {$this->name}";
    }
}

$result = mysqli_query($mysqli, "SELECT name, email FROM users");

while ($user = mysqli_fetch_object($result, User::class)) {
    echo $user->greet(), "\n"; // calls a real method on a real User object
}
?>

La asignación de propiedades ocurre antes de que se ejecute el constructor. PHP establece los valores de las columnas directamente en las propiedades del object primero y luego llama a __construct(). Si tu clase necesita que el constructor vea esos valores, ten en cuenta ese orden:

<?php
class Product
{
    public string $name;
    public float  $price;
    public string $label;

    public function __construct(string $currency = "USD")
    {
        // $this->name and $this->price are already set here
        $this->label = "{$this->name}: {$this->price} {$currency}";
    }
}

// Constructor args are passed as the third parameter:
$product = mysqli_fetch_object($result, Product::class, ["EUR"]);
?>

Manejo de ausencia de filas y errores

Distingue "no hay más filas" (null) de un fallo real (false):

<?php
$result = mysqli_query($mysqli, "SELECT name FROM users WHERE id = 999");

if ($result === false) {
    echo "Query failed: " . mysqli_error($mysqli);
} else {
    $row = mysqli_fetch_object($result);

    if ($row === null) {
        echo "No user found.";
    } else {
        echo $row->name;
    }
}
?>

Para código en producción, activa el modo de excepción para que las consultas fallidas lancen excepciones en lugar de devolver false:

<?php
mysqli_report(MYSQLI_REPORT_ERROR | MYSQLI_REPORT_STRICT);

fetch_object frente a los otros fetchers

Elige mysqli_fetch_object() cuando quieras un acceso limpio con ->propiedad o cuando quieras convertir cada fila en un object de dominio con comportamiento (métodos). Elige los fetchers de array cuando solo necesites datos planos para iterar o serializar.

Buenas prácticas

• Usa sentencias preparadas para cualquier valor que provenga de la entrada del usuario para prevenir la inyección SQL; aún puedes llamar a fetch_object() sobre el resultado de una sentencia preparada.
• Libera el resultado con mysqli_free_result() cuando hayas terminado para liberar memoria en conjuntos de resultados grandes.
• Selecciona solo las columnas que necesitas para que las propiedades del object sean predecibles y las consultas se mantengan rápidas.

Conclusión

mysqli_fetch_object() recorre un conjunto de resultados MySQLi fila por fila, devolviendo cada fila como un object con propiedades nombradas por columna — o, cuando se le proporciona un nombre de clase, como una instancia completamente construida de tu propia clase. Devuelve null cuando se agotan las filas y false en caso de fallo. Úsala cuando la sintaxis de object o la hidratación de dominio sea más clara que los fetchers basados en array como mysqli_fetch_assoc().

Práctica