Weblap Hová jutunk?

JavaScript deklarálás. 101

Állandókat és változókat be kell vezetni, azaz deklarálni kell.

Változók létrehozását JavaScriptben, változó deklarálásának nevezzük.

Álandókat változókat egyedi nevekkel, úgynevezett azonosítókkal, azonosítjuk.
Álandó: Ha változó értéke nem változik, azaz fix értéket képvisel, vagy konstans meghatározással vezetjük be.
Változó értékének szöveget írunk, akkor kifejezésnek hívjuk.
Az "a", nevezzük változónak.
Változó deklarálásakor (bevezetéskor) a változónév van elől és egyenlőségjel ( = ) után írjuk az értéket.
Példa: var a=2; vagy var a="alma";
Műveleti jeleknél, változó bármelyik oldalon állhat.
A következő két példa ugyan azt jelenti: if(a == 2) vagy if(2 == a)

A kódblokkok lehetővé teszik, hogy több utasítást egyetlen egységként kezeljünk.
Egy JavaScript függvény törzse, mindig egy kódblokkon belül { ... } helyezkedik el.
A JavaScript blokk (block statement) kapcsos zárójelekkel { ... } csoportosított utasítások összessége,
amely vezérli a kód végrehajtását és meghatározza a let/const változók hatókörét.
Főleg vezérlési szerkezeteknél (if, for, while) használják a kódblokkok együttes futtatására,
elszigetelve a benne deklarált változókat a globális hatóköröktől.

A deklarálás (bevezetés, létrehozás) feltételei.

var kulcsszóval
"a" azonosító néven
deklarált változó.
var a=5;

var kulcsszóval újra deklarálható "a" azonosító néven, azaz, ismét létrehozható.
let kulcsszóval nem deklarálható újra "a" azonosító néven.
const kulcsszóval nem deklarálható újra "a" azonosító néven.

Kivétel:
kódblokkon belül { ... }
let vagy conts kulcsszóval, újra deklarálható "a" azonosító néven.

let kulcsszóval
"b" azonosító néven
deklarált változó.
let b=5;

let kulcsszóval nem deklarálható újra "b" azonosító néven, a már létező
let b=5; változó értékét, újra módosíthatjuk. Például így: b=10;
var kulcsszóval nem deklarálható újra "b" azonosító néven.
const kulcsszóval nem deklarálható újra "b" azonosító néven.

Kivétel:
kódblokkon belül { ... }
let vagy var vagy const kulcsszóval, újra deklarálható "b" azonosító néven.

const kulcsszóval
"c" azonosító néven
deklarált változó.
const c=5;

const kulcsszóval nem deklarálható újra "c" azonosító néven, és a már létező
const c=5; változó értékét, nem módosíthatjuk újra. Például így: c=10;
let kulcsszóval nem deklarálható újra "c" azonosító néven.
var kulcsszóval nem deklarálható újra "c" azonosító néven.

Kivétel:
kódblokkon belül { ... }
const vagy, let vagy, var kulcsszóval, újra deklarálható "c" azonosító néven.


Megjegyzés:
- Változónak vagy állandónak, tetszőleges általunk választott elnevezést adhatunk. De ékezetes betűket nem alkalmazhatunk.
- Jó, ha minden azonosítót, azaz elnevezést, kisbetűvel írunk.
- Ha nagybetűket is alkalmazunk, a JavaScript megkülönbözteti a kis és nagybetűket, azaz másképpen értelmezi.
- Hosszabb programnál, ha többször is le kell írni ugyanazon azonosító nevét, könnyen téveszthetünk és programunk nem fog működni.
- Másik oka, hogy a JavaScript programban vannak foglalt kifejezések, szerencsére többségükben nagybetű is előfordul, így könnyebben megkülönböztetjük őket a mi általunk kitalált azonosító nevektől.

Foglalt kifejezések:
JavaScript használja különböző műveletek, utasítások végrehajtására, azaz, ilyen elnevezést nem alkalmazhatunk változók vagy más műveletek jelölésére, azonosítására.



Kulcsszó var

A var kulcsszóval egyedi néven létrehozott változó értékét, a program további részén is, megváltoztathatjuk.
Függvény- vagy globális hatókörű változókat deklarál.

Leírás Eredmény
<script language="JavaScript" type="text/javascript">
   var t=5;
    document.write ('t értéke = '+t+'<br>');
   var t="Kakas";
    document.write ('t értéke = '+t+'<br>');
   var t=15;
    document.write ('t értéke = '+t+'<br>');

	
function Var(){
   document.write ('1. t értéke function elején = '+t+'<br>');
   // var t=t/5;  // Letíltva!  Ez, hibás meghatározás.
   t=t/5;           // Ez, jó meghatározás.
   document.write ('2. t értéke function-ban = '+t+'<br>');
}
Var();

   document.write ('3. t értéke function után = '+t+'<br>');
</script>




Kulcsszó let

Blokk hatókörű változókat deklarál.
A let kulcsszóval nem hozható létre olyan egyedi néven változó, mely őt megelőzően vagy őt követően már létezik.

Leírás 
      Helyes! A kulcsszók ( let ) egyeznek,  azonosítónevek eltérőek. (k  és  g)

<script language="JavaScript" type="text/javascript">
  let k=6;    // deklarálás bevezetés.
  let g=5;    // deklarálás bevezetés.
      document.write ('k értéke = '+k+'<br>');
      document.write ('g értéke = '+g+'<br><br>');
	
function Let(){
   document.write ('1. k értéke function elején = '+k+'<br>');
   // var k=20;     // Letíltva, function elején = undefined
   // let k=20;     // Letíltva, mert ez a deklarálás, hibát eredményez
   document.write ('2. k értéke function-ban = '+k+'<br>');
}
Let();
document.write ('3. k értéke function után = '+k+'<br>');

  k=16;         // Nem deklarálás. Ez frissítés, érték módosítás.
  g=15;         // Nem deklarálás. Ez frissítés, érték módosítás.
      document.write ('k értéke = '+k+'<br>');
      document.write ('g értéke = '+g+'<br>');
	  
</script>
Eredmény.
Hibás meghatározások.
      Hibás! A kulcsszók ( let ) egyeznek,  azonosítónevek egyeznek. (v és v )

<script language="JavaScript" type="text/javascript">
  let v=6;
  let v=5;
      document.write ('v értéke = '+v+'<br>');
      document.write ('v értéke = '+v+'<br>');
</script>
Nincs eredmény.

 
      Hibás! A kulcsszók eltérőek (var és let),  azonosítónevek egyeznek. (k és k )

<script language="JavaScript" type="text/javascript">
  var k=5;
         document.write ('k értéke = '+k+'<br>');
  let k=6;
         document.write ('k értéke = '+k+'<br>');
</script>
Nincs eredmény.

 
      Hibás! A kulcsszók eltérőek (let és var),  azonosítónevek egyeznek.  (g és g )

<script language="JavaScript" type="text/javascript">
  let g=6;
   document.write ('g értéke = '+g+'<br>');
  var g=5;
   document.write ('g értéke = '+g+'<br>');
</script>
Nincs eredmény.

Konstans "const"
Egy fix, azaz, állandó érték elhelyezése.

const x = 5;
A const kulcsszó olyan változók deklarálására szolgál, amelyeket a kezdeti értékadás után nem szabad újraértékelni.
Ez a kulcsszó a let-hez hasonlóan, blokk hatókörű is.
Ha egy konstans inicializálva van, akkor a továbbiakban, nem tudjuk megváltoztatni az értékét.
Ha a továbbiakban véletlen beírunk egy változtatást.
Például x=10; vagy const x = 10; vagy var x=10; akkor a programunk további része, nem fog működni.

const példák.

1. Példa:
A const meghatározással létrehozott változó értékét, nem módosítjuk.

<script language="JavaScript" type="text/javascript">
const x = 5;
document.write ('x értéke = '+x+'<br>');  // Itt, x értéke = 5
     // x = 15;    // HIBA! Letíltva. Oka: const már bevezette "x" változót. 
var y = 25;
document.write ('y értéke = '+y+'<br>');  // Itt, y értéke = 25

 y = 30;
document.write ('y értéke = '+y+'<br>');  // Itt, y értéke = 30
</script>
Eredmény:

2. Példa:
A const meghatározással létrehozott változó értékét módosítjuk,
módosítást követően program leáll.
<script language="JavaScript" type="text/javascript">
const z = 5;
document.write ('z értéke = '+z+'<br>');  // Itt, z értéke = 5

z = 15;               // Megváltoztatjuk z értékét.
document.write ('z értéke = '+z+'<br>');  // Nincs kiírás.  Változás miatt, program leállt.

var y = 25;
document.write ('y értéke = '+y+'<br>');  //  Nincs kiírás.  Változás miatt, program leállt.

 y = 30;
document.write ('y értéke = '+y+'<br>');  //  Nincs kiírás.  Változás miatt, program leállt.
</script>
Eredmény:

3. Példa:
Egy meglévő deklarált változónevet utólagosan,
const kulcsszóval deklarálunk, programunk leáll. (Lefagy.)

<script language="JavaScript" type="text/javascript">
var a = 5;
document.write (a+'<br>');  // Itt,  "a"  értéke = 5 lenne.

a = 10;
document.write (a+'<br>');  // Itt,  "a"  értéke = 10 lenne.

const a = 10;                     // Ez a bejegyzés, lefagyasztotta a programot.
document.write (a+'<br>');  // Itt,  "a"  értéke = 20 lenne.
</script>
Eredmény:


TESZT összefoglaló.

<script language="JavaScript" type="text/javascript">

var tvar=2;
let tlet=4;
const tconst=6;
   document.write ('1. tvar értéke, function elött = '+tvar+'<br>');
   document.write ('2. tlet értéke, function elött = '+tlet+'<br>');
   document.write ('3. tconst értéke, function elött = '+tconst+'<br><br>');

function fmunka(){ 
              var tvar=211;
              let tlet=411;
              const tconst=611;
   document.write ('1. tvar értéke, function-ban = '+tvar+'<br>');
   document.write ('2. tlet értéke, function-ban = '+tlet+'<br>');
   document.write ('3. tconst értéke, function-ban = '+tconst+'<br><br>');
}
fmunka();

   document.write ('1. tvar értéke, function után = '+tvar+'<br>');
   document.write ('2. tlet értéke, function után = '+tlet+'<br>');
   document.write ('3. tconst értéke, function után = '+tconst+'<br><br>');

// Mi történik, ezt követően.
// Már létező, meglévő változókat, blokkon kívül, újra deklaráljuk, bevezetjük.
var tvar=10;    // var kulcsszóvalt deklarált változó, újra deklarálható.
// let tlet=20;   // let kulcsszóvalt deklarált változó, nem deklarálható újra.
// const tconst=30;  // const kulcsszóvalt deklarált változó, nem deklarálható újra.

   document.write ('1. tvar értéke = '+tvar+'<br>');
   document.write ('2. tlet értéke = '+tlet+'<br>');
   document.write ('3. tconst értéke = '+tconst+'<br><br>');
   
</script>











Vissza a lap elejére