Come creare più file con il terminale?


46

Ho imparato a programmare con un libro introduttivo davvero interessante su C e scrivo ogni esempio e compito in modo da poter imparare la sintassi a memoria. Fino ad ora ho fatto manualmente tutti i file, ma il clic, la denominazione e il salvataggio diventano estenuanti.

Ho bisogno di un modo per creare più file come bspl0001.c, bspl0002.c, bspl0003.c, ecc e salvarli nella directory "learning_c" o qualcosa del genere.

Sono un noob con Ubuntu / Linux e onestamente lo eseguo solo tramite VirtualBox perché l'IDE Geany è stato facile da configurare. Pertanto, non so davvero come funzioni il Terminale.

modifica Mi sono appena trovato in questo mio vecchio racconto e sto scuotendo la testa sul motivo per cui avrei mai voluto imparare a memoria una sintassi del codice. Stranamente, ho quasi finito con i miei studi CS / Math BSc. Grazie mille per l'aiuto col senno di poi!


1
Perché creare tutti i file contemporaneamente? Quello che sto effettivamente usando: premere una combinazione di tasti per 1. vedere nella mia directory di codice quale dovrebbe essere il file "successivo", 2. creare il file con nome corretto (incluso shebang) e 3. aprirlo nel mio editor (nel mio caso Inattivo). Tasto tutto in uno. In questo modo si evitano molti file (ancora) inutilizzati.
Jacob Vlijm,

Risposte:


77

Puoi farlo con questi comandi:

mkdir learning_c
cd learning_c
touch bspl{0001..0003}.c

Spiegazione:


  • mkdir learning_c

    • Questo creerà una cartella chiamata learning_cnella cartella corrente
    • La cartella corrente di solito è anche la cartella principale chiamata ~
    • Puoi cambiare la directory corrente usando il cdcomando (es. cd Desktop)
  • cd learning_c

    • Sì, puoi indovinarlo, stai entrando nella cartella appena creata
  • touch bspl{0001..0003}.c

    • touchè uno strumento per creare file vuoti e modificare timestamp; stiamo creando file vuoti.
    • touch myfilecreerà un file vuoto chiamato myfile.
    • Il brutto codice che segue ( bspl{0001..0003}.c) si chiama espansione di parentesi graffe . Questa è una grande caratteristica della bashshell che ti permette di creare lunghi elenchi di combinazioni di stringhe arbitrarie. Puoi saperne di più su questo nel Wiki di Bash Hackers . In questo caso, verrà creato un lungo elenco di parametri a cui verrà passato touch. Puoi anche usare il suo equivalente lungo:

      touch bspl0001.c bspl0002.c bspl0003.c
      
    • È possibile modificare il numero di file: se si desidera 12 file, è possibile eseguire bspl{0001..0012}.c.

    • Gli zeri iniziali ( 0012anziché 12) assicurano che l'output utilizzi 4 cifre con spaziatura zero.

4
In alternativa, per salvare alcuni tasti,touch bspl000{1..3}.c
Reid

1
@Reid: E cosa succede se Herios vuole 10 o più file?
Helio,

3
Per coloro che vogliono creare un elenco di file con la stessa estensionetouch {test,tes2,tes3}.js
Rick,

1
@Rick: non è quello che rispondo? ;-) . Il tuo codice può essere semplificato:touch tes{t,2,3}.js
Helio,

1
e puoi anche farlo in una riga di comando: $ mkdir learning_c; cd learning_c; touch bspl000 {1,2,3,4} .c. Il ";" ti aiuterà ad aggiungere comandi che verranno eseguiti in ordine uno dopo l'altro.
Pavlos Theodorou,

4

Crea un file (successivo) numerato correttamente con una combinazione di tasti di scelta rapida

Perché creare tutti i file contemporaneamente? Lo svantaggio è che avrai molti file vuoti e inutilizzati. Quello che sto effettivamente usando: premere una combinazione di tasti per:

  1. avere uno script vedere nella mia directory di codice quale dovrebbe essere il file "successivo",
  2. creare il file con nome corretto (incluso shebang) e
  3. apro il nuovo file nel mio editor (nel mio caso Idle).

Tasto tutto in uno. In questo modo si evitano molti file (ancora) inutilizzati; I file vengono creati solo se ne hai bisogno.

Una versione semplificata di seguito (non esegue il passaggio 3). Ad ogni pressione di un tasto, verrà creato un file numerato correttamente come:

bspl0001.c, bspl0002.c, bspl0003.c etc
#!/usr/bin/env python3
import os
#--- set your code directory below
dr = "/path/to/your/coding_files"
#--- set the desired (base) name extension and shebang below (leave it ""if you don't want an automatically set shebang)
name_initial = "bspl"
extension = ".c"
shebang = ""
#---

existing = os.listdir(dr)
n = 1
while True:
    file = dr+"/"+name_initial+str(n).zfill(4)+extension
    if os.path.exists(file):
        n = n+1
    else:
        with open(file, "wt") as out:
            out.write(shebang)
        break

Come usare

  1. Copia lo script in un file vuoto
  2. Nella sezione head, imposta il percorso della tua directory (e facoltativo: cambia il nome di base e / o l'estensione, shebang).
  3. Salvare lo script come create_empty.py
  4. Esegui lo script da un collegamento: Impostazioni di sistema> Tastiera> Collegamenti personalizzati. Aggiungi il comando:

    python3 /path/to/create_empty.py
    

3

Puoi usare il seguente codice Python, puoi modificarlo in base alle tue esigenze.
Salvare il seguente codice con il nome filefilecreator.py

#!/usr/bin/env python
import os
import subprocess
work_path = os.path.abspath(os.path.dirname(__file__))
if not os.path.exists("learning_c"):
    os.mkdir("learning_c")
os.chdir(os.path.expanduser(work_path+"/learning_c"))
n = 10 #put the number as you wish
for i in range(n):
    subprocess.call(['touch', "bsdl"+str(i).zfill(4)+".c"])

E quindi eseguirlo con questo comando:

python filecreator.py

2

La bashstrada è buona, ma cosa succede se stai lavorando con una shell che non supporta l'espansione di parentesi graffe? touch file{1..10}non funziona per me, mkshper esempio. Ecco tre modi alternativi che funzionano indipendentemente dalla shell.

ss

Un approccio più neutro alla shell sarebbe quello di combinare il seqcomando per generare una sequenza di numeri formattati con le printfopzioni e passarlo al xargscomando. Per esempio,

$ ls -l
total 0
$ seq -f "%04.0f" 10 | xargs -I "{}" touch bspl"{}".c                 
$ ls
bspl0002.c  bspl0004.c  bspl0006.c  bspl0008.c  bspl0010.c
bspl0001.c  bspl0003.c  bspl0005.c  bspl0007.c  bspl0009.c

Perl

Ovviamente, Perl, essendo uno strumento abbastanza diffuso * nix, può fare altrettanto. Il comando specifico one-liner che abbiamo qui è il seguente:

perl -le 'do { $var=sprintf("%s%04d.c",$ARGV[0],$_ ); open(my $fh, ">", $var);close($fh) } for $ARGV[1] .. $ARGV[2]' bslp 1 5 

In effetti ciò che accade qui è che specifichiamo 3 argomenti della riga di comando: prefisso del nome file, indice iniziale e indice finale. Quindi usiamo do { } for $ARGV[1] .. $ARGV[2]per iterare per un intervallo specifico di numeri. Diciamo, $ARGV[1]aveva 5 anni e $ARGV[2]9, ripetevamo oltre 5,6,7,8 e 9.

Cosa succede ad ogni iterazione all'interno delle parentesi graffe? prendiamo ogni numero specificato con $_, e usando la sprintf()funzione creiamo una stringa m che unisce il prefisso (primo argomento della riga di comando $ARGV[0]) e il numero dato, ma riempiendo il numero con 4 zeri (che è fatto dallo printfstile di formattazione, %04dparte) e allegare il .csuffisso. Come risultato di ogni iterazione, creiamo un nome come bspl0001.c.

La open(my $fh, ">", $var);close($fh)agisce effettivamente come touchcomando, la creazione di un file con nome specificato.

Sebbene leggermente lungo, si comporta abbastanza bene, in modo simile alla sceneggiatura in pitone di Jacob Vlijm. Se lo si desidera, può anche essere convertito in uno script per essere leggibile, in questo modo:

#!/usr/bin/env perl
use strict;
use warnings;

for my $i ( $ARGV[1] .. $ARGV[2] ) { 
    my $var=sprintf("%s%04d.c",$ARGV[0],$i ); 
    open(my $fh, ">", $var) or die "Couldn't open " . $var ;
    close($fh) or die "Couldn't close " . $var ;
}

Proviamo questo. Innanzitutto il one-liner:

$ ls -l
total 0
$ perl -le 'do { $var=sprintf("%s%04d.c",$ARGV[0],$_ ); open(my $fh, ">", $var);close($fh) } for $ARGV[1] .. $ARGV[2]' bslp 1 5
$ ls -l                                                                                               
total 0
-rw-rw-r-- 1 xieerqi xieerqi 0 2月   5 23:36 bslp0001.c
-rw-rw-r-- 1 xieerqi xieerqi 0 2月   5 23:36 bslp0002.c
-rw-rw-r-- 1 xieerqi xieerqi 0 2月   5 23:36 bslp0003.c
-rw-rw-r-- 1 xieerqi xieerqi 0 2月   5 23:36 bslp0004.c
-rw-rw-r-- 1 xieerqi xieerqi 0 2月   5 23:36 bslp0005.c

E ora la sceneggiatura:

$ ls -l
total 4
-rwxrwxr-x 1 xieerqi xieerqi 244 2月   5 23:57 touch_range.pl*
$ ./touch_range.pl bspl 1 5                                                                           
$ ls -l
total 4
-rw-rw-r-- 1 xieerqi xieerqi   0 2月   5 23:58 bspl0001.c
-rw-rw-r-- 1 xieerqi xieerqi   0 2月   5 23:58 bspl0002.c
-rw-rw-r-- 1 xieerqi xieerqi   0 2月   5 23:58 bspl0003.c
-rw-rw-r-- 1 xieerqi xieerqi   0 2月   5 23:58 bspl0004.c
-rw-rw-r-- 1 xieerqi xieerqi   0 2月   5 23:58 bspl0005.c
-rwxrwxr-x 1 xieerqi xieerqi 244 2月   5 23:57 touch_range.pl*

awk

Un altro approccio sarebbe con awk, eseguendo un ciclo for, reindirizzando a un file specifico. L'approccio è simile al perl one-liner con argomenti da riga di comando. Mentre awkè principalmente un'utilità di elaborazione del testo, può ancora fare una buona programmazione del sistema.

$ awk 'BEGIN{for(i=ARGV[2];i<=ARGV[3];i++){fd=sprintf("%s%04d.c",ARGV[1],i); printf "" > fd;close(fd)}}' bslp 1 5
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.