différence entre grep Vs chat et grep

je voudrais savoir la différence entre le dessous de 2 commandes, je comprends que 2) devrait être utilisée, mais je veux savoir la séquence exacte qui se passe en 1) et 2)
supposons que le nom de fichier a 200 caractères

1) cat nom de fichier | grep regex

2) grep regex nom de fichier

OriginalL'auteur unixadmin007 | 2012-11-22

unix

15

Fonctionnellement (en termes de production), ces deux sont les mêmes. Le premier crée en fait un processus distinct cat qui il suffit d'envoyer le contenu du fichier sur la sortie standard, qui s'affiche sur l'entrée standard de la grep, parce que la coquille a relié les deux avec un tuyau.

Dans ce sens grep regex <filename est également équivalent mais avec un processus moins.

Où vous allez commencer à voir la différence est dans les variantes quand l'information supplémentaire (les noms de fichier) est utilisé par grep, tels que:
```
grep -n regex filename1 filename2
```
La différence entre celle-ci et:
```
cat filename1 filename2 | grep -n regex
```
est que l'ancien sait sur les fichiers individuels alors que les seconds se voit comme un fichier (sans nom).

Tandis que le premier peut vous donner:
```
filename1:7:line with regex in 10-line file
filename2:2:another regex line
```
ce dernier sera plus comme:
```
7:line with regex in 10-line file
12:another regex line
```
Un autre fichier exécutable qui agit différemment s'il connaît les noms de fichier est wc, le compteur de mots de programmes:
```
$ cat qq.in
1
2
3

$ wc -l qq.in           # knows file so prints it
3 qq.in

$ cat qq.in | wc -l     # does not know file
3

$ wc -l <qq.in          # also does not know file
3
```
OriginalL'auteur paxdiablo
4

Première:
```
cat filename | grep regex
```
Normalement chat ouvre un fichier et affiche son contenu ligne par ligne sur la sortie standard stdout. Mais ici, il renvoie son contenu à la pipe'|'. Après que grep lit de tuyau(pipe comme stdin) alors si correspond à l'expression rationnelle imprime ligne sur la sortie standard stdout. Mais ici, il y a un détail grep est ouvert à de nouveaux processus du shell afin de tuyau transmet son entrée comme la sortie de nouveaux processus de shell.

Seconde:
```
grep regex filename
```
Ici grep lit directement à partir d'un fichier(au-dessus c'était la lecture de la conduite) et correspond à l'expression rationnelle si elle s'accompagne d'estampes ligne sur la sortie standard stdout.

+1: Un pédant (par exemple moi) pourrait argumenter que cat toujours écrit sur sa sortie standard, mais dans le contexte de la pipe, la sortie standard est l'écriture, à la fin du tube. De même, lorsque grep est appelée sans arguments de noms de fichiers, ou lorsqu'il traite un nom de fichier en argument de -, il lit son entrée standard, qui, dans ce cas, est lire la fin de la pipe. Notez que pipe ou | n'est pas un commandement; il n'est pas assez clair, si vous reconnaissez qu'avec "so pipe transmet son entrée comme la sortie de nouveaux processus de shell'.

OriginalL'auteur denizeren
2

Si vous souhaitez vérifier les temps d'exécution diffrence, d'abord créer un fichier avec 100000 lignes:
```
user@server ~ $ for i in $(seq 1 100000); do echo line >> test_f; done
user@server ~ $ wc -l test_f
100000 test_f
```
Mesure:
```
user@server ~ $ time grep line test_f
#...
real    0m1.320s
user    0m0.101s
sys     0m0.122s

user@server ~ $  time cat test_f | grep line
#... 
real    0m1.288s
user    0m0.132s
sys     0m0.108s
```
Comme nous pouvons le voir, la différence n'est pas trop grand...

Le deuxième time de commande temps de la cat ou de l'ensemble du pipeline?
Quelle quantité de temps que vous avez observée était due à l'omis de sortie de l'écrit à l'écran? J'ai essayé avec la sortie de grep redirigé vers /dev/null et eu temps de dans la de 10 à 50 ms gamme, pas 1 seconde plage. Maintenant, ma machine n'est pas en reste, mais 20 fois plus rapide que le vôtre semble peu probable (même en admettant que le fichier est probablement la plupart à la mémoire, pas sur le disque). Il est très difficile de faire une bonne analyse comparative. Ce que j'ai peur que l'on mesure est le temps consacré à l'écriture de 100 000 lignes de votre terminal, plutôt que les performances brutes de grep vs cat | grep.
Vous avez peut-être raison, je n'ai pas pris ça en compte.
Pour n'importe qui qui peut être curieux de connaître les résultats avec les commentaires ci-dessus, j'ai juste rediffusé en utilisant le même fichier comme ci-dessus, mais avec ces délais des commandes: time grep line test_f > /dev/null et time (cat test_f | grep line > /dev/null). Les temps ne sont plus en ligne avec @JonathanLeffler 's résultats, mais les deux commandes sont encore presque exactement à la même vitesse.

OriginalL'auteur dstronczak
0

Fonctionnellement, ils sont équivalents, cependant, l'environnement de ligne de commande de la fourche de deux processus de cat filename | grep regex et de les relier à un tuyau.

OriginalL'auteur iabdalkader
0

En fait, si les sorties sont les mêmes;
```
-$cat filename | grep regex
```
Cette commande vérifie le contenu du fichier "nom de fichier", puis extrait les regex; tandis que
```
-$grep regex filename
```
Cette commande directement recherches pour le contenu nommé regex dans le fichier "filename"

OriginalL'auteur Nji

Vous devez vous connecter pour publier un commentaire.