Quali sono gli usi legittimi del comando `touch`?

Qual è il punto del touchcomando? So che posso creare file vuoti con esso, ma lo è anche con echo -n.

Altrimenti, perché qualcuno dovrebbe cambiare i timestamp di un file? A meno che non crei la falsa impressione sull'età di un file, non vedo nessun altro uso, e questo non è legittimo (dal mio punto di vista).

Un vantaggio touchè che può specificare timestamp arbitrari, mentre echo -nsi tradurrà sempre nell'ora corrente.

Un esempio di un uso legittimo è aggiornare un timestamp di un file di codice sorgente in modo che un programma simile makeconsideri il file di origine più recente del suo oggetto compilato e lo ricostruisca.

Altri usi sono la creazione di file che funzionano esclusivamente in base alla loro esistenza /etc/nologin, ad esempio , che non consente l'accesso se esiste. Direi anche che touch myfileè un costrutto più semplice di echo -n >> myfile, oltre ad essere più breve da scrivere.

La chiamata di sistema sottostante ( utime) è importante per varie utility come taressere in grado di impostare i timestamp di un file appena copiato (non tarato). Alcune utility di backup possono anche essere opzionate per reimpostare l'ora dell'ultimo accesso dei file che hanno copiato.

Un uso legittimo di touchè quello di creare un file con un particolare timestamp. Tale file "di riferimento" può quindi essere utilizzato da comandi come find. Ad esempio, per trovare tutti i file modificati più di recente rispetto al 1 ° novembre 2013 (ovvero 2013/11/01) "

touch -amt 201311010000 myref
find . -type f -newer myref -exec ls -ld {} +

Lo touchscopo principale del comando è manipolare i timestamp dei file e creare i file.

Esempi

1. creazione di file

$ ls -l
total 0

$ touch file{1..3}

$ ls -l
total 0
-rw-rw-r--. 1 saml saml 0 Jan 12 13:33 file1
-rw-rw-r--. 1 saml saml 0 Jan 12 13:33 file2
-rw-rw-r--. 1 saml saml 0 Jan 12 13:33 file3

NOTA: l' total 0uscita da ls -lè corretta. Questa implementazione di lsmostra il numero di blocchi utilizzati dai file quando sono elencati. Puoi assicurarti di questo fatto aggiungendo il -spassaggio a ls. Questo elencherà i blocchi in uso da ciascun file. Qui ho aggiunto 2 caratteri a file1 e file2.

Esempio

$ ls -ls
total 8
4 -rw-rw-r--. 1 saml saml 3 Jan 13 12:07 file1
4 -rw-rw-r--. 1 saml saml 3 Jan 13 12:09 file2
0 -rw-rw-r--. 1 saml saml 0 Jan 13 12:05 file3

2. informazioni su ora / data di un file - comando stat

$ stat file1
  File: ‘file1’
  Size: 0           Blocks: 0          IO Block: 4096   regular empty file
Device: fd02h/64770d    Inode: 11403667    Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/    saml)   Gid: ( 1000/    saml)
Context: unconfined_u:object_r:user_home_t:s0
Access: 2014-01-12 13:33:38.279456149 -0500
Modify: 2014-01-12 13:33:38.279456149 -0500
Change: 2014-01-12 13:33:38.279456149 -0500
 Birth: -

Possiamo usare touchper manipolare i vari timestamp su un dato file.

3. estratto dalla pagina man touch

   -a     change only the access time
   -m     change only the modification time
   -t STAMP
          use [[CC]YY]MMDDhhmm[.ss] instead of current time

4. manipolazione dei tempi di accesso

$ touch -a -t200001010000 file1

$ stat file1
  File: ‘file1’
  Size: 0           Blocks: 0          IO Block: 4096   regular empty file
Device: fd02h/64770d    Inode: 11403667    Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/    saml)   Gid: ( 1000/    saml)
Context: unconfined_u:object_r:user_home_t:s0
Access: 2000-01-01 00:00:00.000000000 -0500
Modify: 2014-01-12 13:33:38.279456149 -0500
Change: 2014-01-12 13:38:52.023434696 -0500
 Birth: -

5. manipolare il tempo di modifica

$ touch -m -t200001010000 file1

$ stat file1
  File: ‘file1’
  Size: 0           Blocks: 0          IO Block: 4096   regular empty file
Device: fd02h/64770d    Inode: 11403667    Links: 1
Access: (0664/-rw-rw-r--)  Uid: ( 1000/    saml)   Gid: ( 1000/    saml)
Context: unconfined_u:object_r:user_home_t:s0
Access: 2000-01-01 00:00:00.000000000 -0500
Modify: 2000-01-01 00:00:00.000000000 -0500
Change: 2014-01-12 13:39:31.060432026 -0500
 Birth: -

Potresti chiederti del tempo di cambio (ctime). Questo non può essere manipolato usando touch. Ciò tiene traccia del tempo in cui uno dei metadati è stato toccato sul file. Vedi queste domande e risposte per maggiori dettagli, intitolato: Cosa puoi fare per un file senza attivare il timestamp "Modifica"? .

A parte le altre due ottime risposte che hai ottenuto, un altro uso è, nelle tue parole, a

crea la falsa impressione sull'età di un file

ad esempio per l'uso in schemi di backup . Potresti voler non aggiornare un backup con uno più recente poiché sono identici o poiché le modifiche sono irrilevanti rispetto alla spesa di aggiornamento di un backup, ad esempio, su una linea lenta a un host remoto. Per raggiungere questo obiettivo, hai la semplice opzione di contrassegnare il file di backup con un timestamp più recente, non falsificando ma dichiarando che il timestamp di validità di quel file è ora diverso.

L'impressione sull'età del file è ora effettivamente falsa, ma il suo significato è reale e legittimo.

Uno degli usi più comuni di touchè - o almeno usato per essere - per innescare una ricostruzione del codice.

I soliti strumenti di compilazione - makee i suoi derivati ​​- provano a salvare il lavoro non ricompilando / ricostruendo i file a meno che uno dei file che sono stati creati non sia cambiato, ad esempio se un file .o è più recente del .c fonte, di solito è sicuro presumere che la fonte C non sia stata modificata da quando è stata compilata per produrre quel file oggetto.

Ma ci sono momenti in cui vuoi forzare qualcosa da ricostruire. Potresti apportare una modifica inutile a uno dei suoi file di origine, ma questo rischia di danneggiare accidentalmente qualcosa. Invece, potresti semplicemente copiare touchil file, facendolo apparire nuovo senza alcun rischio di alterarne il contenuto - e ciò sarebbe sufficiente per convincere makeche era tempo di ricostruire tutto ciò che dipende da quel file.

Ci sono altri usi, ma storicamente quello era il più grande.

Ho lavorato con almeno un framework web (non ricordo quale) che in modalità di sviluppo ha guardato i file del codice sorgente per le modifiche e ricaricato l'applicazione quando è successo.

Ovviamente a volte volevi che si ricaricasse dopo aver cambiato qualcosa che non stava guardando, nel qual caso touchil suo file di configurazione principale ha funzionato.

Quindi, nel caso generale, ogni volta che si desidera avviare un processo attivato da modifiche a un file, senza effettivamente modificare il file.

Uso legittimo del tocco:

• Aggiorna il timestamp dei file di immagine (GIF / JPG / ecc.) Nel momento in cui sono stati acquisiti. Non tutti i renderer leggono o tengono conto delle informazioni EXIF.
• Mantenere il tempo c / m quando si aggiorna in massa un set di file in cui il timestamp è importante per il pacchetto di file.
• Imposta l'ora di un file batch (ovvero CSV) se devi eseguire un'altra importazione dopo un errore e il programma di importazione dipende dal timestamp (lascia quella discussione su un altro argomento :-))
• Scopo dell'archiviazione, ovvero backup delle cartelle in base all'anno, quindi impostazione dell'ora su queste cartelle su 1 gennaio AAAA per un ordinamento semplice

Un uso è correggere il timestamp di un file che è stato impostato in modo errato.

Ad esempio, quasi tutti i modi in cui copi un file (e per alcuni modi in cui potresti spostare un file) si traducono nel nuovo file con un timestamp dell'ora corrente, piuttosto che il timestamp del file originale.

Di solito, questo non è ciò che si desidera. Il tocco può "risolvere" quello.

Un altro uso è quello di riflettere una modifica del file che è stata annullata ripristinando il timestamp del file a quello che era prima delle operazioni "modifica ... annulla-modifica".

Una differenza importante rispetto a thingscome echo(o anche meglio > filecome menzionato da altri) è che il tocco non distruggerà i contenuti. > filesvuota un file. touchno. Invece di pensare a trucchi per evitare danni ai contenuti, basta usare il tocco! Farà comunque meno lavoro nel kernel, perché funzionerà solo con gli attributi del file senza perdere tempo a prepararsi per l'apertura e quindi a chiudere.

Il tocco può probabilmente modificare il timestamp anche se il file si trova attualmente in un blocco obbligatorio o consultivo o in un'apertura esclusiva. Hmmm, non l'ho mai provato o letto su di esso ...

Eccone uno - uso un programma software chiamato SageTV per registrare programmi TV - questi sono spesso registrati in MPEG-2 che non è un codec molto efficiente, ma non è anche compatibile con iPad / iPhone. Quindi converto i file in file .mp4. Ma quando si riproducono i file, SageTV si aspetta che la data e l'ora del file coincidano con l'inizio dello show TV, altrimenti rovina la sequenza temporale dello show in modo che non sia facile eseguire FF o REW. Pertanto utilizzo touch per reimpostare il timestamp del file .mp4 in modo che sia uguale al file originale.
È legittimo?

Spesso potresti avere un processo che cambia da userid, come da root -> qualcos'altro. Tocco può darti la possibilità di creare un file in un punto che solo root può toccare prima che l'applicazione inizi a registrarsi come l'altro utente.

Al lavoro abbiamo un archivio di mappe digitali che risale a più di 15 anni fa. Queste vecchie mappe vengono salvate in una varietà di formati come PostScript, EMF, PRN, hpgl2, pdf, ecc. Che la maggior parte dei programmi non comprende. Oppure hai bisogno di una dozzina di programmi diversi per vederli tutti.

Per facilitare la ricerca e la navigazione di tutti questi diversi formati, creiamo versioni jpeg delle mappe, quindi utilizziamo il tocco per far corrispondere il file jpeg al timestamp del file sorgente originale, spesso anni dopo la creazione dell'originale.

Ora possiamo usare un singolo programma come Picasa per vedere l'intera libreria e individuare banalmente determinati intervalli di date. Senza il tocco dovremmo aggiungere metadati della data per ogni singola immagine, probabilmente manualmente, e quindi cercare quelle stringhe quando si cerca un intervallo di date specifico.

Non l'ho ancora usato per questo scopo, ma ho uno script che legge i file e le loro date da una directory e li legge per l'uso su una pagina web. Se devo modificarne uno, cambierà la sua data. Ho preso in considerazione l' touchidea di reimpostare il loro ordine.

Alcuni script init confrontano il timestamp di un file di configurazione con il proprio file pid. Il risultato decide se ricaricare il servizio in esecuzione o meno.

Se si verifica una situazione in cui non si desidera modificare la configurazione ma si desidera forzare la ricarica, toccare qui aiuta.

Ho un lavoro cron che ottiene le modifiche da un database che si sono verificate tra l'ultima esecuzione del lavoro e la corsa corrente. Produce un file XML delle modifiche che vengono quindi elaborate in un database diverso. Ottiene l'ultimo tempo di esecuzione dal timestamp sul file di output XML. *

Se qualcosa dovesse andare storto nell'elaborazione del file XML, potrei voler ripetere la corsa dalla data originale e non dalla data indicata nel timestamp del nuovo file XML.

Il modo più semplice per farlo, piuttosto che modificare gli script chiamati ecc. È toccare il file XML e forzare il timestamp alla data da me richiesta.

Inoltre, se ricomincio da capo (senza un precedente file di output XML) posso semplicemente simularne l'esistenza usando il tocco.

[*] Prima che qualcuno lo sottolinei: mi rendo conto dell'ora in cui inizia il lavoro e la scrittura del file XML lascia un intervallo di tempo di alcuni minuti in cui potrebbero verificarsi modifiche al DB. Il lavoro viene eseguito in un momento in cui le modifiche al DB sono estremamente improbabili. Questa è la mia scusa e mi sto attenendo ad esso :-)