Supponendo un grep semplice come:

$ psa aux | grep someApp
1000     11634 51.2  0.1  32824  9112 pts/1    SN+  13:24   7:49 someApp

Questo fornisce molte informazioni, ma poiché manca la prima riga del comando ps, non c'è contesto per le informazioni. Preferirei che venisse mostrata anche la prima riga di ps:

$ psa aux | someMagic someApp
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
1000     11634 51.2  0.1  32824  9112 pts/1    SN+  13:24   7:49 someApp

Certo, potrei aggiungere una regex a grep appositamente per ps:

$ ps aux | grep -E "COMMAND|someApp"

Tuttavia, preferirei una soluzione più generale in quanto vi sono altri casi in cui vorrei avere anche la prima riga.

Sembra che sarebbe un buon caso d'uso per un descrittore di file "stdmeta" .

Buon modo

Normalmente non puoi farlo con grep ma puoi usare altri strumenti. AWK è già stato menzionato ma puoi anche usare sed, in questo modo:

sed -e '1p' -e '/youpattern/!d'

Come funziona:

1. L'utilità Sed funziona su ciascuna riga singolarmente, eseguendo i comandi specificati su ciascuna di esse. Puoi avere più comandi, specificando diverse -eopzioni. Possiamo anteporre ogni comando con un parametro range che specifica se questo comando deve essere applicato o meno a una riga specifica.

2. "1p" è un primo comando. Usa un pcomando che normalmente stampa tutte le linee. Ma lo anteponiamo con un valore numerico che specifica l'intervallo a cui dovrebbe essere applicato. Qui, usiamo 1che significa prima linea. Se si desidera stampare più linee, è possibile utilizzare x,ypdove xè la prima linea per la stampa, yè ultima riga da stampare. Ad esempio, per stampare le prime 3 righe, si utilizzerà1,3p

3. Il comando successivo è dche normalmente elimina tutte le righe dal buffer. Prima di questo comando mettiamo yourpatterntra due /personaggi. Questo è l'altro modo (in primo luogo era di specificare quali linee come abbiamo fatto con il pcomando) di indirizzare le linee su cui il comando dovrebbe essere in esecuzione. Ciò significa che il comando funzionerà solo per le linee corrispondenti yourpattern. Tranne, usiamo il !carattere prima del dcomando che inverte la sua logica. Quindi ora rimuoverà tutte le linee che non corrispondono al modello specificato.

4. Alla fine, sed stamperà tutte le righe rimaste nel buffer. Ma abbiamo rimosso le linee che non corrispondono dal buffer, quindi verranno stampate solo le linee corrispondenti.

Per riassumere: stampiamo la prima riga, quindi eliminiamo dall'input tutte le righe che non corrispondono al nostro modello. Resto delle linee vengono stampati (in modo che solo le linee che fanno corrispondere al modello).

Problema di prima linea

Come menzionato nei commenti, c'è un problema con questo approccio. Se il motivo specificato corrisponde anche alla prima riga, verrà stampato due volte (una volta per pcomando e una volta a causa di una corrispondenza). Possiamo evitarlo in due modi:

1. Aggiunta del 1dcomando dopo 1p. Come ho già accennato, il dcomando elimina le righe dal buffer e specifichiamo che è intervallo per il numero 1, il che significa che eliminerà solo la 1a riga. Quindi il comando sarebbesed -e '1p' -e '1d' -e '/youpattern/!d'

2. Usando il 1bcomando, invece di 1p. È un trucco. bIl comando ci consente di passare ad altri comandi specificati da un'etichetta (in questo modo alcuni comandi possono essere omessi). Ma se questa etichetta non viene specificata (come nel nostro esempio) passa alla fine dei comandi, ignorando il resto dei comandi per la nostra linea. Quindi, nel nostro caso, l'ultimo dcomando non rimuoverà questa riga dal buffer.

Esempio completo:

ps aux | sed -e '1b' -e '/syslog/!d'

Usando il punto e virgola

Alcune sedimplementazioni possono farti risparmiare un po 'di battitura utilizzando il punto e virgola per separare i comandi anziché utilizzare più -eopzioni. Quindi se non ti interessa essere portatile il comando sarebbe ps aux | sed '1b;/syslog/!d'. Funziona almeno in GNU sede busyboximplementazioni.

Modo folle

Ecco, tuttavia, un modo piuttosto folle per farlo con grep. Non è sicuramente ottimale, sto pubblicando questo solo a scopo di apprendimento, ma potresti usarlo ad esempio, se non hai altri strumenti nel tuo sistema:

ps aux | grep -n '.*' | grep -e '\(^1:\)\|syslog'

Come funziona

1. Innanzitutto, utilizziamo l' -nopzione per aggiungere i numeri di riga prima di ogni riga. Vogliamo numerare tutte le linee che stiamo abbinando .*- qualsiasi cosa, anche una linea vuota. Come suggerito nei commenti, possiamo anche abbinare '^', il risultato è lo stesso.

2. Quindi stiamo usando espressioni regolari estese in modo da poter usare \|caratteri speciali che funzionano come OR. Quindi abbiniamo se la linea inizia con 1:(prima riga) o contiene il nostro modello (in questo caso è syslog).

Problema con i numeri di riga

Ora il problema è che stiamo ottenendo questi brutti numeri di riga nel nostro output. Se questo è un problema, possiamo rimuoverli con cut, in questo modo:

ps aux | grep -n '.*' | grep -e '\(^1:\)\|syslog' | cut -d ':' -f2-

-dL'opzione specifica il delimitatore, -fspecifica i campi (o colonne) che vogliamo stampare. Quindi vogliamo tagliare ogni riga su ogni :carattere e stampare solo la 2a e tutte le colonne successive. Questo rimuove efficacemente la prima colonna con il suo delimitatore ed è esattamente ciò di cui abbiamo bisogno.

Come ti senti a usare awkinvece di grep?

chopper:~> ps aux | awk 'NR == 1 || /syslogd/'
USER              PID  %CPU %MEM      VSZ    RSS   TT  STAT STARTED      TIME COMMAND
root               19   0.0  0.0  2518684   1160   ??  Ss   26Aug12   1:00.22 /usr/sbin/syslogd
mrb               574   0.0  0.0  2432852    696 s006  R+    8:04am   0:00.00 awk NR == 1 || /syslogd/

• NR == 1: Numero di record == 1; vale a dire. la prima riga
• ||: o:
• /syslogd/: Pattern da cercare

Potrebbe anche valere la pena dare un'occhiata pgrep, anche se questo è più per gli script piuttosto che per l'output rivolto all'utente. grepTuttavia, evita che il comando stesso venga visualizzato nell'output.

chopper:~> pgrep -l syslogd
19 syslogd

ps aux | { read line;echo "$line";grep someApp;}

EDIT: dopo i commenti

ps aux | { head -1;grep someApp;}

Pensavo di head -1leggere tutti gli input, ma dopo averli testati, funziona anche.

{ head -1;grep ok;} <<END
this is a test
this line should be ok
not this one
END

l'uscita è

this is a test
this line should be ok

Ps supporto filtro interno,

Supponiamo che tu stia cercando un processo bash:

ps -C bash -f

Elencherà tutto il processo chiamato bash.

Tendo a inviare l'intestazione a stderr :

ps | (IFS= read -r HEADER; echo "$HEADER" >&2; cat) | grep ps

Questo di solito è sufficiente per scopi di lettura umana. per esempio:

  PID TTY          TIME CMD
 4738 pts/0    00:00:00 ps

La parte tra parentesi potrebbe essere inserita nel proprio script per uso generale.

C'è un'ulteriore comodità in quanto l'output può essere ulteriormente convogliato (a sortecc.) E l'intestazione rimarrà in cima.

Puoi anche usare teee head:

ps aux | tee >(head -n1) | grep syslog

Si noti tuttavia che fino a quando teenon è possibile ignorare i SIGPIPEsegnali (vedere ad esempio la discussione qui ) questo approccio richiede una soluzione alternativa per essere affidabile. La soluzione alternativa è ignorare i segnali SIGPIPE, ad esempio questo può essere fatto in questo modo come bash come shell:

trap '' PIPE    # ignore SIGPIPE
ps aux | tee >(head -n1) 2> /dev/null | grep syslog
trap - PIPE     # restore SIGPIPE handling

Si noti inoltre che l' ordine di uscita non è garantito .

Forse due pscomandi sarebbero i più facili.

$ ps aux | head -1 && ps aux | grep someApp
USER             PID  %CPU %MEM      VSZ    RSS   TT  STAT STARTED      TIME COMMAND
100         3304   0.0  0.2  2466308   6476   ??  Ss    2Sep12   0:01.75 /usr/bin/someApp

Puoi usare pidstat con:

pidstat -C someApp
or
pidstat -p <PID>

Esempio:

# pidstat -C java
Linux 3.0.26-0.7-default (hostname)    09/12/12        _x86_64_

13:41:21          PID    %usr %system  %guest    %CPU   CPU  Command
13:41:21         3671    0.07    0.02    0.00    0.09     1  java

Ulteriori informazioni: http://linux.die.net/man/1/pidstat

Inserisci quanto segue nel tuo file .bashrc o copia / incolla prima nella shell, per il test.

function psls { 
ps aux|head -1 && ps aux|grep "$1"|grep -v grep;
}

Utilizzo: psls [modello grep]

$ psls someApp
USER             PID  %CPU %MEM      VSZ    RSS   TT  STAT STARTED      TIME COMMAND
root              21   0.0  0.0  2467312   1116   ??  Ss   Tue07PM   0:00.17 /sbin/someApp

Assicurati di procurarti il ​​tuo .bashrc (o .bash_profile se invece lo metti lì):

source ~/.bashrc

La funzione si completerà anche automaticamente dalla riga di comando della shell. Come indicato in un'altra risposta, è possibile reindirizzare la prima riga a un file per salvare una chiamata su ps.

ordina ma mantieni la riga di intestazione in alto

# print the header (the first line of input)
# and then run the specified command on the body (the rest of the input)
# use it in a pipeline, e.g. ps | body grep somepattern
body() {
    IFS= read -r header
    printf '%s\n' "$header"
    "$@"
}

E usalo in questo modo

$ ps aux | body grep someApp
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
1000     11634 51.2  0.1  32824  9112 pts/1    SN+  13:24   7:49 someApp

Grazie principalmente a Janis Papanagnou in comp.unix.shell, utilizzo la seguente funzione:

function grep1 {
    IFS= read -r header && printf "%s\n" "$header"; grep "$@"
}

Questo ha una serie di vantaggi:

• Funziona con bash, zsh e probabilmente ksh
• È un sostituto drop-in per grep, quindi puoi continuare a usare qualsiasi flag tu voglia: -iper la corrispondenza senza distinzione tra maiuscole e minuscole, -Eper regex estese, ecc.
• Produce sempre lo stesso codice di uscita di grep, nel caso in cui si desideri determinare a livello di codice se tutte le righe corrispondono effettivamente
• Non stampa nulla se l'input era vuoto

Esempio di utilizzo:

$ ps -rcA | grep1 databases
  PID TTY           TIME CMD

$ ps -rcA | grep1 -i databases
  PID TTY           TIME CMD
62891 ??         0:00.33 com.apple.WebKit.Databases

Un altro modo con gnu ed:

ed -s '!ps aux' <<< $'2,$v/PATTERN/d\n,p\nq\n'

oppure, se la shell supporta la sostituzione di processo:

printf '%s\n' '2,$v/PATTERN/d' ,p q | ed -s <(ps aux)

questo è:

2,$v/PATTERN/d  - remove all lines not matching pattern (ignore the header)
,p              - print the remaining lines
q               - quit

Più portatile, senza gnu '!' o sostituzione della shell - utilizzando solo edincorporato rper rtrasferire l'output ps auxnel buffer e quindi eliminare le righe non corrispondenti 2,$nell'intervallo e stampare il risultato:

printf '%s\n' 'r !ps aux' '2,$v/PATTERN/d' ,p q | ed -s

E poiché i sedcomandi nella risposta accettata producono anche la riga corrispondente, con un sedsupporto che supporta -f-e una shell che supporta la sostituzione del processo, eseguirei:

printf '%s\n' '2,${' '/PATTERN/!d' '}' | sed -f - <(ps aux)

che praticamente fa la stessa cosa dei edcomandi precedenti .

La via del Perl:

ps aux | perl -ne 'print if /pattern/ || $.==1'

Molto più facile da leggere rispetto a sed, più veloce, nessun rischio di scegliere linee indesiderate.

Se fosse solo per i processi grepping con intestazioni complete, espanderei il suggerimento di @ mrb:

$ ps -f -p $(pgrep bash)
UID        PID  PPID  C STIME TTY      STAT   TIME CMD
nasha     2810  2771  0  2014 pts/6    Ss+    0:00 bash
...

pgrep bash | xargs ps -fpotterrà lo stesso risultato ma senza una subshell. Se è richiesta un'altra formattazione:

$ pgrep bash | xargs ps fo uid,pid,stime,cmd -p
  UID   PID STIME CMD
    0  3599  2014 -bash
 1000  3286  2014 /bin/bash
 ...

Se conosci i numeri esatti delle righe, è facile con perl! Se vuoi ottenere la linea 1 e 5 da un file, dì / etc / passwd:

perl -e 'while(<>){if(++$l~~[1,5]){print}}' < /etc/passwd

Se vuoi ottenere anche altre righe, aggiungi i loro numeri nell'array.