web-dev-qa-db-fra.com

Comment puis-je empêcher «grep» d'apparaître dans les résultats ps?

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

Évidemment, je ne me soucie pas de grep - cela a autant de sens que de rechercher le processus ps!

Comment puis-je empêcher grep d'apparaître dans les résultats?

grepps
323
Wayne Werner

Il s'avère qu'il y a une solution trouvée dans troussea .

$ ps aux | grep "[f]nord"

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

Mais puisque vous placez les crochets dans le modèle, 'f' est maintenant suivi de ']', donc grep n'apparaîtra pas dans la liste des résultats. Neato!

463
Wayne Werner

Une autre option que j'utilise (surtout pour voir si un processus est en cours d'exécution) est la commande pgrep. Cela recherchera un processus de correspondance, mais ne répertoriera pas une ligne grep pour la recherche. Je l'aime parce que c'est un moyen de recherche rapide, sans regexing ou échappant à rien.

pgrep fnord
173
BriGuy

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"
64
RSFalcon7

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

$ ps aux | grep fnord | grep -v grep

26
Brandon Kreisel

Dans zsh, grep fnord =(ps aux).

L'idée est, d'abord exécuter ps aux, placez le résultat dans un fichier, puis utilisez grep sur 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 de loin trop compliqués et/ou longs à taper. Ce n'est pas seulement une question de raison, elle doit également être utilisable. Mais cela ne signifie pas que certaines de ces solutions sont mauvaises; seulement, ils doivent être emballés dans une mini-interface utilisateur pour les rendre utilisables.

16
Emanuel Berg

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

Recherche de processus

Si vous recherchez simplement des processus fnord, vous pouvez utiliser le -C option pour sélectionner par nom de commande:

ps -C fnord

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

Vous cherchez autre chose?

Si vous avez besoin de quelque chose de plus avancé qu'une recherche exacte d'un nom de commande, ne perdez pas espoir! Cela peut toujours être fait du côté ps du tuyau. Tout ce que nous avons à faire est de dire à ps d'exclure les processus grep du résultat:

ps -NC grep | grep 'fnord'

-C grep sélectionne tous les processus grep et -N annule 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.

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

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 est sans rapport avec 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

Le principal avantage 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, puis de l'insérer entre les accolades carrées, puis de concaténer à nouveau cette dernière. Lors de l'écriture de scripts dans Shell, il est plus facile de simplement coller "[^]]" devant le motif que vous cherchiez. Le tranchage de cordes dans Bash est une chose moche, donc ma variation l'évite. Cette variation indique de montrer les lignes où le motif correspond SANS un crochet carré à droite]. Étant donné que le motif de recherche pour exclure un crochet carré ajoute en fait le crochet carré au motif, il ne se correspondra jamais.

Vous pouvez donc écrire une commande 'psgrep' portable comme suit. Ici, je prends en compte les différences entre Linux, OS X BSD et d'autres. Cela ajoute les en-têtes de colonne de 'ps', fournit un format 'ps' plus personnalisé qui convient à mes besoins, et affiche les processus listant extra, extra wide afin qu'aucun des arguments de la ligne de commande ne soit manqué. Eh bien, la plupart ne sont pas manqués. Java étant Java, il fait souvent les choses de la pire façon possible, donc certains services Java exécuteront au-delà de la longueur maximale autorisée d'arguments que la table de processus Je pense qu'il s'agit de 1024 caractères. La longueur de la commande seule autorisée pour démarrer un processus est beaucoup plus longue, mais la table des processus du noyau ne prend pas la peine de garder une trace de plus de 1 Ko. Une fois la commande lancée le nom de la commande et la liste des arguments ne sont pas nécessaires, donc ce qui est stocké dans la table de processus est juste informatif.

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
}
3
Noah Spurrier

La façon la plus simple de le faire indépendamment de Shell serait de le stocker d'abord dans une variable:

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

Appel: la réponse de grep fnord =(ps aux) d'EmanuelBerg est de loin la plus élégante, bien qu'elle nécessite zsh. Je l'avais brièvement dans mes fichiers rc, mais bash se plaint de cette syntaxe même en dépit d'un conditionnel qui devrait empêcher son évaluation.

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

Promenade dans le code, une puce par ligne de code:

  • Capture la sortie verbeuse ps (dans une variable local pour qu'elle disparaisse lorsque la fonction revient)
  • Afficher la première ligne (le titre) en erreur standard afin que les résultats puissent être filtrés davantage sans affecter le titre. La substitution dit: prenez $PS_OUTPUT Et supprimez tout après le premier saut de ligne (équation régulière: s/\n.*$//msg). Cela nous empêche de saluer le titre
  • Affichez la sortie ps avec tout sauf la première ligne (regex equiv: s/^.*\n//m) Et grepez son contenu avec -i Pour insensible à la casse et avec tous les arguments remis à cette fonction (dans le cas d'aucun argument, ^, Qui correspond au début d'une ligne pour tout faire correspondre)
2
Adam Katz

Voici une version étendue du grep -v grep solution, filtrant tous les processus grep qui n'ont pas été exécutés depuis plus d'une seconde, ce qui est une amélioration par rapport à "simplement supprimer 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 commande locale ps.

Vous souhaiterez peut-être combiner cela avec une sortie colorée grep pour plus de commodité:

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

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

Moche car il y aura un fichier f, mais ce n'est pas ma faute s'il n'y a pas de syntaxe pour les processus séquentiels où vous souhaitez toujours utiliser la sortie d'un processus précédemment exécuté.

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

ps aux ||| grep tmpfs
0
Anne van Rossum

Voici un exemple simple pour trouver le PID de ssh-agent pour le nom d'utilisateur sans afficher le PID du processus grep lui-même:

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

Si vous voulez par exemple tuer ssh-agent pour 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 l'alias, voici des exemples pour forcer tout le monde à apprendre des expressions régulières:

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

P.S. Je n'ai testé ces commandes que sur Ubuntu et Gentoo.

0
Constantin Zagorsky

L'utilisation de l'option -x (correspondance exacte) a fonctionné pour moi. Je l'ai combiné avec -f (ligne de commande complète), afin que je puisse faire correspondre mon processus avec précision avec:

pgrep -x -f "path_i_used_when_starting/cmd params_i_used"
0
moodboom

La commande pgrep, comme d'autres l'ont indiqué, 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 le nom correspond à ceux exécutés par l'utilisateur <username>. Vous pouvez utiliser le commutateur -x avant pour renvoyer uniquement les correspondances exactes.

Si vous souhaitez obtenir plus d'informations sur ces processus (comme cela implique l'exécution des options aux de ps), vous pouvez utiliser l'option -p avec ps, qui correspond en fonction du PID. Ainsi, par exemple,

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

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

0
eToThePiIPower