Cuando busco algún proceso que no existe, por ejemplo

$ ps aux | grep fnord                          
wayne    15745  0.0  0.0  13580   928 pts/6    S+   03:58   0:00 grep fnord

Obviamente no me importa el grep, ¡eso tiene tanto sentido como buscar el psproceso!

¿Cómo puedo evitar que grep aparezca en los resultados?

Resulta que hay una solución encontrada en llavero .

$ ps aux | grep "[f]nord"

Al poner los corchetes alrededor de la letra y las comillas alrededor de la cadena, busca la expresión regular, que dice: "Encuentra el carácter 'f' seguido de 'nord'".

Pero dado que coloca los corchetes en el patrón 'f' ahora va seguido de ']', por greplo que no aparecerá en la lista de resultados. Neato!

Otra opción que uso (especialmente para ver si se está ejecutando un proceso) es el pgrep comando. Esto buscará un proceso de coincidencia, pero no mostrará una línea grep para la búsqueda. Me gusta porque es una forma rápida de búsqueda, sin regexing ni escapar de nada.

pgrep fnord

La solución ideal es la presentada por BriGuy

pgrep fnord 

Pero si no desea hacer eso, puede excluir todas las líneas que coinciden con grep con:

ps aux | grep -v grep | grep "fnord"

No es la solución más elegante, pero podría hacer esto:

$ ps aux | grep fnord | grep -v grep

En zsh, grep fnord =(ps aux).

La idea es, primero ejecutar ps aux, poner el resultado en un archivo, luego usarlo grepen ese archivo. Solo que no tenemos un archivo, ya que usamos la "sustitución de proceso" de zsh.

Para ilustrar, intente

ps aux > ps.txt
grep fnord ps.txt
rm ps.txt

El resultado debería ser el mismo.

Comentario general sobre algunas de las otras respuestas. Algunos son muy complicados y / o largos de escribir. No es solo una cuestión de tener razón, también debe ser utilizable. Pero eso no significa que algunas de esas soluciones sean malas; solo, deben estar envueltos dentro de una mini interfaz de usuario para que sean utilizables.

ps aux | grep $(echo fnord | sed "s/^\(.\)/[\1]/g")

⚠ Esta respuesta es específica de GNU . Vea la respuesta de Wayne para una solución más general.

Buscando procesos

Si solo está buscando fnordprocesos, puede usar la -Copción para seleccionar por nombre de comando:

ps -C fnord

Esto se puede mezclar con las opciones de formato de estilo BSD y POSIX a su gusto. Consulte la página de manual de ps para obtener una lista completa.

¿Buscando algo más?

Si necesita algo más avanzado que una búsqueda exacta de un nombre de comando, ¡no pierda la esperanza! Esto todavía se puede hacer en el pslado de la tubería. Todo lo que tenemos que hacer es decirle psque excluya grepprocesos del resultado:

ps -NC grep | grep 'fnord'

-C grepselecciona todos los procesos grep y -Nniega la selección. Esto se puede usar para buscar argumentos de comando, parte del nombre de un comando o expresiones regulares más complejas.

Mi respuesta es una variación de la respuesta típica para buscar "foobar" en una lista 'ps'. El argumento de "-A" "ps" es más portátil que "aux", creo, pero este cambio es irrelevante para la respuesta. La respuesta típica se ve así:

$ ps -A -ww | grep [f]oobar

En cambio, uso este patrón:

$ ps -A -ww | grep [^]]foobar

La principal ventaja es que es más fácil escribir scripts basados ​​en estos patrones porque simplemente concatena una cadena estática "[^]]" con cualquier patrón que esté buscando. No necesita quitar la primera letra de la cadena, luego insertarla entre las llaves cuadradas y luego concatenarla nuevamente. Al hacer scripts en shell, es más fácil simplemente pegar "[^]]" delante del patrón que estaba buscando. Cortar cadenas en Bash es algo feo, por lo que mi variación lo evita. Esta variación dice mostrar las líneas donde el patrón coincide SIN un corchete derecho]. Dado que el patrón de búsqueda para excluir un corchete en realidad agrega el corchete al patrón, nunca coincidirá.

Entonces podría escribir un comando portátil 'psgrep' de la siguiente manera. Aquí, considero algunas diferencias entre Linux, OS X BSD y otros. Esto agrega los encabezados de columna de 'ps', proporciona un formato 'ps' más personalizado que se adapta mejor a mis necesidades, y muestra procesos que enumeran más, más ancho para que ninguno de los argumentos de la línea de comandos se pierda. Bueno, la mayoría no se pierden. Java es Java, a menudo hace las cosas de la peor manera posible, por lo que algunos servicios de Java superarán la longitud máxima permitida de argumentos de los que la tabla de procesos realizará un seguimiento. Creo que esto es 1024 caracteres. La longitud de comando único permitida para iniciar un proceso es mucho más larga, pero la tabla de proceso del núcleo no se molesta en realizar un seguimiento de nada de más de 1K de longitud. Una vez que se inicia el comando, el nombre del comando y la lista de argumentos no

psgrep ()
{
    pattern=[^]]${1};
    case "$(uname -s)" in
        Darwin)
            ps -A -ww -o pid,ppid,nice,pri,pcpu,pmem,etime,user,wchan,stat,command | grep -i -e "^[[:space:]]*PID" -e ${pattern}
        ;;
        Linux)
            ps -A -ww -o pid,ppid,tid,nice,pri,pcpu,pmem,etime,user,wchan:20,stat,command | grep -i -e "^[[:space:]]*PID" -e ${pattern}
        ;;
        *)  # other UNIX flavors get a minimalist version.
            ps -A -ww | grep -i -e ${pattern}
        ;;
    esac
}

La forma más simple de hacer esto sin agnóstico sería almacenarlo primero en una variable:

PS_OUTPUT="$(ps aux)"; echo "$PS_OUTPUT" |grep fnord

Llamada: la grep fnord =(ps aux)respuesta de @ EmanuelBerg es, con mucho, la más elegante, aunque requiere zsh. Lo tuve brevemente en mis archivos rc, pero bash se queja de esa sintaxis incluso a pesar de una condicional que debería evitar su evaluación.

De mis archivos rc, tengo una versión que no distingue entre mayúsculas y minúsculas que toma los argumentos de grep:

psl() {
  local PS_OUTPUT="$(ps auxww)"
  echo "${PS_OUTPUT%%$'\n'*}" >&2  # title, in stderr to avoid pipes
  echo "${PS_OUTPUT#*$'\n'}" |grep -i "${@:-^}"
}

Paseo de código, una viñeta por línea de código:

• Capture la pssalida detallada (en una localvariable para que desaparezca cuando la función regrese)
• Muestre la primera línea (el título) en error estándar para que los resultados se puedan filtrar aún más sin afectar el título. La sustitución dice: tomar $PS_OUTPUTy eliminar todo después del primer avance de línea (regex equiv:) s/\n.*$//msg. Esto nos impide agarrar el título
• Muestre la pssalida con todo excepto la primera línea (regex equiv:) s/^.*\n//my grep su contenido con -imayúsculas y minúsculas y con todos los argumentos entregados a esta función (en el caso de no argumentos ^, que coincide con el inicio de cualquier línea para que coincida todo)

Aquí hay una versión extendida de la grep -v grepsolución, filtrando todos los grepprocesos que no se han estado ejecutando por más de un segundo, lo cual es una mejora sobre "simplemente descartar todas las ocurrencias de grep".

$ ps -ef | grep -vw "00:00:00 grep" | grep <searchTerm>

respectivamente

$ ps aux | grep -vw "0:00 grep" | grep <searchTerm>

Esto puede no ser portátil y depende del formato de salida real de su pscomando local .

Es posible que desee combinar esto con una grepsalida en color para mayor comodidad:

$ alias grep='grep --color=auto'

Tal vez es hora de usar una secuencia real esta vez. El uso de tuberías lo hace paralelo.

ps aux >f && grep tmpfs <f

Feo porque habrá un archivo f, pero no es mi culpa que no haya una sintaxis para procesos secuenciales en los que aún desee utilizar la salida de un proceso ejecutado anteriormente.

Sugerencia para la sintaxis de un operador secuencial:

ps aux ||| grep tmpfs

El comando pgrep, como han dicho otros, devolverá el PID (ID de proceso) de los procesos en función del nombre y otros atributos. Por ejemplo,

pgrep -d, -u <username> <string>

le dará los PID, delimitados por una coma (,) de todos los procesos cuyo nombre coincide con el que ejecuta el usuario <username>. Puede usar el modificador -x antes para devolver solo coincidencias exactas.

Si desea obtener más información sobre estos procesos (como implica la ejecución de las opciones auxiliares desde ps), puede usar la opción -p con ps, que coincide en función del PID. Así por ejemplo,

ps up $(pgrep -d, -u <username> <string>)

proporcionará información detallada de todos los PID coincidentes con el comando pgrep.

Aquí hay un ejemplo simple para encontrar el PID del ssh-agentnombre de usuario sin mostrar el PID del grepproceso en sí:

ps xu | grep "${USER}.*[ ]/usr/bin/ssh-agent" | awk '{print $1 $2;}'

Si desea, por ejemplo, matar ssh-agentpara el usuario actual, puede usar el siguiente comando:

kill `ps xu | grep "${USER}.*[ ]/usr/bin/ssh-agent" | awk '{print $2;}'`

Para crear un práctico alias, agregue a su archivo ~ / .bashrc o ~ / .zshrc el siguiente código:

function function1 () {
    ps xu | grep "$1.*$2" | awk '{print $1" "$2" "$11;}'
}
alias mygrep="function1"

Y para usar el alias aquí hay ejemplos para obligar a todos a aprender expresiones regulares:

. /etc/profile #to make alias usable
mygrep ${USER} ${PROCESS_PATH}
mygrep ${USER} "[f]nord"
mygrep "[f]nord"
mygrep ".*[s]shd"

PD: solo he probado estos comandos en Ubuntu y Gentoo.

Usar la opción -x (coincidencia exacta) funcionó para mí. Lo combiné con -f (línea de comando completa), para poder hacer coincidir mi proceso precisamente con:

pgrep -x -f "path_i_used_when_starting/cmd params_i_used"

Puedes hacerlo fácilmente, solo definiendo un ALIAS en tu .bashrc estilo:

alias grep='grep -v grep | grep'