JavaScript: Hogyan kezdjük el az interaktív webhelyek fejlesztését

Közzététel: Támogatása segít fenntartani a webhely működését! Az ezen az oldalon javasolt szolgáltatások némelyikén referenciadíjat keresünk.


A JavaScript a világ egyik legnépszerűbb programozási nyelve. A HTML és a CSS mellett a JavaScript is a három alapvető technológia egyike, amelyre gyakorlatilag minden webhely támaszkodik.

Míg a HTML az a nyelv, amellyel a webhely minden egyes tartalmához értéket rendelhet, míg a CSS a HTML elemek stílusának és elrendezésének formázásához használt nyelv, a JavaScript hozzáadja a weboldal viselkedését.

Bevezetés a JavaScript-be

Mi a JavaScript??

Először tisztítsuk meg a névvel kapcsolatos bármilyen zavart: a JavaScriptnek semmi köze nincs a Java-hoz. Most, hogy tudjuk, mi nem a JavaScript, beszélhetünk arról, hogy mi a JavaScript.

Ha a webhelyével csupán néhány alapszöveget és képet jelenít meg, akkor elegendő a HTML és a CSS a munka elvégzéséhez.

Ha azonban többet szeretne elérni – például a stílusok dinamikus megváltoztatását, a menük animálását, a funkcionális gombok létrehozását, az űrlapba bevitt adatok érvényesítését és még sok más -, akkor szüksége lesz egy másik eszközre.

A JavaScript a leggyakrabban használt eszköz a weboldalak viselkedésével kapcsolatos általános feladatok kezeléséhez.

Az első lépések a JavaScript használatával

Ha készen áll arra, hogy piszkosítsa kezét, és elmulasztja a JavaScripti tanulás feladatát, kétféle forrásból áll ki ellenőrizni.

Ha inkább a cselekedeteket tanulja, fontolja meg egy vagy két interaktív tanfolyamon való továbbhaladást, ahol megtanulja a JavaScriptet, amikor arra kéri, hogy hozzon létre egyszerű szkripteket egy böngésző alapú interaktív tanfolyamon..

Ha készen állsz arra, hogy mélyebben belemerüljön, és valódi JavaScript-fejlesztővé váljon, az online könyvek és oktatóanyagok segítenek odajutni.

Ha teljes kezdő vagy, akkor a legjobban megteszi a kezdetét néhány ingyenes interaktív tanfolyammal. Miután megismerte a JavaScript működését, lépjen bele néhány finomabb könyvbe és oktatóanyagba, amelyek segítenek a kezdő státusztól az illetékes programozóig való szintbe lépésben..

Ingyenes interaktív tanfolyamok

Codecademy az ingyenes programozási oktatás elsőszámú szolgáltatója. Kínálnak egy JavaScript sávot, amely a leghatékonyabb módja a JavaScript elsajátításának.

Code School prémium (fizetett) oktatási szolgáltató.

A gyors bevezető JavaScript kurzusuk azonban ingyenes, és 10 perces áttekintést nyújt a JavaScriptről, amely oktatásait a megfelelő irányba vezetheti. Ha abszolút kezdő vagy, akkor sok percet lefedhet néhány perc alatt ebben a kurzusban.

Az jQuery Alapítvány, a Code School-szal együttműködve bevezette az interaktív jQuery tanfolyamot.

Ne feledje, hogy a legtöbb ember, köztük köztünk is, javasolja a JavaScripti megismerését, mielőtt belemerülne a jQuerybe. Tehát miután befejezte a JavaScript számot a Codecademy-n, próbálja ki ezt a kurzust, és megértheti, mit lehet tenni a jQuery segítségével.

Online könyvek és oktatóanyagok

JavaScript macskáknak egy ingyenes bemutató, amelyet online olvashat, és amelynek célja az, hogy előkészítse és futtassa kezdő JavaScript-programozóként.

Macskák számára írt, de emberi társaik számára is alkalmas oktatóanyagból nem válik teljes értékű fejlesztővé, ám lefedi az alapokat, és segít egy szilárd alap kidolgozásában, amelyre épít.

Régebbi JavaScript írta: Marijn Haverbeke ingyenesen olvasható online, vagy kaphat egy régimódi papírkötésű példányt.

Olyan webes nehézsúlyú eszközökkel, mint a Mozilla és a Hack Reactor, fejlesztették ki az Eloquent JavaScriptet a tapasztalt programozók tiszteletben tartják.

Az Mozilla fejlesztői hálózat (MDN) átfogó útmutatókat kínál az alapvető webes technológiákhoz, beleértve a JavaScriptet.

Az MDN által biztosított tartalom rendkívül részletes, és megfelelőnek tekinthető ahhoz, hogy fegyelmezett hallgatóvá váljon a kezdő státusztól a kompetens front-end fejlesztőig..

Az Nem ismered JS-t A Kyle Simpson könyvsorozat egy mély merülés sorozat, amelynek célja, hogy elősegítse az egyes témák elsajátítását.

Ez nem egy „felkelés és futás” sorozat. Mielőtt elkezdené, már viszonylag kompetensnek kell lennie. Ha készen állsz arra, hogy meghaladja az alapvető JavaScripti használatot, és valóban hozzáértő JavaScript-programozóvá váljon, ezzel a könyvsorozattal közvetlenül a mélybe fog merülni.

JavaScript könyvtárak és keretek

JavaScript könyvtárak és keretek

Amikor elõször elkezdi tanulni a JavaScriptet, akkor meg akarja tanulni és natív formájában használja. Gyorsan rájön azonban, hogy a JavaScripttel rutinszerűen elvégzett sok dolgot nagyon sok kódolás igényel.

Itt jönnek be a JavaScript könyvtárak és keretek: csökkentik a közös feladatok elvégzéséhez szükséges kódmennyiséget.

Noha természetesen használhatja a JavaScript-et natív formátumban, és a továbblépés előtt alapos ismeretet kell kifejlesztenie a tiszta JavaScript-ről, sokkal többet szerezhet a JavaScriptről sokkal kevesebb billentyűleütéssel, ha megtanulja használni a sok könyvtár és keretek.

A W3Techs szerint a jQuery, a Bootstrap és a Modernizr a legnépszerűbb JavaScript könyvtárak és keretek..

jQuery a nagy népszerűséggel a legnépszerűbb JavaScript könyvtár, amelynek célja, hogy segítsen kevesebb kódírásban.

Ez egyben az egyik legegyszerűbb JavaScript könyvtár, amellyel kezdődik, mivel többnyire ugyanazt a szintaxist használja, mint a tiszta JavaScript. Alapvetõen, ha egy feladatot végre tud hajtani a JavaScript segítségével, ugyanazt a feladatot sokkal kevesebb kóddal is elvégezheti a jQuery elsajátításával..

bootstrap sokkal több, mint egy JavaScript könyvtár. Ez egy teljes keret vagy eszközkészlet az érzékeny webhelyek fejlesztésére.

A Bootstrap weboldal felépítése szilárd HTML, CSS és JavaScript kódot eredményez. A Bootstrap mindent megad, amire szükség lehet bármilyen típusú weboldal felületének fejlesztéséhez.

Modernizr egy kis darab JavaScript-kód, amelyet arra használnak, hogy felismerjék a webhely látogatói böngészőjében rendelkezésre álló funkciókat, és hogy a megjelenített tartalom és stílus az észlelt szolgáltatások alapján testreszabhatók legyenek.

A jQuery-től és a Bootstrap-tól eltérően, amelyek szinte bármi megvalósításához felhasználhatók, a Modernizr egy niche szkript, amelyet nagyon specifikus célra használnak: a webhely látogatói élmény testreszabására a látogató böngészője által támogatott szolgáltatások alapján..

Néhány további JavaScript-keretrendszer, amelyet a legfejlettebb webes alkalmazások fejlesztésére használnak ma, az Angular.js, Backbone.js, Ember és React.

Ha át akarja venni a JavaScriptet az egyszerű front-end manipulációtól a teljes körű egyedi alkalmazások fejlesztéséig, egy kevés idő ezeknek a kereteknek a kutatására tölti be a projekt legjobb keretének meghatározását, és megnyitja a szemét az általuk kínált hatalom előtt..

Modernizr

A Modernizr egy JavaScript könyvtár, amely felismeri, hogy a böngésző HTML5 és CSS3 kompatibilis-e. Ez lehetővé teszi, hogy csak azokat a dolgokat tegye, amelyeket a böngésző tehet. Ez nem ad hozzá funkcionalitást a kódhoz, de gondoskodik arról, hogy a böngésző csak olyan parancsokat küldjön, amelyeket a böngésző képes végrehajtani.

Számos oktatóanyag és könyv található, ha ez valami, amit Ön szerint használ.

Modernizr oktatóanyagok

Nincs sok könyv a Modernizr-ről, mert inkább szakirányú. És azokat, amelyek körül vannak, még nem vizsgálták meg jól. Inkább ragaszkodjon az online oktatóprogramokhoz:

  • Modernizr: ez a Modernizr hivatalos oldala, és annyi részletet tartalmaz, amennyire bármikor szüksége lehet.

  • Az első lépések a Modernizr-rel: ez egy rövid bevezetés, de készen áll a beállításra. És ha az Ön igényei nem túl nagyok, akkor ez lehet minden, amire szüksége van.

  • Kezdő / tervezői útmutató a Modernizr használatához a böngészőn keresztüli kihívások megoldásában: egy szép, alapvető oktatóanyag, amelynek kevés idő alatt fel kell készülnie és futnia kell.

jQuery

Már említettük a jQuery-t. Miután elsajátította a JavaScriptet, valószínűleg megvizsgálja a jQuery-t, ami valóban megkönnyíti a JavaScript programozását.

Van egy teljes cikkünk a Learn and Master jQuery-ről, amely nem csak a jQuerry használatának megkezdésével foglalkozik, hanem tartalmaz egy útmutatót a jQuery használatáról a tervezők számára.

Backbone.js

A Backbone.js egy JavaScript könyvtár, amelyet Jeremy Ashkenas hozott létre, aki a CoffeeScript, a LiveScript és az Underscore.js társszerzője is..

A projektet a GitHub ad otthont, és a folyamatos fejlesztést Ashkenas vezette egy nyílt forrású közreműködők közösségével..

A Backbone.js egyoldalú JavaScript webes alkalmazások készítésére szolgál. A könyvtár felépíti a webes alkalmazások fejlesztését azáltal, hogy ösztönzi az alkalmazás logika és az alkalmazás tartalmának teljes elválasztását.

Backbone.js alapok

A Backbone.js egy ügyféloldali JavaScript könyvtár. Függőségei között szerepel az Underscore.js és a jQuery könyvtárak, amelyeket a böngészőnek be kell töltenie a Backbone.js betöltése előtt..

A könyvtár RESTful JSON felülettel rendelkezik, ami azt jelenti, hogy adatokat küldhet és fogadhat egy webszerverre és onnan egy könnyű JSON adatformátum segítségével.

A könyvtárat a Model-View-Presenter (MVP) programozási architektúrával tervezték, amely a felhasználói felületek népszerű szoftver-tervezési mintája. A Backbone.js ökoszisztéma azonban a „modellek, nézetek és gyűjtemények” kifejezést használja.

Modellek, nézetek és gyűjtemények

A Backbone.js mögött rejlő filozófia az, hogy az alkalmazás logikáját és az alkalmazás adatainak bemutatását el kell választani. Ezt a szétválasztást a modellek és nézetek létrehozásának és manipulálásának módjában tartják fenn.

A Backbone.js fájlban a modell egyetlen adattáblázatot ábrázol, az adatok kezeléséhez szükséges funkciókkal és logikával együtt.

Az adatok egy vagy több nézet segítségével kerülnek bemutatásra, amelyek egyszerűen csak egy webalkalmazás felhasználói felületének részei, amelyek lefordítják a modellben található adatokat, és a DOM weboldalhoz igazítják.

A nézetek azt is meghallgatják a felhasználói bemenetet, és visszaküldik azt a megfelelő modellbe a modellben tárolt adatok frissítése céljából.

A Backbone.js tartalmaz egy beépített JSON API-t. A modell megváltoztatásakor a változás a JSON API-n keresztül visszajuttatható egy webkiszolgáló-adatbázisba.

Mivel gyakorlatilag az összes szerveroldali programozási nyelv fel van szerelve a JSON-adatok küldésére és fogadására, szinte bármilyen szerveroldali nyelv vagy alkalmazás JSON API-val használható az adatok kommunikálására a Backbone.js webalkalmazásba és onnan, valamint az alkalmazás-adatbázis frissítésére Eszerint.

A kapcsolódó modelleket úgy lehet megszervezni és kezelni, hogy gyűjteményekre csoportosítják őket, amelyek további előnye, hogy egyetlen meghallgatási pontot biztosítanak, amely során több nézet felhasználható egy vagy több nézet folyamatos frissítésére..

Mire jó a Backbone.js??

Noha a Backbone.js nem olyan elterjedt, mint a legnépszerűbb JavaScript könyvtárak, például a jQuery és a Modernizr, a könyvtár az összes ügyféloldali JavaScript technológia tizenöt legfontosabb közé tartozik..

Ezenkívül a Backbone.js projektek nem feltétlenül sokak, de a könyvtárat használó projektek általában nagyobb forgalmú webes alkalmazások, amelyek közül néhánynak magas a névfelismerése.

A Backbone.js webhely például a Backbone.js segítségével létrehozott ismert projektek listáját tartalmazza, amely magában foglalja a jól ismert internetes indítók és az olyan digitális titánok igazi kiét, mint például:

  • Hulu

  • Kvarc

  • Hang

  • WordPress.com

  • Disqus

  • Khan Akadémia

  • Walmart Mobile

  • Alaptábor

  • Airbnb

  • Pandora

  • Code School

  • Trello

  • Csík

  • És még sok más.

Ami a Backbone.js-t különbözteti meg sok más népszerű JavaScript-kerettől – figyelemre méltó, az AngularJS -, a relatív szabadság, amelyet kínál a fejlesztőknek.

Míg a többi vezető keretrendszer tartalmazhat beépített alapértelmezett szolgáltatásokat, amelyek nagy segítséget nyújtanak (pl. Kétirányú adatmegkötést vehetünk igénybe), a Backbone.js nem. Ez a legfontosabb ok, amiért a Backbone.js-t könyvtárnak, és nem keretnek nevezik.

Ehelyett a fejlesztőknek teljes szabadságot biztosít a preferenciáiknak megfelelő webes alkalmazás létrehozásában, ahelyett, hogy a fejlesztőt különféle előre meghozott döntések elfogadására kényszerítenék..

Másrészt ez azt jelenti, hogy több alapvető alapot kell megtenni a Backbone.js webes alkalmazásának felépítésekor, mint az AngularJS-hez hasonló keretrendszerrel, amely tartalmaz egy előzetes alapozási alapot..

Tanulási anyagok

Ha meg akarja tanulni a Backbone.js fájlt, akkor az elsőként tennie kell a JavaScript és a jQuery elsajátítását.

Mivel a Backbone.js egy JavaScript könyvtár, amely a jQuery mellett működik, a két programozási nyelv elsajátítása a Backbone.js kezelése előtt sok időt és frusztrációt takarít meg..

  • Bevezetés a JavaScript-be

  • Tanulj és mester jQuery

  • JavaScript és jQuery a tervezők számára.

Ezenkívül gyors lépést kell tennie az Underscore.js-sel, vagy annak leszármazott könyvtárával, Lodash-lal..

A Backbone.js megköveteli, hogy a Backbone.js betöltése előtt feltöltse a két könyvtár egyikét, így hasznos lesz az egyik vagy a másik szint ismerete..

Online oktatóprogramok

Ha azt szeretné, hogy a lehető leggyorsabban felálljon és működjön a Backbone.js segítségével, akkor a következő legjobb megoldás az, ha a következő oktatóanyagok közül néhányat kezel..

Az összetettség szerint soroltuk őket. Tehát, ha kezdő vagy, kezdje meg az első felsorolt ​​források egyikével, mivel az utóbbi erőforrások meglehetősen előzetes ismereteket igényelnek.

  • Backbone.js Az első lépések

  • A gerinc.js az Absolute Beginners számára: Adrian Mejia

  • Gerinc, az alapozó

  • Egyoldalas alkalmazás kiépítése a Backbone.js, Underscore.js és jQuery segítségével, Henrik Joreteg

  • Gerinc-kapcsolatkezelő bemutatója

  • Példa gerincű mobilalkalmazásra.

A Backbone.js GitHub lerakat tartalmaz további útmutatásokat, blogbejegyzéseket és a Backbone.js webes alkalmazások példáit is..

Könyvek

Ha igazán szeretne elsajátítani a Backbone.js-t, vagy ha inkább oktatását inkább nyomtatásra és kötésre szeretné, vegye fontolóra a következő, pozitívan áttekintett szövegeket.

  • Mastering Backbone.js (2016), Abiee Echamea

  • Full Stack JavaScript: Tanulja meg a Backbone.js, Node.js és a MongoDB (2015) készítőjét: Azat Mardan

  • A Backbone.js minták és bevált gyakorlatok (2014), készítette: Swarnendu De

  • Backbone.js tervrajzok (2014), Andrew Burgess.

Végső gondolatok a Backbone.js oldalon

A Backbone.js egy JavaScript könyvtár, amelyet egyoldalas webes alkalmazások fejlesztésére terveztek.

A könyvtár figyelemre méltó abban az értelemben, hogy teljes mértékben elválasztja az alkalmazás adatait és az alkalmazás felhasználóit megjelenítő nézeteket, valamint a Java fejlesztők számára biztosítja a relatív szabadságot és a megfelelő felelősségeket..

Funkcionális JavaScript

Funkcionális JavaScript

Amikor a programozók funkcionális programozásról beszélnek, általában két különböző, de egymással összefüggő dologról beszélnek:

  • Programozási stílus, amely hangsúlyozza a mellékhatások szándékos elkerülését, valamint a rejtett bemeneteket és kimeneteket.

  • A Lamba calculusból származó programozási funkciók halmaza – például curry, map és szűrő -.

Ezek a fogalmak összefüggenek, mivel a funkcionális programozáshoz kapcsolódó funkciótípusok nagyobb mértékű kódkivonást tesznek lehetővé erős és összetett matematikai számítások elvégzésével..

Mi teszi a funkcionális programozást funkcionálissá?

Minden funkció egy vagy több bemenetet vesz fel, és egy vagy több kimenetet hoz létre. Vegyük például ezt az egyszerű funkciót:

példa (a) {
var eredmény = a + 1;
visszatérési eredmény;
}

Ez az egyszerű függvény egyetlen bemenetet vesz, a, hozzáad egy értéket, majd az eredményt egy eredmény nevű változóban tárolja. Ebben az esetben a a bemenet és az eredmény a kimenet.

Elég egyszerű, igaz?

Mi van ezzel a kissé összetettebb funkcióval? Milyen bemenetei és kimenetei vannak??

példa (a) {
var eredmény = doSomething (a) + 1;
visszatérési eredmény;
}

Nos, most hirtelen a dolgok összetettebbek. Van egy, a doSomething () függvény, amely be van ágyazva függvényünkbe és a változóra hat. Ha módosítani kellene a doSomething () -et, akkor szükségszerűen megváltoztatja a () példa eredményét is.

Ebben az esetben van egy úgynevezett rejtett bemenet. Bármi legyen is, amit a doSomething () ténylegesen betesz a példa () függvénybe, nem lehet megmondani, ha pontosan megnézzük a funkciónkat, hogy mit fog tenni.

Ezenkívül azt mondanánk, hogy a doSomething () függvénynek mellékhatásai vannak. Ez azt jelenti, hogy ha a doSomething () megváltozik, ez más funkciókat is befolyásol. A funkció teljes hatóköre nem tartozik a funkcióba.

A funkcionális programozás egy olyan programozási stílus, amely megpróbálja kiküszöbölni az összes mellékhatást, valamint a rejtett bemeneteket és kimeneteket olyan funkciók írásával, amelyek kifejezetten deklarálják az összes bemenetet és kimenetet.

Például a fenti függvényt úgy alakíthatjuk át, hogy a függvényeket külön tartsuk és a doSomething (a) -et bemenetiként deklaráljuk az (a) példa bejegyzéséhez, így:

doSomething (a) függvény {
var b = a + 1;
visszatérés b;
}
példa (c) {
var eredmény = c + 1;
visszatérési eredmény;
}
var c = példa (doSomething (1));

Noha ez első pillantásra bonyolultabbnak tűnhet, könnyedén megnézheti a változót bejelentő sort, és tudja, hogy a kimenet létrehozásában két funkció működik, míg az előző példa elhomályosította ezt az információt..

Ha még mindig kissé zavarodott benne, hogy pontosan mi a funkcionális programozás, mi az a funkcionális programozás? Kris Jenkins készítette a téma kiváló technikai bevezetését, amely bármilyen programozási nyelvre vonatkozik.

Funkcionális programozás JavaScript segítségével

A JavaScript funkcionális programozási nyelv? Nos, a kérdésre adott válasz attól függ, hogy mit ért a funkcionális programozási nyelv.

Kódot írhat funkcionális programozási stílus használatával, a JavaScript használatával. A sima vanília JavaScript azonban nem tartalmazza azokat a hatékony matematikai funkciókat, amelyeket a legtöbb programozó keres, amikor funkcionális programozásról beszélnek..

A megoldás természetesen egy funkcionális programozási funkciók JavaScript könyvtárának felépítése vagy beépítése. Csináld ezt, és a JavaScript remek nyelv lesz a funkcionális kód írására.

Ha elsősorban a funkcionális programozási stílus megtanulásával, és kevésbé az összetett matematikai funkciókkal foglalkozik, akkor a következő források segítenek jobban megérteni a funkcionális programozási stílust és annak alkalmazhatóságát a JavaScripten:

  • M David Green bevezetése a funkcionális JavaScripthez a SitePointon, amely röviden összehasonlítja a imperatív, objektum-orientált és funkcionális programozást a JavaScript-ben.

  • Gyengéd bevezetés a funkcionális JavaScriptbe: James Sinclair négy részből álló sorozata.

  • Funkcionális programozás: az Eloquent JavaScript 6. fejezete.

Funkcionális JavaScript

Noha a JavaScript felhasználható a funkcionális stílusú programozáshoz, amint már említettük, hiányzik a funkcionális könyvtár, ahogyan sok funkcionális programozó keres.

2007-ben Oliver Steele kiadta a Functional – egy JavaScript könyvtárat, amely bemutatja a matematikai képleteket és funkciókat, amelyeket a funkcionális programozók gyakran használnak.

Ahelyett, hogy a programozókra kényszerítenék a funkcionális kód írására kényszeríteni őket, a Functional alapvetően lambda kalkulációs képletek halmaza, amely JavaScript függvényekké alakul át..

  • A Funkcionális magas szintű funkciói közé tartozik a térkép, kicsinyítés és szűrés.

  • A funkcionális szintű módszerek közé tartozik a curry, a részleges, a komponálás, az őrzés és addig.

  • Ezenkívül a Functional támogatja a lambda kifejezéseket.

A Functional a GitHub házigazdája, és teljesen ingyenes és nyílt forráskódú. 2007 óta azonban nem történt jelentős frissítés. Más szavakkal: a régi könyvtár használatának megkísérlésekor várható néhány ütés az út mentén..

Ha többet szeretne megtudni a funkcionális Javascript-ről, nézd meg a következő forrásokat:

  • Funkcionális JavaScript könyvtár: a GitHub-on.

  • Funkcionális JavaScript: Oliver Steele. Lásd még ezeket az archívumokat:

    • Funkcionális JavaScript: a bejelentés

    • Funkcionális JavaScript 1.02: a könyvtár frissítése.

Funkcionális JS

Ha egy kb. 2007-es JavaScript könyvtár használatának ötlete kissé idegesít – mint kellene -, miért ne keresse meg egy modernabb alternatívát??

Lee Crossly Funkcionális JS-jét 2013 végén adták ki. Ez hasonló az Oliver Steele Functional JS-hez abban, hogy alapvetően a számítási funkciók gyűjteménye, nem pedig a programozás funkcionális stílusának érvényesítésére vonatkozó korlátozások. Ugyanakkor sokkal szélesebb körű funkciókat tartalmaz, beleértve a curry-t, az aritást, a lambda-t, a térképet, a csökkentést, a kiválasztást, a partíciót, a csoportot és még sok más.

A funkcionális JS a GitHub házigazdája, és a projekt hivatalos weboldala kiváló és alapos könyvtári dokumentációt kínál. De figyelmeztetni kell arra, hogy a dokumentáció olyan stílusban készült, amely feltételezi, hogy azt tapasztalt fejlesztők olvasják el.

Záró gondolatok a funkcionális JavaScriptről

A funkcionális programozás a lambda calculus támogatására kifejlesztett programozási stílus, amely ösztönzi az összes bemenet és kimenet kifejezett deklarálását és a mellékhatások elkerülését. Funkcionális programozási stílus használható, ha JavaScript-rel kódolunk.

A szokásos JavaScript azonban nem tartalmazza az olyan hatékony matematikai funkciókat, amelyeket sok funkcionális programozó keres. A JavaScript javítható úgy, hogy jobban megfeleljen a funkcionális programozási stílusnak, olyan ingyenes JavaScript könyvtárak használatával, mint például a Functional by Oliver Steele és a Functional JS, Lee Crossley.

JavaScript stílus

JavaScript stílus

A JavaScript egy nagyon megbocsátó programozási nyelv. Ennek eredményeként ugyanaz a kód, amelyet két különböző JavaScript programozó írt, gyakran meglehetősen eltérőnek tűnik.

A stílusszabályoknak való megfelelés biztosítja, hogy minden kód úgy néz ki, mintha egyetlen programozó írta volna, még akkor is, ha több programozó is részt vesz. Ezenkívül megkönnyíti a kód olvashatóságát és megértését.

Ebben az útmutatóban egy sor JavaScript kódolási irányelvet fogunk nyújtani, amelyeket elfogadhat tisztább, elegáns kód megírásához, és biztosíthatja a következetes programozási stílus használatát.

Irányadó elv

Bármely nyelven történő programozáskor, beleértve a JavaScriptet is, hangsúlyozza az átláthatóságot az okosság felett.

Ez azt jelenti, hogy a programozó célja, hogy a kódot a lehető legolvashatóbb módon írja, nem pedig a lehető legkevesebb billentyűleütést használja..

Ha kétféle módon lehet megtenni egy dolgot – és a JavaScripten gyakran fél-tucat vagy annál is többféle módon lehet megtenni egy dolgot – akkor inkább a legtisztább módszert használja, ne pedig a legokosabb módszert.

Például:

// Okos, de potenciálisan összezavaró
; [‘foo’, ‘bar’, ‘baz’, ‘qux’] .forEach (function () {
// Funkciókód
});

// Valamivel szó szerint, de világos
var foobars = [‘foo’, ‘bar’, ‘baz’, ‘qux’];
működjen valamiClever () {
// Funkciókód
};
foobars.forEach (somethingClever);

Hozzászólások

Mivel ebben az útmutatóban az észrevételeket fogjuk használni, nézzük meg először a megjegyzés stílusát.

A programozóknak tévedniük kellett, mert túl sok hozzászólást nyújtanak, nem pedig túl keveset. A megjegyzés felbecsülhetetlen értékű módja annak, hogy segítsen más fejlesztőknek megérteni, mi folyik, és segítse az eredeti fejlesztőt is, hogy emlékezzen az egyes kódrészek céljára.

Háromféle megjegyzés létezik, amelyek felhasználhatók a JavaScripten:

  • Egysoros megjegyzések.

  • Több soros megjegyzés.

  • Beépített megjegyzések.

Így javasoljuk az egyes típusú megjegyzés formázását:

/ **
Ez egy több soros megjegyzés. Ez a fajta megjegyzés
a fájl címsorokra és a leírásra kell fenntartani
a komplex funkciók célja.
* /

// Ez egy soros megjegyzés. Használja rövid jegyzetek készítéséhez.

// Próbálja meg elkerülni az inline hozzászólásokat az alábbiak szerint.
var foobars = [‘foo’, ‘qux’ / * szintén quux és quuux * /];

Az egy- és többsoros megjegyzéseket mindig egy üres sor előzi meg. Ezenkívül az egysoros megjegyzéseknek a leírt kód fölött, nem pedig annak mellett vagy alatt kell megjelenniük.

A több soros megjegyzés formázható sokféleképpen.

/ ************************************************* **********
* *
* Egyes fejlesztők szeretnek nagy blokkokat létrehozni *
* a több soros megjegyzések beágyazására. Minden bizonnyal *
* nem a mi preferenciánk, de itt a kulcs a következetesség. *
* Ha ezt a formátumot fogja használni, csak ellenőrizze, hogy *
* következetesen használja. *
* *
************************************************** ********* /

/ **
* Előnyünk az egyszerűség. Több soros megjegyzések
* A gépelés egyszerűen kevesebb erőfeszítést igényel, és ugyanolyan
* Könnyen olvasható – és kevésbé látványos, ha van
* kérdezz minket. Javasoljuk, hogy csak egy előremeneti perjel használatos
* és két csillag a több soros megjegyzés megnyitásához. Akkor,
* minden sor két szóközzel kezdődik, an
* csillag és egy szóköz. A megjegyzés lezárva van
* két hely behúzás, egy csillag és egy záró
* perjel.
* /

/ ************************************************* **********

De ez a megjegyzés stílus vitathatatlanul olvasható, mint a
a többi stílus. És az az előnye, hogy létezik
könnyen karbantartható, függetlenül a szerkesztőt, hogy a
programozó használja.

************************************************** ********* /

Szöveg, szóköz, oszlopok és behúzás

A helymeghatározás a kód olvashatóságának legfontosabb meghatározója. A következetesen elosztott és behúzott kód sokkal könnyebben olvasható, mint az alternatív.

A behúzás

Kezdjük a behúzással. Míg a behúzási gyakorlat eltérő, az uralkodó behúzási módszer – és az általunk ajánlott módszer – az, hogy behúzásra kerüljön két tér használata.

A behúzást gyakorlatilag minden integrált fejlesztési környezetben (IDE) vagy szövegszerkesztőben konfigurálhatjuk, tehát állítsuk be a behúzást 2 szóközre, és érdemes megtenni.

Oszlopok

Ha a programozás oszlopairól beszélünk, arra utalunk, hogy hány karakternek kell megjelennie egy sorban a sortörés hozzáadása előtt. Az olvashatóság érdekében fontos a sortörések hozzáadása. Általánosságban a konszenzus az, hogy 80 karakter vagy oszlop jó áttörési pont. Mások tökéletesítik a kisebb hosszúságot, mint például 65.

Egy további kérdés, amelyet szemléltetni kell, a vonalszakítást követő behúzás használata. Amikor ez bekövetkezik, a legjobb dolog az, ha a becsomagolt tartalom behúzása 2 helyett 2 helyre kerül, mint az alábbi példában látható:

var foo = ‘Ez a változó nagyon hosszút tartalmaz’ +
‘karakterlánc, amely többszörösen kibomlik’ +
„Sorokat. Az egyértelműség kedvéért a „ +
„az új sorokban megjelenő tartalom legyen” +
“behúzott négy szóköz.”,
bar = ‘Ilyen behúzás megkönnyíti’ +
“a sor közötti vizuális megkülönböztetés” +
„szünetek az oszlop burkolásának és a vonal törésének köszönhetően” +
„egy nyilatkozat végén.”;

(Vegye figyelembe, hogy rövidebb vonalhosszt használunk annak érdekében, hogy azok jól néznek ki ezen a weboldalon.)

Fehér űr

Néhány további helyes gyakorlati szabály a szóköz használatára vonatkozik:

  • Kerülje a sorvég és az üres sor szóközt. Ez azt jelenti, hogy ne hagyjon üres helyet a kódsor végén vagy egy üres sorban. A legtöbb szövegszerkesztőben és az IDE-kben bekapcsolja a „láthatatlanok megjelenítése” vagy a „szóköz kiemelése” funkciót, és megjeleníti ezeket a karaktereket, így észreveheti és kiküszöbölheti őket..

  • Adjunk egy szóközt vesszők után a listákba, így: var foo = [‘bar’, ‘baz’, ‘qux’];.

  • Adjon szóközt a zárójelek és azok tartalma között, így: function (foo)….

  • Adjunk szóközt az operátorok és a tartalom között, amikor egy karakterláncot egyesítünk, például: ‘Hello’ + ‘world!’.

  • Egy üres sor hozzáadása a különféle és a kapcsolódó bit bitcsoportokhoz rendben van. Több sor hozzáadása nem ajánlott.

elnevezési

A funkciók, változók és egyéb elemek elnevezésekor a JavaScript-ben a következő néhány szabályt kell betartani:

  • Használjon emberi olvasható neveket, amelyek intuitív módon értelmesek, amikor csak lehetséges.

  • Használjon többségi nevet tömbökhöz és szinguláris nevet más típusú változókhoz.

  • A camelCase használatával nevezze meg a függvényeket és a változókat, például: var longName = ”;.

  • Használja a PascalCase-t a konstruktorok (objektumosztályok) elnevezéséhez, például: a HostingCompany függvény (név, URL, besorolás) {….

  • Ha szimbolikus állandókat hoz létre, nevezze el őket az összes sapka és aláhúzás használatával, így: var MAX_RATING = 100;.

  • Rendszeres kifejezések létrehozásakor írja elő a nevet kisbetűvel, például ehhez az e-mail címek érvényesítéséhez: var rEmail = /[A-Z0-9._%+-← ^ e-mail védett] [A-Z0-9.-] +. [AZ] {2,63};.

pontosvessző

Gyakorlatilag minden modern JavaScript megvalósítás tartalmaz egy automatikus pontosvessző-beillesztés (ASI) nevű funkciót. Ez a szolgáltatás úgy működik, hogy a pontosvesszők megjelenjenek, és automatikusan hozzáadja azokat.

Ennek eredményeként egyes programozók arra buzdítják a többieket, hogy soha ne használjunk pontosvesszőt, néhány szélső eset kivételével. Mások programozók arra ösztönzik, hogy tegye hozzá őket, mintha az ASI nem létezik.

Szilárdan az utóbbi táborban vagyunk. Éppen túl sok összekapcsolt JavaScript-fájlt láttunk, hogy azt gondoljuk, hogy rendben lehet ezeket hagyni.

Akkor válik a kérdés, mikor kell pontosvesszőt hozzáadni? Általában pontosvesszőt kell hozzáadni minden nyilatkozat vagy megbízás után. Például:

var foo = ”;
foo = 1;
ize ++;
foo = function () {
// Semicolon szükséges, mert ezt a funkciót egy változóhoz rendelik.
};
riasztás (foo);
console.log (foo);

Semicolonokra nincs szükség egy utasítás vagy függvény záró göndör zárójele után – kivéve, ha a függvényt egy változó értékének jelölik, ahogy az a kód utolsó bitjében látható.

Ha azonban pontosvesszőt ad hozzá a függvények és utasítások után, akkor semmit sem fog megtörni.

Ezenkívül soha nem kell pontosvesszőt hozzáadni a záró parantézis és a nyitó göndör tartó közé egy ilyen állításban vagy függvényben: funkció (paraméter); {… vagy ha (feltétel); {….

Idézetek

A JavaScript-ben akár egy, akár dupla idézőjelek használhatók. A legtöbb közzétett stíluskalauz azonban egyetért az egyedi idézetek használatával – ez a konszenzus, amelyet örömmel folytatunk.

Ha egynél több idézőkészletet kell használnia, például amikor HTML-t fészkel a JavaScript-ben, váltson az egy- és dupla idézetek között.

// Csináld ezt
var foo = ‘bár’;

// Nem ez
var foo = "rúd";

// Rendben van
var foo = ‘Néhány tartalom itt.’;

// De ez könnyebb és olvashatóbb
var foo = ‘Néhány tartalom itt.’;

változók

A JavaScript nagyon megbocsátó, mivel lehetővé teszi a változók deklarálását különféle formátumokban. Javasoljuk a lehető legolvashatóbb és világosabb formátum használatát.

// Ez rossz, mert nehéz olvasni. Ne csináld ezt.
var foo = "", bar = [], baz = {}, qux = function () {
/ * Beszúrás ide. * /};

// Ez rossz, mert következetlen.
var foo = ”,
bar = [];
var baz = {};
qux = function () {/ * Ide illessze be az utasításokat. * /};

// Ez jó, mert következetes és olvasható.
var foo = ”,
bar = [],
baz = {},
qux = function () {
// Ide illessze be az állításokat.
};

// Ez a legjobb.
var foo = ”;
var bar = [];
var baz = {};
var qux = function () {
// Ide illessze be az állításokat.
};

Sokszor meg kell deklarálni egy változót egy függvényen vagy egy if… egyéb utasításon belül. Amikor ez megtörténik, csoportosítsa az összes változót és deklarálja őket először.

Tömbök és tárgyak

Komplex tömbök és objektumok létrehozásával nagymértékben olvashatatlan kódot lehet előállítani. Ezért kritikus a megfelelő behúzás és a vonalszakadások használata. Nézzük meg néhány példát a tömbök és objektumok létrehozására vonatkozó jó és rossz kódolási gyakorlatról.

// Rendben, ha rövid, egyszerű tömböket deklarálunk egyetlen soron.
var foobars = [‘foo’, ‘bar’, ‘baz’, ‘qux’];

// A hosszú tömböket sorszakadással kell deklarálni.
var emailAddresses = [
„[Email protected]">Lépjen kapcsolatba velünk’,
„[Email protected]">Webmaster”,
„[Email protected]">Sales’,
„[Email protected]">Támogatás’
];

// Az objektumokat mindig sorválasztással kell bejelenteni.
var helyőrzők = {
1: „foo”,
2: „bár”,
3: „baz”,
4: ‘qux’
};

Nyilatkozatok és funkciók

Az utasítások és funkciók megfelelő formázása megkönnyíti azok megértését, és segíthet elkerülni a problémákat, amikor a kód összekapcsolódik vagy megjelenik egy böngészőben. Így formázhatók a funkciók és utasítások általában:

function functionName () {
// Írja ide a kódot.
}

Ezt az alapformátumot kell használni a funkciókhoz, ha utasítások, az utasításokhoz, míg az utasításokhoz és így tovább. Az ezt a stílust diktáló szabályok a következők:

  • Mindig helyezze a nyitókonzolt ugyanarra a sorra, mint a függvény vagy a kijelentés paraméterei: (paraméterek) {…. Ha sortörést ad a záró zárójelek és a nyitó zárójelek között, az automatikus pontosvessző-beillesztés (ASI) a kód eltöréséhez vezethet, ha hozzáad pontosvesszőt nem megfelelő módon.

  • Az utasításokat és a funkciókat mindig több sorra bontja úgy, hogy minden funkció vagy utasítás kód megjelenjen a nyitó és záró zárójelek közötti sorokon.

Fészekrakási funkciók

A következő példában bemutatott funkciók beillesztése a funkciókba teljesen elfogadható:

funkció fooBar (foo) {
var bar = function () {
// Funkciókód itt.
}
nestedFunction () függvény {
// További funkciókód itt.
}
nestedFunction (bar) visszatérés;
}

Az utasításokon belüli fészkelési funkciókat azonban csak akkor kell elvégezni, ha a függvényt egy változóhoz rendelik. Ennek oka az, hogy az ECMAScript szabvány nem támogatja az utasítások beágyazott funkcióit.

Noha a legtöbb JavaScript implementáció ezt a helytelen felhasználást csak finom módon kezeli, az ECMAScriptet szigorúbban követő implementációk nem fogják megfelelően feldolgozni a kódot.

A következő példa szemlélteti a különbséget:

if (foo > rúd ) {

// Ne csináld ezt
fooBar funkció (foo, bár) {
foobar = foo + bár;
visszatér foobar;
}
fooBar (foo, bár);

// Tegye ezt helyette
var foobar = függvény fooBar (foo, bar) {
visszatérő foo + bár;
}
}

Ha más állításokat ír, tisztázza, hogy a teljes állítás össze van-e kapcsolva, mivel elkerüli a sortörések hozzáadását az utasítás egyes részei előtt..

// Használja a következő formátumot.
if (feltétel) {
// Ide illessze be az állításokat.
} máshol, ha (feltétel) {
// További állítások itt.
} más {
// Még több kijelentés itt.
}

// Ne csináld ezt. Ez összezavaró.
if (feltétel) {
// Ide illessze be az állításokat.
}
egyébként, ha (feltétel) {
// További állítások itt.
}
más {
// Még több kijelentés itt.
}

Összehasonlítás

Ha két értéket összehasonlít JavaScript-ben, akkor két lehetősége van. Ellenőrizheti, hogy szigorú-e az egyenlőség a === és! == gombokkal, vagy ellenőrizheti az absztrakt egyenlőség elérését a == és! = Gombokkal..

A két lehetőség közötti különbség az, hogy amikor elvont egyenlőséget ellenőriz, a JavaScript gép megpróbálja átalakítani az értéktípusokat, mielőtt a hamis értéket adja vissza.

Amikor azonban ellenőrzi a szigorú egyenlőséget, a gép csak akkor tér vissza igazra, ha mind a típus, mind az érték megegyezik. Íme néhány példa arra, hogy ez hogyan gyakorolható a gyakorlatban:

// Egy szám
var foo = 0;

// Húr
var bar = ‘0’;

// “igaznak” értékeli
foo == bár;
foo == hamis;
bar == hamis;
foo! == bár;

// ‘hamisnak’ értékeli
foo! = bár;
foo === bár;
foo === hamis;
foo === hamis;

Az absztrakt összehasonlítások zavart okozhatnak a változó típusok tekintetében. Ennek eredményeként azt javasoljuk, hogy ragaszkodjon a szigorú összehasonlításokhoz, hogy elkerülje a következő kérdést:

// Húr
var foo = ‘123’;

// Egy szám
var bar = 123;

// igaz lesz
foo == bár;

// hamisat fog adni
foo === bár;

Ha elvont összehasonlítást használ, akkor azt gondolhatja, hogy mindkét érték megegyezik a „123” számmal, ha a foo valójában megegyezik a „123” karakterlánccal.

Ennek eredményeként megpróbálhatja matematikai számításokat elvégezni a foo húrjával. Az értékek szigorú összehasonlítása ráveszi Önt a kérdésre, és tudatja Önnel, hogy a számítás elvégzése előtt foo-t számra kell konvertálnia..

További információ a JavaScript stílusról

Ha többet szeretne megtudni a JavaScript stílusáról, az alábbi források hasznosak lesznek:

  • A következetes, idiomatikus JavaScript írásának alapelvei

  • JavaScript standard stílus

  • jQuery Foundation JavaScript stílusú útmutató

  • Google JavaScript stílus útmutató.

Záró gondolatok a stílusról

A következetes és átgondolt stílus használata a JavaScript írásakor megkönnyíti a kód olvashatóságát és megértését.

Ezenkívül egy konstans stílus használata több fejlesztőt bevonó projekteknél biztosítja, hogy minden kód következetesen jelen legyen.

Ebben az útmutatóban bemutattunk egy javasolt stílust a JavaScript-kód írásához. Fogadja el, módosítsa az igényeinek megfelelően, és élvezze a tisztább, tisztább, következetesebb kód előnyeit.

CoffeeScript

CoffeeScript

A CoffeeScript (CS) Jeremy Ashkenas által kifejlesztett tömör programozási nyelv, amely szabványos JavaScript-hez fordul, és bármilyen JavaScript környezetben végrehajtható..

Ez egy nyílt forráskódú nyelv, és a folyamatos fejlesztést Ashkenas és egy közel 200 közreműködő hadsereg együttműködésével fejezik be.

A CS célja, hogy a fejlesztők egyszerű és tömör szintaxis segítségével kódot írhassanak. Ezután fordítson egy JavaScript-kódba, amely kihasználja a programozás bevált gyakorlatait, és bármilyen JavaScript futási környezetben könnyen végrehajtható.

A CoffeeScript története

2009 decemberében Jeremy Ashkenas új GitHub tárházat hozott létre, amelynek kezdeti elkötelezettsége „rejtélynyelv eredeti elkötelezettsége” volt.

Ez a kezdeti kötelezettségvállalás gyorsan épült, és a nyelv első hivatalos kiadása, a CS 0.1.0 verziója kevesebb mint 2 héttel később, 2009. karácsony estéjén érkezett..

A CS fordító eredetileg Ruby nyelven készült. A 2010. februárban kiadott 0.5-es verzió azonban a fordítót maga a CoffeeScript-ben leírt verzióra váltotta fel. A CS-nek az első stabil verziója, az 1.0.0 verzió, amelyet 2010 karácsony estéjén jelentettek meg, kb. Egy évvel azután, hogy a projekt életre lépett, továbbra is megvolt a lehetősége..

A CoffeeScript legújabb verziója a 2.3.1, 2018 májusa.

Annak érdekében, hogy lépést tudjon tartani a CS-nél végzett legújabb fejlesztési munkákkal, olvassa el a CoffeeScript 6.0 GitHub lerakatot.

Jeremy Ashkenas

A CS tervezője, Jeremy Ashkenas, befolyásos és eredményes JavaScript fejlesztő. Jeremy a CS mellett a következő figyelemre méltó projekteket is kifejlesztette:

  • LiveScript: egy funkcionális programozási nyelv az objektumorientált és a kötelező programozási stílusok támogatásával, amely közvetett leszármazottja a CoffeeScript-től. A CS-hez hasonlóan a szabványos JavaScriptté is fordul.

  • Backbone.js: egy egyoldalas webes alkalmazásokkal kialakított, rugalmas JavaScript könyvtár, amely hangsúlyozza az alkalmazás logikai kódjának elválasztását a kódtól, amely meghatározza az alkalmazás adatainak bemutatását.

  • Underscore.js: JavaScript könyvtár segédfunkciókkal a közös programozási feladatok kezelésére.

Jeremy a The New York Times fejlesztője, valamint a konferenciák népszerű előadója, és számos videót talál a beszélgetéséről a YouTube-on, például:

  • Az átültetők emelkedése

  • JS.Next és CoffeeScript

  • Szimbiotikus nyelvek

  • CoffeeScript mint JS / Next

  • Egy csésze CoffeeScript.

CoffeeScript szintaxis

A CS címke „Unfancy JavaScript”, és ez a címke a CS szintaxis hatékony leírása.

A CoffeeScript tervezésének egyik elsődleges célja egy könnyen írható nyelv létrehozása volt – a Ruby, Python és Haskell nyelvekre modellezve. Ezért a CoffeeScript elhagyja a JavaScriptre vonatkozó számos szintaktikai szabályt.

A legfontosabb: a göndör zárójelek, pontosvesszők és az olyan hozzárendelési kulcsszavak használata, mint a var és a függvény, mind a CS-ben elhagyásra kerül.

Ez a CS-t rendkívül tömöré teszi, de ez az olvashatóság rovására történik. Hogy megértsék, hogyan működik ez, fontolja meg a következő JavaScript funkciót, amelyet a CS-egyenérték követ.

// Funkció az átlagos host osztályzat visszatérítéséhez JavaScript-ben
var hostRating;
hostRating = függvény (totRatingsVal, totRatingsNo) {
visszatérő totRatingsVal / totRatingsNo;
}

// Ugyanaz a funkció a CoffeeScript-ben
hostRating = (totRatingsVal, totRatingsNo) ->
totRatingsVal / totRatingsNo

Mint láthatja, a CS verzió tisztább, rövidebb és kevesebb nyelvi operátort tartalmaz. Ez a CS verziót egy kicsit gyorsabbá teszi a gépeléshez, de bizonyos mértékben elfedi a színfalak mögött zajló eseményeket is.

Írásbeli CoffeeScript

A CS egyik érdekes változatát írástudó CoffeeScript-nek hívják. A fordító felismeri ezt a variációt, mindaddig, amíg a forráskódfájl a .coffee helyett .litcoffee kiterjesztéssel ér véget.

Az Literate CS lehetővé teszi a fejlesztők számára, hogy kódot írjanak a markdown szintaxis segítségével. A fordító figyelmen kívül hagyja az összes írást, míg a behúzott kódblokkok programkódként kerülnek felismerésre.

Nézzünk egy rövid példát.

## Írásos CoffeeScript

A [Literate CoffeeScript] (http://coffeescript.org/#literate) lehetővé teszi a [markdown] (https://daringfireball.net/projects/markdown/syntax#precode) használatát a CoffeeScript kód írására. Az összes szöveget – címsorokat, bekezdéseket, listákat és így tovább – figyelmen kívül hagyja, és a fordító kommentárként kezeli.

Azonban a behúzott kódblokkok, mint például az alábbi kódblokk, JavaScriptbe vannak fordítva.

fooBar = (foo) -> foo + 1
doSomething = (fooBar) -> figyelmeztetés fooBar
ha fooBar? csinálj valamit

Ez a funkcionalitás néhány érdekes forgatókönyvet hoz létre, ahol egy CoffeeScript fájlt jelöléssel lehet írni és weboldalon oktatóanyagként megjeleníteni, miközben egyidejűleg funkcionális program forráskódként is szolgálhat..

Hogyan lehet beszerezni a Coffeecriptet

A CS fordítót általában a Node.js használatával telepítik és futtatják, a CS elérhető NPM csomagként. A projekt letölthető vagy klónozható a GitHubból is.

Ha még nem áll készen a CoffeeScript telepítésére, akkor azt is megadhatja, ha elindul a CoffeeScript.org oldalra, és kiválasztja a Kipróbálni a CoffeeScript fület.

Ez a lap egy böngésző alapú CoffeeScript környezetet tartalmaz. Egyszerűen gépelje be a bal oldali Coffeecriptet, és nézze meg, hogy a jobb oldalon valós időben forduljon a JavaScript-be.

CoffeeScript források

Ha CS-t szeretne megtanulni, akkor először meg kell tanulnia a JavaScriptet. A legjobb, ha a CS-ről azt a nyelvet gondoljuk, amelynek célja a JavaScript-fejlesztők termelékenységének növelése, a kevesebb hiba előállításának lehetővé tétele és a bevált gyakorlatokat alkalmazó JavaScript előállítása..

Mivel a CS a szabványos JavaScriptre fordul, a CS hibakeresése szilárd alapot igényel a JavaScript programozásában. Ezenkívül a CS tanulási görbéje drámaian csökken, ha már ismeri a JavaScriptet, mivel áttekintheti a fordító kimenetet, hogy megértse, mit csinál a CS kód.

Ezt a figyelmeztetést szem előtt tartva, a következő források segítenek az illetékes JavaScript fejlesztőknek rövid időn belül felállni és futtatni a CS-t.

oktatóanyagok

  • Egy korty CoffeeScript: egy rövid és ingyenes bevezető tanfolyam a CodeSchool-tól.

  • Az Abszolút Kezdő Útmutató a CoffeeScript-hez: ez az oktató megnöveli a nevét, telepítve van a szoftver és megtanítja a nyelv alapjait.

  • CoffeeScript.org: a hivatalos CS webhely részletes leírást tartalmaz a nyelvről és egy böngésző alapú fordítóról.

  • Sima CoffeeScript: interaktív, ingyenes, böngésző alapú e-könyv.

  • Bevezetés a JavaScript forrástérképekbe: A CS hibakeresése forrástérképek használatát igényli. Ez az oktatóanyag segít elindítani a CS-kód hibakeresését.

Könyvek

  • CoffeeScript: Útmutató az alkalmazásfejlesztéshez a CoffeScript-rel (2016), Nicholas Brown.

  • CoffeeScript Ristretto (2014), Reg “raganwald” Braithwaite. Ingyenesen elérhető online.

  • Lee és Marino CoffeeScript in Action (2014).

  • Alex MacCaw kis könyve a CoffeeScripten (2012). Ingyenesen elérhető online.

összefoglalás

A CoffeeScript egy tömör szintaxissal rendelkező programozási nyelv, amely minimalizálja a kulcsszavak és az operátorok használatát, és lehetővé teszi a fejlesztők számára, hogy gyorsan elegáns kódot írjanak.

Ezenkívül a szokásos JavaScript-hez való fordítás után a CS-kód bármilyen JavaScript-kompatibilis környezetben végrehajtható.

JavaScript összefoglaló

JavaScript összefoglaló

A JavaScript rossz rappel rendelkezik. De ennek oka az a tény, hogy annyira hasznos és így használt. A JavaScript ismerete nagyon fontos. Bár sokkal többet tehet más nyelvekkel, a JavaScript továbbra is a leghasznosabb nyelv, amelyet tudni kell.

Remélhetőleg ezzel a bevezetéssel gyorsan képes felállni és működni – interaktív weboldalakat létrehozni.

További irodalom

Több útmutató, oktatóanyag és infographics található a kódoláshoz és fejlesztéshez:

  • F # programozás: megtudhatja a .NET keretrendszer funkcionális programozását.

  • Erlang programozási bevezetés és források: a párhuzamos kód létrehozásához használt korai funkcionális nyelv.

  • Gyors bevezetés és források: ez az egyik legújabb C-szerű nyelv. A programozás jövője? Megtudhatja itt!

Milyen kódot kell megtanulnia?

Zavaros abban, hogy milyen programozási nyelvet kell megtanulnia a kódoláshoz? Nézze meg az Infographic című cikket, Milyen kódot kell megtanulnia?

Nemcsak a nyelvek különféle aspektusait tárgyalja, hanem olyan fontos kérdéseket is megválaszol, mint például: “Mennyit fogok pénzt keresni a Java megélhetéséhez?”

Milyen kódot kell megtanulnia?
Milyen kódot kell megtanulnia?

Jeffrey Wilson Administrator
Sorry! The Author has not filled his profile.
follow me
    Like this post? Please share to your friends:
    Adblock
    detector
    map