Melhor resposta
Não acredito que ninguém disse Vim ainda. Vim!
Depois de superar a curva de aprendizado inicial, é uma ferramenta incrível para automatizar tarefas de programação mundanas. Vou te dar um exemplo que usei hoje cedo.
Eu estava criando uma classe de leitor XML (herdada de uma classe XML base) para um componente de nossa base de código. O .xml era parecido com isto.
...
O problema era (devido à arquitetura existente) que todos esses valores de campo precisavam ser membros de dados privados de Some\_XML\_Class no código. O que significava que eu estava prestes a fazer um monte de trabalho sem sentido convertendo field-one em std :: string m\_field\_one , para cada um desses campos.
É aí que entra o Vim. Em vez de matar 20 minutos fazendo da maneira mais difícil. Colei a seção de código acima e gravei uma macro.
^xistd::string m\_
Esta série de comandos do vim faz o seguinte. Vai para o primeiro caractere da linha e o exclui (‘ é excluído). Vai para o modo de inserção e adiciona std :: string m\_ a campo . Em seguida, ele encontra a primeira ocorrência de ‘-’ e a substitui por ‘\_’. Em seguida, ele salta para o final da palavra field\_N , entra no modo anexar e adiciona um ponto e vírgula e move o cursor um para a direita. De modo que agora temos
std::string m\_field\_one;value="value1" />
Mas ainda não terminamos. Em seguida, entramos no modo de comando, apagamos o resto da linha e pulamos para a próxima. Para que tenhamos:
std::string m\_field\_one;
Observe que a linha um está perfeitamente formatada e o cursor está atualmente na linha dois.
A próxima parte é onde entra a mágica. Antes de executarmos esse comando, começamos a gravar uma macro para registrar a . Usando o comando q seguido por a . Fazendo assim o comando completo da seguinte maneira (onde o q final é usado para indicar o encerramento da macro).
qa^xistd::string m\_
Agora, se bem chamarmos essa macro usando o comando Vim:
@a
Ele executa novamente a macro e formata automaticamente sua próxima linha:
std::string m\_field\_one;
std::string m\_field\_two;
Mas espere, ainda temos N-2 linhas com estrutura semelhante! Vamos supor que, neste caso, N fosse igual a 100. Sem problemas. Simplesmente digitamos o comando:
98@a
Isso executa a macro acima 98 vezes mais, formatando automaticamente o restante do seu código !! Agora temos:
std::string m\_field\_one;
std::string m\_field\_two;
std::string m\_field\_three;
...
std::string m\_field\_ninetynine
std::string m\_field\_onehundered;
Estupendo .
* PS: No início, esses comandos podem parecer estranhos e assustadores para você, mas depois de passar algum tempo com o Vim como seu editor principal, eles se tornam uma segunda natureza. A macro de exemplo me levou 10 segundos para escrever e economizou uma grande quantidade de tempo.
* PPS: Eu sei que o código de exemplo é muito estúpido, mas usei-o apenas para ilustrar um ponto. No entanto, no mundo real, você encontrará casos semelhantes.
Resposta
Obrigado por perguntar.
Vim aqui inicialmente para alertar contra esse objetivo, com base apenas no título … Basicamente, hoje você escreveria um editor de texto porque:
- Você tem uma necessidade muito específica (mas, neste caso, é melhor começar a partir de uma base existente, em vez de ir do zero, a menos que você tenha ideias muito novas);
- OU você acha que é um exercício interessante de programação; que é de fato o seu objetivo.
Porque, francamente, se você não consegue encontrar o editor dos seus sonhos na casa das centenas, se não milhares dos existentes, você é muito exigente!; -)
Também fiquei tentado a dizer que escrever um editor de texto do zero pode ser um pouco assustador para um iniciante; digamos que é uma tarefa de nível intermediário: um pouco difícil para um iniciante absoluto, executável uma vez você ganha alguma experiência.
Dito isso, eu escrevi meu próprio editor de texto quando ainda era um iniciante: recém-saído da universidade, codificado apenas um pouco em C, sem nenhum projeto real. Mas eu estava em um PC com SCO Unix tendo apenas o vi como editor. E não gosto por causa dos dois modos (navegação x edição) que sempre me confunde (começar a digitar, ver meu texto só depois do primeiro i …).
Então eu comecei a codificar meu editor em C, usando Curses como interface, fazendo minhas próprias estruturas de dados (provavelmente ineficientes, mas lidávamos com arquivos pequenos na época), etc.
Eu me diverti muito, aprendi muito, e quando outros usuários começaram a usar também, descobri que eles sempre fazem coisas inesperadas, como misturar tabulações e espaços … 🙂
Novamente, se você é um iniciante, deve começar com projetos menores, para aprender sobre as bases da linguagem (loops, arrays, etc.), sobre estruturas de dados, como ler e escrever arquivos de texto, etc.
É difícil aconselhar para uma linguagem … Para um projeto baseado em JVM, eu usaria Ceylon, talvez com JavaFX ou SWT. Para um projeto “próximo ao metal”, eu usaria Rust (há um projeto inicial sobre como escrever um editor de texto em Rust, parece promissor), enquanto outros aconselhariam o uso de C ++ (o que pode ser esmagador para um iniciante!) Para uma linguagem mais fácil, talvez Lua seja uma boa opção (outros recomendariam usar Python, mas não tenho experiência com isso). Ou talvez JavaScript, com Node.js e a plataforma Electron, uma opção de tendência … (Atom, Visual Studio Code e Brackets foram escritos com isso. Mas isso é apenas “do zero”, pois eles usam editores de código JS existentes. )
Conselho geral: primeiro projete sua estrutura de dados (a estratégia de duas partes usada pelo projeto Scintilla é boa; as cordas, como usadas pelo projeto Rust, são um pouco mais / muito avançadas), como você manipula os dados: como adicionar ou remover um caractere, uma linha, uma seleção, etc.
Então pense na IU. O ideal é separar as duas (manipulação de dados e exibição de dados). Dessa forma, algum dia você pode alterar o destino da IU (de Swing para JavaFX, de GTK + para Qt, qualquer que seja) com pouca ou nenhuma mudança em sua lógica de base. Bom para portabilidade.