Ho un file CSV che assomiglia a questo

AS2345, ASDF1232, Mr. Plain Esempio, 110 Binary ave., Atlantis, RI, 12345, (999) 123-5555,1,56
AS2345, ASDF1232, Mrs. Plain Example, 1121110 Ternary st. 110 Binary ave .., Atlantis, RI, 12345, (999) 123-5555,1.56
AS2345, ASDF1232, Mr. Plain Esempio, 110 Binary ave., Liberty City, RI, 12345, (999) 123-5555,1,56
AS2345, ASDF1232, Mr. Plain Esempio, 110 Ternary ave., Some City, RI, 12345, (999) 123-5555,1,56

Ho bisogno di ordinarlo per lunghezza della linea compresi gli spazi. Il seguente comando non include gli spazi, c'è un modo per modificarlo in modo che funzioni per me?

cat $@ | awk '{ print length, $0 }' | sort -n | awk '{$1=""; print $0}'

Risposta

cat testfile | awk '{ print length, $0 }' | sort -n -s | cut -d" " -f2-

Oppure, per eseguire il tuo sotto-ordinamento originale (forse non intenzionale) di qualsiasi linea di uguale lunghezza:

cat testfile | awk '{ print length, $0 }' | sort -n | cut -d" " -f2-

In entrambi i casi, abbiamo risolto il problema dichiarato allontanandoci da awk per il tuo taglio finale.

Linee di lunghezza corrispondente: cosa fare in caso di pareggio:

La domanda non specificava se si desiderasse o meno un ulteriore ordinamento per le linee di lunghezza corrispondente. Ho supposto che ciò sia indesiderato e ho suggerito l'uso di -s( --stable) per impedire che tali linee vengano ordinate l'una contro l'altra e mantenerle nell'ordine relativo in cui si verificano nell'input.

(Coloro che desiderano un maggiore controllo sull'ordinamento di questi legami potrebbero guardare --keyall'opzione sort .)

Perché la soluzione tentata della domanda ha esito negativo (ricostruzione di riga awk):

È interessante notare la differenza tra:

echo "hello   awk   world" | awk '{print}'
echo "hello   awk   world" | awk '{$1="hello"; print}'

Rendono rispettivamente

hello   awk   world
hello awk world

La sezione pertinente del manuale di (gawk) menziona solo a parte che awk ricostruirà l'intero $ 0 (basato sul separatore, ecc.) Quando cambi un campo. Immagino che non sia un comportamento folle. Ha questo:

"Infine, ci sono momenti in cui è conveniente forzare Awk a ricostruire l'intero record, usando il valore corrente dei campi e OFS. Per fare questo, usa l'assegnazione apparentemente innocua:"

 $1 = $1   # force record to be reconstituted
 print $0  # or whatever else with $0

"Questo costringe Awk a ricostruire il disco."

Test input che include alcune linee di uguale lunghezza:

aa A line   with     MORE    spaces
bb The very longest line in the file
ccb
9   dd equal len.  Orig pos = 1
500 dd equal len.  Orig pos = 2
ccz
cca
ee A line with  some       spaces
1   dd equal len.  Orig pos = 3
ff
5   dd equal len.  Orig pos = 4
g

La soluzione AWK di Neillb è fantastica se vuoi davvero usarla awke spiega perché è una seccatura lì, ma se quello che vuoi è svolgere il lavoro rapidamente e non preoccuparti di ciò che fai, una soluzione è usare La sort()funzione di Perl con una routine caparison personalizzata per scorrere le righe di input. Ecco una fodera:

perl -e 'print sort { length($a) <=> length($b) } <>'

Puoi metterlo nella tua pipeline ovunque tu ne abbia bisogno, ricevendo STDIN (da cato un reindirizzamento della shell) o semplicemente dando il nome del file a perl come un altro argomento e lasciarlo aprire il file.

Nel mio caso prima avevo bisogno delle linee più lunghe, quindi ho scambiato $ae $bnel confronto.

Prova invece questo comando:

awk '{print length, $0}' your-file | sort -n | cut -d " " -f2-

Risultati benchmark

Di seguito sono riportati i risultati di un benchmark tra le soluzioni di altre risposte a questa domanda.

Metodo di prova

• 10 corse sequenziali su una macchina veloce, in media
• Perl 5.24
• awk 3.1.5 (gawk 4.1.0 volte erano ~ 2% più veloci)
• Il file di input è una mostruosità di 550 MB, 6 milioni di linee (British National Corpus txt)

risultati

1. La perlsoluzione di Caleb impiegò 11,2 secondi
2. la mia perlsoluzione ha richiesto 11,6 secondi
3. La awksoluzione n. 1 di neillb ha richiesto 20 secondi
4. La awksoluzione n. 2 di neillb ha richiesto 23 secondi
5. la awksoluzione di anubhava ha impiegato 24 secondi
6. La awksoluzione di Jonathan impiegò 25 secondi
7. La bashsoluzione di Fretz impiega 400 volte più a lungo delle awksoluzioni (utilizzando un caso di prova troncato di 100000 linee). Funziona bene, richiede solo un'eternità.

perlOpzione extra

Inoltre, ho aggiunto un'altra soluzione Perl:

perl -ne 'push @a, $_; END{ print sort { length $a <=> length $b } @a }' file

Pure Bash:

declare -a sorted

while read line; do
  if [ -z "${sorted[${#line}]}" ] ; then          # does line length already exist?
    sorted[${#line}]="$line"                      # element for new length
  else
    sorted[${#line}]="${sorted[${#line}]}\n$line" # append to lines with equal length
  fi
done < data.csv

for key in ${!sorted[*]}; do                      # iterate over existing indices
  echo -e "${sorted[$key]}"                       # echo lines with equal length
done

La length()funzione include spazi. Vorrei apportare solo piccole modifiche alla tua pipeline (anche evitando UUOC ).

awk '{ printf "%d:%s\n", length($0), $0;}' "$@" | sort -n | sed 's/^[0-9]*://'

Il sedcomando rimuove direttamente le cifre e i due punti aggiunti dal awkcomando. In alternativa, mantenendo la formattazione da awk:

awk '{ print length($0), $0;}' "$@" | sort -n | sed 's/^[0-9]* //'

Ho scoperto che queste soluzioni non funzioneranno se il tuo file contiene righe che iniziano con un numero, poiché verranno ordinate numericamente insieme a tutte le righe contate. La soluzione è fornire sortil -gflag -n(ordinamento numerico generale) anziché (ordinamento numerico):

awk '{ print length, $0 }' lines.txt | sort -g | cut -d" " -f2-

Con POSIX Awk:

{
  c = length
  m[c] = m[c] ? m[c] RS $0 : $0
} END {
  for (c in m) print m[c]
}

Esempio

1) soluzione awk pura. Supponiamo che la lunghezza della linea non possa essere più> 1024 allora

nome file cat | awk 'BEGIN {min = 1024; s = "";} {l = lunghezza ($ 0); if (l <min) {min = l; s = $ 0;}} END {stampa s} '

2) una soluzione bash di linea supponendo che tutte le righe abbiano solo 1 parola, ma possono essere rielaborate per ogni caso in cui tutte le righe hanno lo stesso numero di parole:

LINEE = $ (nome file gatto); per k in $ LINES; fare printf "$ k"; echo $ k | wc -L; fatto | ordina -k2 | head -n 1 | cut -d "" -f1

Ecco un metodo compatibile multibyte per ordinare le linee per lunghezza. Richiede:

1. wc -m è a tua disposizione (ce l'ha macOS).
2. Le impostazioni internazionali correnti supportano caratteri multibyte, ad esempio impostando LC_ALL=UTF-8. Puoi impostarlo nel tuo .bash_profile o semplicemente anteponendolo prima del seguente comando.
3. testfile ha una codifica dei caratteri corrispondente alla tua locale (ad es. UTF-8).

Ecco il comando completo:

cat testfile | awk '{l=$0; gsub(/\047/, "\047\"\047\"\047", l); cmd=sprintf("echo \047%s\047 | wc -m", l); cmd | getline c; close(cmd); sub(/ */, "", c); { print c, $0 }}' | sort -ns | cut -d" " -f2-

Spiegare parte per parte:

• l=$0; gsub(/\047/, "\047\"\047\"\047", l);← crea una copia di ogni riga in una variabile awk le fa doppio escape ogni volta che 'la riga può essere tranquillamente ripetuta come un comando shell ( \047è una virgoletta singola in notazione ottale).
• cmd=sprintf("echo \047%s\047 | wc -m", l);← questo è il comando che eseguiremo, che fa eco alla linea di escape wc -m.
• cmd | getline c;← esegue il comando e copia il valore del conteggio dei caratteri restituito nella variabile awk c.
• close(cmd); ← chiudere la pipe al comando shell per evitare di colpire un limite di sistema sul numero di file aperti in un processo.
• sub(/ */, "", c);← taglia lo spazio bianco dal valore del conteggio dei caratteri restituito da wc.
• { print c, $0 } ← stampa il valore del conteggio dei caratteri della linea, uno spazio e la linea originale.
• | sort -ns← ordina le righe (in base ai valori di conteggio dei caratteri anteposti) numericamente ( -n) e mantenendo un ordinamento stabile ( -s).
• | cut -d" " -f2- ← rimuove i valori di conteggio dei caratteri anteposti.

È lento (solo 160 righe al secondo su un Macbook Pro veloce) perché deve eseguire un comando secondario per ogni riga.

In alternativa, basta farlo solo con gawk(dalla versione 3.1.5, gawk è a conoscenza del multibyte), che sarebbe significativamente più veloce. È un sacco di problemi fare tutte le escape e le virgolette doppie per passare in sicurezza le linee attraverso un comando shell da awk, ma questo è l'unico metodo che ho trovato che non richiede l'installazione di software aggiuntivo (gawk non è disponibile per impostazione predefinita su Mac OS).