¿Por qué ci "puede estar fuera del área citada y ci (solo funciona dentro de paréntesis?

Cuando se usa ci"el cursor no tiene que residir en el área doblemente citada.

|String somestring = "some text";

Asumiendo que la tubería es la posición del cursor, ci"saltará al área citada.

Por otro lado, cuando se usa ci(, el cursor debe estar dentro de los paréntesis para funcionar y no moverá el cursor dentro de ellos.

¿Cuál es la razón de esta diferencia de comportamiento? Supongo que hay una manera de asignar las claves para que este comportamiento esté presente. ¿Hay algún inconveniente para hacer esto?

La principal diferencia aquí es que las declaraciones entre paréntesis (dirigidas por ci() pueden anidarse, mientras que las cadenas entre comillas (dirigidas por ci") no.

Si su cursor está fuera de una declaración entre paréntesis, aún podría estar dentro de otra. Por ejemplo ( *marca la posición del cursor):

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

La línea en la que está el cursor contiene (1, 2, 3), pero el cursor también está dentro del array(...)bloque más grande . En este caso, el más grande es el objetivo apropiado para ci(.

Si su cursor está fuera de una cadena entre comillas, ya que no pueden anidarse, no hay nada perfectamente sensato que hacer. Entonces, Vim aprovecha y encuentra la primera cadena entre comillas en la línea.

La familia de cotización de los objetos de texto ( i', i", a', y a") son diferentes que el resto de los objetos de texto en que sólo se ven en la línea actual. Debido a esto, se tomó la decisión de no requerir que el cursor esté dentro de las comillas. En cambio, Vim buscará hacia adelante dentro de la línea para encontrar una cadena entre comillas cuando el cursor no esté dentro de una.

Hay una discusión sobre algunos parches que permitirían implementar este comportamiento de búsqueda hacia adelante también para objetos de texto basados ​​en bloques.

Las otras respuestas cubrieron por qué sucede esto. Aquí hay una buena manera de evitarlo.

Wellle / Target.vim . Hace poco encontré este complemento y creo que está extremadamente subestimado. Se proporciona un nuevo objeto de texto: din(Mnemonic:. (D) elete (i) nside (n) ext "(" Esto es compatible con otros operadores y varios objetos diferentes, tales como an(, in", il((en el interior último paréntesis)

También anula el comportamiento predeterminado de i(modo que primero busca ver si el cursor está entre paréntesis, y luego, si no lo está, funciona de la misma manera que in(. Este comportamiento se puede activar o desactivar. Por ejemplo:

def foo(bar):
^cursor here

La escritura ci(funciona igual que cin(, ya que el cursor no está entre paréntesis.

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

Esto también acepta un recuento:

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

Escribiendo c2in(:

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

Esto también proporciona un nuevo objeto, "argumento". Por ejemplo, danasignifica "Eliminar alrededor del siguiente argumento". Esto también acepta un recuento. Por ejemplo:

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

Escribiendo d3ana:

def foo(arg1, arg2):
                  ^ cursor here

Hay muchas otras características que tiene este complemento, pero estas son las básicas.