JavaScript alapok

Tartalomjegyzék

  1. egy egyszerű JavaScript program ("Hello!" kiírása)
  2. változók használata
  3. ciklusok
  4. elágazások
  1. nyelvi elemek
  2. adatok bevitele és kiírása
  3. vezérlési szerkezetek
  4.  
  5. ajánlott irodalom, felhasznált források
  6. gyakorló feladatok

A példákhoz használt online JavaScript interpreter:

Online JavaScript Interpreter by Peter Jipsen, Chapman University (January 2013).
http://math.chapman.edu/~jipsen/js/ (2019-11-23)


Ismerkedés a JavaScript nyelvvel


egy egyszerű JavaScript program

/* 1. program */
writeln("Hello!");

Általában bármilyen programozási nyelvvel kezdünk el ismerkedni, az első lépés mindig egy "Hello!" (vagy "Hello, World!") kiírása. A JavaScript eredetileg a Netscape Navigator böngészőprogram programozási nyelve volt, de manapság már egy önálló, magas szintű programozási nyelv (bár a legtöbb JavaScript programot ma is böngészőprogramok számára írják). A JavaScript utasításokat rendszerint egy program, az ún. JavaScript interpreter egyenként hajtja végre, azonban a program végrehajtásának feltétele, hogy a JavaScript utasítások nyelvileg, szintaktikailag helyesen legyenek megadva.

Tanuljuk meg:

/* 2. program */
writeln("Hello!");
writeln();
writeln("------");

A fenti program három JavaScript utasításból áll. Mindhárom utasítás a 'writeln' eljárást hívja meg (kétszer string típusú paraméterrel, egyszer paraméter nélkül). A 'writeln' eljárás meghívásakor a böngésző JavaScript interpretere ("motorja")

a 'writeln' eljárás meghívása

változók használata

/* 3. program */
var s;
s="Hello!";
writeln(s);
s="Hello, World!";
writeln(s);
writeln();
writeln("------");

A programban a 'var' utasítással egy 's' nevű változót hozunk létre, majd az '=' operátor segítségével értéket adunk a változónak. Innentől kezdve az 's' változó addig tárolja a megadott string típusú értéket ("Hello!"), amíg azt egy másik értékadó utasítással meg nem változtatjuk.

A 'writeln' eljárás paramétereként nemcsak input értékeket adhatunk meg, hanem változókat is. Ebben az esetben az eljárás a változó értékét fogja kiírni.

/* 4. program */
var x,y,z;
x=1;
writeln(x);
y=2;
writeln(y);
z=x+y;
writeln(z);
writeln("------");

A létrehozott változók tárolhatnak számokat, numerikus típusú értékeket is.A számok között műveleteket (pl. összeadást) is végezhetünk, és a művelet eredményét kiírathatjuk vagy eltárolhatjuk egy újabb változóban.

/* 5. program */
var s1,s2,s3;
s1="Hello";
writeln(s1);
s2="World";
writeln(s2);
s3=s1+", "+s2+"!";
writeln(s3);
writeln();
writeln("------");

A karakterlánc vagy string típusú értékek között használhatjuk az összefűzés vagy konkatenáció ('+') műveletét. Ezzel mind string típusú értékek (pl. ", " vagy "!"), mind string típusú változók (pl. s1, s2) összekapcsolhatók.

/* 6. program */
var x,y,z;
x=1;
writeln("x = "+x);
y=2;
writeln("y = "+y);
z=x+y;
writeln("x+y = "+x+"+"+y+" = "+z);
writeln("------");
A fenti programban mind a string típusú értékek közötti konkatenáció (pl. "y = "+y), mind a numerikus értékek közötti összeadás (x+y) előfordul. Vegyük észre, hogy a '+' művelet mást jelent, ha számokat vagy ha stringeket kapcsolunk össze. (A '+' operátornak több jelentése van, a kontextustól függően. Az ilyen operátorokat szokás "túlterhelt" operátoroknak nevezni.) Ha pedig a '+' operátor egy számot és egy stringet (vagy ilyen típusú értékeket tartalmazó változókat) kapcsol össze, akkor mindig konkatenációként értelmezzük, vagyis ilyenkor a művelet eredménye mindig string típusú érték. A 'writeln' eljárás paraméterében a konkatenáció műveletét nagyon sokszor alkalmazzuk.

A fenti, 6. program képernyőképe a következő: egy változókat használó program képernyőképe

/* 7. program */
var x,y,z;
x=1;
y=2;
z=x+y;
writeln("x+y = "+x+"+"+y+" = "+z);
z=x-y;
writeln("x-y = "+x+"-"+y+" = "+z);
z=x*y;
writeln("x*y = "+x+"*"+y+" = "+z);
z=x/y;
writeln("x/y = "+x+"/"+y+" = "+z);
writeln("------");

Az összeadás mellett más műveletek operátorai is rendelkezésre állnak. A fenti programban a számok közötti alapműveletek szerepelnek: az összeadás (+), a kivonás (-), a szorzás (*) és az osztás (/). Például az 1/2 művelet eredménye 0.5 (a programozási nyelvekben szinte mindig tizedespontot használunk).

Tanuljuk meg:

Gyakorló feladatok:

(1) Hozzon létre három változót, és adja nekik értékül a "Tercsi", "Fercsi" és "Kata" neveket. Írassa ki külön sorokban a nevek összes lehetséges permutációját (szögletes zárójelek között és a neveket vesszővel elválasztva).

A megoldás képernyőképe a következő: az (1) feladat megoldásának képernyőképe

(2) Írassa ki a négyzetszámok és köbszámok táblázatát 1-től 10-ig!

A megoldás képernyőképe a következő: a (2) feladat megoldásának képernyőképe


ciklusok

/* 8. program */
var k,n;
k=1;
n=10;

for(var i=1;i<=n;i++) {
 writeln(i+". szám: "+k);
 k=k+1;
 }

writeln();
writeln("-----");

A fenti program az első 10 egész számot íratja ki egymás alá (némi magyarázó szöveggel egyetemben). Ezt természetesen megtehetnénk a következőképpen is:

writeln("1. szám: 1");
writeln("2. szám: 2");
writeln("3. szám: 3");
writeln("4. szám: 4");
writeln("5. szám: 5");
writeln("6. szám: 6");
writeln("7. szám: 7");
writeln("8. szám: 8");
writeln("9. szám: 9");
writeln("10. szám: 10");

Ha a 8. programhoz teljesen hasonlóan szeretnénk eljárni, a fenti utasítások helyett a következőket is írhatnánk:

writeln(1+". szám: "+1);
writeln(2+". szám: "+2);
writeln(3+". szám: "+3);
writeln(4+". szám: "+4);
writeln(5+". szám: "+5);
writeln(6+". szám: "+6);
writeln(7+". szám: "+7);
writeln(8+". szám: "+8);
writeln(9+". szám: "+9);
writeln(10+". szám: "+10);

Azonban már komolyabb nehézségbe ütköznénk, ha egy olyan programot kellene készítenünk, amely pl. az első 100 számot írja ki (éppen másolgathatnánk az utasításokat, de azért a türelemnek is van határa :) ). Ha pedig a programtól azt várnánk el, hogy 'n' darab számot írjon ki, például egy adott 'k' számtól kezdve, akkor minden különböző 'k' értékre állandóan át kellene írnunk a 'writeln' utasítások paramétereit. Ezért a fenti programot úgy készítettük el, hogy a 'k' és az 'n' változóknak különböző kezdőértéket adva a program mindig 'n' darab számot ír ki a 'k' számtól kezdve.

A fenti, 8. program képernyőképe a következő: egymás után következő egész számokat kiíró program képernyőképe

A program alapját a

for(var i=1;i<=n;i++) {
 ...
 }

szerkezettel megvalósított ún. rögzített lépésszámú ciklus jelenti, amely a JavaScript programozási nyelv legfontosabb ismétlő (iterációs) szerkezete. Ezt használva tudjuk elérni, hogy esetünkben az egyes 'writeln' utasításokat a program helyettünk készítse el egy megadott minta szerint, és pontosan addig ismételje őket (bizonyos szabályszerű változtatásokkal), amíg kell.

A 'for' ciklus a következő elemekből tevődik össze:

A ciklus lényege a ciklus blokkjában szereplő utasítások ismétlése. A legfontosabb feladat annak a beállítása, hogy a program hányszor hajtsa végre a ciklusblokkot. A ciklus a következő lépések végrehajtását valósítja meg:

  1. a ciklusváltozó kezdőértékének beállítása;
  2. a ciklusfeltétel megvizsgálása
  3. a ciklusblokk utasításainak végrehajtása;
  4. a ciklusváltozó nővelése (ha a ciklusfejben 'i++' szerepel, akkor az 'i' ciklusváltozó értékét eggyel növeljük);
  5. visszaugrás a 2. lépésre.

Nagyon fontos annak a megértése, hogy a ciklusváltozó kezdőértékének beállításával, a ciklusfeltétellel, és a ciklusváltozó növelésével tudjuk beállítani, pontosan hányszor ismétlődjön meg a ciklusblokk (vagyis hányszor hajtódjon végre a ciklusblokkban szereplő utasítások sorozata, szekvenciája).

Gyakorlásképpen írassuk ki az első 15 négyzetszámot:

/* 9. program */
var k,n;
k=1;
n=15;

for(var i=1;i<=n;i++) {
 k=i*i;
 writeln(i+". szám: "+k);
 }

writeln();
writeln("-----");

Majd írassuk ki 2 első 20 hatványát:

/* 10. program */
var k,n;
k=1;
n=20;

for(var i=1;i<=n;i++) {
 writeln(i+". szám: "+k);
 k=k*2;
 }

writeln();
writeln("-----");

Írassuk ki az si=(1+i)/i sorozat első 15 elemét:

/* 11. program */
var k,n;
k=1;
n=15;

for(var i=1;i<=n;i++) {
 k=(1+i)/i;
 writeln(i+". szám: "+k);
 }

writeln();
writeln("-----");

Végül írassuk ki d=3 növekmény mellett az s1=1, si=si−1+d (i>1, i∈ℕ) számtani sorozat első 10 elemét:

/* 12. program */
var k,n,d;
d=3;
k=1;
n=10;

for(var i=1;i<=n;i++) {
 writeln(i+". szám: "+k);
 k=k+d;
 }

writeln();
writeln("-----");

Vegyük észre, hogy az előző programok a 'for' ciklus segítségével különböző számsorozatok első 'n' elemét írták ki:

(1) ha a sorozat elemeit közvetlenül az elem sorszáma ('i') segítségével adtuk meg, a sorozat i-dik elemét tartalmazó 'k' változó értékét a 'writeln' kiíró utasítás előtt állítottuk be, az 'i' ciklusváltozó aktuális értékét felhasználva (ilyenkor a 'k' változó kezdőértékének nincs semmilyen jelentősége);
(2) ha viszont a sorozat elemeit a megelőző sorozatelemek segítségével adtuk meg (rekurzív módon), akkor
– először kiírattuk a sorozat i-dik elemét tartalmazó 'k' változó értékét, majd
– a 'writeln' kiíró utasítás után beállítottuk a 'k' változó értékét úgy, hogy az értékadás után már a sorozat következő, (i+1)-dik elemét tartalmazza. Ehhez az értékadásban (az = értékadó operátor jobb oldalán) felhasználtuk a 'k' változó korábbi értékét, amely az értékadáskor a sorozat előző, i-dik elemét tartalmazta.

Azokat a rekurzív módon megadott sorozatokat, amelyekben a sorozat i-dik elemének megadásakor az (i−1)-dik és az (i−2)-dik elemre is szükségünk van, egy 'm' segédváltozó segítségével tudjuk a legegyszerűbben kiíratni. Például tekintsük az alábbi sorozatot:

s1=1; s2=1; si=si−1+si−2 (i>2, i∈ℕ).

A sorozat elemei: {1, 1, 2, 3, 5, 8, ...} (ún. Fibonacci-sorozat).

Az alábbi program a Fibonacci-sorozat első 10 elemét íratja ki:

/* 13. program */
var m,k,n;
m=1
k=1;
n=10;

writeln(1+". szám: "+m);

for(var i=2;i<=n;i++) {
 writeln(i+". szám: "+k);
 k=k+m;
 m=k-m;
 }

writeln();
writeln("-----");

Vegyük észre, hogy az 'm' segédváltozóban a sorozat (i−1)-dik elemét tároljuk. Mivel a 'k' változóra vonatkozó k=k+m; értékadás után 'k' a sorozat (i+1)-dik elemét fogja tartalmazni, az előző, i-dik elemet újra elő kell állítanunk, hogy tárolni tudjuk 'm'-ben. Ha egy 'temp' nevű segédváltozót is bevezetünk, ez elkerülhető:

/* 14. program */
var m,k,n;
m=1
k=1;
n=10;

writeln(1+". szám: "+m);

for(var i=2;i<=n;i++) {
 writeln(i+". szám: "+k);
 var temp;
 temp=k;
 k=k+m;
 m=temp;
 }

writeln();
writeln("-----");

Mivel a 'temp' változót csak a 'for' ciklus ciklusmagjában használjuk a sorozat i-dik elemének ideiglenes tárolására, érdemes ott létrehozni.

Gyakorló feladatok:

Készítse el az alábbi sorozatok első 'n' elemét kiíró programot:

(1) n=10; si=3*i

(2) n=9; si=(2*i2−3*i+4)

(3) n=8; si=(i2+7*i−2)/(3*i−6)

(4) n=10; q=0.5; s1=1; si=si−1*q (i>1, i∈ℕ) (mértani sorozat)

(5) n=11; s1=3; si=2*si−1 (i>1, i∈ℕ); a sorozat elemei: {3, 6, 12, 24, ...}

(6) n=12; s1=3; si=3*si−12−4*si−1+5 (i>1, i∈ℕ)

Végül három, valamivel nehezebb feladat:

(7) n=8; s0=1; s1=1; si=si−1*i (i>1, i∈ℕ); a sorozat elemei: {1, 1, 2, 6, 24, ...} (faktoriálisok sorozata, si=i!)

(8) n=10; s1=1; si=si−1+(i−1) (i>1, i∈ℕ); a sorozat elemei: {1, 2, 4, 7, 11, ...} (növekményes sorozat)

(9) n=12; s1=2; si=si−1+(2*i−1) (i>1, i∈ℕ); a sorozat elemei: {2, 5, 10, 17, ...} [tipp: alakítsuk át a sorozat növekményét megadó (2*i−1) kifejezést (2*i−1) = (2*(i−1+1)−1) = (2*(i−1)+2−1) = (2*(i−1)+1) módon]

Az utolsó két feladat egy 'm' segédváltozó segítségével is megoldható, ha a sorozatok növekményét egy új, ti sorozatnak tekintjük, és ennek az elemeit állítjuk elő 'm'-ben.

Például a (8) feladat esetében a növekményt előállító sorozat
    t1=0; ti=i−1 (i>1, i∈ℕ), a sorozat elemei: {0, 1, 2, 3, ...}.
Vegyük észre, hogy ez a ti sorozat rekurzív módon is megadható
   t1=0; ti=ti−1+1 (i>1, i∈ℕ)
módon. Az így definiált ti sorozattal az eredeti sorozat
   s1=1; si=si−1+ti (i>1, i∈ℕ)
módon állítható elő.

Nézzük meg például a (8)-as feladat megoldását ilyen módon:

/* 15. program */
var m,k,n;
m=0;
k=1;
n=10;

for(var i=1;i<=n;i++) {
 writeln(i+". szám: "+k);
 m=m+1;
 k=k+m;
 }

writeln();
writeln("-----");

Utolsó feladatként készítsük el ciklussal az első 'n' négyzetszám és köbszám táblázatát! Emlékezzünk rá, hogy a feladatot korábban már megoldottuk, így a ciklusmagban szereplő 'writeln' utasítás mintája adott, pusztán a változó értékeket kell megfelelő változókkal helyettesíteni.

/* 16. program */
var k1,k2,n;
n=10;

writeln("szám szám_négyzete szám_köbe");

for(var i=1;i<=n;i++) {
 k1=i*i;
 k2=k1*i;
 writeln("  "+i+"         "+k1+"          "+k2);
 }

writeln();
writeln("-----");

A megoldás képernyőképe a következő: a 16. program megoldásának képernyőképe

Vegyük azonban észre, hogy az előző feladat megoldásához képest a két- és háromjegyű számok megjelenése eltolja a kiírt számokat, így a táblázat (finoman szólva) nem lesz esztétikus. Ennek kiküszöbölésére egy újabb programozási eszközre lesz szükségünk.


elágazások

A korábbi, 16. programban azért nem tudtuk a négyzetszámokat és a köbszámokat egy táblázatban, esztétikusan elrendezni, mert a táblázat soraiban a számok pozícióját meghatározó szóközök száma független volt a megjelenített számjegyek számától. Például a 3. sorban jelenik meg először egy két számjegyből álló köbszám (27), amely egy szóközzel eltolja a köbszámok oszlopát. A 4. sorban pedig először jelenik meg egy két számjegyből álló négyzetszám (16), amely egy szóközzel eltolja a négyzetszámok oszlopát, és egy további szóközzel eltolja köbszámok oszlopát.

A megoldás az, hogy a szóközök számát a megjelenítendő számok számjegyeinek függvényében állapítsuk meg. Mivel a táblázat oszlopaiban az 'i', 'k1' és 'k2' nevű változók értékét íratjuk ki, a következő szerkezetet kellene megvalósítanunk a programban (feltéve, hogy 'i' esetében maximum 2 jegyű számokkal, 'k1' esetében maximum 3 jegyű számokkal, 'k1' esetében pedig maximum 4 jegyű számokkal dolgozunk):

ha i<10 akkor írassunk ki 3 db. szóközt,
egyébként írassunk ki 2 db. szóközt,
és ezután írassuk ki i-t;

ha k1<10 akkor írassunk ki 9 db. szóközt,
egyébként ha k1<100, akkor írassunk ki 8 db. szóközt,
egyébként írassuk ki 7 db. szóközt,
és ezután írassuk ki k1-t;

ha k2<10 akkor írassunk ki 10 db. szóközt,
egyébként ha k2<100, akkor írassunk ki 9 db. szóközt,
egyébként ha k2<1000, akkor írassunk ki 8 db. szóközt,
egyébként írassuk ki 7 db. szóközt,
és ezután írassuk ki k2-t.

A JavaScript programozási nyelv az if(...) {...} else {...} , ún. kétirányú elágazás szerkezetet biztosítja a fenti megoldásokhoz. Lássuk ezzel a szerkezettel megvalósítva a korábbi, 16. program javított változatát:

/* 17. program */
var k1,k2,n,s1,s2,s3;
n=10;

writeln("szám szám_négyzete szám_köbe");

for(var i=1;i<=n;i++) {
 k1=i*i;
 k2=k1*i;

 if(i<10) {
  s1="   "; // 3 db. szóköz
  }
 else {
  s1="  "; // 2 db. szóköz
  }

 if(k1<10) {
  s2="        "; // 8 db. szóköz
  }
 else if(k1<100) {
  s2="       "; // 7 db. szóköz
  }
 else {
  s2="      "; // 6 db. szóköz
  }

 if(k2<10) {
  s3="          "; // 10 db. szóköz
  }
 else if(k2<100) {
  s3="         "; // 9 db. szóköz
  }
 else if(k2<1000) {
  s3="        "; // 8 db. szóköz
  }
 else {
  s3="       "; // 7 db. szóköz
  }

 writeln(s1+i+s2+k1+s3+k2);
 }

writeln();
writeln("-----");

A programban feltüntettük az 's1', 's2' és 's3' változókban tárolt szóközök számát a // után megadott soron belüli megjegyzések megadásával (amelyeket a JavaScript interpreter figyelmen kívül hagy).

A program képernyőképe a következő: a 17. program megoldásának képernyőképe


JavaScript összefoglaló


a JavaScript nyelvi elemei

Írjon be egy adatot:

[elemi adattípusok, adatok (literálok)]

[változók, változótípusok]

[elemi típusú változók]

// számrendszerek

var x,d,b,h;

x=123;
d=Number(x).toString();
writeln(x+" | "+d);

x=123;
b=Number(x).toString(2);
writeln(x+" | "+b);

x=123;
h=Number(x).toString(16);
writeln(x+" | "+h);

writeln("--------------------------------------------------");

b="10110100";
x=parseInt(b,2)
writeln(x+" | "+b);

h="2cd";
x=parseInt(h,16)
writeln(x+" | "+h);

writeln("--------------------------------------------------");

b="10101010";

write(b+" közvetlen átváltása decimális számrendszerbe: ");
x=1*128+0*64+1*32+0*16+1*8+0*4+1*2+0*1;
writeln(x);

x=0; // részösszegek
he=1; // helyiérték
i=b.length-1; // ciklusváltozó

while(i>=0) {
 d=parseInt(b.charAt(i),2); // számjegy adott helyiértéken
 x+=d*he; // vagy x=x+d*he;
 he*=2; // vagy he=he*2;
 i--; // vagy i=i-1;
 }

writeln(b+"  -->  "+x);
writeln("--------------------------------------------------");

h="3de5";

write(h+" közvetlen átváltása decimális számrendszerbe: ");
x=3*16**3+13*16**2+14*16+5*1;
writeln(x);

x=0; // részösszegek
he=1; // helyiérték
i=h.length-1; // ciklusváltozó

while(i>=0) {
 d=parseInt(h.charAt(i),16); // számjegy adott helyiértéken
 x+=d*he; // vagy x=x+d*he;
 he*=16; // vagy he=he*16;
 i--; // vagy i=i-1;
 }

writeln(h+"  -->  "+x);
writeln("--------------------------------------------------");

[egy- és többdimenziós tömbök (array)]

Egy példa egydimenziós tömbök létrehozására:

// egydimenziós tömbök

var tanulok=["Jancsi","Zoe","Peti","Kata","Ildi"];
var i;

tanulok[5]="Tercsi"; // vagy tanulok[this.length]="Tercsi";
tanulok[6]="Fercsi";

writeln("Névsor:\n");

for(i=0;i<tanulok.length;i++) {
 writeln(tanulok[i]);
 }

writeln("\nÖsszesen "+tanulok.length+" tanuló.\n");

writeln("--------------------------------------------------");

tanulok.sort();

writeln("Rendezett névsor:\n");

for(i=0;i<tanulok.length;i++) {
 writeln(tanulok[i]);
 }

writeln("--------------------------------------------------");

Egy példa egydimenziós, számokból álló tömbök (vektorok) létrehozására és a tömb elemeinek összeadására:

// számok (tömbelemek) összeadása

var szamok=[1,4,3,2];
var i,osszeg=0;

for(i=0;i<szamok.length;i++) {
 osszeg+=szamok[i];
 // if(i+1>=szamok.length) break;
 writeln("részösszeg: "+osszeg);
 }

writeln("\nvégösszeg: "+osszeg);

writeln("--------------------------------------------------");

Egy példa többdimenziós tömbök (mátrixok) létrehozására és kiírására:

// többdimenziós tömbök (mátrixok) létrehozása

// négyzetes mátrix

var i,j;
var matrix=[
 [1,4,3,2],
 [6,1,5,5],
 [1,2,3,4],
 [7,1,2,6]
 ];

for(i=0;i<matrix.length;i++) {
 for(j=0;j<matrix.length;j++) {
  write(matrix[i][j]+" ");
  }
 writeln();
 }

writeln("--------------------------------------------------");

// általános mátrix

matrix=[
 [1,4,3,2,8],
 [6,1,5,5,0],
 [1,2,3,4,9],
 [7,1,2,6,4]
 ];

// 4 sor és 4 oszlop kiírása

for(i=0;i<matrix.length;i++) {
 for(j=0;j<matrix.length;j++) {
  write(matrix[i][j]+" ");
  }
 writeln();
 }

writeln();

// 4 sor és 5 oszlop kiírása

for(i=0;i<matrix.length;i++) {
 for(j=0;j<matrix[i].length;j++) {
  write(matrix[i][j]+" ");
  }
 writeln();
 }

writeln("--------------------------------------------------");

[objektumok]

[nem definiált értékű és típusú változók]

Az azonosítók (pl. a változók neve) esetében tartsuk be a következőket: a nevek kezdődjenek kisbetűvel és csak betűket, számjegyeket, és aláhúzás-karaktert (_) tartalmazzanak. Az azonosítók neveiben a nagy- és kisbetűk különbözőek, nagybetűt csak kivételes esetben használjunk (pl. két szóból álló név esetén, szóköz helyett: tanuloNeve, tanarNeve stb.), és a magyar ékezetes betűket a nevekben ne használjuk.

[operátorok, függvények]

aritmetikai operátorok

logikai operátorok


Lássunk néhány példát a logikai operátorok használatára:

// igazságtáblázat készítése (implikáció)

function imp(x,y) {
 var a=Boolean(x), b=Boolean(y);
 var c=!a || b;
 return Number(c);
 }

writeln("A"+" " +"B"+" "+"⊃");
writeln("A"+" " +"B"+" "+"\u2283");
writeln("-----");

for(i=0;i<=1;i++) {
 for(j=0;j<=1;j++) {
  writeln(i+" " +j+" "+imp(i,j));
  }
 }

writeln("--------------------------------------------------");

Készítsük el a

geza(A,B) = ( A ⊃ ( A ⊃ B) ) ∨. A

és a

peti(A,B) = ( ( A ⊃ B) ⊃ A ) ∨. A

logikai függvények igazságtáblázatát:

// geza(A,B) = ( A ⊃ ( A ⊃ B) ) ∨. ⌝A
// peti(A,B) = ( ( A ⊃ B) ⊃ A ) ∨. ⌝A

function imp(x,y) {
 var a=Boolean(x), b=Boolean(y);
 var c=!a || b;
 return Number(c);
 }

function geza(x,y) {
 var a=Boolean(x), b=Boolean(y);
// var c=(imp(x,imp(x,y))) || !a;
// var c=(imp(a,imp(a,b))) || !a;
  var c=(!a || (!a || b)) || !a;
 return Number(c);
 }

function peti(x,y) {
 var a=Boolean(x), b=Boolean(y);
// var c=(imp(imp(x,y),x)) || !a;
// var c=(imp(imp(a,b),a)) || !a;
  var c=(!(!a || b) || a) || !a;
 return Number(c);
 }

writeln("A"+" " +"B"+" "+"(A g B)");
writeln("-----------");

for(i=0;i<=1;i++) {
 for(j=0;j<=1;j++) {
  writeln(i+" " +j+"    "+geza(i,j));
  }
 }

writeln("--------------------------");

writeln("A"+" " +"B"+" "+"(A p B)");
writeln("-----------");

for(i=0;i<=1;i++) {
 for(j=0;j<=1;j++) {
  writeln(i+" " +j+"    "+peti(i,j));
  }
 }

writeln("--------------------------");

Készítsük el a kata(A,B) = ( A ∧ ( A ⊃ B) ) logikai függvény igazságtáblázatát:

// kata(A,B) = ( A ∧ ( A ⊃ B) ) 

function imp(x,y) {
 var a=Boolean(x), b=Boolean(y);
 var c=!a || b;
 return Number(c);
 }

function kata(x,y) {
 var a=Boolean(x), b=Boolean(y);
// var c=a && imp(x,y);
// var c=a && imp(a,b);
 var c=a && (!a || b);
 return Number(c);
 }

writeln("A"+" " +"B"+" "+"(A k B)");
writeln("-----------");

for(i=0;i<=1;i++) {
 for(j=0;j<=1;j++) {
  writeln(i+" " +j+"    "+kata(i,j));
  }
 }

writeln("--------------------------");

Végül egy összetettebb példa: készítsük el az mp(A,B) = ( A ∧ ( A ⊃ B) ) ⊃. B logikai függvény igazságtáblázatát, valamint Quine-táblázatát:

// mp(A,B) = ( A ∧ ( A ⊃ B) ) ⊃. B (modus ponens)

function imp(x,y) {
 var a=Boolean(x), b=Boolean(y);
 var c=!a || b;
 return Number(c);
 }

function mp(x,y) {
 var a=Boolean(x), b=Boolean(y);
 var c=!(a && (!a || b)) || b;
 return Number(c);
 }

writeln("A"+" " +"B"+" "+"mp(A,B)");
writeln("-----------");

for(i=0;i<=1;i++) {
 for(j=0;j<=1;j++) {
  writeln(i+" " +j+"     "+mp(i,j));
  }
 }

writeln("--------------------------------------------------");

writeln("( A ∧ ( A ⊃ B) ) ⊃. B");
writeln("-----------");

for(i=0;i<=1;i++) {
 for(j=0;j<=1;j++) {
  writeln(" "+
         i+" " +
         Number(i && imp(i,j))+"  "+  
         i+" "+
         imp(i,j)+" "+
         j+" | "+
         mp(i,j)+" | "+
         j);
  }
 }

writeln("--------------------------------------------------");

Megjegyzések:

(I.) Az mp(A,B) = ( A ∧ ( A ⊃ B) ) ⊃. B logikai függvény Quine-táblázatában a belső ( A ∧ ( A ⊃ B) ) konjunkciót (i && imp(i,j)) módon állíthatjuk elő (A ↔ i, B ↔ j), mert az 'i' ciklusváltozó 0 vagy 1 értékű szám, amelyet a && logikai operátor használata miatt a JavaScript interpreter automatikusan logikai (Boolean) értékké alakít át. Azonban a kifejezés értéke logikai érték (true vagy false) lesz, amit a táblázatban számként (1 vagy 0) akarunk megjeleníteni, tehát a logikai kifejezés értékét számmá kell alakítanunk Number(Boolean(i) && imp(i,j)) módon.

(II.) A modus ponens következtetési szabálynak megfelelő logikai törvény levezethető a logikai azonosságokból:

( A ∧ ( A ⊃ B) ) ⊃. B ~ ( A ∧ ( A ∨ B) ) ⊃. B (az implikáció átalakítása)
( A ∧ ( A ∨ B) ) ⊃. B ~ ( ( A ∧ A ) ∨ ( A ∧ B) ) ⊃. B (disztributivitás)
( ( A ∧ A ) ∨ ( A ∧ B) ) ⊃. B ~ ( A ∧ B ) ⊃. B (az ellentmondás törvénye és a ⊥ ∨ P ~ P kiszámítási törvény)
( A ∧ B ) ⊃. B ~ ( A ∧ B ) ∨ B (az implikáció átalakítása)
( A ∧ B ) ∨ B ~ ( A ∨ B ) ∨ B (De Morgan-azonosság)
( A ∨ B ) ∨ B ~ A ∨ ( B ∨ B ) (asszociativitás)
A ∨ ( B ∨ B ) ~ (a kizárt harmadik törvénye és a P ∨ ⊤ ~ ⊤ kiszámítási törvény).

Vagyis az mp(A,B) = ( A ∧ ( A ⊃ B) ) ⊃. B logikai függvény tautológia.


összehasonlító operátorok

matematikai állandók, függvények (Math osztály)

// kör kerülete és területe

var kor_sugara, x,xk,xt;

kor_sugara=4;
xk=(2*kor_sugara*Math.PI);

writeln("kerület = "+xk);
x=Math.round(xk*100)/100;
// x=xk.toFixed(2);
writeln("kerület (közelítőleg) = "+x);

writeln("--------------------------------------------------");

xt=kor_sugara*kor_sugara*Math.PI;
writeln("terület = "+xt);
x=Math.round(xt*100)/100;
// x=xt.toFixed(2);
writeln("terület (közelítőleg) = "+x);

writeln("--------------------------------------------------");

karakterláncokkal kapcsolatos függvények, operátorok, elemváltozók, metódusok (String osztály)

// betűk kiírása egymás alá

var s;
var idezojel="?"; // stringen belül nem lehet közvetlenül megadni
var i;

s="Hello!";
for(i=0;i<s.length;i++){
 writeln(s.charAt(i));
 }

writeln("--------------------------------------------------");

// betűk kiírása egymás mellé, szóközzel elválasztva

s="HELLO-BELLO";
for(i=0;i<s.length;i++){
 write(s.charAt(i)+" "); 
 }

writeln();
writeln("--------------------------------------------------");

// az idézőjel kódját megnéztük a Google-val (34 vagy 0x22)
// idezojel=String.fromCharCode(34);
idezojel="\u0022";

s="alma kajszibarack";
// writeln("Az \""+s+"\" string hossza: "+s.length);
writeln("Az "+idezojel+s+idezojel+ " string hossza: "+s.length);

writeln("--------------------------------------------------");

i=0;
while(i<s.length) {
writeln("Az "+idezojel+
 s.substring(0,4)+"..."+
 idezojel+
 " string "+i+"-dik karaktere: "+
 s.charAt(i));
 i++;
 }

writeln("--------------------------------------------------");

adatok bevitele és kiírása

Egy egyszerű táblázat
1 2
3 4

Egy egyszerű bekezdés

adatok bevitele

adatok kiírása


vezérlési szerkezetek

utasításblokkok

függvények

ciklusok

Hozzuk létre a 'szamok' tömböt pl. var szamok=[1,4,3,2]; módon!

// egyszerű ciklusok

var i,m,n,s;

writeln("első 5 természetes szám (while):\n"); 

i=1;
while(i<=5) {
 writeln(i);
 i++;
 }

writeln("--------------------------------------------------");

writeln("első 5 természetes szám (for):\n"); 
for(i=1;i<=5;i++) {
 writeln(i);
 }

writeln("--------------------------------------------------");

m=3;
n=10;
writeln("'m' és 'n' közötti természetes számok:\n"); 
for(i=m;i<=n;i++) {
 writeln(i);
 }

writeln("--------------------------------------------------");

s="A";
writeln("sok 'A' kiírása:\n"); 
i=0;
while(i<5){
 writeln((i+1)+"-dik ismétlés: "+s);
 s+="A";
 i++; 
 }

writeln("--------------------------------------------------");

elágazások

// páros számok kiíratása

var i,n=10;

for(i=1;i<=n;i++) {
 if(i%2==0) {
  writeln(i);
  }
 }

writeln("--------------------------------------------------");

// hárommal osztható számok kiíratása

for(i=1;i<=n;i++) {
 if(i%3==0) {
  writeln(i);
  }
 }

writeln("--------------------------------------------------");

// hárommal osztható páros számok kiíratása

for(i=1;i<=n;i++) {
 if(i%2==0 && i%3==0) {
  writeln(i);
  }
 }

writeln("--------------------------------------------------");

Irodalomjegyzék

Moncur, Michael 2006. Tanuljuk meg a JavaScript használatát 24 óra alatt. [SAMS Teach Yourself HTML and CSS in 24 Hours.] Budapest: Kiskapu.

Suehring, Steven; Valade, Janet 2014. PHP, MySQL, JavaScript és HTML5. Budapest: Panem K. (Tantusz könyvek)

Internetes források

Online JavaScript Interpreter by Peter Jipsen, Chapman University (January 2013).
http://math.chapman.edu/~jipsen/js/ (2018-12-12)

W3Schools Online Web Tutorials.
https://www.w3schools.com/ (2018-11-23)

JavaScript Tutorial.
https://www.w3schools.com/js/ (2018-12-12)

JavaScript and HTML DOM Reference.
https://www.w3schools.com/jsref/default.asp (2018-12-12)

JavaScript Global Reference.
https://www.w3schools.com/jsref/jsref_obj_global.asp (2018-12-12)

JavaScript - Wikipédia.
https://hu.wikipedia.org/wiki/JavaScript (2020-03-22)

A JavaScript programozási nyelv. (Programnyelvek portál.)
http://nyelvek.inf.elte.hu/leirasok/JavaScript/index.php?chapter=24 (2018-12-12)


Boda István, 2018.