Portál AbcLinuxu, 2. května 2025 11:55
** pro počítání mocnin, (2) while cyklus lze nahradit n.times do x *= zaklad end, (3) jaký smysl má metoda swap, když stačí napsat a, b = b, a?, (4) místo word = word.chomp lze psát word.chomp!
akorát nevidím žádnou podmínkuNa co podmínku?
Vím, že vykřičník se dává, protože se mění příjemce metodyPříjemce metody je pokaždé
word.
chomp bez vykřičníku nemění obsah proměnné word, chomp! mění obsah proměnné word.
Na co podmínku?Už jsem to pochopil, mazané.
chomp bez vykřičníku nemění obsah proměnné wordMyslel jsem to takhle:
btw. autorovi (tady toho zapisu na abc) bych doporucil at zapomene na ruby a nauci se perl...
A kdyz mluvi o Perlu, automaticke zplostovani seznamu v Perlu byl opravdu hloupy napad, tedy alespon me to odradilo, abych se Perl vubec ucil.
Jinak ten clanek jsem sem postnul hlavne proto, ze se v nem zminuje Ruby a je vtipne napsany, neprijde mi prilis neobjektivni (rekl bych, ze je to pohled, ke kteremu dojde vetsina lidi, co zna vsechny ty jazyky), a autor zminoval, ze jich moc nezna.
No to bych zrovna netvrdil.Proc ? Kvuli Unicode ? Ano, ruby 1.8 + unicode je tragedie. Nicmene regexpy v ruby sou vykradnute z Perlu, a na rozdil od C, pythonu a dalsich X jazyku, je radost s nimi pracovat.
Dříve to byla třeba co se týče Unicode v Ruby tragédie, ale to snad už doufám napravili?Jo, v 1.9.x
A pak také Ruby si podle mě z Perlu občas vzalo až moc syntaktického bordelu (a nejsem jediný kdo si to myslí - jestli se nepletu, tak i Matz, autor Ruby, se tak jednou vyjádřil).Nemylite se. AFAIK v novych verzich (1.9.x) jsou ty divne dolarove promenne deprecated (maji citelnejsi ekvivalenty).
This is because the regular acquire() method on a basic lock cannot be interrupted. That's unlikely to go away, so you'll just have to live with this.A WTF veci jsou napriklad proc len() neni metoda, sort()/sorted() prasarna atd.
Jestli to chapu spravne, tak 1167930 neni race condition, ale nejaky kompromis, ktery vyplyva ze situace (konkretne tady z navrhu acquire() v knihovneNejedna se o kompromis ale o chybu, ktera se pak projevi na mnoha dalsich mistech. Jako priklad uvedu pouziti asynchroniho IO, ktere pouziva signal SIGPOLL (na linuxu synonymum k SIGIO) k oznameni udalosti na deskriptoru. To je misto, kde jsem se s tim setkal ja. Perl je na tom v tomdle smeru mnohem lip, obcas narazite na memleak ale ne na problem, ktery by Vas zasadne omezil v praci a o kterem vyvojari reknou, ze ho neopravi.
. Navíc to co dělá externí knihovna pomalé není (takže pokud uděláš v ruby přehrávač hudby tak, že stisknutím na tlačítko Play se zavolá funkce z jiné knihovny, které se předá název souboru a ona ho začne přehrávat, vše bude ok, ale jakmile se rozhodneš napsat si v ruby parsování mp3 přímo, už to ideální nebude). U mě taky kreslení nebylo pomalé, staralo se o to SDL. Jenže já musel za tu sekundu při fps třeba 25, 25x projet objekty v cyklu, zkontrolovat kolize a vypočítat nové pozice. To už za mě knihovna neudělá a proto to moc nešlo.
Naopak tyhlety skriptovací jazyky mají velkou sílu v datových strukturách. Nic nemusíš vymýšlet, umí to objekty, ruby hash tabulky, knihovna pro parsování xml, yamlu, atd.. je na každém kroku, takže třeba skript co ti stáhne přes http rss kanál (to je xml), najde si v něm pár tagů, podle data seřadí a zobrazí 10 nejnovějších třeba v tom Qt je za pár minut hotový. V C by ses s tim lopotil mnohem déle.. A jelikož tu nemáš žádný cyklus co to musí udělat 20x do sekundy, nijak to cpu vytěžovat nebude.
A jako poslední věc ještě doplním regulární výrazy. Další ohromná síla těhle věcí. Ruby je má integrované pěkně.
.
Nevíte, jak si rozumí třeba s GTK nebo Qt?Já bych v této diskusi doporučil na tomto místě mírný boční pohled na perl/TK. Samozřejmě nevím, co s tím plánuješ dělat, ale já osobně se při programování v perl/TK pořád usmívám, protože mi svět připadá takový strašně jednoduchý. Úplně jsem si připomněl, jaký jsem měl před patnácti lety pocit ovládnutí internetu, když jsem stvořil první cgi skript v shellu a podíval se na výsledky z Netscape.
. Jeden řádek a máš okýnko s tlačítkem... Navíc ruby se v lesčem perlem inspirovalo.
Jo, četl jsem, že Ruby je docela pomalé, ale že až tak katastrofálně, to jsem nečekal. Nevíte, jak si rozumí třeba s GTK nebo Qt?No, um, katastrofalne :) Pokud se nepletu, ruby 1.8 je "AST-walking" interpreter (asi jako perl 5.x), kdezto 1.9.x je bytecode-compiled interpreter (jako python 2.x / 3.x). 1.9.x je 2-10x rychlejsi nez 1.8.x; JRuby je zhruba stejne rychle jako ruby 1.9.x, nicmene pouziva o dost vic pameti. Je jasne ze jazyky jako python a ruby nejsou na psani quake enginu ;) nicmene casto pohodlnost a rychlost vyvoje je dulezitejsi. GTK bindingy mi prijdou ze jsou v lepsim stavu nez QT, ale uz dlouho sem se nedival.
30.8.2011 20:47
replicate vytvoříme seznam obsahující n-krát základ a pomocí funkce product základy vynásobíme:
mocnina0 zaklad n = product (replicate n zaklad)Pomocí operátoru dolar odstraníme závorky, kód je pak přehlednější:
mocnina1 zaklad n = product $ replicate n zakladFunkce
flip prohodí parametry funkce replicate – to je zatím k ničemu, ale později to využijeme:
mocnina2 zaklad n = product $ flip replicate zaklad nOperátor tečka skládá funkce – jako v matematice:
mocnina3 zaklad n = (product . flip replicate zaklad) nParametr
n pokrátíme:
mocnina4 zaklad = product . flip replicate zakladOperátor tečka může skládat jakékoliv funkce – třeba i tečky. Rovnou také pokrátíme parametr
zaklad:
mocnina5 = ((.).(.)) product (flip replicate)Operátory lze aplikovat jen částečně, například
(/2) je funkce, jenž vrátí půlku daného čísla. Naopak (2/) je funkce, jenž vydělí dvojku daným číslem. Tohle lze to provést i se skládáním funkcí:
mocnina6 = (product .) . flip replicateA na závěr je tu zápis pro znalce:
mocnina7 = (^)
.
Učím se Céčko, myslím, že je to takový základ programování, a hlavně je rychlé, možná i nejrychlejší?Tohle je dáno současným stavem kompilátorů a runtimů vyšších programovacích jazyků a faktem, že specializovaný kód pro danou úlohu může být rychlejší než kód obecný (například správa paměti). Jenže vyšší programovací jazyky se v tomto postupně zlepšují a je jen otázkou času, než programy ve vyšších programovacích jazycích dosáhnou srovnatelných rychlostí s Céčkovskými programy, jenž byly napsány průměrnými programátory. IMO pokud nepotřebujete z HW vyždímat úplné maximum, tak Vám bude stačit jazyk typu C# nebo OCaml, program bude cca 2-3 krát pomalejší než v Céčku a kód bude kratší.
a je jen otázkou času, než programy ve vyšších programovacích jazycích dosáhnou srovnatelných rychlostí s Céčkovskými programy, jenž byly napsány průměrnými programátory.tak nevim jestli je to vtip, nebo pesimisticky pohled na vyvoj "prumernyho programatora"...
Programy v jazycich jako C nebo Java dosahuji vyssi rychlosti nez programy v assembleru, uz nejakou dobu. S "prumerem" to moc nesouvisi. Kompilatory lidi utahnou ne na kreativite reseni, ale na hrube pocetni sile; proste ne kazdy programator chce resit barveni grafu pri alokaci registru, napriklad.
A neni duvod si myslet, ze stejne jako jsme pomoci high-level (dnes low-level) jazyku abstrahovali alokaci registru a poradi instrukci, v budoucnu patrne budeme schopni abstrahovat dalsi veci, jako napriklad volbu datovych struktur, poradi vypoctu (tam kde na nem nezalezi), specializaci, a vysledek soupereni stroje vs. lide dopadne podobne.
I kdyz (a to je duvod proc pisu tento prispevek, jinak by nemelo cenu reagovat), osobne si myslim, ze staticka analyza na tyhle veci nestaci, a proto je pristup Haskellu navzdy odsouzen do akademicke sfery. Ono v podstate i dnes je znacna cast toho duvodu, proc je kompilator lepsi nez clovek, dana dynamickou analyzou, a to jak v procesoru, tak pri JIT kompilaci. Ja osobne vidim budoucnost v nejake vazbe kompilatoru na profiler, spis nez ve staticke analyze.
Uznávám, chybí tam ještě varianta s nekonečným seznamem.
Takže výrazem iterate (*zaklad) 1 vytvoříme seznam všech mocnin (tj. [z^0, z^1, ..]) a pomocí operátoru indexace seznamu !! vybereme potřebnou mocninu:
mocnina6' zaklad n = iterate (*zaklad) 1 !! n
n můžeme pokrátit, to už umíme:
mocnina6'' zaklad = (iterate (*zaklad) 1 !!)A pro jistotu ještě ve variantě pointfree tj. bez parametrů:
mocnina6''' = (!!) . (flip iterate 1 . (*))
mocnina x n
| n == 0 = 1
| otherwise = square (mocnina x $ n `div` 2) * if odd n then x else 1
where square a = a * amc z 0 = 1 mc z n = z * (mc z (n - 1))Nebo, touzime-li po tail-recursive variante (coz u normal-order jazyku jako Haskell nehraje moc roli), tak:
mc z n = mc2 z n 1 mc2 z 0 ac = ac mc2 z n ac = mc2 z (n - 1) (z * ac)
n.
Tohle je tail rekurzivní:
mc z n = mc2 z n 1 mc2 z 0 ac = ac mc2 z n ac = let newAc = z * ac in newAc `seq` mc2 z (n - 1) newAcnebo tohle:
import Data.List product' = foldl' (*) 1 mocnina0 zaklad n = product' $ replicate n zaklad
To druhé také není tail rekurzivníMyslim, ze je (alespon podle mne znamych definic tail-rekurzivnosti). Ze to kvuli lazy evaluation nema ty same dusledky jako u jazyku se striktnim vyhodnocovanim a ze spotreba pameti bude kvuli ukladani odlozenych vypoctu stejne umerna n, je jina vec.
sub mc{eval"$_[0]*"x$_[1].1}
promenna = nejakaMetoda a někde dál by se pak normálně zavolala promenna(argumenty, ...). Použití takové konstrukce není žádný akademický výmysl, používá se docela běžně.
m = [5,4,3].method(:sort)
m.call
nebo
c = proc {"Ahoj svete"}
print c.call
// vybiram metodu ktera bude neco zpracovavat nejakou logikou.
public interface Zpracovavadlo {
public void zpracuj(NejakaVec nejakaVec);
}
public class XMLZpracovavadlo implements Zpracovavadlo {
public void zpracuj(NejakaVec nejakaVec) {
...
}
}
public class YAMLZpracovavadlo implements Zpracovavadlo {
public void zpracuj(NejakaVec nejakaVec) {
...
}
}
// nekde v kodu
Zpracovavadlo zp;
if(blabla)
zp = new XMLZpracovavadlo();
else
zp = new YAMLZpracovavadlo();
return zp.zpracuj(nejakaVec);
Jak rikam, je to nepohodlny ale jde to. Na druhou stranu, ono to moc nesedi k Javovemu paradigmatu (kde by clovek mel cpat struktury reprezentujici data a metody ktere s nimi neco delaji na jednu hromadu do jedne tridy) takze to asi moc nevadi.
MethodHandle a spol. Pokud k tomu chcete hezčí syntaxi, počkejte si na Javu 8
irb(main):015:0> a = [5,4,3] => [5, 4, 3] irb(main):016:0> b = [5,4,3] => [5, 4, 3] irb(main):017:0> m1 = a.method(:sort) => #Method: Array#sort irb(main):018:0> m2 = a.method(:sort) => #Method: Array#sort irb(main):019:0> m3 = b.method(:sort) => #Method: Array#sort irb(main):020:0> m1 == m2 => true irb(main):021:0> m2 == m3 => false
[1,2,3].sort {|a,b| a <=> b}
A v kódu te metody by bylo něco typu
def sort #... bigger = yield a,b; #... endA tohle se dá použít skoro na cokoliv. Myslím, že mnohem elegantější způsob než předávání ukazatele na funkci / metodu.
31.8.2011 18:06
Bystroushaak | skóre: 36
| blog: Bystroushaakův blog
| Praha
31.8.2011 23:50
class Trieda
def metoda2
puts metoda1
end
end
objekt = Trieda.new
def objekt.metoda1
"abc"
end
objekt.metoda2
1.9.2011 01:46
Bystroushaak | skóre: 36
| blog: Bystroushaakův blog
| Praha
>>> class Trida: ... def metoda2(self): ... print self.metoda2 ... >>> objekt = Trida() >>> objekt.metoda2() # doufam ze ten ruby kod taky vypisuje adresu instance <bound method Trida.metoda2 of <__main__.Trida instance at 0xb74389ac>> >>> objekt.metoda1() # metoda1 tam neni Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: Trida instance has no attribute 'metoda1' # ted prijde to co neni tak elegantni, nvm jak priradit novou metodu primo >>> def metoda1(self): # vytvorim metodu ocekavajici automaticky predavany parametr self (neco jako this vsude jinde) ... print "abc" ... >>> objekt.metoda1 = metoda1 # priradim ji existujicimu objektu >>> objekt.metoda1() # neni to metoda, ale prirazena funkce, takze to failne na predani self Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: metoda1() takes exactly 1 argument (0 given) >>> objekt.metoda1(None) # pokud ji zavolam s prazdnym parametrem, tak funguje abc # bonus >>> objekt2 = Trida() >>> objekt2.metoda1() Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: Trida instance has no attribute 'metoda1' >>> Trida.metoda1 = metoda1 # tride priradim novou metodu >>> objekt2.metoda1() # vsechny v tu chvili existujici instance ji automaticky preberou abc
1.9.2011 01:58
Bystroushaak | skóre: 36
| blog: Bystroushaakův blog
| Praha
>>> class Trida: ... def metoda2(self): ... print self.metoda1() ... >>> objekt = Trida() >>> def metoda1(self): ... return "abc" ... >>> Trida.metoda1 = metoda1 >>> objekt.metoda2() abc
class Trida:
premenna = "premenna triedy"
def metoda2(self):
print self.metoda1()
premenna = "globalna premenna"
objekt = Trida()
def metoda1(self):
return premenna
Trida.metoda1 = metoda1
objekt.metoda2()
import new
objekt.metoda1 = new.instancemethod(lambda self :
premenna,
objekt)
akurát self stále neukazuje na objekt ale na globálny objekt, takže nemôžem pristupovať k členom objektu cez self.
import types
objekt.metoda1 = types.MethodType(lambda self :
self.premenna, objekt)
tento spôsob funguje aj so selfom
1.9.2011 17:01
Bystroushaak | skóre: 36
| blog: Bystroushaakův blog
| Praha
Každopádně když to porovnám, ruby má jen ošklivější a ukecanější syntaxi, jinak je skoro ekvivalentní.Osklivejsi ? Jakoze tam chybi dvacet podtrzitek a tri selfy na radek ? To ano, chybi. Nicmene zustanu u te "osklivejsi" syntaxe :)
1.9.2011 17:03
Bystroushaak | skóre: 36
| blog: Bystroushaakův blog
| Praha
Tiskni
Sdílej:
ISSN 1214-1267, (c) 1999-2007 Stickfish s.r.o.