NEW BOT Телеграм, страница

1 view10:15

How can I modify this bash command that will also output the content of the given file.
https://redd.it/10o2qi5
@r_bash

1 view12:15

What is the fastest way to read groups of N lines from stdin / a pipe?

Im trying to figure out a good, efficient and reliable way to read groups of N lines at a time from stdin or (more generally) from a pipe. Id like to accomplish this without needing to save (or wait for) the entire contents of stdin into a variable. So far the only reliable way Ive found to do this involves something like:

nLines=8 # change as needed
while true; do
outCur="$(kk=0; while (( $kk < $nLines )); do read -r </dev/stdin || break; echo "$REPLY"; done)"
[ -z $outCur ] && break || echo "$outCur"
done # | <...>

That said, if reading the entire pipe, there are some options that are much faster than read. I wrote a little speedtest to test a few:

fgg() { while read -r; do echo "$REPLY"; done | wc -l; }
fhh() { cat | wc -l; }
fii() { head -n $1 | wc -l; }
fjj() { echo "$(</dev/stdin)" | wc -l; }
fkk() { wc -l </dev/stdin; }
fll() { mapfile -t inLines </dev/stdin; printf '%s\n' "${inLines@}" | wc -l; }
fmm() { inLines="$(</dev/stdin)"; echo "${inLines}" | wc -l; }

# note: fll and fmm dont meet the "dont save the full stdin to a variable" criteria

nLines=100000

for fun in fgg fhh "fii $nLines" fjj fkk fll fmm; do
declare -f "${fun% }"
echo
time seq 1 $nLines | $fun
echo
echo '----------------------------------'
echo
done

Which, on my test system, produces

fgg ()
{
while read -r; do
echo "$REPLY";
done | wc -l
}

100000

real 0m5.780s
user 0m3.655s
sys 0m4.306s

----------------------------------

fhh ()
{
cat | wc -l
}

100000

real 0m0.086s
user 0m0.077s
sys 0m0.028s

----------------------------------

fii ()
{
head -n $1 | wc -l
}

100000

real 0m0.085s
user 0m0.107s
sys 0m0.000s

----------------------------------

fjj ()
{
echo "$(</dev/stdin)" | wc -l
}

100000

real 0m0.124s
user 0m0.117s
sys 0m0.039s

----------------------------------

fkk ()
{
wc -l < /dev/stdin
}

1000001

real 0m0.085s
user 0m0.094s
sys 0m0.000s

----------------------------------

fll ()
{
mapfile -t inLines < /dev/stdin;
printf '%s\n' "${inLines[@]}" | wc -l
}

100000

real 0m2.241s
user 0m1.064s
sys 0m2.331s

----------------------------------

fmm ()
{
inLines="$(</dev/stdin)";
echo "${inLines}" | wc -l
}

100000

real 0m0.185s
user 0m0.180s
sys 0m0.039s

This suggests (on my test system) in a worst-case scenario (i.e., many many inputs and most of the time spend looping the `read` command), `read` is about 75x slower than optimal, loading the lines into an array is \~25x slower than optimal (+ more memory usage), and saving the full input into a (non-array) variable is \~2x slower than optimal (+ more memory usage).

From this test, using head -n in a loop seems like the obvious optimal answer, but when I try this I get....strange behavior...

seq 1 1000 | {
head -n 10
head -n 10
head -n 10
}

produces

0
1
2
3
4
5
6
7
8
9
284
285
286
287
288
289
290
291
292
293
540
541
542
543
544
545
546
547
548
549

Playing around with different sized input lines suggests that on every subsequent call after the 1st on the same pipe, head -n throws away the 1st kilobyte worth of input lines. Perhaps it is trying to "skip" reading a 1kb pipe header of some sort, but since it isnt at the start of the pipe it throws away data instead? If anyone knows how to stop head -n from doing this

2 views18:15