Por que ci "pode ​​estar fora da área entre aspas e ci (funciona apenas entre parênteses?

Ao usar ci"o cursor, não é necessário residir na área de aspas duplas.

|String somestring = "some text";

Assumindo que o tubo esteja na posição do cursor, ci"ele fará o salto para a área citada.

Por outro lado, ao usar ci(, o cursor deve estar dentro dos parênteses para funcionar e não moverá o cursor dentro deles.

Qual é o motivo dessa diferença de comportamento? Suponho que existe uma maneira de mapear as chaves para que esse comportamento esteja presente. Existem desvantagens em fazer isso?

A principal diferença aqui é que as declarações entre parênteses (direcionadas por ci() podem ser aninhadas, enquanto as seqüências de caracteres citadas (direcionadas por ci") não podem.

Se o cursor estiver fora de alguma declaração entre parênteses, ele ainda poderá estar dentro de outra. Por exemplo ( *marca a posição do cursor):

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

A linha em que o cursor está contém (1, 2, 3), mas o cursor também está dentro do array(...)bloco maior . Nesse caso, o maior é o destino apropriado ci(.

Se o cursor estiver fora de alguma string citada, uma vez que ela não pode ser aninhada, não há nada perfeitamente sensato a ser feito. Portanto, o Vim aproveita e encontra a primeira string citada na linha.

A família Citação de objetos de texto ( i', i", a'e a") são diferentes do que o resto dos objetos de texto em que eles só olhar para a linha atual. Por esse motivo, optou-se por não exigir que o cursor estivesse dentro das aspas. Em vez disso, o Vim pesquisará para frente dentro da linha para encontrar uma string entre aspas quando o cursor ainda não estiver dentro de uma.

Há uma discussão em torno de alguns patches que permitiriam que esse comportamento de pesquisa direta fosse implementado também para objetos de texto baseados em bloco.

As outras respostas abordaram por que isso acontece. Aqui está uma boa maneira de contornar isso.

wellle / target.vim . Eu encontrei recentemente este plugin e acho extremamente subestimado. Ele fornece um novo objeto de texto: din(Mnemonic:. (D) elete (i) nside (n) ext "(" Este é compatível com outros operadores e vários objetos diferentes, como an(, in", il((dentro do último parênteses)

Ele também substitui o comportamento padrão de i(modo que ele primeiro verifique se o cursor está entre parênteses e, se não estiver, funciona da mesma maneira que in(. Esse comportamento pode ser ativado ou desativado. Por exemplo:

def foo(bar):
^cursor here

A digitação ci(age da mesma forma que cin(, já que o cursor não está entre parênteses.

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

Isso também aceita uma contagem:

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

Digitando c2in(:

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

Isso também fornece um novo objeto, "argumento". Por exemplo, danasignifica "Excluir no próximo argumento". Isso também aceita uma contagem. Por exemplo:

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

Digitando d3ana:

def foo(arg1, arg2):
                  ^ cursor here

Existem muitos outros recursos que este plug-in possui, mas esses são os básicos.