Model CodeIgniter 4 : Guide Ultime pour tout comprendre

Lorsque l’on commence à développer avec le framework PHP CodeIgniter 4, l’un des concepts essentiels à maîtriser est celui de Model CodeIgniter. Les modèles, ou Model, sont une brique fondamentale du schéma MVC (Modèle – Vue – Contrôleur). Ils permettent d’interagir proprement avec la base de données, de centraliser la logique métier, et de rendre votre code plus propre, plus maintenable et plus sécurisé.

Dans ce tutoriel, nous allons détailler en profondeur ce qu’est un Model CodeIgniter, comment le créer, l’utiliser, et surtout, comment l’adapter à vos projets.

Que vous soyez débutant ou développeur curieux, ce guide vous accompagnera étape par étape. Nous illustrerons chaque partie avec des exemples concrets et accessibles.

Qu’est-ce qu’un Model CodeIgniter ?

Un Model CodeIgniter est une classe PHP qui sert à effectuer des opérations sur la base de données : sélections, insertions, mises à jour, suppressions. Le but est de séparer les opérations de manipulation des données de la logique métier ou de l’affichage.

Avec CodeIgniter 4, les modèles étendent généralement la classe CodeIgniter\Model, qui offre de nombreuses fonctionnalités prêtes à l’emploi : pagination, validation, jointures, etc.

Pourquoi utiliser un Model CodeIgniter ?

Utiliser un Model CodeIgniter permet de :

• Centraliser les requêtes vers la base de données
• Éviter la répétition de code
• Respecter le principe DRY (Don’t Repeat Yourself)
• Faciliter les tests unitaires
• Séparer la logique métier de l’affichage
• Rendre votre code plus propre et maintenable

Structure de base d’un Model CodeIgniter

Un Model CodeIgniter est généralement créé dans le dossier app/Models. Voici un exemple simple :

<?php namespace App\Models;

use CodeIgniter\Model;

class UserModel extends Model
{
    protected $table = 'users';
    protected $primaryKey = 'id';

    protected $allowedFields = ['name', 'email', 'password'];
}

Dans cet exemple :

• protected $table indique le nom de la table associée au modèle.
• protected $primaryKey précise la clé primaire.
• protected $allowedFields est essentiel pour sécuriser les opérations insert et update.

Créer un Model CodeIgniter pas à pas

Étape 1 : Créer la table en base de données

Supposons que vous avez une table students :

CREATE TABLE students (
    id INT AUTO_INCREMENT PRIMARY KEY,
    first_name VARCHAR(100),
    age INT,
    city VARCHAR(100)
);

Étape 2 : Créer le modèle dans app/Models

<?php namespace App\Models;

use CodeIgniter\Model;

class StudentModel extends Model
{
    protected $table = 'students';
    protected $primaryKey = 'id';
    protected $allowedFields = ['first_name', 'age', 'city'];
}

Étape 3 : Utiliser le modèle dans un contrôleur

Dans un contrôleur StudentController.php :

<?php namespace App\Controllers;

use App\Models\StudentModel;

class StudentController extends BaseController
{
    public function index()
    {
        $model = new StudentModel();
        $students = $model->findAll();

        return view('students/index', ['students' => $students]);
    }
}

Consultez notre guide pour Tout savoir sur les Controller.

Méthodes principales d’un Model CodeIgniter

findAll()

Avant toute chose, il faut connecter CodeIgniter 4 à votre base de données. Ensuite, on récupère tous les enregistrements de la table.

$model->findAll();

find($id)

Récupère une ligne en fonction de son identifiant.

$model->find(5);

insert($data)

Ajoute un enregistrement.

$data = [
    'first_name' => 'Alban',
    'age' => 43,
    'city' => 'Troyes'
];
$model->insert($data);

update($id, $data)

Met à jour un enregistrement.

$data = ['city' => 'Reims'];
$model->update(5, $data);

delete($id)

Supprime un enregistrement.

$model->delete(5);

Exemple concret d’application avec Model CodeIgniter

Imaginons une application de gestion d’élèves. On souhaite afficher tous les élèves de plus de 18 ans habitant à Troyes.

Voici comment utiliser un Model CodeIgniter pour cette requête :

$students = $model
    ->where('city', 'Troyes')
    ->where('age >', 18)
    ->findAll();

On pourrait ensuite envoyer ces données à une vue :

return view('students/troyes', ['students' => $students]);

Utiliser des méthodes personnalisées dans un Model CodeIgniter

Il est possible d’ajouter vos propres méthodes dans un Model CodeIgniter pour réutiliser des requêtes fréquentes :

public function getStudentsFromCity($city)
{
    return $this->where('city', $city)->findAll();
}

Utilisation :

$students = $model->getStudentsFromCity('Troyes');

Cela rend votre code plus lisible et plus modulaire.

Valider les données dans un Model CodeIgniter

Un Model CodeIgniter peut intégrer une validation automatique :

protected $validationRules = [
    'first_name' => 'required|min_length[3]',
    'age'        => 'required|integer',
];

Avant chaque insert() ou update(), le modèle validera les données. Si les règles ne sont pas respectées, la requête est bloquée.

Pagination avec un Model CodeIgniter

La pagination est simple avec CodeIgniter 4. Voici un exemple :

$data['students'] = $model->paginate(10);
$data['pager'] = $model->pager;

Dans la vue :

<?= $pager->links() ?>

Cela crée automatiquement un système de pagination avec les bonnes URL et un affichage HTML propre.

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

Jointures avec un Model CodeIgniter

Les Model CodeIgniter permettent aussi de faire des jointures entre tables :

return $this->select('courses.*, students.first_name')
            ->join('students', 'students.id = courses.id_student')
            ->findAll();

Gérer des relations avec les Model CodeIgniter

Même si CodeIgniter 4 ne propose pas de relations automatiques comme Eloquent dans Laravel, il est tout à fait possible de gérer des relations manuelles via des jointures ou des modèles complémentaires.

Exemple : Élève et Cours

Imaginons deux modèles :

• StudentModel pour les élèves
• CourseModel pour les cours

Chaque cours est lié à un élève via id_student.

Dans CourseModel, tu peux créer une méthode personnalisée :

public function getCoursesWithStudents()
{
    return $this->select('courses.*, students.first_name')
                ->join('students', 'students.id = courses.id_student')
                ->findAll();
}

Tu peux aussi filtrer les cours d’un élève spécifique :

public function getCoursesByStudent($idStudent)
{
    return $this->where('id_student', $idStudent)->findAll();
}

Cette approche modulaire te permet de garder ton Model CodeIgniter propre et spécifique à chaque entité.

Requête dynamique avec un Model CodeIgniter

Tu peux construire des requêtes dynamiques très facilement :

public function search($keyword)
{
    return $this->like('first_name', $keyword)
                ->orLike('city', $keyword)
                ->findAll();
}

Appel dans le contrôleur :

$results = $model->search('Alban');

Grâce à cela, ton Model CodeIgniter devient une mini-API de requêtes réutilisables.

Utiliser les Model CodeIgniter avec une API REST

Tu peux facilement utiliser un Model CodeIgniter dans une API.

Exemple de méthode API :

public function listStudents()
{
    $model = new \App\Models\StudentModel();
    return $this->response->setJSON($model->findAll());
}

Pour une insertion via POST :

public function addStudent()
{
    $model = new \App\Models\StudentModel();
    $data = $this->request->getJSON(true);

    if ($model->insert($data)) {
        return $this->response->setJSON(['success' => true]);
    }

    return $this->response->setJSON(['errors' => $model->errors()]);
}

Avec les Model CodeIgniter, tu peux bâtir une API REST complète en quelques lignes.

Gérer les erreurs avec un Model CodeIgniter

Lorsque tu insères ou modifies des données avec un Model CodeIgniter, il est important de vérifier si la requête a réussi :

if (!$model->insert($data)) {
    $errors = $model->errors();
    // Afficher les erreurs ou les journaliser
}

Cela permet une gestion d’erreurs propre, surtout si tu travailles sur une API ou un formulaire interactif.

Model CodeIgniter et sécurité

Utiliser les Model CodeIgniter protège naturellement contre certaines failles :

• Injection SQL : grâce à l’utilisation de requêtes préparées
• Mass Assignment : via la propriété $allowedFields
• Validation : intégrée directement dans le modèle

Mais il reste important de filtrer les données utilisateurs avant toute manipulation.

Écrire des tests avec les Model CodeIgniter

Les Model CodeIgniter sont très simples à tester.

Exemple de test unitaire :

public function testInsertStudent()
{
    $model = new \App\Models\StudentModel();
    $id = $model->insert([
        'first_name' => 'Test',
        'age' => 22,
        'city' => 'Testville'
    ]);

    $this->assertIsInt($id);
    $this->assertNotNull($model->find($id));
}

Les Model CodeIgniter permettent une architecture testable dès le départ.

Bonnes pratiques avec les Model CodeIgniter

Voici quelques règles d’or :

1. Créer un modèle par table
   Cela rend ton code clair et modulaire.
2. Utiliser $allowedFields à chaque fois
   Pour éviter les modifications non autorisées.
3. Utiliser des méthodes personnalisées
   Cela te permet de centraliser des requêtes réutilisables.
4. Ajouter la validation dans les modèles
   Cela limite les erreurs dès le niveau modèle.
5. Séparer les responsabilités
   Ne fais pas de logique de traitement dans les modèles.

Astuce bonus : Préfixes automatiques de table

Si ta base contient des préfixes, tu peux configurer le modèle pour les gérer :

$table = 'prefix_students';

Ou bien activer les préfixes dynamiques dans le fichier Config/Database.php.

Pourquoi le Model CodeIgniter est indispensable

• Il centralise les opérations vers la base
• Il améliore la lisibilité et la maintenance du code
• Il sécurise les données
• Il est parfaitement adapté à la création d’API
• Il est léger, rapide et extrêmement flexible

Conclusion

Maîtriser les Model CodeIgniter est un prérequis indispensable pour tout projet avec le framework CodeIgniter 4. Grâce à eux, tu peux créer des applications robustes, sécurisées, et bien structurées.

Dans ce guide complet, nous avons vu :

• La structure de base d’un Model CodeIgniter
• Les méthodes intégrées (findAll, insert, update, delete)
• Des cas concrets : application élève/cours
• La validation automatique
• La pagination et les jointures
• Les requêtes dynamiques
• L’intégration dans une API
• La gestion des erreurs et des tests
• Les bonnes pratiques

Si tu souhaites aller encore plus loin avec CodeIgniter, n’hésite pas à consulter formation.crea-troyes.fr, où tu trouveras des formations gratuites en ligne, ainsi que des lives Twitch pour apprendre à coder dans une ambiance conviviale et accessible.

Allez plus loin avec CodeIgniter 4 :

• Route : Le guide complet
• Controller : Le guide complet
• Gestion des Layout avec CodeIgniter 4
• Connexion et accès sécurisé
• Mise en place d’une pagination
• Envoie de mail automatique

Alban

Fondateur de l’agence Créa-troyes.
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr