Newsgroup: it.comp.os.linux.iniziare
Titolo: selezionare tot file per volta da shell

mi trovo spesso a codificare (con jbig2enc) molte scansioni di libri e poi 
a produrne il pdf
avendo sperimentato che, almeno sul mio pc, la codifica inizia a diventare 
estremamente lenta se il numero di immagini supera una certa soglia, avevo 
pensato di effettuarla selezionandone un certo quantitativo alla volta
per passare a jbig2enc in automatico, tot file per volta, avevo pensato a 
questa combinazione di comandi:
`ls -1 *.png|head -30 |tr '\n' ' '`
ls elenca i file in colonna, con head ne prendo un certo numero e tr mi 
elimina i ritorni a capo dell'elenco
passandolo come argomento di jbig2enc, tra retroapici, e combinandolo con 
pdf.py per ottenere il pdf finale, ho:
jbig2 -s -p -v `ls -1 *.png|head -30 |tr '\n' ' '` ; pdf.py output >out.pdf
sembra funzionare; pensate che ci sia un metodo migliore e che implichi 
meno comandi?
-- 
Puppy Linux wiki:  
http://dokupuppylinux.co.cc
Puppy Linux Forum: 
http://puppylinux.ilbello.com
Windows me genuit, Ubuntu rapuere / tenet nunc Puppy Linux...

 meno comandi?
[...]
in effetti, ora che ci penso, usare head e tail va bene solo se posso 
suddividere il numero totale di file in due, ad esempio se sono 100 i 
primi 50 li seleziono con head e gli ultimi con tail, ma se sono più di 
200, il mio pc arranca e forse dovrei usare sed per selezionare tipo: i 
primi 50, poi i secondi 50, poi i terzi ecc, cioé 1-50, 51-100, 101-150 e 
così via.
non mi ricordo come usare sed in questo modo, ma cercherò di scoprirlo


 meno comandi?
xargs è nato proprio per fare quello che vuoi fare tu.
man xargs

 xargs è nato proprio per fare quello che vuoi fare tu.
[...]
ma è anche troppo complesso
una soluzione che ho trovato con sed è questa:
jbig2 -s -p -v `ls *.svg |sed -n -e "1,+29 p" |tr '\n' ' '`;pdf.py output > out.pdf
jbig2 -s -p -v `ls *.svg |sed -n -e "30,+59 p" |tr '\n' ' '`;pdf.py output > out.pdf
ecc... di 30 in 30


 ecc... di 30 in 30
questo è complicato:
con awk
-------------------   cut here  (completalo se
necessario)----------------
BEGIN { list=""; start=0; }
      {
	    if (start == 0) { printf("jbig2 -v -s "); }
	    printf(" %s", $1);
	    if (!(NR % MODULO))
	    {
		print "";
		list = "";
		start = 0;
	    }
	    else { start++; }
      }
  END { if (start) { print ""; } }
-----------------------------------------------
lo salvi e...
ls | awk -v MODULO=<valore che ti serve> -f file.awk | sh
oppure direttamente in bash:
uso: lsn <dir> <ext> <modulo>
togli gli "echo" di troppo e aggiungi la conversie in pdf
--------------------------------------------------------
function lsn () {
	local dir="$1"
	local ext="$2"
	local -i mod=$3
	local tmp=""
	local cmd=""
	local -i nc
	local -i s
	local -i i
	local -a array
	tmp="/tmp/lst.$$"
	cd $1
	ls *.$2 > $tmp
	nc=`wc -l $tmp | awk '{ print $1; }'`
	readarray -n $nc -t array < $tmp
	s=0
	cmd=""
	for i in `seq 1 $nc`
	do
		if [ $s -eq 0 ]
		then
			cmd="jbig2 -v -s "
		fi
        	cmd=`printf "%s %s" "$cmd" "${array[$((i - 1))]}"`
		if [ $((i % mod)) -eq 0 ]
		then
			echo  $cmd
			cmd=""
			s=0
		else
			s=$((s + 1))
		fi
	done
	if [ $s -gt 0 ]
	then
		echo $cmd
	fi
	rm $tmp
}
---------------------------------------------------------------
ciao
michele

 
Cosa c'è di complicato?
f () { big2 -s -p -v "$@" ; pdf.py output > out.pdf }
find . -name '*.svg' -print0 | xargs -0 -n 30  f 
E sei protetto anche contro i nomi di file con caratteri strani:

 ls | xargs -L 30 echo "jbig2 -s -p -v "
ls non dovrebbe mai essere usato in una pipe; per questo 
c'è find
-L  implica -x ed esce se con 30 argometi si supera il 
massimo numero di caratteri. Io preferisco usare -n che 
in tal caso esegue comunque il comando con meno argomenti.

 Perché?
- Perché non permette di trattare in modo facile i file con
  caratteri strani nel nome (confronta le opzioni -0, -print0
  e simili di molti comandi)
- Perché è abusato. ls è necessario in uno o due casi 
  particolari (principalmente per trattare i timestamp) 
 
- Perché l'output di ls è la cosa meno portabile in assoluto
  e ls è spesso un alias che colora il suo output od 
  aggiunge caratteri strani.
Tutto questo è spiegato più esaurientemente qui:
http://mywiki.wooledge.org/ParsingLs

 particolari (principalmente per trattare i timestamp)
E comunque anche in questo caso esistono modi più 
efficienti e portabili