Quando cerco un processo che non esiste, ad es

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

Ovviamente non mi importa di grep - ha senso tanto quanto cercare il psprocesso!

Come posso evitare che grep compaia nei risultati?

Si scopre che c'è una soluzione trovata nel portachiavi .

$ ps aux | grep "[f]nord"

Mettendo le parentesi attorno alla lettera e le virgolette attorno alla stringa si cerca il regex, che dice "Trova il carattere 'f' seguito da 'nord'."

Ma dato che hai inserito le parentesi nel modello 'f' ora è seguito da ']', quindi grepnon comparirà nell'elenco dei risultati. Neato!

Un'altra opzione che uso (specialmente solo per vedere se un processo è in esecuzione) è il pgrep comando. Questo cercherà un processo di abbinamento, ma non elencherà una linea grep per la ricerca. Mi piace perché è un modo rapido di ricerca, senza regexare o sfuggire a nulla.

pgrep fnord

La soluzione ideale è quella presentata da BriGuy

pgrep fnord 

Ma se non vuoi farlo, puoi semplicemente escludere tutte le righe che corrispondono a grep con:

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

Non è la soluzione più elegante ma potresti farlo:

$ ps aux | grep fnord | grep -v grep

In zsh, grep fnord =(ps aux).

L'idea è, prima di tutto ps aux, inserire il risultato in un file, quindi utilizzarlo grepsu quel file. Solo, non abbiamo un file, poiché utilizziamo la "sostituzione di processo" di zsh.

Per illustrare, prova

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

Il risultato dovrebbe essere lo stesso.

Commento generale su alcune delle altre risposte. Alcuni sono troppo complicati e / o lunghi da scrivere. Non si tratta solo di avere ragione, dovrebbe anche essere utilizzabile. Ma ciò non significa che alcune di quelle soluzioni siano cattive; solo, devono essere racchiusi in una mini-UI per renderli utilizzabili.

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

⚠ Questa risposta è specifica per GNU . Vedi la risposta di Wayne per una soluzione più generale.

Alla ricerca di processi

Se stai solo cercando i fnordprocessi, puoi utilizzare l' -Copzione per selezionare in base al nome del comando:

ps -C fnord

Questo può essere combinato con le opzioni di formato stile BSD e POSIX a proprio piacimento. Vedi la pagina man di ps per un elenco completo.

Cerchi qualcos'altro?

Se hai bisogno di qualcosa di più avanzato di una ricerca esatta di un nome di comando, non perdere la speranza! Questo può ancora essere fatto sul pslato del tubo. Tutto quello che dobbiamo fare è dire psdi escludere i grepprocessi dal risultato:

ps -NC grep | grep 'fnord'

-C grepseleziona tutti i processi grep e -Nannulla la selezione. Questo può essere usato per cercare argomenti di comando, parte di un nome di comando o espressioni regolari più complesse.

La mia risposta è una variazione della risposta tipica per la ricerca di "foobar" in un elenco "ps". L'argomento di "-A" "ps" è più portabile di "aux", credo, ma questo cambiamento è irrilevante per la risposta. La risposta tipica è questa:

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

Invece uso questo modello:

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

Il vantaggio principale è che è più semplice scrivere script basati su questi schemi perché concateni semplicemente una stringa statica "[^]]" con qualsiasi modello tu stia cercando. Non è necessario rimuovere la prima lettera della stringa, quindi inserirla tra le parentesi quadre e quindi concatenarla nuovamente insieme. Quando si esegue lo scripting in shell, è più semplice incollare "[^]]" davanti al modello che stavi cercando. Il taglio delle corde in Bash è una cosa brutta, quindi la mia variazione lo evita. Questa variazione dice mostra le linee in cui il modello corrisponde SENZA una parentesi quadra di destra]. Poiché il modello di ricerca per escludere una parentesi quadra aggiunge effettivamente la parentesi quadra al modello, allora non corrisponderà mai a se stesso.

Quindi potresti scrivere un comando 'psgrep' portatile come segue. Qui, tengo conto delle differenze tra Linux, OS X BSD e altri. Questo aggiunge le intestazioni di colonna da 'ps', fornisce un formato 'ps' più personalizzato che si adatta alle mie esigenze di scommettitori e mostra i processi che elencano extra, extra larghi in modo che nessuno degli argomenti della riga di comando venga perso. Bene, molti non sono mancati. Essendo Java, spesso fa le cose nel modo peggiore possibile, quindi alcuni servizi Java correranno oltre la lunghezza massima consentita degli argomenti che la tabella dei processi terrà traccia. Credo che questo sia 1024 caratteri. La lunghezza della sola riga di comando consentita per avviare un processo è molto più lunga, ma la tabella dei processi del kernel non si preoccupa di tenere traccia di qualsiasi lunghezza superiore a 1 KB. Una volta avviato il comando, l'elenco dei nomi dei comandi e degli argomenti non è '

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
}

Il modo più semplice agnostico di shell per farlo sarebbe quello di memorizzarlo prima in una variabile:

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

Call-out: la grep fnord =(ps aux)risposta di @ EmanuelBerg è di gran lunga la più elegante, anche se richiede zsh. L'ho avuto brevemente nei miei file rc, ma bash si lamenta di quella sintassi, nonostante un condizionale che dovrebbe impedirne la valutazione.

Dai miei file rc, ho una versione senza distinzione tra maiuscole e minuscole che prende gli argomenti di grep:

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

Code walk, un punto elenco per riga di codice:

• Cattura l' psoutput dettagliato (in una localvariabile in modo che scompaia quando la funzione ritorna)
• Visualizza la prima riga (il titolo) in errore standard in modo che i risultati possano essere ulteriormente filtrati senza influire sul titolo. La sostituzione dice: prendi $PS_OUTPUTe rimuovi tutto dopo il feed della prima riga (regex equiv:) s/\n.*$//msg. Questo ci impedisce di aggirare il titolo
• Mostra l' psoutput con tutto tranne la prima riga (regex equiv:) s/^.*\n//me grep il suo contenuto con -imaiuscole e minuscole e con tutti gli argomenti consegnati a questa funzione (nel caso di nessun argomento ^, che corrisponde all'inizio di qualsiasi riga per abbinare qualunque cosa)

Forse è il momento di usare una sequenza reale questa volta. L'uso di tubi lo rende parallelo.

ps aux >f && grep tmpfs <f

Brutto perché ci sarà un file f, ma non è colpa mia se non c'è sintassi per i processi sequenziali in cui si desidera ancora utilizzare l'output di un processo precedentemente eseguito.

Suggerimento per la sintassi di un operatore sequenziale:

ps aux ||| grep tmpfs

Il comando pgrep, come altri hanno affermato, restituirà il PID (ID processo) dei processi in base al nome e ad altri attributi. Per esempio,

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

ti fornirà i PID, delimitati da una virgola (,) di tutti i processi il cui nome corrisponde all'esecuzione dell'utente <username>. È possibile utilizzare l'opzione -x prima di restituire solo corrispondenze esatte.

Se vuoi ottenere maggiori informazioni su questi processi (come implica l'esecuzione delle opzioni aux da ps), puoi usare l'opzione -p con ps, che corrisponde in base al PID. Quindi, per esempio,

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

fornirà informazioni dettagliate su tutti i PID associati al comando pgrep.

Ecco un semplice esempio per trovare PID di ssh-agentper username senza mostrare PID del grepprocesso stesso:

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

Se ad esempio vuoi uccidere ssh-agentper l'utente corrente puoi usare il seguente comando:

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

Per creare un pratico alias aggiungi al tuo file ~ / .bashrc o ~ / .zshrc il seguente codice:

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

E per usare l'alias qui ci sono esempi che obbligano tutti a imparare espressioni regolari:

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

PS Ho testato solo questi comandi su Ubuntu e Gentoo.

Ecco una versione estesa della grep -v grepsoluzione, che filtra tutti i grepprocessi che non sono in esecuzione da più di un secondo, il che rappresenta un miglioramento rispetto a "scartare tutte le occorrenze di grep".

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

rispettivamente

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

Potrebbe non essere portatile e dipende dal formato di output effettivo del pscomando locale .

Potresti voler combinare questo con un grepoutput colorato per comodità:

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

L'uso dell'opzione -x (corrispondenza esatta) ha funzionato per me. L'ho combinato con -f (riga di comando completa), quindi ho potuto abbinare il mio processo precisamente con:

pgrep -x -f "path_i_used_when_starting/cmd params_i_used"

Puoi farlo facilmente, semplicemente definendo un ALIAS .bashrc come questo:

alias grep='grep -v grep | grep'