sed regulární výrazy

s/^(.*)\.1\.gz$/\1/g nahradi (to co je v zavorkach).1.gz (tim, co je v zavorkach).

snad rozumim zadani

Reseni sedem
PROMENNA=`echo jmeno.1.gz | sed s/"\(.*\)\.1\.gz"/"\1"/`

IMHO lepsi je:

PROMENNA=`basename jmeno.1.gz .1.gz`

Moc ti díky řešení číslo 2 funguje, řešení číslo 1 jsem nezkoušel.

alebo este jednoduchsie pomocou
PROMENNA=jmeno.1.gz
echo ${PROMENNA%.1.gz}

Tak ještě bych sem přidal jeden dotaz snad to nebude vadit nevíte proč mi toto nefunguje:

for file in *.1.gz; do
        mv $file $(echo ${file%.1.gz})
done

skoušel sem i toto:

for file in *.1.gz; do
        tmp2=$(echo ${file%.1.gz})
        mv $file $tmp2
done

ale to taky nefunguje.

netreba hned vsetko do pismenka prepisovat :-)) inak uvodzovky su dolezite, inak budu robit problemy subory s medzerami asi to chcete aj rozbalit, ze? preco nie rovno?

for file in *.1.gz; do
        zcat \"${file%.1.gz}\" > \"$file\"
done

inak pekne funguje aj

zcat FILE.gz | less

zcat IMHO pouze zavolá gunzip, je tedy zbytečný.

for file in *.1.gz; do
   gunzip <"$file" >"${file%.1.gz}"
done

ale tato konstrukce je zbytečně složitá, pro rozbalení více souborů stačí zadat:

gunzip *.1.gz

Ještě pěkně funguje

less FILE.gz

Vy máte na disku soubory s názvem v uvozovkách? Něco jako

$ ls \"*\"
"blbejnazev"

Je tam navíc echo, které je v tomto případě zbytečné:

for file in *.1.gz; do
    mv "$file" "${file%.1.gz}"
done

Nezapomínejte na uvozovky, jinak si koledujete...

Ještě mě napadlo jedno řešení, pokud není třeba rozbalovat, ale jen odstranit přípony:

rename ".1.gz" "" *.1.gz

No to by musel mý ten správný rename (rozuměj třeba ten co je v FC). U mě by to bylo třeba

rename 's/\.1\.gz$//' *.1.gz

(perlutils rename)

echo messages.1.gz | sed -e 's/\.1\.gz$//'

Dělat 2x fork+exec a 2x pipe v prvním případě a jednou fork+exec a jedna pipe v druhém případě místo

PROMENNA=${PROMENNA%%.*}
nebo
PROMENNA=${PROMENNA%.1.gz}

je dnes nějaká móda?

Co to máte za basename? moje basename udělá tohle
$ basename /home/jan.novak.1.gz
jan.novak.1.gz

jinak v zadání je doslova napsáno "jen část před první tečkou"

takže na to máme ${var%%.*} které dělá přesně tohle

jinak další otázka v diskusi bylo na

for i in *.1.gz
do
mv "$i" "${i%.1.gz}"
done

P.S.: To je nějaká nová móda radit blbě a ani si to neověřit?

Nevšim jsem si, že už víše je to s basename ukázáno správně. Jinak basename je berlička pro shelly co neumí konstrukce ${var#pattern} ${var##pattern} ${var%pattern} ${var%%pattern} což je csh, kcsh, další klony csh a některé minimalistické shelly. Od těch dob, co tohle umí i sh je zbytečné spouštět podproces basename a nutit shell parsovat jeho výstup.

basename() { local a="${1##*/}"; [ -z "$2" ] && echo $a || echo ${a%$2}; }

Trochu brutálnější verze

basename() { [ -n "$2" ] && set -- "${1%$2}"; echo ${1##*/}; }

stejně se to uvnitř skriptu bude dělat prvním způsobem, protože nebudu přece dělat podproces kvůli přiřazení a=$(basename bla/bla/bla.bl) (a taky se mi nechce koukat do zdrojáku jestli to náhodou shell nějak neoptimalizuje).

Nebo si můžu udělat funkci, která rovnou přiřadí do proměné

basenameset() { [ $# -ge 2 ] && { eval $1=\"${2##*/}\"; [ -n "$3" ] && eval $1='"${'$1'%$3}"'; } }

Trošku elegantnější

basenameset() { [ -n "$3" ] && set -- $1 "${2%$3}"; [ $# -ge 2 ] && eval $1="${2##*/}"; }

V tom evalu musí být uvozovky eskejpnuty jinak to nezebere názvy s mezerou a ten první parametr musí být platné jméno proměné, takže taky žádné skopičiny.

basenameset() { [ -n "$3" ] && set -- $1 "${2%$3}"; [ $# -ge 2 ] && eval $1=\"${2##*/}\"; }

Trošku vylepšená superbrutus verze s ošetřením parametrů a bez zbytečného testu na třetí parametr.

basenameset() { set -- "$1" "${2%$3}"; case "$1" in [^a-zA-Z]*|*[^a-zA-Z0-9]*);; ?*) eval $1=\"${2##*/}\";; esac }

No hlavně že máme zbytečně moc systémových prostředků. Dvakrát fork+exec a jedna roura navíc dnes už nikoho nebolí. Jen toho nikdo nesmí chtít udělat milionkrát, že?

Máte pravdu. Zdá se, že to jde udělat s jedním fork+exec

schematicky:
pipe()
fork()
potomek: exec(cut)
write()
wait(potomek)

jenže vy to tam nikde nepřiřazujete do proměnné (což je požadavek v zadání) a na to se shell ještě jednou forkne na realizaci $() a tak jsou to dvakrát fork a jednou exec a jedno pipe.

Proč něco v shellu dělat efektivně? No třeba potřebuju rychle ad hoc udělat nad několika sty tisici souboru v několika set adresářích. To se pak hodí vědět, že na

find -type f -name '*.mp3' -exec rm {} \;

si počkám podstatně déle než na

find -type f -name '*.mp3' -print0 | xargs -0 rm

no a když je budu chtít přejmenovat několik tisíc souborů pomocí

for i in *.jpg; do mv "$i" "$(echo $i|sed 's/\.jpg$/\.jpeg/')"; done

je dobré vědět, že to není zrovna dobrý nápad a budu to mít mnohem dřív hotové, když napíšu

for i in *.jpg; do mv "$i" "${i%.jpg}.jpeg"; done

a vůbec nejdřív se dočkám výsledku s

find -maxdepth 1 -type f -name '*.jpg' -print0 | xargs -0 rename 's/\.jpg/.jpeg/'

(verze pro opravdu velké množství souborů v adresáři s hodně velkým množstvím souborů s jiným jménem než *.jpg, 10000 a více, jinak si vystačím bez findu)

Další expert co jen planě plácá a nevyzkouší si to? Tak si to zkuste! Vtip je v tom, že se to nerozvine, ale shell to udělá chytře. A příště, když nevím, tak to zkusím.

$ ls
$ for((i=0;$i<10000;i++)); do touch zbytecne_dlouhej_prefix_$i; done
$ echo *
zbytecne_dlouhej_prefix_0 zbytecne_dlouhej_prefix_1 zbytecne_dlouhej_prefix_2 ... zbytecne_dlouhej_prefix_9999
$ ls *
bash: /bin/ls: Příliš dlouhý seznam argumentů
$ for i in zbytecne_dlouhej_prefix_*; do rm $i; done
$ ls
$