0Pricing
Lua Academy · Leçon

Gestion des versions et des dépendances

Suivez les versions des modules d’extension et vérifiez leur compatibilité lors du chargement.

Gestion des versions et des dépendances est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Pourquoi la gestion des versions est importante

Les plug-ins évoluent. Un plug-in en version 2.0 peut être incompatible avec les API de la version 1.0. Le suivi des versions évite les échecs de compatibilité silencieux.

Gestion sémantique des versions

Utilisez la gestion sémantique des versions : MAJOR.MINOR.PATCH. Les changements incompatibles incrémentent MAJOR, les nouvelles fonctionnalités incrémentent MINOR et les corrections de bogues incrémentent PATCH.

Manifeste de plug-in avec version

Chaque plug-in déclare sa propre version et la version requise de l’API de l’application.

return {
  name        = "auth",
  version     = "2.1.0",
  apiRequired = ">=1.0.0",
  deps        = { {name="logger", version=">=1.0.0"} },
  init        = function(app) -- ... end
}

Analyse des versions

Analysez une chaîne de version en composants comparables.

local function parseVersion(v)
  local major, minor, patch = v:match("(%d+)%.(%d+)%.(%d+)")
  return {tonumber(major), tonumber(minor), tonumber(patch)}
end
local function versionGe(a, b)
  a, b = parseVersion(a), parseVersion(b)
  for i = 1, 3 do
    if a[i] ~= b[i] then return a[i] > b[i] end
  end
  return true
end

Vérification de compatibilité

Lors du chargement d’un plug-in, vérifiez que la version de l’API de l’application respecte l’exigence du plug-in.

local APP_VERSION = "1.5.0"
local function checkCompatibility(plugin)
  local req = plugin.apiRequired or ">=0.0.0"
  local minVer = req:match(">=(.+)")
  if minVer and not versionGe(APP_VERSION, minVer) then
    error(("Plugin %s requires app >= %s, got %s"):format(
      plugin.name, minVer, APP_VERSION))
  end
end

Résolution du graphe de dépendances

Construisez un graphe de dépendances et effectuez un tri topologique pour déterminer l’ordre de chargement.

Détection des dépendances circulaires

Suivez les plug-ins en cours de chargement. Si un plug-in dépend d’un autre qui est déjà en cours de chargement (dans un cycle), signalez une erreur.

local loading = {}
local function loadWithCycleCheck(name, plugins)
  if loading[name] then error("Circular dependency: " .. name) end
  loading[name] = true
  -- load deps then load plugin
  loading[name] = nil
end

Voies de mise à niveau

Documentez des guides de migration pour les changements de version MAJOR. Envisagez de fournir une couche de compatibilité pour les anciennes API de plug-ins pendant une période de transition.

Registre des plug-ins avec versions

Un registre central stocke toutes les versions des plug-ins installés. Résolvez les conflits en privilégiant la version compatible la plus élevée.

Modèle de fichier de verrouillage

Comme le fichier package-lock.json de npm : consignez les versions exactes utilisées dans un déploiement de production afin de garantir des compilations reproductibles.

Négociation des versions à l’exécution

Permettez aux plug-ins de déclarer plusieurs versions compatibles de l’API. L’application hôte négocie et choisit la version la plus élevée prise en charge par les deux parties.

Question sur la gestion des versions

Que signale l’incrémentation de la version MAJOR dans la gestion sémantique des versions ?

Récapitulatif : versions et dépendances

Incluez la version et apiRequired dans chaque manifeste de plug-in. Analysez et comparez les versions au chargement. Détectez les dépendances circulaires. Utilisez un tri topologique pour déterminer l’ordre de chargement. Conservez un fichier de verrouillage pour garantir des déploiements de production reproductibles.

Questions Fréquemment Posées

La leçon « Gestion des versions et des dépendances » est-elle gratuite ?

Oui — le texte complet de « Gestion des versions et des dépendances » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gestion des versions et des dépendances » ?

Suivez les versions des modules d’extension et vérifiez leur compatibilité lors du chargement. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Gestion des versions et des dépendances » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Découverte et chargement de modules d’extension
  2. API de modules d’extension et système de hooks
  3. Mettre les modules d’extension en bac à sable
  4. Gestion des versions et des dépendances
← Retour à Lua Academy