Livescript

 ( log69 | 2018. február 18., vasárnap - 11:47 )

Coffeescript leszármazottja. Tervezem az átállást. Szép munka Jeremy!

http://livescript.net/#literals

https://en.wikipedia.org/wiki/LiveScript


Közben hozzáadtam Livescript támogatást a nyelvekhez, példa:

<script type="text/livescript">

    console.log  "hello world"

</script>


Megváltoztattam a script tag formátumot is, az alábbi helyett:

<script type='text/livescript'>

elég ennyi (ugyanígy coffee, typescript vagy babel kulcsszóval is):

<script live>

Hozzászólás megjelenítési lehetőségek

A választott hozzászólás megjelenítési mód a „Beállítás” gombbal rögzíthető.

Válaszként dobok megjegyzéseket előnyökre (és hátrányokra ha találok, azt külön kiemelem):

  1. nem számít a számoknál az aláhúzás és más karakter, pl: 60_000km - milyen régóta vágytam az aláhúzásra Ruby után, de CS-ben nem volt elérhető, szupi

  2. meghagyta Javascript többsoros komment formázását, vagyis ### helyett lehet használni /* formátumot

  3. nem kell kacsacsőr az objektumokhoz, sem pedig vessző a sorok végén - ezt is könnyű volt elvéteni

  4. tömbnél nem kell vessző: [1 2 3 4 5 "something else"]

  5. ranges-ben végre van a - z -ig: [\a to \z], ez mennyire hiányzott

  6. van csökkenő range: [10 to 1 by -1]

  7. van exclusive or :) a xor b

  8. végre össze lehet adni tömböket: [1 to 5] ++ [45 to 90]

  9. végre van Ruby-nál elérhető sokszorosítás: "ha" * 3 #=> "hahaha"

  10. van szövegből szöveg kivonása: "hello" - "he" #=> "llo"

  11. require-nél felkiáltójellel hívva meg ugyanazon nevű változóba teszi az objektumot: require! "fs" #=> itt létrejött egy fs nevű változónk, JS kód: var fs = require("fs");

  12. require-nél bonyolultabb path-ból is kihámozza a változót az objektumhoz: require! './dir/lib1.js' #=> var lib1 = require('./dir/lib1.js');

  13. lehet string-eket is indexelni tömbként: "hello"[1] = "e" vagy "hello"[0 to 2] = ["h", "e", "l"]

> nem kell kacsacsőr az objektumokhoz, sem pedig vessző a sorok végén - ezt is könnyű volt elvéteni

coffeescript-ben se kell:

kids =
  brother:
    name: "Max"
    age:  11
  sister:
    name: "Ida"
    age:  9

via http://coffeescript.org/#objects-and-arrays

> van csökkenő range: [10 to 1 by -1]

coffescriptben is majdnem ugyanez:

for i in [10..1]
  alert(i)

for i in [10..1] by -2
  alert(i)

> lehet string-eket is indexelni tömbként: "hello"[1] = "e" vagy "hello"[0 to 2] = ["h", "e", "l"]

indexelni sima js-ben is lehet a valami[0 to 512] meg erre fordul: [valami[0], valami[1], ... valami[512]] szoval akkor inkabb valami.split("")[0..2]

Kösz. Valóban, a [5..1] működik CS-ben is. A split tényleg jobb.

"tömbnél nem kell vessző: [1 2 3 4 5 "something else"]"

És az miért jó?

"végre van Ruby-nál elérhető sokszorosítás: "ha" * 3 #=> "hahaha""

"van szövegből szöveg kivonása: "hello" - "he" #=> "llo""

"nem számít a számoknál az aláhúzás és más karakter, pl: 60_000km - milyen régóta vágytam az aláhúzásra Ruby után, de CS-ben nem volt elérhető, szupi"

Ezekre tudsz mondani értelmes felhasználási területet?

Számomra rendkívül fontos, mivel még jobban hozzájárul a még rövidebb, még átláthatóbb és így még jobban karbantarthatóbb kódhoz.

Azért díjazom a fentit, mert "beszédes" programnyelvből (aminél sok szintaktikát kell belekódolni) van sok, lehet válogatni, kinek mi tetszik. Viszont az ellenkezőjéből nem igazán.

1) mivel nem kell vessző, nekem olvashatóbb, hasonlítsd össze te magad:

[ 1, 2, 3, 4, 5 ]

[ 1 2 3 4 5 ]

2) részemről sokszor használom ezt az ún. sokszorosító funkciót, most rákerestem neked frontfoo projektemben és 7 helyen is használom, például ha nulla karakterből ki akarok rakni sokat zero paddinghez, vagy HTML-nél írtam egy rutint ami "<br>" taget vagyis új sort tesz ki adott számban és a bemenetnél meghatározhatod a sorok számát:

br = (n) ->  return "<br>" * n

Vagy például tettem bele egy funkciót mellyel a kódot tudod formázni úgy, hogy a tab-okat lecseréli szóközre - viszont változó a szóköz hosszának értéke (2, 4 vagy 8), így nem 3 sorba írom ki a kódot if ágakkal, hogy ha ilyen a beállítás akkor ez a kód fusson le ilyen hosszú stringgel x db szóközt tartalmazva meg ugyanez 4-re 8-ra stb, hanem megszorzom a szóköz stringet:

" " * n

A másik helyen karakterrel kirajzolt "bar chart"-ot nyomtatok ki a | karakterrel, például:

||||| 5%
|||||||||||||||||| 18%
|||||||||||||| 14%

Na itt is megszorzom a karaktert. Kérdezheted hogy miért nem egy ciklust használok string összeadással. Azért mert így nagyságrenddel kisebb és átláthatóbb a kód. Gondold végig.

3) szövegből való kivonás nem más mint replace, vagyis "hello" - "he" erre a Javascript kódra fordul: "hello".replace("he", ""); / nézd meg mennyivel olvashatóbb, részemről ezt is sokszor használom, konkrétan az üres stringre való cserét - megnéztem a kódomban és 28 helyen alkalmazom

4) a szám formázás nagyon fontos, Ruby-nál rengeteget használom - ha sok nagyobb számjegyű érték szerepel a kódban, akkor nehéz kiolvasni azonnal és megállapítani az ezres tizedeshelyeket - ezzel sokkal olvashatóbb, nézzünk példát:

66732874
72364423

72_364_423

Az meg hogy további karaktereket írhatok hozzá, tovább növeli a kód értelmezhetőségét szerintem. Például: 300m / 1.8s^2 #=> 92.59259259259258

Ezek a dolgok hosszú távon nagyon számítanak szerintem. Például mennyi időbe és energiába kerül átnézned egy kódot több hónap után stb.

> " " * n

Ezekkel a magic dolgokkal az a baj, hogy inkonzisztens.

Pl. ez már nem működik:

hello = "a"

alert(hello * 5)

mert nem tudja, hogy a hello az egy string. Emiatt inkább maradnék a hello.repeat(5) -nél.

Ahol nem működik, ott lehet bármi mást csinálni, de ahol működik, ott részemről az olvashatóságot helyezem előtérbe általában.

Szóval olyan mint a törvény, hiába tudom elolvasni, nem biztos hogy úgy működik. :)

Mindenesetre nekem fontos hogy bármilyen JS fejlesztő el tudja olvasni, be tudjon kapcsolódni a fejlesztésbe, mint hogy a kód egy újabb kódhalmaztól függjön, amit kevesen ismernek.

+1 Ezért nem fogok soha Elmet használni, olyan projekten amin más is dolgozni fog...

Hmmm... Tavaly nyaron indult egy spa ujrairasa elm-ben, mert eleg volt a "sok" js buvesz amokfutasabol... :DDD (No offense, kivaloan szuri az analitikus gondolkodasra alkalmasakat...)

:)

Piszok mázlista :D

Nyilván mindig az a kérdés hogy kinek mi a hatékony :)

További dolgok amelyek tetszenek:

  1. for-t lehet így is definiálni:

    for x from 0 to 9  then print x
    

  2. ha for-nál nullától iterálunk, akkor elhagyható a kezdőérték definiálása:

    for x to  9   then print x
    for x til 10  then print x
    

  3. végtelen ciklus:

    loop
        print "yes"
    
    for ever
        print "yes"
    

  4. tömb splice:

    [1 2 3 4 5 6 7][til 3] = [11 12 13]    #=> [11 12 13 4 5 6 7]
    

  5. tömbnél a csillag jel a hosszát jelenti:

    a = [1 2 3 4 5]
    a[*] = 6            #=> [1 2 3 4 5 6]
    [1 2 3 4 5][*-1]    #=> [5]
    

Közben megtaláltam hogy az ajánlott kiegészítő lib hozzá a prelude-ls:

https://www.preludels.com

<script live>

    pl = require "prelude-ls"

    console.log  pl.fold1 (+), [to 100]    #=> 5050

</script>