javascript

"Hallo Amigo!"

"Hallo Bilaabo!"

"Ik ben blij je te zien. Vandaag hebben we een kleine maar zeer informatieve les. Vandaag zal ik je vertellen over de JavaScript-taal."

"Een nieuwe taal? Hoe interessant..."

"JavaScript is momenteel populair dankzij internet. Feit is dat het de enige taal is die alle browsers kunnen uitvoeren. Als je animatie of logica aan je webpagina wilt toevoegen, dan kan dat met JavaScript."

"Klopt het dat JavaScript de meest populaire taal is?"

"Ja, maar het zou juister zijn om te zeggen dat het de meest populaire 'tweede taal' is. C++-, Java-, C#- en PHP-programmeurs moeten kleine scripts in JavaScript schrijven om hun webpagina's op te fleuren. Maar alleen veel minder mensen schrijf code in JavaScript."

"Waarom heet het JavaScript? Het klinkt bijna als Java."

"Eigenlijk heette het aanvankelijk LiveScript, maar toen Java populairder begon te worden, werd het omgedoopt tot JavaScript."

"Java en JavaScript zijn twee totaal verschillende talen. Verwar ze niet."

"In tegenstelling tot Java heeft JavaScript geen klassen en ondersteunt het geen statisch typen, multithreading en nog veel meer. Java is als een grote set constructietools, terwijl JavaScript meer een Zwitsers zakmes is. JavaScript is ontworpen om problemen op te lossen. kleine taken, maar Java is voor het oplossen van grote en zeer grote taken."

"Hier zijn enkele feiten over JavaScript:"

"Het eerste feit is dat JavaScript functies heeft, maar geen klassen"

"Je schrijft gewoon programma's met verschillende functies en dat is alles. Bijvoorbeeld:"

function min(a, b)
{
 return a
}

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

"Nieuwe functies worden gedeclareerd met «functie <naam>».

"Een ander voorbeeld:"

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);
}

"Het tweede feit is dat JavaScript variabelen heeft, maar die variabelen hebben geen typen"

"JavaScript is een dynamisch getypeerde taal. Dit betekent dat variabelen eigenlijk geen typen hebben. Aan elke variabele kan een waarde van elk type worden toegewezen (waarden hebben typen). Bijvoorbeeld:"

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();
}

"Maar dynamisch typen verhoogt het risico op runtime-fouten:"

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();
}

"In het bovenstaande voorbeeld hebben we de variabele k (een geheel getal) gebruikt in plaats van s (een tekenreeks). In Java zou de fout tijdens het compileren worden gedetecteerd, maar in JavaScript wordt deze pas later opgespoord wanneer de code is aan het rennen."

"Als je een variabele in JavaScript wilt declareren, moet je «var <naam>» schrijven. Er zijn geen variabeletypes en er zijn geen types voor methoden/functies of hun argumenten."

"JavaScript heeft heel weinig strikte regels en veel anarchie."

"Je kunt een functie declareren met 5 argumenten en deze met twee aanroepen - de rest is gewoon nul. Je kunt een functie declareren met twee argumenten en er vijf doorgeven als je hem aanroept. Drie worden gewoon weggegooid. Er is minimale controle over fouten, typefouten en wijzigingen."

"Het derde feit is dat JavaScript if, for en while statements heeft"

"JavaScript heeft als, voor en zolang. Dit is geweldig nieuws. Kijk eens naar deze voorbeelden:"

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);
 }
}

"Ze lijken erg op elkaar. Ik denk dat ik erachter kan komen hoe code geschreven in JavaScript werkt."

"Uw optimisme is goed."

"Het vierde feit is dat JavaScript try-catch-finally-blokken ondersteunt"

" JavaScript heeft uitzonderingen ( Error ) en dat is goed. Het heeft geen aangevinkte uitzonderingen, alleen ongecontroleerde uitzonderingen die lijken op een RuntimeException . De constructie try-catch-finally werkt hetzelfde als in Java. Bijvoorbeeld:"

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);
 }
}

"Wanneer we proberen de lengte van de string te krijgen, wordt er een uitzondering gegenereerd omdat de variabele null is."

"Het vijfde feit is dat JavaScript arrays heeft"

"Goed nieuws: JavaScript heeft arrays. Slecht nieuws: er zijn geen lijsten of verzamelingen."

"Een ander goed nieuws is dat arrays dynamisch kunnen worden uitgebreid wanneer nieuwe elementen worden toegevoegd en afnemen wanneer elementen worden verwijderd. Het is meer een hybride tussen een array en een lijst. "

Bijvoorbeeld:

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));
 }
}

"Wat zijn die vierkante haken in de array-declaratie?"

"Dat is precies wat een array-declaratie is. Om een ​​array te declareren, moet je vierkante haakjes schrijven. Vervolgens som je de elementen van de array tussen de haakjes op. Je declareert een lege array eenvoudig met een paar haakjes."

var m = [];

"Het zesde feit is dat JavaScript objecten heeft"

"JavaScript heeft objecten. In feite is alles in JavaScript een object, zelfs primitieve typen. Elk object wordt weergegeven als een reeks sleutel-waardeparen. Grofweg is elk JavaScript-object gelijk aan een HashMap in Java. Hier is een voorbeeld van een objectverklaring:"

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);

"Om een ​​nieuw object te maken, hoef je alleen maar twee accolades te schrijven: «{}»."

"Binnen de accolades kunt u objectgegevens specificeren in het volgende formaat: «sleutel, dubbele punt, waarde, komma»."

"Objectvelden zijn op twee manieren toegankelijk:"

m.age = 45;

m[“age”] = 45;

"Als het opgegeven veld niet bestaat, wordt het gemaakt."

'Mijn overdrukventiel is overbelast of zoiets. Ik denk dat we een pauze moeten nemen.'

"Het zevende feit is dat JavaScript is gemaakt om binnen webpagina's te werken."