*usr_27.txt* For Vim version 6.1. Last change: 2001 Sep 03
MANUEL de l'UTILISATEUR VIM - par Bram Moolenaar
Motifs et commandes de recherche
Dans le chapitre 3, quelques motifs de recherche simples ont été mentionnés
|03.9|. Vim peut effectuer des recherches bien plus
complexes. Ce chapitre explicite les plus utilisées d'entre elles.
Une spécification plus détaillée peut être trouvée ici : |pattern||27.1| Ignorer la casse
|27.2| Dépasser la fin d'un fichier
|27.3| Décalage
|27.4| Occurences multiples
|27.5| Alternatives
|27.6| Séries de caractères
|27.7| Classes de caractères
|27.8| Chercher un retour à la ligne
|27.9| Exemples
Chapître suivant: |usr_28.txt| Repliages
Chapître précédent: |usr_26.txt| Répétitions
Table des matières: |usr_toc.txt|==============================================================================*27.1* Ignorer la casse
Par défaut, les recherches de Vim sont sensibles à la casse. Par conséquent, "inclus",
"INCLUS", et "Inclus" sont trois mots différents et une recherche ne correspondra
qu'à l'un d'entre eux.
Activez l'option 'ignorecase':
:set ignorecase
Cherchez à nouveau "inclus", vous trouverez maintenant aussi "Inclus", "INCLUS" et
"InClUs". (activez l'option 'hlsearch' pour voir
rapidement où les motifs correspondent.)
Vous pouvez désactiver cette fonction avec:
:set noignorecase
Mais gardez-la, et cherchez "INCLUS". Vous trouverez le même texte qu'en
cherchant "inclus". Activez maintenant l'option 'smartcase':
:set ignorecase smartcase
Si vous avez un motif avec au moins une majuscule, la recherche devient
sensible à la casse. L'idée, c'est qu'il n'était pas nécessaire de taper une
majuscule; si vous l'avez fait, c'est que vous ne vouliez chercher que
l'occurence du mot comportant cette majuscule. Ca, c'est malin (smart)!
Avec ces deux options activées, vous trouverez ces occurences :
motif occurences
mot mot, Mot, MOT, MoT, etc.
Mot Mot
MOT MOT
MoT MoT
CASSE DANS UN MOTIF
Si vous voulez ignorer la casse sur un motif particulier, utilisez le
pré-caractère de commande "\c". Taper "\C" contraindra la recherche au respect
de la casse. Vous outrepassez de cette façon les options 'ignorecase' et 'smartcase', quand
"\c" ou "\C" est utilisé leur valeur est sans importance.
motif occurences
\Cmot mot
\CMot Mot
\cmot mot, Mot, MOT, MoT, etc.
\cMot mot, Mot, MOT, MoT, etc.
Le grand avantage de l'utilisation de "\c" et "\C" est qu'ils collent au
motif. Ainsi, si vous répétez un motif dans l'historique de recherche, la même
contrainte interviendra, même si les options 'ignorecase' ou 'smartcase' ont
été changées entre temps.
Note:
L'utilisation des pré-caractères "\" dans les motifs recherchés
dépend de l'option 'magic'.
Dans ce chapitre, nous supposons que l'option 'magic' est activée, ce qui est la configuration standard
et recommandée. Si vous la désactivez, de nombreux motifs de recherche
deviendront soudainement invalides.
Note:
Si votre recherche prend plus de temps qu'escompté, vous pouvez
l'interrompre avec CTRL-C sur Unix et CTRL-Break sur MS-DOS et MS-Windows.
==============================================================================*27.2* Dépasser la fin d'un fichier
Par défaut, la recherche vers l'avant d'une chaîne de caractères commence à
l'emplacement courant du curseur. Elle se déplace ensuite vers la fin du
fichier. Si, à ce moment, elle n'a pas trouvé l'occurence recherchée, elle
continue depuis le début du fichier jusqu'à l'emplacement courant du curseur.
Gardez à l'esprit qu'en utilisant "n" pour rechercher la prochaîne
occurence, vous revenez finalement à la première occurence trouvée. Si vous
oubliez ce point, la recherche se poursuit éternellement ! Pour vous guider,
Vim affiche ce message :
search hit BOTTOM, continuing at TOP (la recherche a
atteint la FIN, et continue du DEBUT)
Si vous utilisez la commande "?" pour chercher dans l'autre sens, vous obtenez
plutôt ce message :
search hit TOP, continuing at BOTTOM (la recherche a
atteint le DEBUT, et continue depuis la FIN)
Vous ne savez cependant pas quand vous êtes revenu à la première occurence
trouvée. Une façon de le savoir consiste à activer l'option 'ruler':
:set ruler
Vim affichera la position du curseur en bas à droite de la fenêtre (dans la
ligne de status, s'il y en a une). Elle ressemble à ceci:
101,29 84%
Le premier nombre est le numéro de la ligne du curseur. Mémorisez ce numéro en
commençant la recherche, de façon à savoir quand vous reviendrez à la position
initiale.
NE PAS CONTINUER
Pour désactiver cette fontion de poursuite de la recherche au delà de la fin
du fichier, utilisez la commande :
:set nowrapscan
Dès lors, quand la recherche atteint la fin du fichier, un message d'erreur
apparaît :
E385: search hit BOTTOM without match for: mot (E385
: la recherche a atteint la FIN sans trouver d'occurence pour : mot)
De cette façon, vous pouvez trouver toutes les occurences en commençant depuis
le début du fichier, avec la commande "gg" et en poursuivant la recherche
jusqu'à l'obtention de ce message.
Si vous cherchez dans l'autre sens avec "?", le message sera :
E384: search hit TOP without match for: mot (E384:
la recherche a atteint le DEBUT sans trouver d'occurence pour : mot) ==============================================================================*27.3* Décalages
Par défaut, la commande de recherche laisse le curseur positionné au début de
l'occurence. Vous pouvez demander à Vim de le laisser ailleurs en spécifiant
un emplacement. Pour la recherche en avant avec la commande "/",
l'emplacement est spécifié en ajoutant un slash (/) et l'emplacement souhaité :
/défaut/2
Cette commande cherche l'occurence "défaut" et se déplace au début de la
deuxième ligne qui suit l'occurence. En utilisant cette commande sur le
paragraphe qui précède, Vim trouve le mot "défaut" dans la première ligne. Le
curseur se déplace alors deux lignes plus bas, sur "en spécifiant".
Si l'emplacement est un nombre, le curseur sera positionné au début de la
ligne correspondante au numéro de ligne distant de l'occurence. Le numéro peut
être positif ou négatif. S'il est positif, le curseur descend d'un nombre de
lignes correspondant au numéro. S'il est négatif, il remonte.
DECALAGES DE CARACTERES
L'emplacement "e" indique un emplacement partant de la fin de l'occurence. Il
déplace le curseur sur le dernier caractère de l'occurence. La commande :
/const/e
met le curseur sur le t de "const".
Depuis cette position, ajouter un nombre déplace le curseur vers l'avant du
nombre de caractères. Cette commande déplace le curseur jusqu'au caractère
suivant l'occurence :
/const/e+1
Un numéro positif déplace le curseur vers la droite, un numéro négatif vers la
gauche. Par exemple:
/const/e-1
déplace le curseur sur le "s" de "const".
Si le décalage commence par "b", le curseur se déplace vers le début de
l'occurence. Ce n'est pas vraiment utile, puisque ne pas mettre "b" produit le
même effet. Ca n'est utile que quand un nombre est ajouté ou soustrait. Le
curseur se déplace alors d'un nombre correspondant de caractère vers l'avant
ou l'arrière. Par exemple :
/const/b+2
Déplace le curseur au début de l'occurence, puis de deux caractères vers la
droite. On arrive ainsi à "n".
REPETITION
Pour répéter la recherche de l'occurence cherchée précédemment, mais avec un
décalage différent, laissez l'occurence :
/ceci
//e
Est équivalent à :
/ceci/e
Pour la répéter avec le même décalage :
/
"n" fait la même chose. Pour enlever un décalage utilisé précédemment :
//
CHERCHER EN ARRIERE
La commande "?" utilise les décalages de la même façon, mais vous devez utiliser
"?" pour séparer le décalage de l'occurence, au lieu de "/" :
?const?e-2
Le "b" et le "e" gardent leur signification, ils ne changent pas de direction
avec le "?".
POSITION DE DEPART
Quand on commence une recherche, elle débute normalement à la position du
curseur. Quand vous spécifiez la ligne d'un décalage, cela peut prêter à
confusion. Par exemple :
/const/-2
Ceci cehrche le prochain mot "const" et remonte de deux lignes. Si vous
utilisez "n" pour chercher à nouveau, Vim repart de la même position et
retrouve le même "const" ! En utilisant le même décalage, vous retourneriez à
votre psoition de départ, et ainsi de suite : vous seriez immobilisé.
Ce pourrait être pire : supposez qu'il y ait une autre occurence de "const"
à la ligne suivante. Répéter la recherche vers l'avant trouverait cette
occurence et reculerait le curseur de deux lignes : vous retourneriez ainsi en
fait vers l'arrière !
Quand vous spécifiez un décalage, Vim compense. De cette façon, la recherche
commence quelques caractères plus haut ou plus bas, pour éviter de retrouver
la même occurence.
==============================================================================*27.4* Occurences multiples
Le caractère "*" spécifie que l'objet qui le précède peut figurer un nombre de
fois indéfini. Ainsi :
/a*
foncitonne avec "a", "aa", "aaa", etc. Mais aussi "" (chaîne vide), parce que
'zéro fois' est valide aussi.
"*" ne s'applique qu'au caractère qui le précède. Ainsi "ab*" fonctionne
avec "a", "ab", "abb", "abbb", etc. Pour que la chaîne entière soit valide
plusieurs fois, elle doit être regroupée dans un seul ensemble. On le fait en
utilisant "\(" avant et "\)" après cette chaîne. Ainsi :
/\(ab\)*
cherche : "ab", "abab", "ababab", etc. Et aussi "".
Pour ne pas accepter une chaîne vide, utilisez "\+". Cela implique que la
chaîne soit représentée une fois ou plus.
/ab\+
cherche "ab", "abb", "abbb", etc. "a" n'est pas trouvé s'il n'y a pas "b"
ensuite.
Pour représenter un objet optionnel, utilisez "\=". Exemple:
/onglets\=
cherche "onglet" et "onglets".
COMPTAGES SPECIFIQUES
Pour chercher un certain nombre d'objets, utilisez la forme "\{n,m}". "n" et "m" sont des nombres. L'objet qui les
précède sera représenté de "n" à "m" fois (inclusif). Exemple :
/ab\{3,5}
cherche "abbb", "abbbb" and "abbbbb".
Quand on omet "n", il est par défaut à zéro. Quand "m" est omis, il vaut par
défaut l'infini. Quand ",m" est omis, il vaut alors "n". Exemples:
occurence nombre de fois
\{,4} 0, 1, 2, 3 ou 4
\{3,} 3, 4, 5, etc.
\{0,1} 0 ou 1, équivalent à \=
\{0,} 0 ou plus, équivalent à *
\{1,} 1 ou plus, équivalent à \+
\{3} 3
FAIRE CORRESPONDRE UN CHAINE COURTE
A ce stade, on recherche les occurences du plus grand nombre de caractères
possible. Pour faire l'inverse, utilisez "\{-n,m}".
Le fonctionnement est le même que "\{n,m}", sauf que
dans ce cas on cherche le plus petit nombre d'occurences.
Par exemple, utilser:
/ab\{-1,3}
trouvera "ab" dans "abbb". En fait, il ne trouvera pas plus d'un b, parce
qu'il n'y a pas de raison d'en trouver plus. Il faut quelque chose de plus
pour forcer le système à trouver plus que la limite inférieure.
La même règle s'applique pour désactiver "n" et "m". Il est même possible
d'enlever les deux virgules, ce qui donne "\{-}".
Cela fait correspondre l'occurence zero fois ou plus, le moins de fois
possible. L'occurence est toujours trouvée au moins zero fois : ceci n'est
utile que combiné à autre chose. Par exemple :
/a.\{-}b
Ceci trouve "axb" dans "axbxb". Si on utilise ce schéma :
/a.*b
On chercherait autant de caractères que possible avec ".*", il trouverait donc
"axbxb" comme un tout.
==============================================================================*27.5* Alternatives
L'opérateur "ou" ("or") dans un motif est "\|". Exemple:
/foo\|bar
Ceci cherche "foo" ou "bar". D'autres alternatives peuvent être concaténées :
/un\|deux\|trois
Cherche "un", "deux" ou "trois".
Pour les chercher plus d'une fois, l'ensemble doit être placé entre "\(" et "\)":
/\(foo\|bar\)\+
Ceci cherche "foo", "foobar", "foofoo", "barfoobar", etc.
Autre exemple:
/fin\(si\|tantque\|pour\)
Ceci cherche "finsi", "fintantque" et "finpour".
Un motif relatif est marqué "\&". Ceci nécessite que les deux
alternatives soient trouvées dans la même position. Le résultat renvoie la
dernière alternative. Exemple :
/toujours\&...
Ceci cherche "tou" dans "toujours". On ne trouvera pas "toupet" par exemple.
==============================================================================*27.6* Séries de caractères
Pour trouver "a", "b" ou "c" on pourrait utiliser "/a\|b\|c". Quand on veut
chercher toutes les lettres de "a" à "z", ça devient laborieux. Il existe une
méthode plus courte :
/[a-z]
La construction avec les [] trouve ne serait-ce qu'un seul caractère. A
l'intérieur, vous spécifiez quels sont les caractères à chercher. On peut
spcécifier une liste de caractères, comme ceci :
/[0123456789abcdef]
Ceci trouvera n'importe lequel des carcatères désignés. Pour des caractères
consécutifs, on peut spécifier la série. "0-3" signifie "0123". "w-z"
signifie "wxyz".
De la sorte, la commande précédente peut être abrégée en :
/[0-9a-f]
Pour chercher le caractère "-" lui-même, mentionnez-le en premier ou en
dernier. Les caractères spéciaux suivants sont acceptés pour faciliter la
recherche dans [] (ils peuvent être utilisés partout dans la chaîne
recherchée) :
\e <Esc>
\t <Tab>
\r <CR>
\b <BS>
Il y a quelques autres cas particuliers pour les séries [], reportez-vous à
|/[]| pour plus de détails.
SERIES COMPLETEES
Pour spécifiquement ne pas chercher un caractère, utilisez "^" au début de la
série.
La recherche [] trouve alors tout, sauf les caractères spécifiés. Exemple :
/"[^"]*"
" guillemet
[^"] tout ce qui n'est pas un guillemet
* autant que possible
" encore un guillemet
Ceci trouve "foo" et "3!x", avec les guillemets.
SERIES PREDEFINIES
Certaines séries sont utilisées très souvent. Vim permet un raccourci pour les
désigner.
Par exemple:
/\a
Cherche les caractères alphabétiques. Cela revient à utiliser "/[a-zA-Z]". En
voici quelques autres :
caractère recherche equivalent
\d numérique [0-9]
\D non-numérique [^0-9]
\x numérique hexa [0-9a-fA-F]
\X numérique non-hexa [^0-9a-fA-F]
\s espace [ ] (<Tab> and <Space>)
\S non-espace [^ ] (not <Tab> and <Space>)
\l alphanumérique minuscule [a-z]
\L alpahnumérique non-minuscule [^a-z]
\u alphanumérique majuscule [A-Z]
\U alphanumérique non-majuscule [^A-Z]
Note:
Utiliser ces séries prédéfines est bien plus rapide que préciser la
série qu'ils reporésentent.
Ces caractères ne peuvent cependant pas être utilisés entre []. Ainsi,
"[\d\l]" NE MARCHE PAS pour désigner un chiffre ou un alphanumérique
minusucle. Utilisez à la place "\(\d\|\l\)".
Reportez-vous à |/\s| pour la liste complète de ces
séries.
==============================================================================*27.7* Classes de caractères
Les séries de caractères délimitaient une quantité de caractères. Une classe
de caractères est semblable, mais avec une différence essentielle : la
quantité de caractères peut être redéfinie sans changer le motif recherché.
Par exemple, chercher ce motif :
/\f\+
Le "\f" signifie caractères de noms de fichiers. Ainsi, on trouve une séquence
de caractères qui peut former un nom de fichier.
Les caractères qui peuvent former un nom de fichier dépendent de votre
système d'exploitation. Sur MS-Windows, il faut un backslash (\), pas sur
Unix. Ceci est spécifié avec l'option 'isfname'. La
valeur par défaut pour Unix est :
:set isfname
isfname=@,48-57,/,.,-,_,+,,,#,$,%,~,=
Pour d'autres systèmes d'exploitation la valeur par défaut est différente.
Vous pouvez ainsi faire une recherche avec "\f" pour chercher un nom de fichier, et
Vim s'daptera automatiquement au système d'exploitation que vous utilisez.
Note:
En fait, Unix autorise tout caractère dans un nom de fichier, y
compris l'espace. Inclure ces caractères dans 'isfname' serait théoriquement correct, mais invaliderait la possibilité de trouver la fin du nom de fichier. C'est pourquoi
la valeur par défaut de 'isfname' est celle
mentionnée plus haut, qui est un compromis.
Les classes de caractères sont :
caractère recherche option
\i caractère identifiant 'isident'
\I comme \i, sans les chiffres
\k caractère mot-clef 'iskeyword'
\K comme \k, sans les chiffres
\p caractère imprimable 'isprint'
\P comme \p, sans les chiffres
\f caractère nom de fichier 'isfname'
\F comme \f, sans les chiffres
==============================================================================*27.8* Chercher un retour à la ligne
Vim peut chercher un motif qui comprend un retour à la ligne. Il faut
préciser où ce retour a lieu, parce que tous les motifs mentionnés jusqu'ici
ne recherchent pas de retour à la ligne.
Pour en chercher un utilisez "\n" :
/le\nmot
Ceci correspondra à une ligne qui finit par "le" et une autre ligne commençant
par "mot". Pour trouver aussi "le mot", il faut pouvoir chercher un retour à
la ligne ou un espace. Pour ce faire, utilisez "\_s":
/le\_smot
Pour autoriser n'importe quelle quantité d'espaces:
/le\_s\+mot
Ceci trouve aussi quand "le " est à la fin de la ligne et " mot" au
début de celle qui suit.
"\s" trouve l'espace, "\_s" trouve l'espace ou le retour à la ligne.
De la même façon, "\a" trouve un caractère alphabétique, et "\_a" un caractère
alphabétique ou un retour à la ligne. Les autres séries et classes de
caractères peuvent être modifiées de la même façon en insérant un "_".
De nombreux autres motifs peuvent être utilisés en incluant un retour à la
ligne avec "\_". Par exemple, "\_." cherche tout caractère ou un retour à la
ligne.
Note:
"\_.*" trouve tout jusqu'à la fin du fichier. Soyez prudent, ceci peut
rendre votre recherche très lente.
Un autre exemple, "\_[]", une série qui inclue un retour à la ligne:
/"\_[^"]*"
Ceci trouve un texte entre guillemets qui peut être réparti sur plusieurs
lignes.
==============================================================================*27.9* Exemples
Voici quelques motifs de recherche qui vous paraîtront sans doute utiles. Ils
montrent comment ce qui a été mentionné peut être combiné.
TROUVER UNE PLAQUE D'IMMATRICULATION CALIFORNIENNE
Un exemple de plaque d'immatriculation serait "1MGU103". Elle comporte un
chiffre, trois lettres majuscules puis trois chiffres. On peut entrer cette
séquence directement dans un motif de recherche :
/\d\u\u\u\d\d\d
Une autre façon de faire consiste à spécifier les trois chiffres et trois
lettres avec un chiffre:
/\d\u\{3}\d\{3}
En utilisant les séries [] à la place:
/[0-9][A-Z]\{3}[0-9]\{3}
Laquelle utiliser ? Celle dont vous vous souviendrez le plus facilement. Une
technique basique et facile à mémoriser vaut mieux qu'une technique élaborée dont on
ne se souvient pas. Si vous vous les rappelez toutes, alors évitez la dernière, qui
est plus longue à taper et à exécuter.
TROUVER UN IDENTIFIANT
Dans les programmes en C (et dans de nombreux autres langages de
programmation), un identifiant débute avec une lettre, et la suite est
constituée de lettres et chiffres. Les tirets-bas (_) peuvent aussi être
utilisés. On peut trouver tout cela avec :span class="c36">
/\<\h\w*\>
"\<" et "\>" sont utilisés pour ne trouver que les mots entiers. "\h"
signifie "[A-Za-z_]" et "\w" [0-9A-Za-z_]".
Note:
"\<" et "\>" dépendent de l'option 'iskeyword'. Si elle comprend "-", par exemple, alors
"ident-" ne sera pas trouvé. Pour éviter cela, utilisez :
/\w\@<!\h\w*\w\@!
Ceci vérifie si "\w" ne se vérifie pas avant ou après l'identifiant.
Voyez |/\@<!| et |/\@!|.
==============================================================================
Prochain chapître: |usr_28.txt| Repliages
Copyright: voyez |manual-copyright| vim:tw=78:ts=8:ft=help:norl: