Sstrhsrtj

Is there a way to make jobs -p in zsh behave as in bash, ie. give
only a number, such that one can do kill $(jobs -p)?

jobs reports about jobs, which can have more than one process.

When interactive, jobs are places in process groups, so they can be suspended/resumed/interrupted as a whole.

jobs -p (in both zsh and bash) return the process group id of each job, not the process ids of all the processes in the job.

When the shell doesn't run interactively (where there's no job control), the shell reports the pid of the process that would have been the process group leader if there had been job control (which may not be the same as the one returned in $! by the way).

$ sleep 1 | sleep 20 &

[1] 29643 29644

$ jobs -p

[1]  + 29643 done       sleep 1 |

             running    sleep 20

zsh reports that for job 2 of pgid 29643, zsh started 2 processes, one of which is already done, the other still running.

If you want to get the pgids only like in bash, you can pipe that do:

awk '/^[/{print $3}'

If you want to get the pids in the job (only the ones started by the shell), you can look at the $jobstates special associative array:

$ typeset jobstates

jobstates=( 1 'running:+:29643=done:29644=running' )

To extract the pids of the processes still running in job 1:

$ echo ${${(M)${(s/:/)jobstates[1]}:#*=running}%=*}

29644

Now if you want to kill those jobs, you'd want to kill the process groups (in interactive shells), i.e. the whole jobs, not one process at random in the job.

You can kill the process group of id 29643 with kill -- -29643, kill 29643 would only kill the process of id 29643 (which is already dead in our example above).

Here, it would make more sense to pass job numbers instead of pid or pgid (which wouldn't work in non-interactive shells) to kill. That's what the job numbers are for:

kill %${(k)^jobstates}

Unfortunately, I don't think bash has a reliable equivalent.

bash-4.4$ sleep $(: '

> [213] ...') 2134 &

[1] 29856

bash-4.4$ jobs

[1]+  Running                 sleep $(: '

[213] ...') 2134 &

It's difficult to extract the job numbers reliably from that. (I also find that even while kill %; do continue; done doesn't work because of what looks like some race condition bug).

Note that when not running interactively, there's no job control, so when you do kill %1 to kill the job number 1, that job doesn't have a process group. So as a poor man's approximation, the shell (both bash and zsh) will kill each process it knows about individually instead. In our example above, instead of:

kill(-29643, SIGTERM);

it will do:

kill(29643, SIGTERM);

kill(29644, SIGTERM);

It will not kill the other processes (if any) that those 2 processes have spawned themselves, though it's still better than killing only 29643 like in your kill $(jobs -p) approach.