JavaScript

– Szia Amigo!

– Szia, Bilaabo!

"Örülök, hogy látlak. Ma van egy kicsi, de nagyon informatív leckénk. Ma a JavaScript nyelvről fogok mesélni."

"Egy új nyelv? Milyen érdekes…"

"A JavaScript jelenleg az internetnek köszönhetően népszerű. A helyzet az, hogy ez az egyetlen nyelv, amelyet minden böngésző képes végrehajtani. Ha animációt vagy logikát szeretne hozzáadni a weboldalához, akkor ezt JavaScripttel is megteheti."

"Igaz, hogy a JavaScript a legnépszerűbb nyelv?"

"Igen, de pontosabb lenne azt mondani, hogy ez a legnépszerűbb "második nyelv". A C++, Java, C# és PHP programozóknak kis szkripteket kell írniuk JavaScript-be, hogy élénkítsék weboldalaikat. De sokkal kevesebb ember csak írjon kódot JavaScriptben."

"Miért nevezik JavaScriptnek? Majdnem úgy hangzik, mint a Java."

"Tulajdonképpen kezdetben LiveScriptnek hívták, de amikor a Java egyre népszerűbb lett, átnevezték JavaScriptre."

"A Java és a JavaScript két teljesen különböző nyelv. Ne keverje össze őket."

"A Java-val ellentétben a JavaScriptnek nincsenek osztályai, és nem támogatja a statikus gépelést, a többszálú feldolgozást és még sok minden mást. A Java olyan, mint egy nagy építőeszköz-készlet, míg a JavaScript inkább egy svájci kés. A JavaScriptet úgy tervezték, hogy megoldja kis feladatok, de a Java nagy és nagyon nagy feladatok megoldására való."

"Íme néhány tény a JavaScriptről:"

"Az első tény az, hogy a JavaScript-nek vannak függvényei, de nincsenek osztályai"

"Egyszerűen programokat írsz több függvény segítségével és ennyi. Például:"

function min(a, b)
{
 return a
}

public static int min(int a, int b)
{
return a
}

"Az új függvények deklarálása a «<név> függvény) használatával történik.

"Egy másik példa:"

function min(a, b)
{
 return a < b ? a: b;
}

function main()
{
 var s = 3;
 var t = 5;
 var min = min(s, t);
}

public static int min(int a, int b)
{
 return a < b ? a : b;
}

public static void main()
{
 int s = 3;
 int t = 5;
 int min = min(s,t);
}

"A második tény az, hogy a JavaScriptben vannak változók, de ezeknek a változóknak nincs típusuk"

"A JavaScript egy dinamikusan tipizált nyelv. Ez azt jelenti, hogy a változóknak valójában nincs típusuk. Bármely változóhoz bármilyen típusú érték rendelhető (az értékekhez típusok tartoznak). Például:"

function main()
{
 var s = "Bender";
 var k = 1;
 var n = s.length;
}

public static void main()
{
 String s ="Bender";
 int k = 1;
 int n = s.length();
}

"A dinamikus gépelés azonban növeli a futásidejű hibák kockázatát:"

function main()
{
 var s = "Bender";
 var k = 1;
 var n = k.length;
}

public static void main()
{
 String s ="Bender";
 int k = 1;
 int n = k.length();
}

"A fenti példában a k változót (egy egész szám) használtuk s (karakterlánc) helyett. Java esetén a hiba a fordításkor észlelhető, JavaScriptben azonban csak később, amikor a kód fut."

"Ha JavaScript-ben szeretne deklarálni egy változót, akkor a «var <név> kifejezést kell írnia». Nincsenek változótípusok, és nincsenek típusok a metódusokhoz/függvényekhez vagy argumentumaikhoz."

"A JavaScript nagyon kevés szigorú szabályt és sok anarchiát tartalmaz."

"Deklarálhat egy függvényt 5 argumentummal, és meghívhatja kettővel – a többi csak nulla lesz. Deklarálhat egy függvényt két argumentummal, és megadhat öt argumentumot, amikor meghívja. Három egyszerűen ki lesz dobva. Minimális vezérlés hibák, elírások és változtatások felett."

"A harmadik tény az, hogy a JavaScript rendelkezik if, for és while utasításokkal."

"A JavaScript rendelkezik if, for and while. Ez nagyszerű hír. Nézze meg ezeket a példákat:"

function main()
{
 var s = "Bender";

 var result = "";

 for(var i = 0; i < s.length; i++)
 {
  result += s[i] + "";
 }
 if(result.length > 10)
 {
  alert (result);
 }
 else
 {
  while(result.length <= 10)
  {
   result += " ";
  }
  alert(result);
 }
}

public static void main()
{
 String s = "Bender";
 char[] s2 = s.toCharArray();
 String result = "";

 for(int i = 0; i < s.length(); i++)
 {
  result += s2[i] + "";
 }
 if(result.length() > 10)
 {
  System.out.println(result);
 }
 else
 {
  while (result.length() <= 10)
  {
   result += " ";
  }
  System.out.println(result);
 }
}

"Elég hasonlóak. Azt hiszem, ki tudnám találni, hogyan működik a JavaScriptben írt kód."

– Jó az optimizmusod.

"A negyedik tény az, hogy a JavaScript támogatja a try-catch-finally blokkokat"

" A JavaScriptben vannak kivételek ( Error ) és ez jó. Nincsenek ellenőrzött kivételek, csak a RuntimeException-hez hasonló , ellenőrizetlen kivételek . A try-catch-finally konstrukció ugyanúgy működik, mint a Java-ban. Például:"

function main()
{
 try
 {
  var s = null;
  var n = s.length;
 }
 catch(e)
 {
  alert(e);
 }
}

public static void main()
{
 try
 {
  String s = null;
  int n = s.length();
 }
 catch(Exception e)
 {
  System.out.println(e);
 }
}

"Amikor megpróbáljuk megszerezni a karakterlánc hosszát, kivételt dobunk, mivel a változó nulla."

"Az ötödik tény az, hogy a JavaScript tömbökkel rendelkezik"

"Jó hír: a JavaScript tömbökkel rendelkezik. Rossz hír: nincsenek listák vagy gyűjtemények."

"Egy másik jó hír, hogy a tömbök dinamikusan bővülhetnek új elemek hozzáadásakor, és csökkenhetnek az elemek eltávolításával. Ez inkább egy tömb és lista hibridje. "

Például:

function main()
{
 var m = [1, 3, 18, 45, 'c', "roma", null];
 alert(m.length); // 7

 m.push("end");
 alert(m.length); // 8

 for (var i = 0; i < m.length; i++)
 {
  alert(m[i]);
 }
}

public static void main()
{
 List m = Arrays.asList(1, 3, 18, 45,'c', "roma", null);
 System.out.println(m.size()); // 7

 m.add("end");
 System.out.println(m.size()); // 8

 for (int i = 0; i < m.size(); i++)
 {
  System.out.println(m.get(i));
 }
}

"Mik azok a szögletes zárójelek a tömbdeklarációban?"

"Pontosan ez a tömbdeklaráció. Egy tömb deklarálásához szögletes zárójeleket kell írni. Ezután a zárójelek közé sorolja a tömb elemeit. Egy üres tömböt egyszerűen egy zárójelpárral deklarál."

var m = [];

"A hatodik tény az, hogy a JavaScriptnek vannak objektumai"

"A JavaScriptben vannak objektumok. Valójában a JavaScriptben minden objektum, még a primitív típusok is. Minden objektum kulcs-érték párok halmazaként van ábrázolva. Durván szólva minden JavaScript objektum egyenértékű a Java HashMap-jével. Íme egy példa egy objektum deklaráció:"

function main()
{
 var m = {
  first_name : "Bill",
  last_name: "Gates",
  age: 54,
  weight: 67,
 children: ["Emma", "Catrin"],
 wife: {
  first_name : "Melinda",
  last_name: "Gates",
  age: 45,
  }
};

 alert(m.first_name); // Bill
 alert(m.age); // 54
 alert(m.wife.first_name); // Melinda

 m.age = 45;
 m.age++;
 m["first_name"] = "Stive";
 m["wife"] = null;

public static void main()
{
 HashMap m = new HashMap();
 m.put("first_name", "Bill");
 m.put("last_name", "Gates");
 m.put("age", 54);
 m.put("weight", 67);

 String[] children = {"Emma", "Catrin"};
 m.put("children", children);

 HashMap wife = new HashMap();
 wife.put("first_name", "Melinda");
 wife.put("last_name", "Gates");
 wife.put("age", 45);
 m.put("wife", wife);

 System.out.println(m.get("first_name"));
 System.out.println(m.get("age"));

 HashMap w = ((HashMap)m.get("wife"));
 System.out.println(w.get("first_name")));

 m.put("age", 45);
 m.put("age", ((Integer)m.get("age")) + 1);
 m.put("first_name", "Stive");
 m.put("wife", null);

"Új objektum létrehozásához csak két kapcsos zárójelet kell írnia: «{}»."

"A kapcsos zárójelben az objektumadatokat a következő formátumban adhatja meg: «kulcs, kettőspont, érték, vessző».

"Az objektummezőket kétféleképpen lehet elérni:"

m.age = 45;

m[“age”] = 45;

"Ha a megadott mező nem létezik, akkor létrejön."

"Túlterhelt a nyomáscsökkentő szelepem, vagy valami ilyesmi. Szerintem tartsunk egy kis szünetet."

"A hetedik tény az, hogy a JavaScriptet úgy hozták létre, hogy weboldalakon belül működjön."