Lorsque je recherche un processus qui n'existe pas, par exemple

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

De toute évidence, je me fiche de grep - cela a autant de sens que de chercher le psprocessus!

Comment puis-je empêcher que grep apparaisse dans les résultats?

Il s'avère qu'une solution a été trouvée dans le trousseau .

$ ps aux | grep "[f]nord"

En mettant les crochets autour de la lettre et les guillemets autour de la chaîne, vous recherchez l'expression régulière, qui dit: "Recherchez le caractère" f "suivi de" nord "."

Mais puisque vous mettez les crochets dans le motif 'f' est maintenant suivi de ']', grepne sera donc pas affiché dans la liste des résultats. Neato!

Une autre option que j'utilise (en particulier pour vérifier si un processus est en cours d'exécution) est la pgrep commande. Cela recherchera un processus correspondant, mais ne listera pas une ligne grep pour la recherche. J'aime ça parce que c'est un moyen rapide de chercher, sans regexing ni échapper à rien.

pgrep fnord

La solution idéale est celle présentée par BriGuy

pgrep fnord 

Mais si vous ne voulez pas faire cela, vous pouvez simplement exclure toutes les lignes qui correspondent à grep avec:

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

Ce n'est pas la solution la plus élégante mais vous pouvez le faire:

$ ps aux | grep fnord | grep -v grep

En zsh, grep fnord =(ps aux).

L'idée est, tout d'abord ps aux, de placer le résultat dans un fichier, puis de l'utiliser grepsur ce fichier. Seulement, nous n'avons pas de fichier, car nous utilisons la "substitution de processus" de zsh.

Pour illustrer, essayez

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

Le résultat devrait être le même.

Commentaire général sur certaines des autres réponses. Certains sont trop compliqués et / ou longs à taper. Ce n’est pas seulement une question d’avoir raison, cela devrait aussi être utilisable. Mais cela ne signifie pas que certaines de ces solutions sont mauvaises; seulement, ils doivent être enveloppés dans une mini-interface utilisateur pour les rendre utilisables.

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

⚠ Cette réponse est spécifique GNU . Voir la réponse de Wayne pour une solution plus générale.

Recherche de processus

Si vous recherchez uniquement des fnordprocessus, vous pouvez utiliser l' -Coption pour sélectionner par nom de commande:

ps -C fnord

Cela peut être mélangé avec les options de format de style BSD et POSIX à votre convenance. Voir la page de manuel ps pour une liste complète.

Vous cherchez autre chose?

Si vous avez besoin de quelque chose de plus avancé que la recherche exacte d'un nom de commande, ne perdez pas espoir! Cela peut encore être fait sur le pscôté du tuyau. Tout ce que nous avons à faire est de dire psd'exclure les grepprocessus du résultat:

ps -NC grep | grep 'fnord'

-C grepsélectionne tous les processus grep et -Nannule la sélection. Cela peut être utilisé pour rechercher des arguments de commande, une partie d'un nom de commande ou des expressions régulières plus complexes.

Ma réponse est une variation de la réponse typique pour la recherche de "foobar" dans une liste "ps". L'argument de "-A" "ps" est plus portable que "aux", je crois, mais ce changement n'a aucune incidence sur la réponse. La réponse typique ressemble à ceci:

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

Au lieu de cela, j'utilise ce modèle:

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

L'avantage principal est qu'il est plus facile d'écrire des scripts basés sur ces modèles, car vous concaténez simplement une chaîne statique "[^]]" avec le modèle que vous recherchez. Vous n'avez pas besoin de retirer la première lettre de la chaîne, de l'insérer entre les accolades puis de la concaténer à nouveau. Lors de la création de scripts dans un shell, il est plus simple de coller "[^]]" devant le motif recherché. Le tranchage de cordes dans Bash est une chose laide, ma variante l’évite donc. Cette variation indique de montrer les lignes où le motif correspond SANS un crochet de droite]. Etant donné que le modèle de recherche pour exclure un crochet ajoute le crochet au modèle, il ne se correspondra jamais.

Ainsi, vous pourriez écrire une commande 'psgrep' portable comme suit. Ici, je tiens compte des différences entre Linux, OS X BSD et d’autres. Cela ajoute les en-têtes de colonne à partir de 'ps', fournit un format 'ps' plus personnalisé qui convient mieux à mes besoins et affiche les processus listant extra, extra wide afin qu'aucun des arguments de ligne de commande ne manque. Eh bien, la plupart ne sont pas manqués. Java étant Java, il fait souvent les choses de la pire façon possible, de sorte que certains services java fonctionneront au-delà de la longueur maximale autorisée des arguments que la table de processus va suivre. Je crois que c'est 1024 caractères. La longueur autorisée par commande permettant de démarrer un processus est beaucoup plus longue, mais la table des processus du noyau ne prend pas la peine de garder trace de tout ce qui dépasse 1K. Une fois la commande lancée, le nom de la commande et la liste des arguments isn '

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 manière la plus simple, agnostique vis-à-vis du shell, serait de le stocker dans une variable:

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

Call-out: @ La grep fnord =(ps aux)réponse d'EmanuelBerg est de loin la plus élégante, bien qu'elle soit nécessaire zsh. Je l'ai brièvement eu dans mes fichiers rc, mais bash se plaint de cette syntaxe même malgré une condition qui empêcherait son évaluation.

De mes fichiers rc, j'ai une version non sensible à la casse qui prend l'argument 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 "${@:-^}"
}

Code walk, une balle par ligne de code:

• Capturez la pssortie commentée (dans une localvariable afin qu'elle disparaisse lorsque la fonction retourne)
• Affiche la première ligne (le titre) en erreur standard afin que les résultats puissent être filtrés sans affecter le titre. La substitution dit: prenez $PS_OUTPUTet supprimez tout après le premier saut de ligne (regex equiv:) s/\n.*$//msg. Cela nous empêche de grepper le titre
• Afficher la pssortie avec tout sauf la première ligne (regex equiv:) s/^.*\n//met grep son contenu avec -ipour insensible à la casse et avec tous les arguments transmis cette fonction (dans le cas d'aucun argument ^, qui correspond au début de toute ligne tout)

Voici une version étendue de la grep -v grepsolution, filtrant tous les grepprocessus qui n'exécutent pas depuis plus d'une seconde, ce qui constitue une amélioration par rapport à "supprime simplement toutes les occurrences de grep".

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

respectivement

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

Cela peut ne pas être portable et dépend du format de sortie réel de votre pscommande locale .

Vous voudrez peut-être combiner cela avec une grepsortie colorée pour plus de commodité:

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

Peut-être le temps d'utiliser une vraie séquence cette fois. L'utilisation de tuyaux le rend parallèle.

ps aux >f && grep tmpfs <f

C'est moche, car il y aura un fichier f, mais ce n'est pas de ma faute s'il n'y a pas de syntaxe pour les processus séquentiels pour lesquels vous souhaitez toujours utiliser le résultat d'un processus exécuté précédemment.

Suggestion pour la syntaxe d'un opérateur séquentiel:

ps aux ||| grep tmpfs

Comme d'autres l'ont indiqué, la commande pgrep renverra le PID (ID de processus) des processus en fonction du nom et d'autres attributs. Par exemple,

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

vous donnera les PID, délimités par une virgule (,) de tous les processus dont les noms correspondent exécutés par l'utilisateur <username>. Vous pouvez utiliser le commutateur -x avant pour ne renvoyer que des correspondances exactes.

Si vous souhaitez obtenir plus d'informations sur ces processus (comme le fait d'exécuter les options aux depuis ps implique), vous pouvez utiliser l'option -p avec ps, qui correspond au PID. Donc, par exemple,

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

donnera des informations détaillées sur tous les PID associés à la commande pgrep.

Voici un exemple simple pour trouver le PID de ssh-agentnom d'utilisateur sans afficher le PID du grepprocessus lui-même:

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

Si vous voulez par exemple tuer ssh-agentpour l'utilisateur actuel, vous pouvez utiliser la commande suivante:

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

Pour créer un alias pratique, ajoutez à votre fichier ~ / .bashrc ou ~ / .zshrc le code suivant:

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

Et pour utiliser alias, voici des exemples pour forcer tout le monde à apprendre les expressions régulières:

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

PS Je n’ai testé ces commandes que sur Ubuntu et Gentoo.

L'utilisation de l'option -x (correspondance exacte) a fonctionné pour moi. Je l'ai combiné avec -f (ligne de commande complète) afin de pouvoir assortir mon processus précisément avec:

pgrep -x -f "path_i_used_when_starting/cmd params_i_used"

Vous pouvez le faire facilement, simplement en définissant un ALIAS dans votre .bashrc genre:

alias grep='grep -v grep | grep'