Quando procuro algum processo que não existe, por exemplo,

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

Obviamente, eu não ligo para grep - isso faz tanto sentido quanto procurar pelo psprocesso!

Como posso impedir que o grep apareça nos resultados?

Acontece que há uma solução encontrada no chaveiro .

$ ps aux | grep "[f]nord"

Ao colocar os colchetes em volta da letra e das aspas, você procura a regex, que diz: "Encontre o caractere 'f' seguido de 'nord'".

Mas como você coloca os colchetes no padrão 'f' agora é seguido por ']', grepnão será exibido na lista de resultados. Neato!

Outra opção que eu uso (especialmente apenas para verificar se um processo está em execução) é o pgrep comando Isso procurará um processo de correspondência, mas não listará uma linha grep para a pesquisa. Gosto porque é uma maneira rápida de pesquisar, sem regexar ou escapar de nada.

pgrep fnord

A solução ideal é a apresentada pela BriGuy

pgrep fnord 

Mas se você não quiser fazer isso, poderá excluir todas as linhas que correspondem ao grep com:

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

Não é a solução mais elegante, mas você pode fazer isso:

$ ps aux | grep fnord | grep -v grep

No zsh grep fnord =(ps aux),.

A idéia é, primeiro executar ps aux, colocar o resultado em um arquivo e depois usá grep-lo. Apenas não temos um arquivo, pois usamos a "substituição de processo" do zsh.

Para ilustrar, tente

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

O resultado deve ser o mesmo.

Comentário geral sobre algumas das outras respostas. Alguns são muito complicados e / ou demoram para digitar. Não é apenas uma questão de estar certa, deve ser utilizável também. Mas isso não significa que algumas dessas soluções sejam ruins; somente, eles devem ser agrupados em uma mini-interface do usuário para torná-los utilizáveis.

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

⚠ Essa resposta é específico do GNU . Veja a resposta de Wayne para uma solução mais geral.

Procurando por Processos

Se você está apenas procurando fnordprocessos, pode usar a -Copção para selecionar pelo nome do comando:

ps -C fnord

Isso pode ser combinado com as opções de formato no estilo BSD e POSIX ao seu gosto. Veja a página de manual do ps para uma lista completa.

Procurando algo mais?

Se você precisar de algo mais avançado do que uma busca exata por um nome de comando, não perca a esperança! Isso ainda pode ser feito na pslateral do tubo. Tudo o que precisamos fazer é dizer pspara excluir grepprocessos do resultado:

ps -NC grep | grep 'fnord'

-C grepseleciona todos os processos grep e -Nnega a seleção. Isso pode ser usado para procurar argumentos de comando, parte de um nome de comando ou expressões regulares mais complexas.

Minha resposta é uma variação da resposta típica para procurar "foobar" em uma lista de 'ps'. O argumento de "-A" "ps" é mais portátil que "aux", acredito, mas essa mudança é irrelevante para a resposta. A resposta típica é assim:

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

Em vez disso, uso este padrão:

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

A principal vantagem é que é mais fácil escrever scripts com base nesses padrões, porque você simplesmente concatena uma sequência estática "[^]]" com qualquer padrão que esteja procurando. Você não precisa retirar a primeira letra da string, depois inseri-la entre os colchetes e concatenar isso novamente. Ao criar scripts no shell, é mais fácil colocar "[^]]" na frente do padrão que você estava procurando. Fatiar cordas no Bash é uma coisa feia, então minha variação evita isso. Essa variação indica as linhas em que o padrão corresponde SEM um colchete quadrado direito]. Como o padrão de pesquisa para excluir um colchete, na verdade, adiciona o colchete ao padrão, ele nunca será compatível.

Então você pode escrever um comando portátil 'psgrep' da seguinte maneira. Aqui, considero algumas diferenças entre Linux, OS X BSD e outros. Isso adiciona os cabeçalhos das colunas de 'ps', fornece um formato 'ps' mais personalizado, adequado às minhas necessidades, e exibe processos listando extra, extra largo, para que nenhum dos argumentos da linha de comando seja esquecido. Bem, a maioria não faz falta. Java sendo Java, geralmente faz as coisas da pior maneira possível; portanto, alguns serviços java executam o comprimento máximo permitido de argumentos que a tabela de processos acompanhará. Acredito que sejam 1024 caracteres. O tamanho do comando único que é permitido iniciar um processo é muito mais longo, mas a tabela de processos do kernel não se preocupa em rastrear algo com mais de 1K de comprimento. Depois que o comando é iniciado, a lista de nome e argumento do comando não é mais '

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
}

A maneira mais simples, independente do shell, de fazer isso seria armazená-lo em uma variável primeiro:

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

Texto explicativo: A grep fnord =(ps aux)resposta de @ EmanuelBerg é de longe a mais elegante, embora exija zsh. Eu o tive brevemente nos meus arquivos rc, mas o bash reclama dessa sintaxe, apesar de um condicional que deve impedir sua avaliação.

Nos meus arquivos rc, tenho uma versão que não diferencia maiúsculas de minúsculas que aceita os argumentos do grep:

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

Caminhada pelo código, um marcador por linha de código:

• Capture a pssaída detalhada (em uma localvariável para que ela desapareça quando a função retornar)
• Exiba a primeira linha (o título) com erro padrão para que os resultados possam ser filtrados ainda mais sem afetar o título. A substituição diz: pegue $PS_OUTPUTe remova tudo após o primeiro avanço de linha (regex equiv:) s/\n.*$//msg. Isso nos impede de cumprimentar o título
• Exiba a pssaída com tudo, exceto a primeira linha (regex equiv s/^.*\n//m:), e grep seu conteúdo com -ifor case-insensitive e com todos os argumentos entregues a essa função (no caso de sem argumentos ^, que corresponde ao início de qualquer linha para corresponder) tudo)

Talvez seja hora de usar uma sequência real desta vez. O uso de tubos torna paralelo.

ps aux >f && grep tmpfs <f

Feio porque haverá um arquivo f, mas não é minha culpa que não haja sintaxe para processos sequenciais em que você ainda deseja usar a saída de um processo executado anteriormente.

Sugestão para a sintaxe de um operador seqüencial:

ps aux ||| grep tmpfs

O comando pgrep, como outros já declararam, retornará o PID (ID do processo) dos processos com base no nome e outros atributos. Por exemplo,

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

fornecerá os PIDs, delimitados por vírgula (,) de todos os processos cujo nome corresponde à execução do usuário <username>. Você pode usar a opção -x antes para retornar apenas correspondências exatas.

Se você deseja obter mais informações sobre esses processos (como implica a execução das opções aux do ps), você pode usar a opção -p com ps, que corresponde com base no PID. Então, por exemplo,

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

fornecerá informações detalhadas de todos os PIDs correspondentes ao comando pgrep.

Aqui está um exemplo simples para encontrar o PID do ssh-agentnome de usuário sem mostrar o PID do greppróprio processo:

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

Se você deseja, por exemplo, matar ssh-agento usuário atual, pode usar o seguinte comando:

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

Para criar um alias útil, adicione ao seu arquivo ~ / .bashrc ou ~ / .zshrc o seguinte código:

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

E para usar o alias, aqui estão exemplos para forçar todos a aprender expressões regulares:

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

PS: Apenas testei esses comandos no Ubuntu e Gentoo.

Você pode fazer isso facilmente, apenas definindo um ALIAS .bashrc como este:

alias grep='grep -v grep | grep'

Usar a opção -x (correspondência exata) funcionou para mim. Combinei com -f (linha de comando completa), para que eu pudesse combinar meu processo precisamente com:

pgrep -x -f "path_i_used_when_starting/cmd params_i_used"