Supondo um grep simples como:

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

Isso fornece muita informação, mas como a primeira linha do comando ps está ausente, não há contexto para a informação. Eu preferiria que a primeira linha do ps seja mostrada também:

$ 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

Obviamente, eu poderia adicionar um regex ao grep especificamente para ps:

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

No entanto, eu preferiria uma solução mais geral, pois há outros casos em que gostaria de ter a primeira linha também.

Parece que este seria um bom caso de uso para um descritor de arquivo "stdmeta" .

Bom caminho

Normalmente você não pode fazer isso com o grep, mas pode usar outras ferramentas. O AWK já foi mencionado, mas você também pode usar o sedseguinte:

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

Como funciona:

1. O utilitário Sed trabalha em cada linha individualmente, executando comandos especificados em cada uma delas. Você pode ter vários comandos, especificando várias -eopções. Podemos acrescentar cada comando com um parâmetro range que especifica se esse comando deve ser aplicado a uma linha específica ou não.

2. "1p" é o primeiro comando. Ele usa o pcomando que normalmente imprime todas as linhas. Mas o anexamos com um valor numérico que especifica o intervalo ao qual ele deve ser aplicado. Aqui, usamos o 1que significa primeira linha. Se você quiser imprimir mais linhas, poderá usar x,yponde xestá a primeira linha a ser impressa, a yúltima linha a ser impressa. Por exemplo, para imprimir as 3 primeiras linhas, você usaria1,3p

3. O próximo comando é o dque normalmente exclui todas as linhas do buffer. Antes deste comando, colocamos yourpatternentre dois /caracteres. Essa é a outra maneira (primeiro foi especificar em quais linhas, como fizemos com o pcomando), de endereçar as linhas nas quais o comando deve estar em execução. Isso significa que o comando funcionará apenas para as linhas correspondentes yourpattern. Exceto, usamos !caractere antes do dcomando que inverte sua lógica. Portanto, agora ele removerá todas as linhas que não correspondem ao padrão especificado.

4. No final, o sed imprimirá todas as linhas restantes no buffer. Mas removemos as linhas que não correspondem ao buffer, para que apenas as linhas correspondentes sejam impressas.

Resumindo: imprimimos a primeira linha e excluímos todas as linhas que não correspondem ao nosso padrão da entrada. Resto das linhas são impressos (para que apenas as linhas que fazem corresponder ao padrão).

Problema de primeira linha

Como mencionado nos comentários, há um problema com essa abordagem. Se o padrão especificado corresponder também à primeira linha, ele será impresso duas vezes (uma vez por pcomando e uma vez por causa de uma correspondência). Podemos evitar isso de duas maneiras:

1. Adicionando 1dcomando depois 1p. Como já mencionei, o dcomando exclui as linhas do buffer e especificamos seu intervalo pelo número 1, o que significa que ele excluirá apenas a primeira linha. Então o comando seriased -e '1p' -e '1d' -e '/youpattern/!d'

2. Usando o 1bcomando, em vez de 1p. É um truque. bO comando nos permite pular para outro comando especificado por um rótulo (dessa maneira, alguns comandos podem ser omitidos). Mas se esse rótulo não for especificado (como no nosso exemplo), ele simplesmente pula para o final dos comandos, ignorando o restante dos comandos da nossa linha. Portanto, no nosso caso, o último dcomando não removerá essa linha do buffer.

Exemplo completo:

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

Usando ponto e vírgula

Algumas sedimplementações podem economizar digitação usando ponto-e-vírgula para separar comandos, em vez de usar várias -eopções. Portanto, se você não se importa em ser portátil, o comando seria ps aux | sed '1b;/syslog/!d'. Funciona pelo menos em GNU sede busyboximplementações.

Maneira louca

Aqui está, no entanto, uma maneira bastante louca de fazer isso com o grep. Definitivamente não é o ideal, estou publicando isso apenas para fins de aprendizado, mas você pode usá-lo, por exemplo, se não tiver nenhuma outra ferramenta no seu sistema:

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

Como funciona

1. Primeiro, usamos a -nopção para adicionar números de linha antes de cada linha. Queremos numerar todas as linhas com as quais estamos combinando .*- qualquer coisa, até a linha vazia. Como sugerido nos comentários, também podemos combinar '^', o resultado é o mesmo.

2. Então, estamos usando expressões regulares estendidas para que possamos usar \|caracteres especiais que funcionam como OR. Então, combinamos se a linha começa com 1:(primeira linha) ou contém nosso padrão (nesse caso, é syslog).

Problema de números de linha

Agora, o problema é que estamos obtendo esses números de linha feios em nossa saída. Se este for um problema, podemos removê-los com cut, desta forma:

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

-dopção especifica delimitador, -fespecifica campos (ou colunas) que queremos imprimir. Portanto, queremos cortar cada linha de cada :caractere e imprimir apenas a segunda e todas as colunas subseqüentes. Isso efetivamente remove a primeira coluna com seu delimitador e é exatamente isso que precisamos.

Como você se sente ao usar em awkvez de 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: Número de registro == 1; ie a primeira linha
• ||: ou:
• /syslogd/: Padrão para procurar

Também pode valer a pena olhar pgrep, embora isso seja mais para scripts, em vez de saída voltada para o usuário. grepPorém, evita que o próprio comando apareça na saída.

chopper:~> pgrep -l syslogd
19 syslogd

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

EDIT: após comentários

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

Embora eu head -1lesse toda a entrada, mas depois de testá-la, também funciona.

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

saída é

this is a test
this line should be ok

Ps suporte filtro interno,

Suponha que você esteja procurando pelo processo bash:

ps -C bash -f

Irá listar todos os processos que nomearam bash.

Costumo enviar o cabeçalho para stderr :

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

Isso geralmente é suficiente para fins de leitura humana. por exemplo:

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

A parte entre colchetes pode entrar em seu próprio script para uso geral.

Há uma conveniência adicional, pois a saída pode ser canalizada ainda mais (para sortetc.) e o cabeçalho permanecerá no topo.

Você também pode usar teee head:

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

Observe, no entanto, que, desde que teenão seja possível ignorar SIGPIPEsinais (consulte, por exemplo, a discussão aqui ), essa abordagem precisa de uma solução alternativa para ser confiável. A solução alternativa é ignorar os sinais SIGPIPE; isso pode, por exemplo, ser feito assim no bash como shells:

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

Observe também que a ordem de saída não é garantida .

Talvez dois pscomandos sejam mais fáceis.

$ 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

Você pode usar o pidstat com:

pidstat -C someApp
or
pidstat -p <PID>

Exemplo:

# 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

Informações adicionais: http://linux.die.net/man/1/pidstat

Coloque o seguinte no seu arquivo .bashrc ou copie / cole no shell primeiro, para teste.

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

Uso: psls [padrão 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

Certifique-se de fornecer seu arquivo .bashrc (ou .bash_profile, se você o colocar lá):

source ~/.bashrc

A função será concluída automaticamente na linha de comando do shell. Como você afirmou em outra resposta, você pode canalizar a primeira linha para um arquivo para salvar uma chamada em ps.

classifique, mas mantenha a linha do cabeçalho no topo

# 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 use assim

$ 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

Graças principalmente a Janis Papanagnou no comp.unix.shell, eu uso a seguinte função:

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

Isso tem várias vantagens:

• Funciona com bash, zsh e provavelmente ksh
• É um substituto para o grep, para que você possa continuar usando os sinalizadores que desejar: -ipara correspondência sem distinção entre maiúsculas e minúsculas, -Epara expressões regulares ampliadas etc.
• Sempre gera o mesmo código de saída que o grep, caso você queira determinar programaticamente se alguma linha realmente corresponde
• Não imprime nada se a entrada estiver vazia

Exemplo de uso:

$ 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

Outra maneira com gnu ed:

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

ou, se o shell suportar a substituição do processo:

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

isso é:

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

Mais portátil, sem gnu '!' substituição de shell ou - usando apenas o edbuilt-in rpara rdirecionar a saída ps auxpara o buffer e, em seguida, excluir linhas não correspondentes no 2,$intervalo e imprimir o resultado:

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

E como os sedcomandos na resposta aceita também geram a linha correspondente, com um sedque suporta -f-e um shell que suporta a substituição de processos, eu executaria:

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

que praticamente faz a mesma coisa que os edcomandos anteriores .

O caminho Perl:

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

Muito mais fácil de ler do que sed, mais rápido, sem risco de escolher linhas indesejadas.

Se isso for apenas para processos grepping com cabeçalhos completos, eu expandiria a sugestão do @ 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 -fpobterá o mesmo resultado, mas sem um subshell. Se for necessária outra formatação:

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

Se você conhece os números exatos das linhas, é fácil com o perl! Se você deseja obter as linhas 1 e 5 de um arquivo, diga / etc / passwd:

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

Se você quiser obter outras linhas também, basta adicionar seus números na matriz.