Je voudrais utiliser la fonction de substitution de vim (:% s) pour rechercher et remplacer un certain modèle de code. Par exemple, si j'ai un code similaire au suivant:

if(!foo)

Je voudrais le remplacer par:

if(foo == NULL)

Cependant, foo n'est qu'un exemple. Le nom de la variable peut être n'importe quoi.

Voici ce que j'ai proposé pour ma commande vim:

:%s/if(!.*)/if(.* == NULL)/gc

Il recherche correctement les instructions, mais il essaie de le remplacer par ". *" Au lieu de la variable qui s'y trouve (c'est-à-dire "foo"). Existe-t-il un moyen de faire ce que je demande avec vim?

Sinon, y a-t-il d'autres éditeurs / outils que je peux utiliser pour m'aider avec de telles modifications?

Merci d'avance!

1
still.Learning 26 janv. 2017 à 03:29

4 réponses

Meilleure réponse

Pour ce faire, vous devez utiliser le regroupement de capture et le renvoi en arrière :

      Pattern     String sub. flags
    |---------| |------------| |-|
:%s/if(!\(.*\))/if(\1 == NULL)/gc
         |---|    |--|
           |        ^
           |________|
 The matched string in pattern will be exactly repeated in string substitution

:help /\(

\(\)    A pattern enclosed by escaped parentheses.                 /\(/\(\) /\)
        E.g., "\(^a\)" matches 'a' at the start of a line.
        E51 E54 E55 E872 E873 

\1      Matches the same string that was matched by                     /\1 E65
        the first sub-expression in \( and \). {not in Vi}
        Example: "\([a-z]\).\1" matches "ata", "ehe", "tot", etc. 
\2      Like "\1", but uses second sub-expression,                      /\2  
   ...                                                                  /\3
\9      Like "\1", but uses ninth sub-expression.                       /\9
        Note: The numbering of groups is done based on which "\(" comes first
        in the pattern (going left to right), NOT based on what is matched
        first.
5
Meninx - メネンックス 26 janv. 2017 à 03:18

Essayez ce qui suit:

%s/if(!\(.\{-}\))/if(\1 == NULL)/gc

Le quantificateur .\{-} correspond à un mot non vide, le moins possible (plus strict que .*).

Les paranthèses \( et \) sont utilisées pour diviser l'expression recherchée en sous-expressions, afin que vous puissiez utiliser ces sous-groupes dans la chaîne de substitution.

Enfin, \1 permet à l'utilisateur d'utiliser la première sous-expression correspondante, dans notre cas c'est tout ce qui est pris à l'intérieur de la paranthèse.

J'espère que c'est plus clair, plus d'informations peuvent être trouvées ici. Et merci pour le commentaire qui suggère d'améliorer la réponse.

0
ilke444 26 janv. 2017 à 19:06

Une macro est facile dans ce cas, procédez comme suit:

qa .............. starts macro 'a'
f! .............. jumps to next '!'
x ............... erase that
e ............... jump to the end of word
a ............... starts append mode (insert)
== NULL ........ literal == NULL
<ESC> ........... stop insert mode
q ............... stops macro 'a'

:%norm @a ........ apply marco 'a' in the whole file
:g/^if(!/ norm @a  apply macro 'a' in the lines starting with if...
0
SergioAraujo 26 janv. 2017 à 17:27

Vous pouvez utiliser

:%s/if(!\(.*\))/if(\1 == NULL)/gc

En mettant. * Dans \ (\), vous créez un groupe capturé numéroté, ce qui signifie que l'expression régulière capturera ce qui se trouve. * Lorsque le remplacement commence, en utilisant \ 1, vous imprimerez le groupe capturé.

2
Viktor Nonov 26 janv. 2017 à 00:38