0Pricing
Lua Academy · Leçon

Tampons et fenêtres

Manipulez l’éditeur.

Tampons et fenêtres est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Tampons, fenêtres et onglets

Neovim sépare le contenu de l’affichage. Un tampon contient du texte en mémoire ; une fenêtre est une vue sur un tampon ; un onglet est une disposition de fenêtres.

Un même tampon peut apparaître dans plusieurs fenêtres. Les extensions manipulent ces identifiants, qui sont des entiers, au moyen des familles d’API nvim_buf_* et nvim_win_*.

local buf = vim.api.nvim_get_current_buf()
local win = vim.api.nvim_get_current_win()
print(buf, win)

Lire les lignes d’un tampon

nvim_buf_get_lines(buf, start, end_, strict) renvoie les lignes sous forme de liste. Les indices commencent à zéro et la borne de fin est exclue ; transmettez -1 comme fin pour atteindre la dernière ligne.

Définir strict_indexing sur false permet d’accepter les indices hors limites au lieu de générer une erreur.

local lines = vim.api.nvim_buf_get_lines(0, 0, -1, false)
print('line count: ' .. #lines)

Écrire les lignes d’un tampon

nvim_buf_set_lines remplace une plage par un nouveau texte. Pour ajouter du contenu à la fin, définissez le début et la fin sur -1. Pour tout remplacer, utilisez 0, -1.

Le remplacement est une liste Lua de chaînes, une par ligne, sans caractères de saut de ligne finaux.

vim.api.nvim_buf_set_lines(0, -1, -1, false, {
  '-- appended line',
})

Tampons temporaires

Créez un tampon non répertorié et jetable avec nvim_create_buf(listed, scratch). En transmettant false, true, vous obtenez un tampon temporaire idéal pour l’interface d’une extension.

Définissez bufhidden = 'wipe' afin qu’il disparaisse lorsque sa fenêtre se ferme et d’éviter les tampons résiduels.

local buf = vim.api.nvim_create_buf(false, true)
vim.bo[buf].bufhidden = 'wipe'
vim.api.nvim_buf_set_lines(buf, 0, -1, false, { 'Panel' })

Options propres au tampon

Utilisez vim.bo[buf] pour définir les options propres au tampon correspondant à un identifiant précis. Les paramètres courants des extensions comprennent modifiable = false et buftype = 'nofile'.

Rendre un tampon d’affichage non modifiable empêche les utilisateurs de modifier accidentellement le contenu généré.

vim.bo[buf].modifiable = false
vim.bo[buf].buftype = 'nofile'
vim.bo[buf].filetype = 'myplugin'

Ouvrir des fenêtres flottantes

nvim_open_win(buf, enter, config) place un tampon dans une fenêtre flottante. La configuration définit relative, row, col, width, height et border.

Les fenêtres flottantes sont à la base des interfaces modernes comme la documentation au survol, les sélecteurs et les notifications.

local win = vim.api.nvim_open_win(buf, true, {
  relative = 'editor', row = 5, col = 10,
  width = 40, height = 10, border = 'rounded',
})

Configuration des fenêtres

Ajustez une fenêtre flottante ouverte avec nvim_win_set_config, notamment pour la redimensionner lors de VimResized. Lisez la disposition actuelle avec nvim_win_get_config.

Définissez les options propres à la fenêtre avec vim.wo[win], par exemple pour masquer la ligne du curseur ou désactiver les colonnes de numéros dans les panneaux d’interface.

vim.wo[win].number = false
vim.wo[win].cursorline = true
vim.api.nvim_win_set_config(win, { width = 50 })

Curseur et position

Déplacez le curseur avec nvim_win_set_cursor(win, {row, col}). Notez que la ligne commence à un, tandis que la colonne commence à zéro : c’est une source fréquente d’erreurs de décalage d’une unité.

Relisez sa position avec nvim_win_get_cursor afin de mémoriser et de restaurer la position de l’utilisateur autour d’une opération.

local pos = vim.api.nvim_win_get_cursor(0)
vim.api.nvim_win_set_cursor(0, { pos[1], 0 })

Validité et nettoyage

Les identifiants peuvent devenir obsolètes. Vérifiez leur validité avec nvim_buf_is_valid et nvim_win_is_valid avant d’utiliser des identifiants conservés.

Fermez les fenêtres avec nvim_win_close(win, force) et supprimez les tampons avec nvim_buf_delete(buf, { force = true }). Vérifiez toujours la validité au préalable pour éviter les erreurs.

if vim.api.nvim_win_is_valid(win) then
  vim.api.nvim_win_close(win, true)
end

Repères étendus et espaces de noms

Les repères étendus associent des métadonnées à un texte qui se déplace au fil des modifications. Créez un espace de noms avec nvim_create_namespace, puis associez-lui du texte virtuel ou des surbrillances.

nvim_buf_set_extmark prend en charge virt_text, les colonnes de signes et les surbrillances en ligne : c’est le moteur des indications intégrées et des modules Git d’identification de l’auteur.

local ns = vim.api.nvim_create_namespace('myplugin')
vim.api.nvim_buf_set_extmark(0, ns, 0, 0, {
  virt_text = { { ' hint', 'Comment' } },
})

Lister et parcourir

nvim_list_bufs et nvim_list_wins renvoient tous les identifiants actuels. Filtrez-les avec nvim_buf_is_loaded ou en vérifiant les options.

Le parcours permet à un module complémentaire d’agir sur toute la session, par exemple en fermant chaque fenêtre flottante ou en actualisant chaque tampon d’un type de fichier donné.

for _, b in ipairs(vim.api.nvim_list_bufs()) do
  if vim.api.nvim_buf_is_loaded(b) then print(b) end
end

Vérification rapide

Vérifiez ce que vous avez appris sur les tampons et les fenêtres.

Récapitulatif : tampons et fenêtres

Les tampons contiennent du texte, les fenêtres l’affichent et les identifiants sont des entiers que vous devez valider avant de les utiliser. Vous pouvez lire et écrire des lignes, créer des tampons temporaires et définir des options locales au tampon.

Les fenêtres flottantes via nvim_open_win, le contrôle du curseur, les repères étendus et les API de listage vous fournissent tout le nécessaire pour créer des interfaces de modules complémentaires riches et avec état.

Questions Fréquemment Posées

La leçon « Tampons et fenêtres » est-elle gratuite ?

Oui — le texte complet de « Tampons et fenêtres » 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 « Tampons et fenêtres » ?

Manipulez l’éditeur. 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 3 sur 4.

Combien de temps prend la leçon « Tampons et fenêtres » ?

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. L’API Lua de Neovim
  2. Commandes et raccourcis clavier
  3. Tampons et fenêtres
  4. Empaqueter une extension
← Retour à Lua Academy