Alapok ebben a kurzusban:

A(z) Alapok fogalomról

A Julia egy dinamikus, erősen típusos programozási nyelv. A programozási stílusa főként funkcionális, bár rugalmasabb, mint például a Haskellé.

Erős és sokoldalú típusrendszerrel rendelkezik, amely a későbbi fogalmaknál válik fontossá. A gyakorlatban a Julia általában kikövetkeztet egy megfelelő alapértéket a kontextusból.

Annak ellenére, hogy a hangsúlyt az olvashatóságra helyezi, amitől úgy tűnik, akár egy szkriptnyelv, például a Python vagy a Ruby, a Julia-kód a futtatás előtt lefordításra kerül. A Just In Time (JIT) fordító erősen optimalizált kódot állít elő minden egyes függvényhez, amellyel találkozik, ami nagy futási sebességet eredményez.

A Julia nem objektumorientált nyelv, és nincs olyan osztályhierarchia, amely sok más nyelvben központi szerepet játszik.

Ehelyett (és kérlek, ne ess pánikba, miközben ezt olvasod!) a Julia a következőkre támaszkodik:

• Egy típushierarchiára.
• Összeállítható függvényekre (amelyeket úgy terveztek, hogy könnyen lehessen kombinálni őket, sokoldalú és hatékony módon).
• Többszörös diszpécselésre, ami azt jelenti, hogy a függvények változó számú és típusú argumentummal hívhatók meg.

Ezek a meglehetősen zavarba ejtő kifejezések világosabbá válnak, ahogy haladunk előre a tantervben.

A hivatalos dokumentáció rengeteg értékes információt tartalmaz a jelenlegi kiadásról, bár a kezdők számára kissé nyomasztó lehet.

• Kézikönyv
• Oktatóanyagok
• Ismerkedj meg a Juliával
• Megjegyzések Python-programozóknak
• Megjegyzések R-programozóknak
• Megjegyzések C/C++ programozóknak
• Megjegyzések Matlab-programozóknak (ez egy jogvédett nyelv, amely nagyon népszerű a mérnökök körében, és a Julia egyik ihletője volt)

A videók között megtalálod:

• Rövid bevezetés a Juliába az Exercism vezetőségétől!
• Szélíd bevezetés a Juliába
• Tanuld meg velünk a Juliát : egy négtrészes sorozat

Megjegyzések

Rendkívül fontos, hogy megjegyzéseket írj a kódodba, mert ez segít az embereknek elolvasni a kódodat és megérteni a szándékaidat: talán másoknak, de a jövőbeli önmagadnak is. A fordító (nagyrészt) figyelmen kívül hagyja őket.

A Juliában kétféle lehetőség van:

• Az egysoros megjegyzések # jellel kezdődnek
• A többsoros megjegyzések #= jellel kezdődnek és =# jellel végződnek. Az egymásba ágyazás megengedett.

# This is a single-line comment

x = 3  # This is an inline comment

#=
	Multi-line comments can be used for longer explanations.

	They are especially useful to comment out blocks of code during debugging.
=#

Változók és értékadás

Egy változó létrehozásához egyszerűen rendelj hozzá egy értéket:

julia> myvar = 42  # an integer (in fact, Int64)
42

julia> bigint = 1_234_567_890  # optionally use underscore as digit separator, for readability
1234567890

julia> name = "Maria"  # strings are surrounded by double-quotes ""
"Maria"

Az értékadás hozzáköt egy értéket a változóhoz.

A típus megadása nem kötelező, és a Julia többnyire kikövetkeztet egy megfelelő alapértéket a kontextusból.

A típusok fontos témát jelentenek a Juliában. A későbbi fogalmakban részletesebben is megvizsgáljuk őket. Egyelőre a legjobb, ha nem aggódsz miattuk.

Sok funkcionális nyelvvel ellentétben a Julia változói újraértékesíthetők, és szabadon megváltoztathatod mind a változóhoz kötött értéket, mind a típust:

julia> myvar = 3
3

julia> myvar = "now a string"
"now a string"

Konstansok

A függvényen kívül létrehozott globális változók:

• Megengedettek.
• Néha szükségesek.
• Általában nem ajánlottak (bár csak *.jl fájlokon belül; a REPL másképp működik).

Ha egy értéknek az egész programban elérhetőnek kell lennie, de nem várod, hogy megváltozzon, használj helyette konstanst.

Ha az értékadás elé a const kulcsszót írod, a fordító hatékonyabb kódot tud generálni.

Ha véletlenül megpróbálod megváltoztatni a const értékét, figyelmeztetést kapsz:

julia> const answer = 42
42

julia> answer = 24
WARNING: redefinition of constant Main.answer. This may fail, cause incorrect answers, or produce other errors.
24

Aritmetikai operátorok

Az aritmetika nagyrészt a megszokott módon működik:

2 + 3  # 5 (addition)
2 - 3  # -1 (subtraction)
2 * 3  # 6 (multiplication)
8 / 2  # 4.0 (division)
8 % 3  # 2 (remainder)
2 ^ 3  # 8 (exponentiation)

Vedd figyelembe, hogy a / jellel végzett osztás mindig lebegőpontos értéket ad eredményül.

A későbbi fogalmakban visszatérünk erre: szó lesz az egészosztásról a csonkoláshoz használt div() vagy ÷ operátorral, és a racionális számot adó // operátorral.

Függvények

A legjobb futásidejű teljesítmény érdekében a legjobb, ha a kód nagy részét függvények belsejébe teszed. Sok kis függvény sem gond, ellentétben néhány más nyelvvel.

A Juliában két gyakori módja van egy nevesített függvény definiálásának:

1. A function kulcsszó használatával

   function muladd(x, y, z)
       x * y + z
   end
   

   Az olvashatóság érdekében a 4 szóközös behúzás a szokásos, de a fordító figyelmen kívül hagyja. Az end kulcsszó elengedhetetlen: inkább a Rubyhoz, mint a Pythonhoz hasonlít.

   Vedd figyelembe, hogy írhattunk volna return x * y + z alakot is. A Julia függvényei azonban mindig az utoljára kiértékelt kifejezést adják vissza, így a return kulcsszó elhagyható. Sok programozó mégis inkább kiírja, hogy egyértelműbbé tegye a szándékát.

2. Az „értékadásos forma” használatával

   muladd(x, y, z) = x * y + z
   

   Ezt leggyakrabban egysoros függvénydefiníciókhoz vagy matematikai függvényekhez használják, ahol a függvény törzse egyetlen kifejezés. Az értékadásos formában soha nem használunk return kulcsszót.

A két forma egyenértékű, és pontosan ugyanúgy használjuk őket, ezért válaszd azt, amelyik olvashatóbb.

Egy függvény meghívásához meg kell adni a nevét, és minden paraméteréhez át kell adni egy argumentumot:

# invoking a function
muladd(10, 5, 1)

# and of course you can invoke a function within the body of another function:
square_plus_one(x) = muladd(x, x, 1)

Abból, hogy ezeket „nevesített” függvényeknek nevezzük, sejtheted, hogy léteznek „névtelen” függvények is. Ezekre egy későbbi fogalomban térünk ki.

Elnevezési konvenciók

Sok nyelvhez hasonlóan a Julia megköveteli, hogy a nevek (változók, függvények és sok más dolog nevei) betűvel kezdődjenek, amelyet betűk, számjegyek és aláhúzásjelek tetszőleges kombinációja követhet.

Megállapodás szerint a változók, konstansok és függvények nevei kisbetűsek, és az aláhúzásjelet csak akkor használjuk, ha az a félreértés elkerüléséhez szükséges.

A Julia azonban végig Unicode-ot használ, így a „betű” fogalmát meglehetősen rugalmasan értelmezi.

Az angolon kívül más nyelveket is támogat, és az emojikat is (de kérlek, legyen ízlésed, és válassz valami odaillőt).

Különösen a matematikusok által kedvelt összes görög betű elérhető (és több hasznos érték előre definiálva is van):

julia> π   # a built-in constant
π = 3.1415926535897...

A Juliát ismerő szerkesztők, köztük a REPL, a Pluto.jl és a Julia pluginnal ellátott VS Code, megkönnyítik ezeknek a karaktereknek a bevitelét.

A π beírásához gépeld be, hogy \pi, majd nyomd meg a <Tab> billentyűt. A beírt szöveg helyére a görög karakter kerül.

Sok további példát láthatsz majd erre a későbbi fogalmakban.

Valójában a fordított perjellel írt rövidítések nem a Juliára jellemzőek. A LaTeX-ből származnak, egy szedőrendszerből, amelyet sok tudós és mérnök szinte naponta használ jelentések írásához.