English
English
When using PHP for database operations, the PDOStatement class provides a variety of methods to extract query results. Among them, fetchObject() is a very convenient way to directly map query results into objects. This article will discuss in detail the differences between using fetchObject() and custom classes, specific usage scenarios, and their performance differences.
The fetchObject() method takes a row from the result set and returns it as an object. By default, it returns an instance of stdClass , but can also be passed in a custom class name so that the query result becomes an object of a specific type.
The basic usage is as follows:
<?php
$pdo = new PDO('mysql:host=localhost;dbname=test', 'user', 'password');
$stmt = $pdo->query('SELECT id, name FROM users');
// Used by default stdClass
$user = $stmt->fetchObject();
echo $user->name;
// Using custom classes
class User {
public $id;
public $name;
public function greet() {
return "Hello, " . $this->name;
}
}
$stmt->execute(); // Re-execute the query
$user = $stmt->fetchObject('User');
echo $user->greet();
?>
Features : PHP built-in empty objects. Attributes are added dynamically, without any method.
Advantages : Lightweight, minimal creation overhead, no prior definition required.
Disadvantages : Only data can be stored, but behavioral logic cannot be attached.
Suitable for scenarios:
Just temporary data is required.
No additional business operations are required on the data object.
Quick processing of simple query results, such as presentation lists or simple API return.
Example:
$user = $stmt->fetchObject();
echo $user->name; // Read properties directly
If you want to quickly package this data into JSON:
echo json_encode($user);
Very simple and direct, with the best performance.
Features : You can define your own methods, magic methods (such as __construct , __get ), and attribute type constraints.
Advantages : Objects not only store data, but also encapsulate logic, and are more in line with the principle of OOP (object-oriented programming).
Disadvantages : There is a certain overhead when instantiating, especially when complex constructors.
Suitable for scenarios:
The data object needs to be bound to the business logic.
Properties need to be processed uniformly (such as automatic date formatting, encryption and decryption fields, etc.).
I hope the code is more maintainable and testable.
Follow the MVC and DDD (domain-driven design) model in large-scale projects.
Example:
class Product {
public $id;
public $name;
public function getDisplayName() {
return strtoupper($this->name);
}
}
$stmt = $pdo->query('SELECT id, name FROM products');
$product = $stmt->fetchObject('Product');
echo $product->getDisplayName();
This not only makes the data clear at a glance, but also increases subsequent scalability.
| project | Default stdClass | Custom Classes |
|---|---|---|
| Instantiation speed | Extremely fast (built-in) | Slightly slow (requires instantiation of user class) |
| Memory usage | Extremely low | Slightly higher (including method definition) |
| flexibility | Lower | high |
| Suitable data volume | Large amount of data | Small and medium batch data |
Generally speaking, when you need to process more than thousands of rows of large data sets and have no special requirements for object behavior, use stdClass has the best performance .
If you process business logic one by one , such as form processing, domain object modeling, and REST API response, custom classes are more suitable .
If your custom class has a constructor and the constructor has parameters, fetchObject will encounter problems. Because fetchObject calls the parameterless constructor by default. If you need to pass parameters, you can use the second parameter:
$user = $stmt->fetchObject('User', ['param1', 'param2']);
However, it should be noted that when passing parameters, PDO will call the constructor before the attribute assignment .
The default class stdClass : fast and simple, suitable for simple data reading and performance-first scenarios.
Custom Class : Strongly extensible, suitable for structured and rich behavioral scenarios, suitable for medium and large projects.
Performance Difference : stdClass is faster and more memory-saving, but in small-scale applications, the performance differences in custom classes are usually negligible.
Which method you choose depends on your project size, business complexity, and future maintenance costs .
If it is a lightweight API, such as https://api.gitbox.net/user/list , stdClass may be sufficient;
If it is a large business system, such as the order processing logic of an e-commerce platform, it is more reasonable to use custom classes!
Related Tags:
PDOStatement
