Vorrei rimuovere tutti gli spazi e le schede iniziali e finali da ciascuna riga di un output.

Esiste uno strumento semplice come il quale trimpotrei convogliare il mio output?

File di esempio:

test space at back 
 test space at front
TAB at end  
    TAB at front
sequence of some    space in the middle
some empty lines with differing TABS and spaces:





 test space at both ends 

awk '{$1=$1;print}'

o più corto:

awk '{$1=$1};1'

Taglia i spazi iniziali e finali o i caratteri di tabulazione ¹ e comprime anche sequenze di tabulazioni e spazi in un unico spazio.

Questo funziona perché quando assegni qualcosa a uno dei campi , awkricostruisce l'intero record (come stampato da print) unendo tutti i campi ( $1, ..., $NF) con OFS(spazio per impostazione predefinita).

_{¹ (e possibilmente altri caratteri vuoti a seconda della locale e awkdell'implementazione)}

Il comando può essere condensato in questo modo se si utilizza GNU sed:

$ sed 's/^[ \t]*//;s/[ \t]*$//' < file

Esempio

Ecco il comando sopra in azione.

$ echo -e " \t   blahblah  \t  " | sed 's/^[ \t]*//;s/[ \t]*$//'
blahblah

È possibile utilizzare hexdumpper confermare che il sedcomando sta rimuovendo correttamente i caratteri desiderati.

$ echo -e " \t   blahblah  \t  " | sed 's/^[ \t]*//;s/[ \t]*$//' | hexdump -C
00000000  62 6c 61 68 62 6c 61 68  0a                       |blahblah.|
00000009

Classi di personaggi

Puoi anche usare i nomi delle classi di caratteri invece di elencare letteralmente i set in questo modo [ \t]:

$ sed 's/^[[:blank:]]*//;s/[[:blank:]]*$//' < file

Esempio

$ echo -e " \t   blahblah  \t  " | sed 's/^[[:blank:]]*//;s/[[:blank:]]*$//'

La maggior parte degli strumenti GNU che utilizzano espressioni regolari (regex) supportano queste classi.

 [[:alnum:]]  - [A-Za-z0-9]     Alphanumeric characters
 [[:alpha:]]  - [A-Za-z]        Alphabetic characters
 [[:blank:]]  - [ \x09]         Space or tab characters only
 [[:cntrl:]]  - [\x00-\x19\x7F] Control characters
 [[:digit:]]  - [0-9]           Numeric characters
 [[:graph:]]  - [!-~]           Printable and visible characters
 [[:lower:]]  - [a-z]           Lower-case alphabetic characters
 [[:print:]]  - [ -~]           Printable (non-Control) characters
 [[:punct:]]  - [!-/:-@[-`{-~]  Punctuation characters
 [[:space:]]  - [ \t\v\f]       All whitespace chars
 [[:upper:]]  - [A-Z]           Upper-case alphabetic characters
 [[:xdigit:]] - [0-9a-fA-F]     Hexadecimal digit characters

L'utilizzo di questi set anziché di set letterali sembra sempre uno spreco di spazio, ma se sei preoccupato che il tuo codice sia portatile o che tu abbia a che fare con set di caratteri alternativi (pensa a livello internazionale), probabilmente vorrai usare i nomi delle classi anziché.

Riferimenti

• Sezione 3 della FAQ sed

Come suggerito da Stéphane Chazelas nella risposta accettata, ora puoi
creare uno script /usr/local/bin/trim:

#!/bin/bash
awk '{$1=$1};1'

e dare a quel file i diritti eseguibili:

chmod +x /usr/local/bin/trim

Ora puoi passare ogni output ad trimesempio:

cat file | trim

(per i commenti qui sotto: l'ho usato prima: while read i; do echo "$i"; done
che funziona anche bene, ma è meno performante)

xargs senza argomenti lo fa.

Esempio:

trimmed_string=$(echo "no_trimmed_string" | xargs) 

sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//'

Se stai leggendo una riga in una variabile shell, lo readfa già se non diversamente indicato .

Se memorizzi le linee come variabili, puoi usare bash per fare il lavoro:

rimuovere lo spazio bianco iniziale da una stringa:

shopt -s extglob
echo ${text##+([[:space:]])}

rimuovere gli spazi vuoti finali da una stringa:

shopt -s extglob
echo ${text%%+([[:space:]])}

rimuovere tutto lo spazio bianco da una stringa:

echo ${text//[[:space:]]}

Per rimuovere tutti gli spazi iniziali e finali di una determinata linea grazie a uno strumento "convogliato", posso identificare 3 modi diversi che non sono completamente equivalenti. Queste differenze riguardano gli spazi tra le parole della riga di input. A seconda del comportamento previsto, farai la tua scelta.

Esempi

Per spiegare le differenze, consideriamo questa linea di input fittizia:

"   \t  A   \tB\tC   \t  "

TR

$ echo -e "   \t  A   \tB\tC   \t  " | tr -d "[:blank:]"
ABC

trè davvero un comando semplice. In questo caso, elimina qualsiasi spazio o carattere di tabulazione.

awk

$ echo -e "   \t  A   \tB\tC   \t  " | awk '{$1=$1};1'
A B C

awk elimina gli spazi iniziali e di coda e comprime in un unico spazio tutti gli spazi tra le parole.

sed

$ echo -e "   \t  A   \tB\tC   \t  " | sed 's/^[ \t]*//;s/[ \t]*$//'
A       B   C

In questo caso, sedelimina gli spazi iniziali e di coda senza toccare gli spazi tra le parole.

Osservazioni:

Nel caso di una parola per riga, trfa il lavoro.

sed è un ottimo strumento per questo:

                        # substitute ("s/")
sed 's/^[[:blank:]]*//; # parts of lines that start ("^")  with a space/tab 
     s/[[:blank:]]*$//' # or end ("$") with a space/tab
                        # with nothing (/)

Puoi usarlo per il tuo caso sia come tubazioni nel testo, ad es

<file sed -e 's/^[[...

o agendo su di esso "inline" se il tuo sedè quello GNU:

sed -i 's/...' file

ma cambiare la fonte in questo modo è "pericoloso" in quanto potrebbe essere irrecuperabile quando non funziona correttamente (o anche quando lo fa!), quindi esegui prima il backup (o l'uso -i.bakche ha anche il vantaggio di essere portabile su alcuni BSD sed) !

il comando translate funzionerebbe

cat file | tr -d [:blank:]

Se la stringa che si sta cercando di tagliare è corta e continua / contigua, si può semplicemente passarla come parametro a qualsiasi funzione bash:

    trim(){
        echo $@
    }

    a="     some random string   "

    echo ">>`trim $a`<<"
Output
>>some random string<<