Pourquoi ci "peut-il être en dehors de la zone citée et ci (ne fonctionne qu'à l'intérieur des parenthèses?

Lors de l'utilisation ci"du curseur ne doit pas résider dans la zone entre guillemets doubles.

|String somestring = "some text";

En supposant que le tuyau est la position du curseur, ci"cela le fera sauter à la zone citée.

D'un autre côté, lors de l'utilisation ci(, le curseur doit être à l'intérieur des parenthèses pour fonctionner et ne déplacera pas le curseur à l'intérieur.

Quelle est la raison de cette différence de comportement? Je suppose qu'il existe un moyen de mapper les clés afin que ce comportement soit présent. Y a-t-il des inconvénients à faire cela?

La principale différence ici est que les instructions entre parenthèses (ciblées par ci() peuvent être imbriquées, contrairement aux chaînes entre guillemets (ciblées par ci").

Si votre curseur se trouve en dehors d'une instruction entre parenthèses, il pourrait toujours être à l'intérieur d'une autre instruction. Par exemple ( *marque la position du curseur):

$foo = array(
    'x' => ar*ray(1, 2, 3),
);

La ligne sur laquelle se trouve le curseur contient (1, 2, 3), mais le curseur se trouve également à l'intérieur du array(...)bloc le plus grand . Dans ce cas, le plus grand est la cible appropriée pour ci(.

Si votre curseur est en dehors d'une chaîne entre guillemets, puisqu'ils ne peuvent pas être imbriqués, il n'y a rien de parfaitement sensé à faire. Ainsi, Vim profite et trouve la première chaîne entre guillemets sur la ligne.

La famille de citation des objets texte ( i', i", a'et a") sont différentes que le reste des objets texte en ce sens qu'ils ne regardent que la ligne actuelle. Pour cette raison, le choix a été fait de ne pas exiger que le curseur soit entre les guillemets. Au lieu de cela, Vim recherchera dans la ligne pour trouver une chaîne entre guillemets lorsque le curseur n'est pas déjà à l'intérieur.

Il y a une discussion autour de certains correctifs qui permettraient également à ce comportement de recherche directe d'être implémenté pour les objets texte basés sur des blocs.

Les autres réponses ont expliqué pourquoi cela se produit. Voici une belle façon de contourner ce problème.

wellle / target.vim . J'ai récemment trouvé ce plugin, et je pense qu'il est extrêmement sous-estimé. Il fournit un nouvel objet texte: din(Mnémonique:. (D) elete (i) nside (n) poste « ( » Ceci est compatible avec d' autres opérateurs et plusieurs objets différents, tels que an(, in", il(( à l' intérieur dernière parenthèse)

Il remplace également le comportement par défaut de i(afin qu'il regarde d'abord si le curseur est entre parenthèses, puis s'il ne l'est pas, il fonctionne de la même manière que in(. Ce comportement peut être activé ou désactivé. Par exemple:

def foo(bar):
^cursor here

La saisie ci(agit de la même manière que cin(, puisque le curseur n'est pas entre parenthèses.

def foo( ):
        ^Cursor here, and in insert mode

Cela accepte également un décompte:

def foo(bar):           #Define function foo(bar)
^cursor here

Dactylographie c2in(:

def foo(bar):           #Define function foo( )
                                             ^cursor here

Cela fournit également un nouvel objet, "argument". Par exemple, danasignifie "Supprimer autour de l'argument suivant". Cela accepte également un décompte. Par exemple:

def foo(arg1, arg2, BADarg3):
^ cursor here

Dactylographie d3ana:

def foo(arg1, arg2):
                  ^ cursor here

Il existe de nombreuses autres fonctionnalités de ce plugin, mais ce sont les principales.