Ebből a cikkből megtudhatja, hogyan definiálhat konstansokat JavaScriptben a const kulcsszó használatával.

Az ES6 biztosítja új út konstansok deklarálása a const kulcsszó használatával. A const kulcsszó írásvédett hivatkozást hoz létre egy értékre.

Const VARIABLE_NAME = érték;

Megállapodás szerint a JavaScriptben az állandó azonosítók nagybetűk.

A const kulcsszó hasonló a let kulcsszóhoz, mivel blokk-hatókörű változókat hoz létre, de a const-tal deklarált értékek nem módosíthatók.

A let kulcsszóval deklarált változók változtathatók. Ez azt jelenti, hogy bármikor megváltoztathatja értékeiket, ahogy az a következő példában is látható.

Legyen v = 10;
v = 20;
v = v + 5;
console.log(v); 35

A const kulcsszóval létrehozott változók azonban megváltoztathatatlanok. Más szóval, nem rendelheti át őket különböző jelentések. Egy állandó változó újrarendelése TypeError-t eredményez.

Állandó ADÓ = 0,1;
ADÓ = 0,2 ; //Típushiba

Ezenkívül a const kulcsszóval deklarált változót azonnal értékkel kell inicializálni. A következő példa SyntaxError-t vet fel egy állandó változó deklarációjában hiányzó inicializátor miatt.

Const RED; // Szintaktikai hiba

Ahogy korábban említettük, a let kulcsszóval deklarált változókhoz hasonlóan a const kulcsszóval deklarált változóknak is blokk hatóköre van.

Ez minden, a következő cikkben a const kulcsszó használatáról fogunk beszélni objektum literálokkal JavaScriptben.

Változók és állandók a JavaScriptben. Változók deklarálása és értékek hozzárendelése. Globális és lokális változók. Állandók használata

Változók deklarálása JavaScriptben

A JavaScriptben a változónevek állhatnak betűkből, számokból, $ és _ jelből, és a változó neve nem kezdődhet számmal. Ne feledje, hogy a JavaScript megkülönbözteti a kis- és nagybetűket, és az a1 és az A1 változók különbözőek. A cirill betű használata nem javasolt, bár lehetséges.
A JavaScript változói a var kulcsszóval vannak deklarálva:

Var Peremennaya_1 var Peremennaya_2

Deklaráció nélkül nem ajánlott változókat használni JavaScriptben. Ez lehetséges, de hibákhoz vezethet.

Értékek hozzárendelése a változókhoz

Érték hozzárendelése a deklarált változókhoz JavaScriptben:

Peremennaya_1 = 25 Peremennaya_2 = "A hozzárendelt szöveg egyenes idézőjelek között van"

A deklaráció után azonnal értéket rendelhet a változókhoz:

Var Peremennaya_1 = 25 var Peremennaya_2 = "A hozzárendelt szöveg egyenes idézőjelek között van"

A JavaScriptben lévő változó értéke a program végrehajtása során változhat. Amikor szöveget írunk egy változóba, azt egyenes idézőjelbe kell tenni.

Lokális és globális változók

Ha egy változó egy függvényen belül van deklarálva, akkor az lokális, és csak ezen a függvényen belül lesz elérhető (látható). Amikor egy függvény kilép, a JavaScript helyi változói megsemmisülnek, így az azonos nevű változókat különböző függvényekben használhatja.

Ha egy változó a függvényeken kívül van deklarálva, akkor az globális és elérhető (látható) az oldalon belüli összes függvényben. Az oldal bezárásakor a globális változók megsemmisülnek a JavaScriptben.

Konstansok a JavaScriptben

A konstansok célja, hogy megkönnyítsék a kóddal való munkát, amikor ismétlődő értékeket vagy kifejezéseket kell használnia. A konstans értékét elég egyszer beállítani, és a programjaink kódjába beillesztve tetszés szerint használhatjuk. A JavaScript nem rendelkezik kulcsszóval a konstansok deklarálására, a konstansok helyett a rendszeres változókat használnak. Az állandók és a változók megkülönböztetésére általában jelölik nagybetűvel, szükség esetén aláhúzással:

Var DRUG_CHELOVEKA = "Kutya"

A konstansra adott példa nem teljesen teljes, mivel a „kutya” szót már könnyű megjegyezni, és beilleszteni a kívánt helyre. A JavaScriptben konstansokat használhat összetettebb értékek rögzítésére és beillesztésére, például nehezen megjegyezhető kódok, karakterkészletek, hosszú szövegek, webcímek, címek. Email, telefonszámok, különféle együtthatók.

A JavaScriptben az állandók átírhatók változókká, de ha ezt megteszi, akkor az állandók jelentése elveszik.

A függvény egy kódblokk, amely műveletet hajt végre vagy értéket ad vissza. A funkciók egyéni kódok, amelyek újra felhasználhatók; Ezért a funkcióknak köszönhetően a programok modulárisak és termelékenyebbek lesznek.

Ez az oktatóanyag számos módot kínál függvények meghatározására és meghívására, valamint függvényparaméterek használatára JavaScriptben.

Funkció meghatározása

A függvények meghatározása vagy deklarálása a function kulcsszó használatával történik. A JavaScript függvény szintaxisa így néz ki:

függvénynévOfFunction() (
// A végrehajtandó kód
}

A függvény deklarációja a függvény kulcsszóval kezdődik, amelyet a függvény neve követ. A függvénynevek ugyanazokat a szabályokat követik, mint a változónevek: tartalmazhatnak betűket, számokat, aláhúzásjeleket és dollárjeleket, és gyakran tevebetűvel írják őket. A nevet zárójelek követik, amelyek nem kötelező paraméterekhez használhatók. A függvénykódot kapcsos zárójelek tartalmazzák, például a for vagy if utasítás.

Amint azt észrevette, a név paraméter értéke nincs hozzárendelve a kódban, ez a függvény meghívásakor történik meg. A függvény meghívásakor a felhasználónév argumentumként kerül átadásra. Az argumentum a függvénynek átadott tényleges érték (ebben az esetben a felhasználónév, például 8host).

// Az üdvözlő függvény meghívása „8host” argumentummal
greet("8host");

A 8host értéket a név paraméteren keresztül adjuk át a függvénynek. Most a név paraméter fogja ezt az értéket képviselni ebben a függvényben. A greetUser.js fájl kódja így néz ki:

// Egyéni üdvözlő funkció inicializálása
függvény greet(név) (
console.log(`Hello, $(név)!`);
}
// Az üdvözlő függvény meghívása „8host” argumentummal
greet("8host");

A program futtatásakor a következő kimenetet kapja:

Most már tudja, hogyan kell újra felhasználni egy függvényt.

A paraméterek mellett változók is deklarálhatók a függvényeken belül. Ezeket a változókat lokálisnak nevezzük, és csak a funkcióblokkjukon belül léteznek. A változó hatóköre határozza meg a változók elérhetőségét; A függvényen belül definiált változók a függvényen kívülről nem érhetők el, de annyiszor használhatók, ahányszor a programban azt a függvényt használják, amelyhez tartoznak.

Visszatérő értékek

Egy függvényben több paramétert is használhat. Több értéket is átadhat egy függvénynek, és visszaadhat egy értéket. Például hozzon létre egy sum.js fájlt, és deklaráljon benne egy függvényt, amely megkeresi két érték, az x és az y összegét.

// Hozzáadás függvény inicializálása
függvény add(x, y) (
vissza x + y;
}

add(9, 7);

Ez a kód egy függvényt határoz meg x és y paraméterekkel. A függvény ezután megkapja a 9-es és 7-es értéket. Futtassa a programot:

A program összeadja a kapott 9-es és 7-es értékeket, és a 16-os eredményt adja vissza.

A return kulcsszó használatakor a függvény leáll, és visszaadja a kifejezés értékét. Ebben az esetben a böngésző megjeleníti az értéket a konzolban, de ez nem ugyanaz, mint a console.log() használata a konzolra történő kimenetre. Meghíváskor egy függvény egy értéket ad ki oda, ahonnan hívták. Ez az érték használható vagy változóba helyezhető.

Funkciókifejezések

Az előző részben deklarált egy függvényt, amely összead két számot, és visszaadja a kapott értéket. Függvénykifejezést úgy is létrehozhat, hogy függvényt rendel egy változóhoz.

Az előző függvény segítségével alkalmazza a kapott értéket az összeg változóra.

// Add függvény hozzárendelése az összeg állandóhoz
const összeg = függvény add(x, y) (
vissza x + y;
}
// A függvény meghívása az összeg megkereséséhez
összeg(20, 5);
25

Most az állandó összeg egy függvény. Ez a kifejezés lerövidíthető, ha névtelen függvénnyel alakítjuk (így nevezzük a névparaméter nélküli függvényeket). Jelenleg a függvény neve add, de a függvénykifejezésekben a név általában kimarad.

// Függvény hozzárendelése konstans összegéhez
const összeg = függvény(x, y) (
vissza x + y;
}
// A függvény meghívása az összeg megkereséséhez
összeg(100; 3);
103

Most már nincs neve a függvénynek, névtelenné vált.

Az elnevezett függvénykifejezések használhatók hibakereséshez.

Nyíl funkciók

Eddig a függvényeket a function kulcsszó használatával határozták meg. Van azonban egy újabb és sűrített módon A függvénydefiníciók az ECMAScript 6 nyílfüggvényei. A nyílfüggvényeket egyenlőségjel jelöli, amelyet egy nagyobb jel követ: =>.

A nyílfüggvények mindig névtelenek, és egyfajta függvénykifejezést jelentenek. Próbáljon létrehozni egy alapvető nyílfüggvényt két szám összegének megkereséséhez.

// A szorzási függvény meghatározása
const szorzás = (x, y) => (
return x * y;
}

szoroz(30, 4);
120

A függvény írása helyett egyszerűen használhat => szimbólumokat.

Ha a függvénynek csak egy paramétere van, a zárójelek elhagyhatók. A következő példában a függvény x négyzetet ad, így csak egy szám kell argumentumként.

// Négyzetfüggvény meghatározása
const négyzet = x => (
vissza x * x;
}
// A termék megkereséséhez hívja meg a függvényt
négyzet(8);
64

Megjegyzés: Ha a nyíl függvénynek nincsenek paraméterei, akkor üres zárójeleket () kell hozzáadnia.

A csak return utasításból álló nyílfüggvények lerövidíthetők. Ha a függvény csak egy visszatérési sorból áll, elhagyhatja a kapcsos kapcsos zárójeleket és a return utasítást, mint az alábbi példában.

// Négyzetfüggvény meghatározása
const négyzet = x => x * x;
// A termék megkereséséhez hívja meg a függvényt
négyzet(10);
100

Következtetés

Ez az oktatóanyag bemutatja a függvények, függvénykifejezések és nyílfüggvények deklarálását, az értékek visszaadását és a függvényértékek hozzárendelését a változókhoz.

A függvény egy kódblokk, amely értéket ad vissza vagy műveletet hajt végre.

Címkék:

Amikor egy programnak el kell tárolnia egy értéket, hogy később felhasználhassa azt, az érték hozzárendelődik egy változóhoz. A változó egyszerűen egy érték szimbolikus neve, amely lehetőséget ad az érték név szerinti lekérésére, vagyis amikor egy program megadja egy változó nevét, az értéket helyettesíti.

A változó arról kapta a nevét, hogy az értéke programvégrehajtás közben változtatható.

Állandók

A konstans egyszerűen egy érték szimbolikus neve. Egy konstans lehetővé teszi, hogy egy értékre névvel hivatkozzunk, ami azt jelenti, hogy amikor egy program megadja egy konstans nevét, akkor az értéket helyettesíti. A konstansok olyan adatok tárolására szolgálnak, amelyek nem változhatnak a program végrehajtása során.

Egy konstans használata előtt deklarálni kell. A konstansok deklarálása a const kulcsszóval, majd a konstans nevével történik. Annak érdekében, hogy a programkódban megkülönböztessük az állandókat a változóktól, megállapodtunk abban, hogy az állandók nevét nagybetűvel írjuk:

Állandó MAX = 10;

Egy állandó létrehozása után, ha megpróbálja újradefiniálni egy változóra, vagy megpróbál értéket rendelni egy meglévő konstanshoz, hibát okoz.

Miért van szükség változókra és állandókra?

A változók és konstansok segítenek a programkód világosabbá tételében. Nézzünk egy kis példát:

Teljes ár = 2,42 + 4,33; // Teljes ár

A számok itt bármit jelenthetnek. Annak érdekében, hogy egyértelmű legyen, miről van itt szó, a candyPrice (cukorka ára) változóhoz 2,42, az olajár (olajár) változóhoz (vagy állandó) 4,33-as értéke rendelhető:

Teljes ár = cukorkaár + olajár;

Most, ahelyett, hogy emlékezne ezeknek az értékeknek a jelentésére, láthatja, hogy a szkript összeadja az édesség árát a vaj árával.

Ezenkívül a változók és állandók időt takarítanak meg a szkriptek hibakeresése során. Ahelyett, hogy mindenhol ugyanazt a literált használná, hozzárendelheti egy változóhoz (vagy konstanshoz) a szkript elején, majd használhatja a változót (vagy konstanst) a literál helyett a szkript kódjának többi részében. Ha később döntenek az érték megváltoztatásáról, akkor nem több helyen kell módosítani a kódot, hanem csak egy helyen - ahol az értéket a változóhoz (vagy állandóhoz) rendelték.

Az állandók köre

A konstansokra ugyanazok a szabályok vonatkoznak, mint a let kulcsszóval deklarált változókra:

Állandó MAX = 5; // Globális állandó( const MAX = 10; // Konstans blokkolása console.log(MAX); // 10 ) console.log(MAX); // 5 foo(); // 15 console.log(MAX); // 5 függvény foo() ( const MAX = 15; // Helyi konstans console.log(MAX); )

Állandók és referenciatípusok

Ha egy állandóhoz referencia típusú értéket rendelünk, az értékre való hivatkozás megváltoztathatatlan, maga az érték pedig változtatható marad:

Const obj = (a: 5); obj.a = 10; console.log(obj.a); // 10

Ez konvenciók és szabályok összessége, amelyeket be kell tartani a JavaScript kód írásakor. Ez a megállapodás a Sun Corporation Java programozási nyelvre vonatkozó dokumentumain alapul. De mivel a JavaScript nem Java, a dokumentumot átírták a JavaScript nyelvhez képest.

Hosszú távú érték szoftver, közvetlenül függ a kód minőségétől. Fennállása során a program rengeteg fejlesztő kezén és szemén halad át. Ha a programkód úgy van megírva, hogy egyértelműen át tudja adni a szerkezetét és jellemzőit, akkor a törésének valószínűsége csökken, ha más fejlesztők vagy maga a szerző hosszabb idő után változtatásokat hajt végre rajta.

Megállapodások a programkód, segíthet javítani a kimeneti termékek minőségét és csökkenteni a termék meghibásodásának valószínűségét.

JavaScript fájlok

A JavaScript programokat .js fájlokban kell tárolni.

JavaScript kódot nem szabad beágyazni HTML fájlok, ha a kód nem egy munkamenetre vonatkozik. A HTML kód jelentősen megnöveli az oldal súlyát anélkül, hogy azt gyorsítótárazással és tömörítéssel csökkentené.

A címkéket lehetőség szerint a dokumentum végére kell helyezni. Ez csökkenti a késéseket a html oldalak betöltésekor.

Bemélyedések

A behúzás négy szóköz legyen. Ezért a kód írásához úgy kell beállítani a szerkesztőt, hogy a lapok pontosan ezt a mennyiséget tartalmazzák. Ennyi karakter használata befolyásolhatja a fájl méretét, de ez a probléma megoldható a fájl tömörítésével a termék használatba vétele előtt.

Vonal hossza

Kerülje a 80 karakternél hosszabb sorokat. Ha az utasítás nem fér el egy sorba, akkor át kell helyezni vagy ketté kell vágni. Sortöréskor a következő sort az elejétől 8 szóközzel kell behúzni.

A megállapodástól eltérően adott modern monitorokés felbontások esetén a sor hossza 120 karakterre növelhető. A modern kódszerkesztők kiemelik ezt a sort, például a NetBeans, a PHPStorm, és a hossza állítható.

Hozzászólások

Meg kell próbálni teljes mértékben leírni a kód összetett szakaszait. Azoknak a fejlesztőknek, akik megnézik a kódot, vagy egy idő után Önnek magának, meg kell érteniük, mit csinál ez a kód. A megjegyzéseknek jól megírtnak, világosnak, korrektnek kell lenniük, ha a megjegyzés nem elég teljes, vagy ami még rosszabb, hibás, ami félrevezetheti a fejlesztőt, ilyenkor jobb, ha egyáltalán nem írunk megjegyzést.

Ezenkívül a megjegyzések nem írhatnak le nyilvánvaló dolgokat, különben csak az olvasó idejét vesztegetik.

i = 0; // Állítsa i-t nullára.

Egy másik hasznos tulajdonságait megjegyzéseket tesz arra, hogy bizonyos szabályokban, például JSDoc-ban írva, kóddokumentáció létrehozására használhatók.

Változók deklarálása

Használat előtt minden változót deklarálni kell. A JavaScript nem igényel ilyen konstrukciókat, de sokkal könnyebben olvashatóvá teszi a programot, és megkönnyíti a nem deklarált változók észlelését, amelyeket az értelmező globálisnak feltételezhet. Soha nem szabad kikövetkeztetett, implicit globális változókat használni; az összes változót csak explicit módon, a var operátor használatával szabad deklarálni.

A var konstrukciónak első helyen kell lennie a függvénytörzsben.

Célszerű minden változót új sorban leírni, és megjegyzéssel kiegészíteni. Amikor csak lehetséges, a legjobb a változódeklarációkat ábécé sorrendben tartani.

Var currentEntry, // jelenleg kiválasztott tábla belépési szint, // behúzási szint mérete; // táblázat mérete

A JavaScript nem rendelkezik változó deklarációs blokkal, mint például a Pascal nyelveknél, de a kód rendjének fenntartása érdekében a legjobb, ha a változókat a függvény elején deklarálja.

A globális változók használatát minimálisra kell csökkenteni, és a globális változók implicit deklarációját egyáltalán nem szabad használni.

Funkciónyilatkozat

Minden függvényt deklarálni kell használat előtt. A belső függvények a var segítségével deklarálhatók. Ez segít tisztázni, hogy mely változók tartoznak a függvény hatókörébe.

A függvény neve és a paraméterlista nyitó zárójele között ne legyen szóköz. A funkciótest záró merevítője és göndör merevítője között térköznek kell lennie. Magát a függvénytestet négy szóközzel kell behúzni. Jobb merevítő magát a függvényt a függvénydeklarációt tartalmazó sorhoz kell igazítani.

Függvény külső(c, d) ( var e = c * d; függvény inner(a, b) ( return (e * a) + b; ) return inner(0, 1); )

Ha egy literális függvény névtelen, akkor szóköznek kell lennie a függvény szó és a paraméterlista nyitó zárójele között. Ha nincs szóköz, félreérthető, hogy a függvény neve függvény, ami hibának tűnhet a kód beolvasásakor.

Div.onclick = függvény (e) ( return false; ); that = ( metódus: függvény () ( return this.datum; ), dátum: 0 );

A globális függvények használatát is minimálisra kell csökkenteni.

Ha egy függvényt azonnal meg kell hívni, akkor azt zárójelek közé kell tenni. Egy ilyen függvény eredménye az lesz, amit a függvény visszaad, de nem magára a függvényre való hivatkozás.

Var gyűjtemény = (függvény () ( var keys = , értékek = ; return ( get: function (key) ( var at = keys.indexOf(key); ha (at >= 0) ( visszatérési értékek; ) ), set: function (kulcs, érték) ( var at = keys.indexOf(key); if (at = 0) ( keys.splice(at, 1); values.splice(at, 1); ) ) ); )()) ;

Nevek

A változók vagy függvények nevei 26 nagy és kis karakterből (A .. Z, a ... z), 10 számjegyből (0 .. 9) és egy aláhúzásból állhatnak. Jobb elkerülni a nemzetközi karakterek használatát, mert ezek olvasása és megértése nehézségeket okozhat. Ne használjon $ (dollárjel) vagy (fordított perjel) változók és függvények nevében.

Ne használja az aláhúzásjelet _ a név első karaktereként. Ezt a technikát néha helyi (privát) változók vagy függvények jelölésére használják, de valójában nem teszi ezeket a változókat priváttá. Ha a kódnak privát tagokat kell használnia, kerülje az adatok nyilvánosságra hozatalát.

A legtöbb változónak és függvénynek kisbetűvel kell kezdődnie.

Olyan konstruktor függvények, amelyek operátort használnak a munkához új nagybetűvel kell kezdődnie. JavaScript szkript összeállításakor vagy a kód harmadik féltől származó eszközökkel történő ellenőrzésekor figyelmeztetések jelennek meg, ha függvényeket vagy változóneveket konstrukció nélkül használnak. új. Operátort nem használó konstruktor függvény munkája új teljesen másként fog viselkedni, így az ilyen függvények nagybetűvel való írása bizonyos mértékig védelmet jelent a hibák ellen.

Az állandók vagy névterek jelentését hordozó globális változókat nagybetűvel kell írni, mivel a JavaScriptben nincsenek ilyen konstrukciók.

Operátorok Egyszerű operátorok

Minden sor legfeljebb egy utasítást tartalmazhat. Minden egyszerű állításnak pontosvesszővel (;) kell végződnie. Vegye figyelembe, hogy a hozzárendelési utasításnak, amelyhez a függvényliterál hozzá van rendelve, pontosvesszővel kell végződnie.

A JavaScriptben minden kifejezés operátor lesz. Ez elrejthet néhány hibát, ha ezek az utasítások pontosvesszőt használnak a végén. Például lehet szabályos húr pontosvesszővel a végén, ami nem okoz hibát és nem töri meg a szkriptet.

Összetett operátorok

Az összetett utasítások olyan utasítások, amelyek ()-ben (kapcsos zárójelben) tartalmazzák az egyéb utasítások listáját.

• Az összetett utasításokon belüli utasításokat négy szóközzel kell behúzni.
• ((bal kapcsos zárójel) annak a sornak a végén kell lennie, ahol az összetett utasítás kezdődik.
• ) (Jobb göndör merevítő) kell felhelyezni új sorés behúzva, hogy igazodjon az egyezést tartalmazó sor elejéhez ((bal kapcsos zárójel).
• Ahol lehetséges, göndör kapcsos zárójelet kell feltüntetni, ez a véletlen hibák elkerülése és a kód könnyebb olvashatósága érdekében szükséges.

Címkék

A címkék elérhetősége szünetÉs folytatni kódban csak konstrukciókban használható míg, számára, csináldÉs kapcsoló.

visszáru nyilatkozat

A return utasítás értékét soha nem szabad ()-be (zárójelbe) tenni. Az utasítás értékének ugyanabban a sorban kell kezdődnie, mint magának a return utasításnak, hogy elkerülje a pontosvessző véletlen beszúrását a kód értelmezésekor vagy tömörítésekor.

ha nyilatkozat

Az if konstrukciónak így kell kinéznie:

If (feltétel) ( utasítások ) if (feltétel) ( utasítások ) else ( utasítások ) if (feltétel) ( utasítások ) else if (feltétel) ( utasítások ) else ( utasítások )

nyilatkozathoz

A for utasításnak a következő szerkezettel kell rendelkeznie:

For (inicializálás; feltétel; frissítés) ( utasítások ) for (változó az objektumban) ( if (szűrő) ( utasítások ) )

A jelölés első formája adott számú iterációjú tömbök és hurkok kezelésére szolgál.

A második formát objektumokkal való munka során használjuk. Ne feledje, hogy az objektum prototípusához hozzáadott tagok szerepelni fognak a felsorolásban. Ehhez a hasOwnProperty metódussal ellenőrizni kell az objektum valódi tulajdonságait:

For (változó az objektumban) ( if (object.hasOwnProperty(variable)) ( utasítások ) )

míg nyilatkozat

A while konstrukciónak így kell kinéznie:

Míg (feltétel) ( nyilatkozatok )

do operátor

A do utasításnak így kell kinéznie:

Do ( állítások ) while (feltétel);

Más kimondott összetett állításokkal ellentétben ennek mindig véget kell érnie; (pontosvessző).

switch utasítás

A switch utasításnak így kell kinéznie:

Kapcsoló (kifejezés) ( eset kifejezés: utasítások alapértelmezett: utasítások )

Minden esetágnak ugyanabban a sorban kell lennie, mint egy switch utasításnak. Ezzel elkerülhető a túlzott bemélyedés.

Az alapértelmezés kivételével az eset-utasítások minden csoportjának a következővel kell végződnie: szünet, Visszatérés vagy dobás.

próbálkozzon kijelentéssel

A try utasításnak így kell kinéznie:

Try ( utasítások ) catch ( változó ) ( utasítások ) try ( utasítások ) catch ( változó ) ( utasítások ) végül ( utasítások )

Folytatás operátor

Kerülje a folytatási utasítás használatát. Ez az utasítás elrejti a függvény végrehajtási folyamatát.

A nyilatkozattal

A With operátort nem szabad használni.

Spaces

Az üres sorok javítják az olvashatóságot azáltal, hogy a kódot logikailag összekapcsolt szakaszokra osztják.

A szóközöket a következő esetekben kell használni:

• A kulcsszót, amelyet a ((bal zárójel) követ, szóközzel kell elválasztani
  míg (igaz) (
• Nem szabad szóközt tenni a függvény neve és a ((bal zárójel) közé az f() függvény konstrukcióban. Ez segít megkülönböztetni kulcsszavakatés a függvény meghívása.
• Minden bináris operátor, kivéve . (pontok), ((bal zárójel) és [ (bal zárójel) szóközzel kell elválasztani.
• Minden egyes; (pontosvessző) a for tagmondat vezérlő részében szóközzel kell elválasztani.
• Minden vesszőt szóköznek kell követnie.

Nagy projektekben nagyon nehéz mindezen konvenciókat figyelembe venni segédeszközök és kódszerkesztők használata nélkül. Ezért saját ellenőrzéséhez szükség van ilyen eszközök beszerzésére.

JSLint. Eszköz a JavaScript ellenőrzés kód

A JavaScript nyelv olyan értelmezett nyelv, amelynek nincs saját fordítója, az olyan nyelvekhez képest, mint a Java, C++, amely a projekt felépítésekor vagy indítás előtt ellenőrizné az írott kód minőségét, figyelembe véve a különböző árnyalatokat, mint pl. deklaráltként, de nem használt változók, nem optimalizált szakaszkódok, hiányzó pontosvesszők stb. Ezért hasznos lenne egy olyan eszköz, amely ellenőrzést végez, és rámutat a különböző hibákra a fejlesztőnek.

Az egyik ilyen eszköz a JSLint. A JSLint egy JavaScript nyelven írt program, amelynek célja a JavaScript programok problémáinak keresése.

Amikor a C még fiatal nyelv volt, számos gyakori programozási hiba volt, amelyeket a primitív fordítók nem kaptak el, ezért egy Lint nevű programot fejlesztettek ki, amely a forrásfájlban található hibákat keresi.

Amikor a nyelv elért egy bizonyos tökéletességi szintet, a fordítók elkezdték jobban ellenőrizni, és megfelelő üzeneteket adtak ki, ami után a lint programra már nem volt szükség.

A JavaScript egy fiatal nyelv. Eredetileg kisebb feladatok elvégzésére használták weboldalakon, amelyekhez a Java túl nehéz és nehézkes volt. Jelenleg JavaScript nyelv nagy szerepet játszik a weben, és nagy és összetett projektekben használják. A nyelven megvalósított szolgáltatások közül sok az egyszerűsítést szolgálta, de amikor a projektek nagyobbak és összetettebbek lesznek, aggodalomra ad okot az ilyen funkciókat illetően. Ezért a JavaScript programoknak olyan eszközre van szükségük, mint pl szösz.

JSLint svájcisapka forrás JavaScript és beolvassa. Ha hibát talál, egy üzenet jelenik meg a leírásával és a hozzávetőleges helyével forrás fájl. A probléma nem feltétlenül szintaktikai hiba, hanem stílusellenőrzéseket és a kódszerkezetnek való megfelelést is végrehajtják.

Globális változók

A legtöbb egy nagy probléma JavaScriptben ez az implicit módon deklarált globális változóktól való függés. Ha egy változó nincs deklarálva a var konstrukcióval, akkor JavaScriptben ez a változó globális lesz, mint az objektum tulajdonsága. ablak. Emiatt különféle típusú hibák fordulhatnak elő.

JSLint megköveteli, hogy minden változót és függvényt deklarálni lehessen használatuk vagy meghívásuk előtt. Ez lehetővé teszi a globális változók könnyű észlelését, és egyben bevált gyakorlat is, és megkönnyíti a program forráskódjának olvasását.

Néha egy fájl máshol definiált globális változóktól és függvényektől függ. Ehhez az ilyen változókat egy speciális /*global */ direktívában kell leírni, amely jelzi a JSLint számára, hogy más fájlokban is használatosak, és nem hibásak. A direktívában lévő változók nevek vesszővel elválasztott listája. Minden név kettőspontot tartalmazhat, amelyet igaz vagy hamis jelző követhet, jelezve, hogy a változót az adott fájlhoz szánták-e vagy sem.

Előfordulhat, hogy néhány globális változó már kezdetben definiálva van. Tételezzünk fel egy böngészőt, amikor előre meghatározzuk a böngésző által biztosított szabványos globális tulajdonságokat, mint pl dokumentumÉs addEventListener.

/*global clearInterval: false, clearTimeout: false, document: false, event: false, frames: false, history: false, Image: false, location: false, name: false, navigator: false, Option: false, szülő: false , képernyő: false, setInterval: false, setTimeout: false, ablak: false, XMLHttpRequest: false */

Beleértve a konzolt, a figyelmeztetést, olyan funkciókat, amelyek globálisan újradefiniálhatók, vagy bővíthetők, vagy amelyeket tanácsos elkerülni a végtermékben.

/*global alert: false, megerősítés: false, console: false, Debug: false, opera: false, prompt: false, WSH: false */

Pontosvessző

A JavaScript C-szerű szintaxist használ, amely pontosvessző használatát igényli az utasítások elválasztásához. A JavaScriptben nem szükséges pontosvesszőt elhelyezni az egyes utasítások végén, helyette használhat soremelést, és ez a kód működni fog a webböngészőben, de ez a megközelítés hibákhoz vezethet.

A JSLint elvárja, hogy minden utasítás véget érjen; (pontosvessző), a kivételek bizonyos helyzetekben csak az nyilatkozatokhoz, function, if, switch, try and while.

Vessző

A vessző operátor túl bonyolult kifejezésekhez vezethet, és elfedhet néhány programozási hibát is.

A JSLint elvárja, hogy a vesszőt határolóként használják, de utasításként nem (kivéve az utasítás inicializálását és növelését).

Láthatósági terület

Sok nyelven egy blokk határozza meg a hatókörét. Az ebben a blokkban deklarált változók nem láthatók azon kívül.

A JavaScriptben a blokkok nem határozzák meg a hatókört. A hatókör csak a függvényen belül van meghatározva. A függvényben meghatározott változó mindenhol látható lesz a függvényben. A JavaScript-blokkok hasonló szintaxisuk miatt megzavarhatják más nyelvek tapasztalt programozóit ebben a tekintetben, ami következésképpen hibákhoz vezethet.

A blokk hatókörű nyelvekben általában javasolt a változók deklarálása azon a helyen, ahol közvetlenül használatosak. De mivel a JavaScript nem rendelkezik blokk hatókörrel, helyes az összes változót a függvény tetején deklarálni. Funkciónként egy var operátor használata javasolt. Ez a javaslat letiltható az opció használatával vars.

Szükséges blokkok

A JSLint feltételezi, hogy az if, while, do és for utasítások zárójeleket tartalmaznak, függetlenül attól, hogy hány operátor van jelen ezekben a konstrukciókban.

A JavaScript a következő írásmódot teszi lehetővé:

if (feltétel) utasítás;

Ez a jelölési forma köztudottan hibákat vezet be a projektekbe. Ezért a JSLint a következő jelölés használatát javasolja:

Ha (feltétel) ( nyilatkozatok; )

A fejlesztők tapasztalatai azt mutatják, hogy ez a rögzítési forma hibaállóbb.

be

A for in ciklus egy objektum összes tulajdonságának felsorolására szolgál. De ennek a ciklusnak a segítségével is megtekinthető az összes tulajdonság, beleértve azokat is, amelyeket a prototípuson keresztül örököltek. Rosszul derül ki mellékhatás, amikor egy metódust tulajdonságként kapunk. Ha egy ilyen ciklust anélkül írnak le, hogy ennek a helyzetnek a tudatában lenne, akkor ez a kódszakasz hibát okozhat.

A ciklus törzsét egy if utasításba kell csomagolni, amely az objektum egy tulajdonságát teszteli, hogy kizárja a prototípus tulajdonságait, például:

For (név az objektumban) ( if (object.hasOwnProperty(name)) ( .... ) )

A legtöbb esetben ezt a kezelőt teljesen el kell kerülni. A legjobb, ha olyan módszerekre hagyatkozik, mint az Object.keys és az Array.prototype.forEach.

kapcsoló

A switch utasítások gyakori hibája, hogy elfelejti a törést az esetkonstrukció után elhelyezni. A JSLint elvárja, hogy minden esetkiírás szünettel, visszatéréssel vagy dobással végződjön. Minden esetkonstrukció sorba kerül egy switch utasítással.

var

A JavaScript lehetővé teszi, hogy a függvényen belül bárhol definiáljon var. A JSLint ebben az esetben szigorúbb az ilyen definíciókkal kapcsolatban.

A JSLint elvárja, hogy a var konstrukciót csak egyszer és használat előtt deklarálják.

A JSLint nem javasolja a zárójelben lévő var használatát, mert nincs saját hatókörük.

val vel

Ez a konstrukció eredetileg a mélyen beágyazott objektumok tulajdonságaihoz való parancsikon elérését szolgálta. Ennek a konstrukciónak a használata zavarhoz vezethet a változók és a tulajdonságok használata között, ami kiszámíthatatlan programviselkedést eredményezhet. Ezért jobb, ha soha nem használja ezt az operátort.

== és!=

ÉS != operátorok típusátadást hajtanak végre az összehasonlítás előtt. Rossz, mert különféle kivitelek, például a " trn" == 0 igaz lesz. Ez elfedheti a hibákat. A JSLint nem tudja megbízhatóan meghatározni, hogy az == használata jelenleg indokolt-e, ezért mindig jobb, ha implicit típusöntés nélküli összehasonlításokat használunk, nevezetesen a === és a !==.

Az eqeq opció használatával letilthatja ennek az operátornak az ellenőrzését.

++ és --

A JSLint ellenzi ezen operátorok használatát. Az opció használatával engedélyezheti a használatukat plusz plusz.

Bitműveletek

A JavaScriptnek nincs egész típusa, de vannak bitenkénti operátorai. A bitenkénti operátorok a lebegőpontos operandusokat egész számokká alakítják, és fordítva, így nem olyan hatékonyak, mint a C vagy más nyelveken. Ritkán hasznosak böngészőalkalmazásokban. Hasonlóságok a logikai operátorok elfedhet néhány programozási hibát. A bitenkénti opció lehetővé teszi ezen operátorok használatát.

Eval gonosz

Az eval függvény (és rokonai, a setTimeout és setInterval) hozzáférést biztosít a JavaScript fordítóhoz. Ez néha szükséges, de legtöbbször nagyon rossz programozási stílusra utal. Az eval függvény a JavaScript leggyakrabban visszaélt funkciója.

Konstruktorok és új

A konstruktorok olyan függvények, amelyeket az új operátorral együtt kell használni. Ez az előtag egy új objektumot hoz létre a függvény prototípusa alapján, és társítja ezt a függvényobjektumot a hozzárendelt változóhoz. Ha figyelmen kívül hagyja az új operátor használatát a konstruktor függvényhez, a visszaadott eredmény nem lesz pontosan a várt eredmény.

A JSLint egy konvenciót biztosít, amely szerint a függvénykonstruktoroknak olyan nevekkel kell rendelkezniük, amelyek első betűje lesz nagybetűs, ellenkező esetben az érvényesítési hibának minősül, ha ezt a függvényt az új operátorral hívjuk meg.

Az új operátor használata olyan objektumokkal, mint a szám, karakterlánc, logikai érték, hibának minősül az ellenőrzés során.

Egy ilyen új objektumkonstrukció ellenőrzésekor a JSLint azt feltételezi, hogy az hibás, és jobb a - () rövidített jelölést használni.

Lehetőségek

A JSLint számos lehetőséget kínál a működésének szabályozására. A JSLint webalkalmazásokban a beállításokat jelölőnégyzetekkel és két mezővel lehet kiválasztani.

Amikor a JSLint függvényként hívják meg, egy paramétert vesz igénybe – egy opciós objektumot, amely lehetővé teszi a JavaScript egy elfogadható részhalmazának megadását. Egy weboldalon a JSLint http://www.JSLint.com verziója ezt automatikusan megteszi.

Az opciók egy szkriptben is beállíthatók a /*JSLint*/ direktívával:

/*jslint nomen: igaz, hibakeresés: igaz, gonosz: hamis, vars: igaz */

Leírás	választási lehetőség	Jelentése
Tűrje a hozzárendelési kifejezéseket	szamár	igaz, ha a hozzárendelést az utasításpozíción kívül kell engedélyezni.
A bitoperátorok figyelmen kívül hagyása	bitenként	igaz, ha a bitenkénti operátorokat nem kell tesztelni
Böngészőfunkciók engedélyezése	böngésző	igaz, a böngésző szabványos globális változóit veszik figyelembe
Google Closure Idioms engedélyezése	bezárás	igaz, ha a Google Close megjegyzéseket engedélyezni kell
Folytatás engedélyezése	folytatni	igaz, így a countinu használatát figyelmen kívül hagyjuk
CouchDB javaslat	kanapé	igaz, ha azt szeretné, hogy a CouchDB függvények globálisnak legyenek tekintve
Hibakeresés engedélyezése	hibakeresés	igaz, ha a debug utasítást engedélyezni kell
Konzol engedélyezése, riasztás	fejleszteni	igaz, ha a böngésző opció nincs beállítva, és ezeket az operátorokat engedélyezni kell
== és != engedélyezése	eqeq	igaz, ha az == és != operátorokat engedélyezni kell
Engedélyezze az eval	gonosz	igaz, ha az eval megengedhető
Szóközök és behúzás	behúzás	A behúzáshoz használt szóközök száma (alapértelmezett 4)
A hibák maximális száma	maxerr	Figyelmeztetések maximális száma egy vizsgálati jelentéshez (alapértelmezett 50)
Maximális vonalhossz	maxlen	Maximális karakterszám soronként
Nagybetűk használata a szó elején a konstruktor nevében	újsapka	igaz, ha a konstruktor függvénynevek első betűire van szükség
Tekintsük a Node.js-t	csomópont	igaz, ha a Node.js-nek figyelembe kell vennie a globális változókat
A kötőjel _ engedélyezése az azonosítókban	nomen	igaz, ha az ilyen változókat nem szabad megengedni
Megállás az első hibánál	passfail	igaz, ha a szkennelés az első hiba hatására leáll
++ és -- engedélyezése	plusz plusz	igaz, ha a ++ vagy -- használatát engedélyezni kell
Engedélyezze a hiányzó „use strict” parancsot a függvény elején	lucskos	igaz, így a "use szigorú" sor beillesztése nem kötelező
A TODO megjegyzéseinek engedélyezése	csinálni	igaz, hogy ne reagáljak a TODO kommentekre
Nem használt paraméterek engedélyezése	unparam	igaz, ne mutasson figyelmeztetést a nem használt paraméterekre
Több változó engedélyezése egy függvényben	vars	igaz, a var többszöri használatára egy függvényben
Piszkos szóköz engedélyezése	fehér	igaz, hogy figyelmen kívül hagyja a piszkos helyeket