Asumiendo un grep simple como:

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

Esto proporciona mucha información, pero como falta la primera línea del comando ps no hay contexto para la información. Preferiría que también se muestre la primera línea de 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

Por supuesto, podría agregar una expresión regular a grep específicamente para ps:

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

Sin embargo, preferiría una solución más general ya que hay otros casos en los que me gustaría tener la primera línea también.

Parece que este sería un buen caso de uso para un descriptor de archivo "stdmeta" .

Buen camino

Normalmente no puede hacer esto con grep pero puede usar otras herramientas. AWK ya se mencionó, pero también puede usarlo sedasí:

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

Cómo funciona:

1. La utilidad Sed funciona en cada línea individualmente, ejecutando comandos específicos en cada una de ellas. Puede tener múltiples comandos, especificando varias -eopciones. Podemos anteponer cada comando con un parámetro de rango que especifica si este comando debe aplicarse a una línea específica o no.

2. "1p" es un primer comando. Utiliza un pcomando que normalmente imprime todas las líneas. Pero lo anteponemos con un valor numérico que especifica el rango al que debe aplicarse. Aquí, usamos lo 1que significa primera línea. Si desea imprimir más líneas, puede usar x,ypdónde xestá la primera línea para imprimir, yes la última línea para imprimir. Por ejemplo, para imprimir las primeras 3 líneas, usaría1,3p

3. El siguiente comando es el dque normalmente elimina todas las líneas del búfer. Antes de este comando ponemos yourpatternentre dos /caracteres. Esta es la otra forma (primero fue especificar en qué líneas como hicimos con el pcomando) de direccionar las líneas en las que el comando debería estar ejecutándose. Esto significa que el comando solo funcionará para las líneas que coinciden yourpattern. Excepto, usamos el !carácter antes del dcomando que invierte su lógica. Entonces ahora eliminará todas las líneas que no coinciden con el patrón especificado.

4. Al final, sed imprimirá todas las líneas que quedan en el búfer. Pero eliminamos las líneas que no coinciden del búfer, por lo que solo se imprimirán las líneas coincidentes.

Para resumir: imprimimos la primera línea, luego eliminamos todas las líneas que no coinciden con nuestro patrón de la entrada. Resto de las líneas se imprimen (tan sólo las líneas que hacen coincidir con el patrón).

Problema de primera línea

Como se mencionó en los comentarios, hay un problema con este enfoque. Si el patrón especificado coincide también con la primera línea, se imprimirá dos veces (una por pcomando y otra por una coincidencia). Podemos evitar esto de dos maneras:

1. Agregar 1dcomando después 1p. Como ya mencioné, el dcomando elimina líneas del búfer y especificamos su rango con el número 1, lo que significa que solo eliminará la primera línea. Entonces el comando seríased -e '1p' -e '1d' -e '/youpattern/!d'

2. Usando el 1bcomando, en lugar de 1p. Es un truco. bEl comando nos permite saltar a otro comando especificado por una etiqueta (de esta manera se pueden omitir algunos comandos). Pero si esta etiqueta no se especifica (como en nuestro ejemplo) simplemente salta al final de los comandos, ignorando el resto de los comandos para nuestra línea. Entonces, en nuestro caso, el último dcomando no eliminará esta línea del búfer.

Ejemplo completo:

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

Usando punto y coma

Algunas sedimplementaciones pueden ahorrarle algo de tipeo usando punto y coma para separar comandos en lugar de usar múltiples -eopciones. Entonces, si no te importa ser portátil, el comando sería ps aux | sed '1b;/syslog/!d'. Funciona al menos en GNU sede busyboximplementaciones.

Manera loca

Aquí hay, sin embargo, una forma bastante loca de hacer esto con grep. Definitivamente no es óptimo, estoy publicando esto solo con fines de aprendizaje, pero puede usarlo, por ejemplo, si no tiene ninguna otra herramienta en su sistema:

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

Cómo funciona

1. Primero, usamos la -nopción para agregar números de línea antes de cada línea. Queremos numerar todas las líneas que estamos haciendo coincidir .*, cualquier cosa, incluso una línea vacía. Como se sugiere en los comentarios, también podemos hacer coincidir '^', el resultado es el mismo.

2. Luego estamos usando expresiones regulares extendidas para que podamos usar \|caracteres especiales que funcionen como OR. Entonces, hacemos coincidir si la línea comienza con 1:(primera línea) o contiene nuestro patrón (en este caso, su syslog).

Problema de números de línea

Ahora el problema es que estamos obteniendo estos números de línea feos en nuestra salida. Si esto es un problema, podemos eliminarlos de cutesta manera:

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

-dLa opción especifica delimitador, -fespecifica los campos (o columnas) que queremos imprimir. Por lo tanto, queremos cortar cada línea en cada :carácter e imprimir solo la segunda y todas las columnas posteriores. Esto elimina efectivamente la primera columna con su delimitador y esto es exactamente lo que necesitamos.

¿Cómo te sientes acerca de usar en awklugar 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; es decir. la primera linea
• ||: o:
• /syslogd/: Patrón para buscar

También podría valer la pena mirarlo pgrep, aunque esto es más para los scripts que para la salida orientada al usuario. Sin embargo, evita que el grepcomando en sí aparezca en la salida.

chopper:~> pgrep -l syslogd
19 syslogd

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

EDITAR: después de los comentarios

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

Pensé head -1que leería todas las entradas, pero después de probarlo, también funciona.

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

la salida es

this is a test
this line should be ok

Ps admite filtro interno,

Supongamos que está buscando un proceso bash:

ps -C bash -f

Enumerará todos los procesos que nombraron bash.

Tiendo a enviar el encabezado a stderr :

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

Esto suele ser suficiente para fines de lectura humana. p.ej:

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

La parte entre corchetes podría ir en su propio guión para uso general.

Hay una conveniencia adicional en que la salida se puede canalizar más (a sortetc.) y el encabezado permanecerá en la parte superior.

También puedes usar teey head:

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

Sin embargo, teetenga en cuenta que, mientras no pueda ignorar las SIGPIPEseñales (ver, por ejemplo, la discusión aquí ), este enfoque necesita una solución alternativa para ser confiable. La solución alternativa es ignorar las señales SIGPIPE, esto se puede hacer, por ejemplo, en bash como shells:

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

También tenga en cuenta que el orden de salida no está garantizado .

Quizás dos pscomandos serían los más fáciles.

$ 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

Podrías usar pidstat con:

pidstat -C someApp
or
pidstat -p <PID>

Ejemplo:

# 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

Más información: http://linux.die.net/man/1/pidstat

Ponga lo siguiente en su archivo .bashrc o copie / pegue en el shell primero, para probar.

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

Uso: psls [patrón 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

Asegúrese de obtener su .bashrc (o .bash_profile si lo coloca allí):

source ~/.bashrc

La función incluso se completará automáticamente en la línea de comandos del shell. Como indicó en otra respuesta, puede canalizar la primera línea a un archivo para guardar una llamada a ps.

ordenar pero mantener la línea de encabezado en la parte superior

# 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"
    "$@"
}

Y úsalo así

$ 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

Gracias principalmente a Janis Papanagnou en comp.unix.shell, uso la siguiente función:

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

Esto tiene una serie de ventajas:

• Funciona con bash, zsh y probablemente ksh
• Es un reemplazo directo para grep, por lo que puede continuar utilizando las banderas que desee: -ipara coincidencias que no distingan entre mayúsculas y minúsculas, -Epara expresiones regulares extendidas, etc.
• Siempre produce el mismo código de salida que grep, en caso de que desee determinar mediante programación si alguna línea coincide realmente
• No imprime nada si la entrada estaba vacía

Ejemplo 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

Otra forma con gnu ed:

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

o, si el shell admite la sustitución del proceso:

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

es decir:

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

Más portátil, sin gnu '!' sustitución de shell, utilizando solo el edincorporado rpara renviar la salida ps auxal búfer y luego eliminar las líneas que no coinciden en el 2,$rango e imprimir el resultado:

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

Y dado que los sedcomandos en la respuesta aceptada también muestran la línea que coinciden, con una sedque admite -f-y una shell que admite la sustitución de procesos, ejecutaría:

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

que prácticamente hace lo mismo que los edcomandos anteriores .

El camino de Perl:

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

Mucho más fácil de leer que sed, más rápido, sin riesgo de elegir líneas no deseadas.

Si eso es solo para procesos grepping con encabezados completos, expandiría la sugerencia de @ 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 -fpobtendrá el mismo resultado pero sin una subshell. Si se requiere otro formato:

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

Si conoce los números de línea exactos, ¡es fácil con perl! Si desea obtener las líneas 1 y 5 de un archivo, diga / etc / passwd:

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

Si desea obtener otras líneas también, simplemente agregue sus números en la matriz.