Názory k článku
Ruby v příkladech (1) - Úvod

Je zajímavé, že článek o Ruby má nálepky "Perl" a "Python". Má to být snaha o přetažení uživatelů (selektivně sledujících pouze články o svých oblíbených jazycích) nenápadnou reklamou od konkurence? ;-)

No ano, Perl jistě může být "úspornější" než Ruby, ale zdá se mi méně elegantní. Když budu chtít načíst obsah textového souboru do proměnné, tak mi prostě víc líbí napsat v Ruby

f = File.new("soubor.txt")
s = f.read

nebo zkráceně

s = File.new("soubor.txt").read

než v Perlu

local $/
$s = <soubor.txt>

Ale proti gustu žádný dišputát. Je to jen můj osobní názor.

A bez jakýchkoli knihoven v perlu

open FILE, '<soubor.txt';
$s = join '', <FILE>;
close FILE;

Napsat si na tohle knihovnu si může každé jojo a pak bude machrovat jak to udělá na jeden řádek. Nehledě na poněkud podpásové nepřenositelné řešení

$s = qx{cat c.jpg};

Hmm, tak tohle mě nenapadlo

{local @ARGV=('soubor.txt'); local $/; $s=<>}

Což je super špína. Ten příklad pana Sýkory s $s = <soubor.txt> samozřejmě nefunguje.

To je pravda, mělo to být správně:

local $/;
open FILE, "pokus.txt";
$s = <FILE>;

Podpásové řešení nabízí Ruby též.

s=`cat c.jpg`
coz je kratší o středník proti ekvivalentu v Perlu.

Ve větším programu jde stejně o něco jiného: jde o to, jak jdou jednotlivé části kódu skládat do sebe. A v tom je Ruby dobrý.

Řešit "bez jakýchkoliv knihoven" nemá cenu, protože šlo o základní knihovny přítomné automaticky.

Hm, ale o kolik je obecnější lokální proměnná blokového uzávěru než nějaké kryptické $_, o kterém nechápu, k čemu asi tak je, že? ;-)

A co je za problém napsat

while(my $filename = <*.JPG>) {rename $filename,lc $filename}

Kdo se ale dokáže stratit na jednom jediném 33 znaků dlouhém řádku, tak tomu nepomůže ani Python.

Ty složené závorky jsou blokový uzávěr? Můžu to uložit do proměnné a "šoupat kolem"? (Nejsem Perlista, bohužel, tak se radši ptám... :-))

Ano, složené závorky ohraničují blok v konstrukci

LABEL while (EXPR) BLOCK
LABEL while (EXPR) BLOCK continue BLOCK

Nerozumím co se myslí pojmem "šoupat kolem". Samozřejmě to jde v daném bloku uložit do jakékoli proměné, případně s tím dělat i jiné skopičiny. Použité my způsobí, že proměnná $filename existuje pouze uvnitř EXPR, BLOCK a continue BLOCK.

Nemtudom magyarül. Asi to bude tím, že jsem nestudoval informatiku.

Měl jsem na mysli, jestli blok (lexikální uzávěr) je first-class objekt jazyka.

Mozno ti pomoze toto: http://www.rcrchive.net/rcr/show/298

Nevím jestli jsem to dobře pochopil a tak nevím jestli můžu odpovědět ano, ale myslím, že jo i když to není asi tak čisté jako v ruby a není to objektové (viz. syntaxe map i nové funkce map2)

use strict;
use warnings;

# long time wanted perl function :-)
sub map2 (&\@\@) {
  my ($sub,$f,$s) = @_;
  map { local (*a, *b) = (\$f->[$_], \$s->[$_]); &$sub } (0..$#$f);
}

# data
my @a1=(1,2,3);
my @a2=(4,5,6);

# output modification
$\="\n";
$"=',';

# use and output
print "map2 result: ", join $", map2 {$a + $b++} @a1, @a2;
print "a1: @a1";
print "a2: @a2";

Jsem liny to hledat tak se zeptam. Kdysi kdyz jsem se koukal na Ruby mi vadila (ne)podpora unicode. V tom je docela dobrej prave Python. Jak je na tom Ruby s unicode dnes ?

Zatím žádný pokrok v Unicode. Ne že by se v Ruby nedalo dělat v Unicode nic (řetězce se "nebrání" obsahu v UTF-8), občas lze použít nějaký trik, ale jinak v této oblasti nic moc. Skutečnou podporu Unicode by měla mít až verze 2.0.

Z 50% mam hotovy binding na ICU. Jeho uvolneni ocekavam tak za dva mesice.

uvod do Perlu. Jednu vec lze napsat na tisic zpusobu. Nevim, jestli se to da oznacit za vyhodu jazyka...mne osobne to dost plete. V kazdem pripade se tesim na serial:)

Ruby filozoficky z Perlu vychází. Jen syntaxe je, IMHO, podstatně "příjemnější". I když občas jsou částečně přebrány i dost děsné věci jako např. proměnná "$_". Naštěstí se to téměř nikdy nemusí použít :-).

perl nemam rad, ale ta premenna $_ mi pride dost sikovna, ked clovek vie naco je

V perlu je plno veci sikovnych, jenom clovek musi vedet na co jsou, protoze se skryvaji pod ruznymi kryptickymi sekvencemi znaku (ani se neda napsat pismen).

V nekterych programovacich jazycich i zacatecnik muze cist kod, ktery napsal guru.
V jinych k tomu potrebuje navic prirucku k perlu :)

Podla mna Ruby hlavne vychadza Zo Smalltalk-u. To, ze blok je objekt, sposob prace s blokom, samotne pouzitie bloku.

Já jsem se o Ruby přestal zajímat před let kvůli slabým knihovnám a nepodpoře unicode. A jak koukám, unicode stále není podporováno. Přešel jsem na Python a nelituji toho. Ten poslední příklad s přejmenováním souboru se v Pythonu udělá např. takto:

import sys, os
from   os.path import split, join

for fPath in sys.argv:
    fDir, fName = split(fPath)
    newPath = join(fDir, fName.lower())
    os.rename(fPath, newPath)

Ale není to nejlepší řešení, protože to nebude fungovat u znaků s diakritikou. Dnes se používá kódování utf-8 a v něm je znak s diakritikou zapsán jako více znaků, což ale metoda lower() netuší, ona se na každý znak dívá samostatně. Řekl bych, že to samé s týká i příkladu pro Ruby, ne? V Pythonu je ale náprava jednoduchá:

import sys, os
from   os.path import split, join

for fPath in sys.argv:
    fDir, fName = split(fPath)
    newPath = join(fDir, fName.decode('utf-8').lower())
    os.rename(fPath, newPath)

Zajímalo by mě řešení v Ruby i Perlu funkční i pro názvy s diakritikou.

No to jsou problémy.

use locale;
use utf8;
foreach (@ARGV) {
  (my $newname = $_) =~ s,(/[^/]*$),lc $1,eo;
  rename $_, $newname;
}

a pokud máš správně nastavený fs i locale tak je v perlu vymalováno.

Vloudilo se mi tam lomítko, takže ještě jednou.

use locale;
use utf8;
foreach (@ARGV) {
  (my $newname = $_) =~ s,([^/]*$),lc $1,eo;
  rename $_, $newname;
}

Někdy mám pocit, že Larryho Walla muselo velice mrzet, že klávesnice má jenom 101 kláves. Kolik hezkých konstrukcí by šlo vykouzlit se znakem libry, eura a jenu.

Pěkné, ale hádám, že to nebude fungovat ve windows, co? Přinejmenším kvůli cestám, nevím jak s tím utf-8. No, mě to vlastně taky nebude fungovat, protože ve windows se používá jiné kódování. Co kdybychom to tedy oba opravili, aby to bylo multiplatformní?

import sys, os
from   os.path import split, join

coding = sys.stdin.encoding

for fPath in sys.argv:
    fDir, fName = split(fPath)
    newPath = join(fDir, fName.decode(coding).lower())
    os.rename(fPath, newPath)

Doufám že milovníci Ruby neodpadli hned v počátku a také nám předvedou implementaci.

No tohle taky asi nebude ono, ne? Neznám tu parodii na OS, ale ne všude platí, že stdin má za všech okolností stejné kódování jako filesystem. Zatím jsem nenašel spolehlivou cestu jak zjistit kódování fylesystemu. Jinak problém s oddělovači řeší File::Basename nebo File::Spec.

use locale;
use utf8;
use File::Spec;
foreach (@ARGV) {
  my ($volume, $path, $name) = File::Spec->splitpath($_);
  $name =~ s,([^/]*$),lc $1,eo;
  rename $_, File::Spec->catpath($volume, $path, $name);
}

Opět při správně nastaveném systému by celá procedura měla proběhnout i bez opičinek s encode/decode.

Uh, spěchám a opět chyby. Takže kromě toho krásného fylesystemu je zbytečný ten překlad v regexpu.

use locale;
use utf8;
use File::Spec;
foreach (@ARGV) {
  my ($volume, $path, $name) = File::Spec->splitpath($_);
  $name = lc $name;
  rename $_, File::Spec->catpath($volume, $path, $name);
}

Jestliže ARGV položka bude získána jako unicode, lc převede string jako unicode, pokud ne, akceptuje se nastavení podle locale.

V Perlu už dosti dlouhou dobu dedělám a s Unicode jsem v něm nedělal nikdy, ale jak se pozná zda ARGV bylo získáno jako Unicode nebo ne? Funguje to ať je ARGV získáno v UTF-8 nebo třeba v UCS-16?

Že by locale?

Také se mi zdálo, že použít locale by bylo nejjednodušší. Ale když jste psal

Jestliže ARGV položka bude získána jako unicode, lc převede string jako unicode, pokud ne, akceptuje se nastavení podle locale.

tak jsem se domníval, že locale se použije jen pokud ARGV se nezíská jako unicode. To mi přišlo divné.

Jde o to, že stringy v perlu mohou být dvou typů: unicode a bytes. Vtip je v tom, že všechny běžné operace se stringy s tím počítají a tak se s unicode stringem provede to, co má, a nemusíš se o to starat. Je fakt, že v tomhle případě (práce s ARGV) to asi vyjde na stejno. Pokud je locale unicode tak je string ARGV v unicode a je to OK. Pokud je locale jiné než unicode, tak je ARGV v bytes, ale při use locale to zase proběhne všechno OK. Jediný problém by asi mohl nastat u toho rename pokud by na fs bylo použité jiné kódování než locale. Tak hluboko do toho nevidím a ještě jsem neměl důvod to ladit.

Jak už jsme psal v jiném vláknu (a ještě budu psát v jednom z dalších dílů), tak rozumná podpora Unicode je plánována až pro verzi 2.0. Ruby 1.8 se dá malým hackem tak maximálně donutit, aby počítal správně délky řetězců v UTF-8, ale pro změny malá <-> velká bych musel asi použít nějakou externí knihovnu. Pak je ale zbytečné uvádět kód, protože ten by byl zcela závislý na použité knihovně (a případně na tom, jak bych ji nalepil do Ruby). Viz např. článek: http://ruphus.com/blog/2005/06/11/ruby-and-unicode/ . Pro jednoduché případy (např. jen čeština a jen Linux a Windows) bych asi volil cestu "přepsání" metody downcase třídy String (a možná bych ani nevolil Unicode).

Nicméně já osobně se úzkostlivě vyhýbám jménům souborů s diakritikou nebo lokálními znaky, protože mne děsí složitost převodu malá <-> velká, která je navíc závislá na jazyku a lokálních pravidlech. Viz např. http://blogs.msdn.com/oldnewthing/archive/2003/09/05/54802.aspx .
A když se zamyslím na tím, že pokud pojmenuju soubor japonsky, tak mohu totéž jméno zapsat buď hiraganou nebo katakanou (dvě různé abecedy, kterými se dá napsat v podstatě totéž), tak se mi tento problém vůbec nechce řešit obecně.

Ten skript v článku slouží jen na převod jmen JPEG souborů z digitálu, abych neměl problémy odkazovat na ně z webových stránek. Řešit to pro úplně obecná jména souborů asi nemá smysl bez omezujících podmínek - kromě kódování bychom se asi navíc dostávali do závislosti na konkrétních systémech i případně na konkrétních filesystémech jednotlivých svazků (např. při převodu malá <-> velká se může změnit počet znaků a tak by teoreticky mohlo dojít k překročení maximální délky jména souboru).

Na macu lze spustit ruby tak, že do terminálu napíšete ruby a cestu k souboru.