Is there a way to run a command (e.g. ps aux|grep someprocess) for n times?

Something like:

run -n 10  'ps aux|grep someprocess'

I want to use it interactively.

Update: The reason I am asking this is, that I do work on a lot of machines and I don't want to import all my adaped scripts etc into every box to get the same functionality accross every machine.


10 Answers 10


I don't think a command or shell builtin for this exists, as it's a trivial subset of what the Bourne shell for loop is designed for and implementing a command like this yourself is therefore quite simple.

Per JimB's suggestion, use the Bash builtin for generating sequences:

for i in {1..10}; do command; done

For very old versions of bash, you can use the seq command:

for i in `seq 10`; do command; done

This iterates ten times executing command each time - it can be a pipe or a series of commands separated by ; or &&. You can use the $i variable to know which iteration you're in.

If you consider this one-liner a script and so for some unspecified (but perhaps valid) reason undesireable you can implement it as a command, perhaps something like this on your .bashrc (untested):

#function run
run() {
    for i in `seq $number`; do


run 10 command


run 5 echo 'Hello World!'
  • 17
    @mahatmanich, A loop is not a script. There is nothing preventing you from using for... at an interactive terminal.
    – Zoredache
    Commented May 24, 2011 at 18:10
  • 3
    Well, the one-liner above is the kind of standard way to do it and it is fairly simple. Why is it not good for you? Maybe you are asking the wrong question? What is the main goal of your scripts or your actions that you want to repeat them a number of times? Maybe there is a better solution if we put the problem in a different way. Commented May 25, 2011 at 8:43
  • 6
    @mahatmanich - for is the bash built-in for iterating.
    – JimB
    Commented May 25, 2011 at 12:58
  • 4
    @Eduardo Ivanec - FYI, bash has built-in range like seq: {1..10}
    – JimB
    Commented May 25, 2011 at 13:03
  • 1
    It seems the inbuilt bracket sequence does not support variable substitution (see stackoverflow.com/a/3737773/713554). The function you gave works perfectly when placed in .bashrc if {1..$number} is exchanged for `seq $number` though.
    – Leo
    Commented Mar 29, 2012 at 13:36

ps aux | grep someprocess looks like you want to watch changes of a program for a fixed time. Eduardo gave an answer that answer your question exactly but there is an alternative: watch:

watch 'ps aux | grep someprocess'

Note that I've put the command in single quotes to avoid the shell from interpreting the command as "run watch ps aux" and pipe the result through grep someprocess. Another way to do the previous command would be:

watch ps aux \| grep someprocess

By default, watch refreshes every two seconds, that can be changed using the -n option. For instance, if want to have an interval of 1 second:

watch -n 1 'ps aux | grep someprocess'

Just for fun

pgrep ssh

NOTE: You must run the command pgrep ssh first, separately, and then enter the !!;!!;!!;!!;!!;!! string. Otherwise, the !! are replaced with the command that was previously executed.

; is a command separator and !! replay last command in bash. So this runs pgrep ssh and then replays it 6 times.

  • 2
    Can someone explain this please? Looks very intriguing. Commented Feb 24, 2014 at 16:31
  • 7
    ; is just command separator. !! replay last command in bash. So this run 'pgrep ssh' and then replay it 6 times. Commented Sep 21, 2014 at 19:11
  • 4
    Won't cmd ;!! on one line just repeat the command entered before the current line? It'd have to be two separate history entries.
    – Joel Purra
    Commented Apr 28, 2015 at 7:16
  • 3
    replace ; with && to stop on first failure.
    – user881300
    Commented Oct 6, 2019 at 8:41
  • 1
    @JoelPurra yes you are correct. This answer is misleading. Commented Aug 12, 2021 at 12:15

similar to previous replies, but does not require the for loop:

seq 10 | xargs -I -- echo "hello"

pipe output of seq to xargs with no arguments or options

  • 4
    This will just do one execution echo "hello" 1 2 3 4 5 6 7 8 9 10. You need to run xargs with -n 1 for one process for each input (number) and with -P 10 for parallel execution (10 parallel processes). Ending up with seq 10 | xargs -n 1 -P 10 echo. Commented Apr 26, 2017 at 22:08

Try this:

yes ls | head -n5 | bash

This requires the command to be executed in a sub-shell, a slight performance penalty. YMMV. Basically, you get the "yes" command to repeat the string "ls" N times; while "head -n5" terminated the loop at 5 repeats. The final pipe sends the command to the shell of your choice.

Incidentally csh-like shells have a built-in repeat command. You could use that to execute your command in a bash sub-shell!


With ZSH (the default in MacOS Terminal) you can use the repeat command.

repeat 10 ps aux | grep someprocess
  • I am not seeing this command on Mac OS 10.15.7 - don't see it as a brew package either? Commented Feb 25, 2021 at 16:17
  • 3
    @PatrickSteil infact It's a zsh keyword zsh.sourceforge.net/Doc/Release/Shell-Grammar.html, ``` repeat word do list done word is expanded and treated as an arithmetic expression, which must evaluate to a number n. list is then executed n times. The repeat syntax is disabled by default when the shell starts in a mode emulating another shell. It can be enabled with the command ‘enable -r repeat’```
    – Fangxing
    Commented Apr 23, 2021 at 9:24
  • In my case, I also had to wrap the output: { repeat 10 uuidgen } | clip Commented Jul 25, 2022 at 16:10



while [ $x -gt 0 ]; do

which could of course be made into a one liner:

x=10; while [ $x -gt 0 ]; do command; x=$(($x-1)); done

and seems to be the most portable way, and thus less likely to make you install programs.

The following are less portable:

  • brace expansion {1..10}: bash specific, and would generate a huge line if the argument is large
  • seq: GNU
  • yes: GNU

And if you get tired of portability, consider GNU parallel:

sudo apt-get install parallel
seq 100 | parallel echo {}

which runs commands in parallel and has many cool options.

See also: https://stackoverflow.com/questions/169511/how-do-i-iterate-over-a-range-of-numbers-defined-by-variables-in-bash

  • GNU Parallel is built to be very portable. sh, zsh, ksh, and bash are all well supported on most platforms. csh, tcsh, fish has some support. Using parallel --embed you can even build a script that can easily be moved to another system which does not have GNU Parallel installed.
    – Ole Tange
    Commented Dec 19, 2018 at 0:35

A fish shell implementation of @eduardo-ivanec's run function above

function run
  set number $argv[1]
  for i in (seq $number)
    eval $argv[2..-1]

To run ps aux multiple times searching for a different known string each time:

for str in {str1,str2,...}; do ps aux | grep $str | grep -v " grep "; done

The grep -v " grep " part will remove grep itself from the result, which is a bad idea if one of your search strings is grep.


That would be 'watch' - should be part of almost every unix system using procps

You can see fs changes or otherwise interesting movement in a system. For example,

watch "df -hP | grep /tmp" 

Just put your commands as an argument (see man watch)

  • There is already an answer with watch ... see right below ... Commented Jun 22, 2018 at 6:57

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .