Migliore risposta
Non posso credere che nessuno abbia ancora detto Vim. Vim!
Una volta superata la curva di apprendimento iniziale, è uno strumento straordinario per automatizzare compiti di programmazione banali. Ti fornirò un esempio che ho usato oggi.
Stavo creando una classe di lettore XML (ereditata da una classe XML di base) per un componente della nostra base di codice. Il file .xml aveva un aspetto simile a questo.
...
Il problema era (a causa dellarchitettura esistente) che questi valori di campo dovevano essere tutti membri di dati privati di Some\_XML\_Class nel codice. Il che significava che stavo per fare un sacco di lavoro senza senso per convertire field-one in std :: string m\_field\_one , per ciascuno di questi campi.
È qui che entra in gioco Vim. Invece di ammazzare 20 minuti nel modo più duro. Ho incollato la sezione di codice precedente e ho registrato una macro.
^xistd::string m\_
Questa serie di comandi vim fa quanto segue. Va al primo carattere della riga e lo elimina (” viene eliminato). Passa alla modalità di inserimento e antepone “ std :: string m\_ a campo . Quindi trova la prima occorrenza di “-” e la sostituisce con “\_”. Quindi salta alla fine della parola field\_N , entra in modalità di aggiunta e aggiunge un punto e virgola e sposta il cursore di uno a destra. Così ora abbiamo
std::string m\_field\_one;value="value1" />
Ma non abbiamo finito. Quindi andiamo in modalità di comando, cancelliamo il resto della riga e passiamo a quella successiva. In questo modo abbiamo:
std::string m\_field\_one;
Nota che la riga uno è perfettamente formattata e il cursore si trova attualmente sulla riga due.
Questa parte successiva è se arriva la magia. Prima di eseguire quel comando, abbiamo iniziato a registrare una macro per registrare “a” . Utilizzando il comando q seguito da a . Così facendo il comando completo come segue (dove il q finale viene utilizzato per indicare la fine della macro).
qa^xistd::string m\_
Ora, se va bene, chiama quella macro usando il comando Vim:
@a
Riesegue la macro e formatta automaticamente la riga successiva:
std::string m\_field\_one;
std::string m\_field\_two;
Ma aspetta, abbiamo ancora N-2 righe con una struttura simile! Supponiamo che in questo caso N sia uguale a 100. Nessun problema. Digitiamo semplicemente il comando:
98@a
Questo esegue la macro sopra 98 altre volte, formattando automaticamente il resto del codice !! Ora abbiamo:
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;
Stupendo .
* PS: Allinizio questi comandi possono sembrarti estranei e spaventosi, ma una volta che hai passato un po di tempo con Vim come editor principale, diventano una seconda natura. La macro di esempio mi ha impiegato 10 secondi per scrivere e ha risparmiato una quantità enorme di tempo.
* PPS: So che il codice di esempio è piuttosto stupido, ma lho usato solo per illustrare un punto. Tuttavia nel mondo reale ti imbatterai in casi simili.
Risposta
Grazie per avermelo chiesto.
Sono venuto qui inizialmente per mettere in guardia contro tale obiettivo, basato solo sul titolo … Fondamentalmente, oggi scriveresti un editor di testo perché:
- Hai unesigenza molto specifica (ma in questo caso, è ancora meglio partire da una base esistente, piuttosto che andando da zero, a meno che tu non abbia idee molto nuove);
- OPPURE lo consideri un interessante esercizio di programmazione; che è davvero il tuo obiettivo.
Perché, francamente, se non riesci a trovare il tuo editor dei sogni tra centinaia, se non migliaia di quelli esistenti, sei molto esigente!; -)
Sono stato anche tentato di dire che scrivere un editor di testo da zero può essere un po scoraggiante per un principiante; diciamo che è un compito di livello intermedio: un po difficile per un principiante assoluto, fattibile una volta hai un po di esperienza.
Detto questo, ho scritto il mio editor di testo quando ero ancora un principiante: appena uscito dalluniversità, codificavo solo un po in C, senza un vero progetto. Ma ero su un PC con SCO Unix che aveva solo vi come editor. E non mi piace per le sue due modalità (navigazione vs. edizione) che mi confondono sempre (iniziare a digitare, vedere il mio testo solo dopo il primo i …).
Quindi ho appena iniziato a codificare il mio editor in C, usando Curses come interfaccia, creando le mie strutture dati (probabilmente inefficienti, ma allepoca ci occupavamo di piccoli file), ecc.
Mi sono divertito molto, ho imparato molto e quando anche altri utenti hanno iniziato a usarlo, ho scoperto che fanno sempre cose inaspettate, come mescolare tab e spazi … 🙂
Anche in questo caso, se sei un principiante assoluto, dovresti iniziare con progetti più piccoli, per conoscere le basi del linguaggio (loop, array, ecc.), Informazioni sulle strutture dati, su come leggere e scrivere file di testo, ecc.
È difficile consigliare una lingua … Per un progetto basato su JVM, userei Ceylon, forse con JavaFX o SWT. Per un progetto “vicino al metallo”, userei Rust (cè un progetto iniziale sulla scrittura di un editor di testo in Rust, sembra promettente), mentre altri consiglierebbero di usare C ++ (che potrebbe essere travolgente per un principiante!). Per un linguaggio più semplice, forse Lua sarebbe una buona misura (altri consiglierebbero di usare Python, ma non ho esperienza con esso). O forse JavaScript, con Node.js e la piattaforma Electron, unopzione di tendenza … (Atom, Visual Studio Code e Brackets sono stati scritti con quello. Ma questo “è appena” da zero “poiché usano gli editor di codice JS esistenti. )
Consiglio generale: prima progetta la tua struttura dati (la strategia in due parti usata dal progetto Scintilla è buona; le corde, come quelle usate dal progetto Rust, sono un po più / troppo avanzate), come manipoli i dati: come aggiungere o rimuovere un carattere, una linea, una selezione, ecc.
Quindi pensa allinterfaccia utente. Idealmente, separa i due (gestione dei dati e visualizzazione dei dati). In questo modo, un giorno puoi cambiare il target dellinterfaccia utente (da Swing a JavaFX, da GTK + a Qt, qualunque cosa) con poche o nessuna modifica alla logica di base. Ottimo per la portabilità.