Príklady chýb js globálnych premenných. JavaScript. Premenné (globálne, lokálne, konštanty). Vlastnosti globálnych objektov

Globálne premenné v javascripte

Čo sú to globálne premenné: premenné, ktoré sú „viditeľné“ v ktoromkoľvek bode vykonávania programu a dajú sa všade čítať a prepisovať.
Globálne premenné sú zvyčajne definované na samom začiatku programu, mimo akýchkoľvek blokov (())
v prípade Js sa nastavujú za skriptom, prípadne všelijakými funkciami

ahoj = "ahoj"; //nastavíme globálnu premennú a skontrolujeme ju
document.writeln("->1 "+ ahoj +" každý jeden
");//->1 Ahojte všetci

Ak pravda)
//ak (nepravda)
{
var hello = "Ahoj Dolly a "; //toto je tiež globálne
svet = "svet"; //globálne
var cont = ", pokračujeme" //global
document.writeln("->1.2 " + ahoj + svet + pokr.+"
");
//1.
}
document.writeln("->2 " + ahoj + svet + pokr.+"
");
//->2 Ahoj Dolly a svet, pokračujeme

Ak je to pravda, dostaneme odpoveď

->1 Zdravím všetkých
->1.2 Ahoj Dolly a svet, pokračujeme
->2 Ahoj Dolly a svet, pokračujeme

Vykonanie sa preruší

Ukazuje sa teda, že použitie var nemá žiadny vplyv na globálny rozsah. Premenná uvedená v skripte mimo procedúr sa považuje za globálnu, aj keď je uzavretá v zátvorkách () v if while pre blok a ostatné oblasti zostanú globálne aj vo vnútri slučiek

Závery, stručne

* pre premenné používané v zóne globálnej viditeľnosti nie je prítomnosť varu dôležitá.
* Bloky po ak, kým pre nevytvoria lokálny rozsah (ako sa to stáva v iných jazykoch)

Lokálne premenné sú premenné definované vo vnútri spustiteľného bloku (funkcie) a neovplyvňujú ostatné funkcie. a vonkajšie prostredie, t.j. globálnej oblasti.

Chlapec = "Jhone";
did = "zabije Kennyho"; //takže máme 2 globálne premenné
funkcia doit()
{
//print už prešiel --1 a zmeníme údaje a zmeníme údaje
var chlapec = "Gary"; //vytvor miestne nastavenie
did = "pomáha Anny"; //zmena global
;
document.writeln("--2 " + chlapec + " " + urobil + "
");
//--2 Gary pomáha Anny
;
//teraz vnútri funkcie nastavíme lokálne a globálne premenné
var good = „bol to dobrý chlapec
";//miestne nastavenie!
zlý = „má rád zlé dievčatá
";//globálne
}
;
document.writeln("--1 " + chlapec + " " + urobil + "
");
//--1 Jhone zabije Kennyho
urob to();
//--2 Gary pomáha Anny
document.writeln("--3 " + chlapec + " " + urobil + "
");
//--3 Jhone pomáha Anny
;
Ak pravda)
//ak(!false)
{
document.writeln("--4 " + dobre);
//vykonanie tohto bloku spôsobí chybu.
//teraz sme mimo miestneho rozsahu
//doit() funkcia, ktorá nám bola poskytnutá cez var
//premenná dobro jednoducho neexistuje
}
document.writeln("--5 " + zle);
//--5 má rád zlé dievčatá

výsledok:

1 Jhone zabije Kennyho
--2 Gary pomáha Anny
--3 Jhone pomáha Anny
--5 má rád zlé dievča

Lokálne premenné v javascripte

* var funguje vo funkcii a deklaruje lokálnu premennú. Toto je jeho hlavná úloha

* Javascript je veľmi odlišný od jazyka C v tom, že vo funkcii sú možné iba (?) lokálne premenné.
* či použiť alebo nepoužiť var v globálnom rozsahu závisí len od vašich osobných skúseností. Ale pre mňa je lepšie nebyť lenivý. v Perle sa to nazýva use strict

>>>pre premenné používané v globálnej zóne viditeľnosti nie je prítomnosť varu dôležitá

Dôležité. Po prvé, „vars“ nemožno vymazať (pomocou delete). Po druhé, ich inštancia nastáva na „nulovom riadku“ (pred začatím práce „riadok po riadku“), kde sa im okamžite priradí nedefinovaná hodnota a až potom môže (alebo nemusí) premenná dostať novú hodnotu:

Var glb_1 = 1;
if (false) (var glb_2 = 2; glb_3 = 3;)

Alert(glb_1) // vytvorila sa inštancia a dostala hodnotu 1
alert(glb_2) // zadané a prijaté hodnoty 'undefined'
alert(glb_3) // vôbec nejde o premennú (bez var), chyba pri prístupe

JavaScript má tri rozsahy: globálny, funkčný a blokový. Variabilný rozsah je oblasť zdrojového kódu programu, v ktorej sú viditeľné a môžu byť použité premenné a funkcie. Globálny rozsah sa tiež nazýva kód najvyššej úrovne.

Globálne premenné

Premenná deklarovaná mimo funkcie alebo bloku sa nazýva globálna. Globálna premenná je dostupná kdekoľvek v zdrojovom kóde:

Var num = 5; funkcia foo() ( console.log(num); ) foo(); // 5 console.log(num); // 5 ( console.log(num); // 5 )

Lokálne premenné

Premenná deklarovaná vo funkcii sa nazýva lokálna. Lokálna premenná je prístupná kdekoľvek v tele funkcie, v ktorej bola deklarovaná. Lokálna premenná sa vytvorí znova pri každom volaní funkcie a zničí sa pri jej ukončení (keď sa funkcia dokončí):

Funkcia foo() ( var num = 5; console.log(num); ) foo(); // 5 console.log(typeof num); //nedefinované

Lokálna premenná má prednosť pred globálnou premennou s rovnakým názvom, čo znamená, že vo funkcii sa použije lokálna premenná namiesto globálnej:

Var x = "globálne"; // Funkcia globálnej premennej checkscope() ( var x = "local"; // Lokálna premenná s rovnakým názvom ako globálna document.write(x); // Použite lokálnu premennú, nie globálnu) checkscope() ; // => "local" Skúste »

Blokové premenné

Premenná deklarovaná vo vnútri bloku pomocou kľúčového slova let sa nazýva bloková premenná. Bloková premenná je dostupná kdekoľvek v bloku, v ktorom bola deklarovaná:

Nech num = 0; ( nech num = 5; console.log(num); // 5 ( nech num = 10; console.log(num); // 10 ) console.log(num); // 5 ) console.log(num) ; // 0

Opätovné oznámenie

Ak použijete kľúčové slovo var na opätovné deklarovanie premennej s rovnakým názvom (v rovnakom rozsahu), nič sa nestane:

Var a = 10; var a; console.log(a); // 10

Ak je opätovná deklarácia sprevádzaná inicializáciou, potom takýto príkaz funguje ako normálne priradenie novej hodnoty:

Var a = 10; var a = 5; // Rovnaké ako a = 5; console.log(a); // 5

Ak použijete kľúčové slovo let na opätovné deklarovanie premennej s rovnakým názvom (v rovnakom rozsahu), zobrazí sa chyba:

Var a = 10; nech a; // Chyba.

Rozsahová reťaz

Zvážte nasledujúci príklad:

Var num = 5; function foo() ( var num2 = 10; function bar() ( var num3 = 15; ) )

Tento kód má tri rozsahy: globálny, rozsah funkcie foo() a rozsah funkcie bar(). Globálny rozsah definuje premennú num a funkciu foo() . Rozsah funkcie foo() definuje premennú num2 a funkciu bar() a je v nej dostupná aj premenná num z globálneho rozsahu. Rozsah funkcie bar() obsahuje jednu premennú, num3, ktorá je dostupná iba v rámci funkcie bar(). Rozsah funkcie bar() má tiež prístup k premenným z ostatných dvoch rozsahov, pretože sú jej rodičmi. Reťazec rozsahu pre tento príklad je znázornený na obrázku nižšie:

Na obrázku sú rôzne oblasti viditeľnosti znázornené obdĺžnikmi rôznych farieb. Vnútorný rozsah v reťazci rozsahov má prístup ku všetkému z vonkajších rozsahov, ale vonkajšie rozsahy nemajú prístup k ničomu z vnútorných rozsahov.

Reťaz ďalekohľadu je objednaná. Tlmočník hľadá identifikátory v reťazci rozsahu smerom von, nie dovnútra. To znamená, že vyhľadávanie názvu začína od rozsahu, v ktorom sa pristupovalo k identifikátoru. Ak sa nájde názov ID, vyhľadávanie sa zastaví. Ak meno nemožno nájsť v aktuálnom rozsahu, vykoná sa vyhľadávanie v ďalšom (vonkajšom) rozsahu atď. Použije sa teda identifikátor z rozsahu, v ktorom bolo nájdené. Ak sa identifikátor nenájde v žiadnom z rozsahov, JavaScript vygeneruje chybu:

Var str = "globálne"; var num = 5; function foo() ( var str = "local"; // Použitie lokálnej premennej str num = 10; // Použitie globálnej premennej num // alert(x); // Chyba. Premenná x nie je v žiadnom rozsahu ) foo( ) ; alert(str); // "global" alert(num); // 10

Ak priradíte hodnotu nedeklarovanej premennej v tele funkcie, potom v čase volania funkcie, ak v globálnom rozsahu nie je žiadna premenná s rovnakým názvom, sa vytvorí nová globálna premenná:

Funkcia foo() ( num = 2; ) foo(); // Vytvorila sa nová globálna premenná num alert(num); // 2

Nárast reklám

V JavaScripte sú deklarované premenné dostupné kdekoľvek vzhľadom na ich rozsah, čo znamená, že premenné sú viditeľné ešte predtým, ako sú deklarované v kóde. Táto vlastnosť JavaScriptu sa neformálne nazýva zdvíhanie: programový kód sa správa tak, ako keby boli deklarácie premenných implicitne zdvihnuté (bez inicializácie) na úplný vrchol svojho rozsahu.

Zvážte nasledujúci útržok kódu:

Var str = "globálne"; function foo() ( alert(str); // nedefinované var str = "local"; alert(str); // "local" ) foo();

Pri pohľade na kód by ste si mysleli, že prvé upozornenie by malo vypísať reťazec „globálny“, pretože deklarácia lokálnej premennej str ešte nebola vykonaná. V skutočnosti však vypíše hodnotu undefined . Zvýšením deklarácií je funkcia vyššie ekvivalentná s implementáciou nižšie, v ktorej je deklarácia premennej zvýšená na začiatok funkcie:

Funkcia foo() ( var str; // Deklarácia lokálnej premennej na začiatku funkcie alert(str); // Tu je dostupná, ale neinicializovaná str = "local"; // Tu je inicializovaná výstraha( str); // A tu má očakávanú hodnotu - "local")

To isté platí pre globálny rozsah, premenná deklarovaná v dolnej časti je prístupná v hornej časti:

Alert(num); // nedefinované var num = 10; alert(num); // 10

Premenné a konštanty v JavaScripte. Deklarovanie premenných a priraďovanie hodnôt k nim. Globálne a lokálne premenné. Použitie konštánt

Deklarovanie premenných v JavaScripte

Názvy premenných v JavaScripte môžu pozostávať z písmen, číslic, znaku $ a znaku _ a názov premennej nemôže začínať číslom. Majte na pamäti, že JavaScript rozlišuje veľké a malé písmená a premenné a1 a A1 sú rôzne premenné. Neodporúča sa používať azbuku, aj keď je to možné.
Premenné v JavaScripte sú deklarované pomocou kľúčového slova var:

Var Peremennaya_1 var Peremennaya_2

Neodporúča sa používať premenné v JavaScripte bez deklarácie. Je to možné, ale môže to viesť k chybám.

Priradenie hodnôt k premenným

Priradenie hodnoty deklarovaným premenným v JavaScripte:

Peremennaya_1 = 25 Peremennaya_2 = "Priradený text je uzavretý v rovných úvodzovkách"

Hodnotu môžete premenným priradiť hneď po deklarácii:

Var Peremennaya_1 = 25 var Peremennaya_2 = "Priradený text je uzavretý v rovných úvodzovkách"

Hodnota premennej v JavaScripte sa môže počas vykonávania programu meniť. Pri písaní textu do premennej musí byť táto vložená do rovných úvodzoviek.

Lokálne a globálne premenné

Ak je premenná deklarovaná vo funkcii, potom je lokálna a bude prístupná (viditeľná) iba v rámci tejto funkcie. Keď sa funkcia ukončí, lokálne premenné v JavaScripte sa zničia, takže premenné s rovnakým názvom môžete použiť v rôznych funkciách.

Ak je premenná deklarovaná mimo funkcií, potom je globálna a bude dostupná (viditeľná) vo všetkých funkciách na stránke. Pri zatvorení stránky sa v JavaScripte zničia globálne premenné.

Konštanty v JavaScripte

Konštanty sú navrhnuté tak, aby uľahčili prácu s kódom, keď potrebujete použiť opakované hodnoty alebo výrazy. Hodnotu konštanty stačí nastaviť raz a vložením do kódu svojich programov ju môžete používať akokoľvek. JavaScript nemá kľúčové slovo na deklarovanie konštánt, namiesto konštánt sa používajú bežné premenné. Na odlíšenie konštánt od premenných sa zvyčajne označujú veľkými písmenami a v prípade potreby sa používajú podčiarknutie:

Var DRUG_CHELOVEKA = "Pes"

Uvedený príklad konštanty nie je úplne úplný, pretože slovo „Pes“ je už ľahko zapamätateľné a vložené tam, kde je to potrebné. Konštanty v JavaScripte môžete použiť na zaznamenávanie a vkladanie zložitejších hodnôt, ako sú ťažko zapamätateľné kódy, znakové sady, dlhý text, webové adresy, e-mailové adresy, telefónne čísla a rôzne kurzy.

V JavaScripte môžu byť konštanty prepísané ako premenné, ale ak to urobíte, význam konštánt sa stratí.

Posledná aktualizácia: 04/05/2018

Všetky premenné v JavaScripte majú špecifický rozsah, v rámci ktorého môžu pôsobiť.

Globálne premenné

Všetky premenné, ktoré sú deklarované mimo funkcií, sú globálne:

var x = 5; nech d = 8; function displaySquare())( var z = x * x; console.log(z); )

Tu sú premenné x a d globálne. Sú dostupné odkiaľkoľvek v programe.

Ale premenná z nie je globálna, pretože je definovaná vo funkcii.

Lokálne premenné

Premenná definovaná vo funkcii je lokálna:

Funkcia displaySquare())( var z = 10; console.log(z); nech b = 8; console.log(b); )

Premenné z a b sú lokálne, existujú len v rámci funkcie. Nemožno ich použiť mimo funkcie:

Funkcia displaySquare())( var z = 10; console.log(z); ) console.log(z); //chyba, pretože z nie je definované

Keď funkcia skončí svoju prácu, všetky premenné definované vo funkcii sa zničia.

Skrytie premenných

Čo ak máme dve premenné – jednu globálnu a druhú lokálnu – ktoré majú rovnaký názov:

Var z = 89; function displaySquare())( var z = 10; console.log(z); // 10 ) displaySquare(); // 10

V tomto prípade funkcia použije premennú z, ktorá je definovaná priamo vo funkcii. To znamená, že lokálna premenná skryje globálnu.

var alebo let

Pri použití príkazu let každý blok kódu definuje nový rozsah, v ktorom premenná existuje. Napríklad môžeme definovať premennú na úrovni bloku a na úrovni funkcie súčasne:

Nech z = 10; function displayZ())( nech z = 20; ( nech z = 30; console.log("Blok:", z); ) console.log("Function:", z); ) displayZ(); console.log("Globálne:", z);

Tu, vo vnútri funkcie displayZ, je definovaný blok kódu, v ktorom je definovaná premenná z. Skryje globálnu premennú a premennú z definovanú na úrovni funkcie. V skutočnom programe môže blok predstavovať vnorenú funkciu, blok cyklu for alebo konštrukciu if. Ale v každom prípade takýto blok definuje nový rozsah, mimo ktorého premenná neexistuje.

A v tomto prípade dostaneme nasledujúci výstup konzoly:

Blok: 30 Funkcia: 20 Globálne: 10

Pomocou operátora var nemôžeme definovať premennú s rovnakým názvom vo funkcii aj v bloku kódu v rámci tejto funkcie:

Funkcia displaySquare())( var z = 20; ( var z = 30; // Chyba! Premenná z je už definovaná console.log("Block:", z); ) console.log("Function:", z) ;)

To znamená, že pomocou var môžeme definovať premennú s jedným názvom buď na úrovni funkcie alebo na úrovni bloku kódu.

Konštanty

Všetko, čo platí pre operátor let, platí aj pre operátor const, ktorý umožňuje definovať konštanty. Bloky kódu definujú rozsah konštánt a konštanty definované na vnorených blokoch kódu skrývajú externé konštanty s rovnakým názvom:

Const z = 10; function displayZ())( const z = 20; ( const z = 30; console.log("Blok:", z); // 30 ) console.log("Function:", z); // 20 ) displayZ ( ); console.log("Globálne:", z); // 10

Nedeklarované premenné

Ak toto kľúčové slovo nepoužijeme pri definovaní premennej vo funkcii, potom bude takáto premenná globálna. Napríklad:

Funkcia bar())( foo = "25"; ) bar(); console.log(foo); // 25

Aj keď premenná foo nie je definovaná nikde mimo funkcie bar, napriek tomu je dostupná mimo funkcie v externom kontexte.

Iné by to bolo, keby sme premennej nielen priradili hodnotu, ale ju aj definovali:

Funkcia bar())( var foo = "25"; ) bar(); console.log(foo); // chyba

prísny režim

Definovanie globálnych premenných vo funkciách môže viesť k potenciálnym chybám. Ak sa im chcete vyhnúť, použite prísny režim:

"používať prísne"; function bar())( foo = "25"; ) bar(); console.log(foo);

V tomto prípade dostaneme chybu SyntaxError: Unexpected identifier, ktorá indikuje, že premenná foo nie je definovaná.

Existujú dva spôsoby, ako nastaviť prísny režim:

pridajte výraz „použiť prísne“ na začiatok kódu JavaScript, potom sa na celý kód použije prísny režim

na začiatok tela funkcie pridajte výraz „použiť prísne“, potom sa prísny režim použije iba na túto funkciu

Dobrý deň, fanúšikovia JavaScriptu a moji verní odberatelia. V dnešnom príspevku vám podrobne poviem, ako sa v JavaScripte vytvárajú globálne a lokálne premenné. Určite zadefinujem dôležité pojmy, porozprávam o vlastnostiach deklarovania a inicializácie premenných, popíšem, čo je rozsah a ako v ňom fungujú vytvorené prvky.

To všetko platí pre tie najzákladnejšie, základné znalosti jazyka. Bez toho, aby ste tomu všetkému porozumeli, nebudete schopní napredovať a rozvíjať svoje zručnosti v programovaní js. Kľúčové pojmy sa vám navyše budú hodiť nielen v tejto špecializácii, ale aj v IT oblasti všeobecne. Nuž, začnime!

Čo je to premenná a ako sa vytvára?

Premenná je prvok programovacieho jazyka, pre ktorý je pridelená pamäťová oblasť a v ktorej sú uložené určité hodnoty.

Môže existovať veľké množstvo premenných a všetky musia mať jedinečný názov.

Existujú dva typy premenných: globálne a lokálne. Ich rozdiel spočíva len v rôznom rozsahu premenných. Globálne prvky sú teda viditeľné v celom kóde a lokálne prvky sú viditeľné iba v malej oblasti, kde boli deklarované.

Mimochodom, skúste pomenovať prvky logickými a zrozumiteľnými názvami už od prvého dňa, od vášho prvého kódu. Pretože neskôr, keď budete pracovať s ťažkými programami, po určitom čase si nebudete pamätať, čo znamená napríklad „aa1“ alebo „perem3“.

A z názvu nie je jasné absolútne nič! To nie je také zlé, koniec koncov, nie je také ťažké porozumieť svojim vlastným spisom. Čo urobíte, ak dostanete za úlohu dokončiť úlohy v inom programe, o ktorom ste nikdy predtým ani nepočuli? Pri takýchto názvoch vám analýza implementácie softvéru zabije veľa užitočného času.

Prečítal som si zápis, teraz sa vráťme k deklarovaniu premenných.

Ak chcete vytvoriť premennú, musíte najskôr napísať kľúčové slovo var a potom samotný názov. Takto to vyzerá:

var text = "Dobrý deň, používateľ!"

Potom sa k textu pristupuje bez „var“:

text = "Nový text."

V tomto prípade bude hodnota prepísaná.

Pre lepšie pochopenie zvážte príklad, v ktorom je vytvorená jedna premenná. Prejdeme k jeho významu pred a po prepísaní.

1 2 3 4

var text = “Dobrý deň, používateľ!”; upozornenie(text); // vypíše „Ahoj, používateľ!“ text= “Nový text!”; upozornenie(text); // vypíše „Nový text!“

var text = “Dobrý deň, používateľ!”; upozornenie(text); // vypíše „Ahoj, používateľ!“ text= “Nový text!”; upozornenie(text); // vypíše „Nový text!“

Vlastnosti globálnych objektov

Všetky vytvorené objekty v kóde js sú rozdelené na globálne a lokálne. Vyššie som vysvetlil, aký je medzi nimi rozdiel. Teraz sa pozrime bližšie na globálne objekty.

Sú to všetky funkcie a premenné, ktoré sú deklarované v hlavnom tele kódu, t.j. nie v rámci žiadnych funkcií. Všetky sa v js automaticky stávajú vlastnosťami globálneho objektu, ktorý je v prehliadačoch prehľadne dostupný pod oknom slova. Pozrime sa na príklad.

var cena = 145; // vytvorenie globálnej premennej

upozornenie(okno.cena); // odpoveď: 145

Zatiaľ je všetko jednoduché, ale buďte pripravení na nástrahy. Niekedy bez toho, aby ste poznali špecifiká ukladania a prepisovania hodnôt premenných, môžete prepísať veľmi dôležité parametre. Takéto chyby je dosť ťažké vystopovať a nie je možné ich nájsť pomocou kompilátorov. Preto pozorne analyzujte nasledujúci materiál.

Úskalia a rozsah

Pre lepšie pochopenie problému najskôr ukážem malý program, kde vo funkcii vytvorím lokálnu premennú a potom mimo jej hraníc – globálnu.

test funkcie() ( p = 2; return p; ) alert(p); // nedefinované p = “dôležitý text”; upozornenie(p); // zobrazí „dôležitý text“ test(); // vyvolanie funkcie alert(p); // vytlačí 2

Najprv som v testovacej funkcii inicializoval lokálnu premennú s hodnotou 2 a potom som vytvoril globálnu textovú premennú, ktorá ukladá niektoré dôležité údaje.

A tu sa objaví „podvodný blok“.

Jednak vďaka tomu, že som použil vytváranie prvkov podľa pravidiel zastaraného JavaScriptového štandardu, všetky “p” premenné boli vytvorené až v čase priradenia (pri použití direktívy var sa premenné vytvárajú okamžite s hodnotou nedefinované a počas inicializácie cez „= » sa hodnota prepíše).

Po druhé, v tomto prípade na priradenie hodnoty implicitne vytvoreným prvkom v js sa použije existujúca alebo sa vytvorí nová globálna premenná. Preto sa vo vyššie uvedenom príklade po zavolaní testovacej funkcie stratila hodnota globálneho „p“.

Aby ste predišli zlyhaniam, vždy používajte kľúčové slovo var. Potom budú všetky objekty explicitne deklarované a budú vytvorené nové.

Tu je opravený príklad:

test funkcie () ( var p = 2; výstraha (p); návrat p; ) výstraha (p); // nedefinované var p = "dôležitý text"; upozornenie(p); // zobrazí „dôležitý text“ test(); // zavolá funkciu, v tomto prípade zobrazí 2 alert(p); // zobrazí "dôležitý text"

Teraz kód funguje správne. Ako ste si všimli, rozsah lokálneho „p“ je v rámci testovacej funkcie a globálny je vo zvyšku kódu.

Pár slov o konštantách

Ako všetky ostatné programovacie jazyky, aj JavaScript má konštanty. Pre tých, ktorí nevedia čo to je, pripájam definíciu.

Konštanta je typ premennej, ktorej hodnota zostáva nezmenená.

Podľa pravidiel syntaxe v js sa ich názov vždy píše malými (veľkými) písmenami. Napríklad,

var MAIN_COLOR = “#fff”

V skriptovacom jazyku nie sú žiadne technické vlastnosti, ktoré by z konštanty urobili skutočnú konštantu. V skutočnosti sú to obyčajné premenné, ktoré sa dajú prepísať. Podľa pravidiel však vývojári používajú tieto prvky s veľkými písmenami v názve ako konštanty a nemenia ich význam pri písaní kódu.

Hlavným účelom konštánt je ukladanie zložitých reťazcov, dôležitých čísel alebo iných hodnôt, v ktorých pri prepisovaní je ľahké urobiť preklep alebo by sa nemali nikdy meniť, prípadne zjednodušiť kód. Napríklad konštanty možno použiť na ukladanie často sa opakujúcich požiadaviek