JavaScript

"Hi, Amigo!"

"Hi, Bilaabo!"

"Natutuwa akong makita ka. Ngayon ay mayroon tayong maliit ngunit napaka-kaalaman na aralin. Ngayon ay sasabihin ko sa iyo ang tungkol sa wikang JavaScript."

"Isang bagong wika? Gaano kainteresante..."

"Kasalukuyang sikat ang JavaScript salamat sa Internet. Ang katotohanan ay ito ang tanging wika na maaaring isagawa ng lahat ng browser. Kung gusto mong magdagdag ng animation o logic sa iyong web page, magagawa mo ito gamit ang JavaScript."

"Totoo ba na ang JavaScript ang pinakasikat na wika?"

"Oo, ngunit mas tumpak na sabihin na ito ang pinakasikat na 'pangalawang wika'. Ang mga programmer ng C++, Java, C#, at PHP ay kailangang magsulat ng maliliit na script sa JavaScript upang buhayin ang kanilang mga webpage. Ngunit, mas kaunting tao lamang sumulat ng code sa JavaScript."

"Bakit ito pinangalanang JavaScript? Parang Java."

"Sa totoo lang, noong una, tinawag itong LiveScript, ngunit nang magsimulang maging mas sikat ang Java, pinalitan ito ng pangalan na JavaScript."

"Ang Java at JavaScript ay dalawang ganap na magkaibang wika. Huwag malito ang mga ito."

"Hindi tulad ng Java, ang JavaScript ay walang mga klase, at hindi sumusuporta sa static na pagta-type, multithreading, at marami pang iba. Ang Java ay tulad ng isang malaking hanay ng mga tool sa pagtatayo, habang ang JavaScript ay mas katulad ng kutsilyo ng Swiss Army. Ang JavaScript ay idinisenyo upang malutas maliliit na gawain, ngunit ang Java ay para sa paglutas ng malalaki at napakalaking gawain."

"Narito ang ilang mga katotohanan tungkol sa JavaScript:"

"Ang unang katotohanan ay ang JavaScript ay may mga function, ngunit walang mga klase"

"Sumusulat ka lang ng mga programa gamit ang ilang mga function at iyon lang. Halimbawa:"

function min(a, b)
{
 return a
}

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

"Ang mga bagong function ay idineklara gamit ang «function <name>».

"Isa pang halimbawa:"

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

"Ang pangalawang katotohanan ay ang JavaScript ay may mga variable, ngunit ang mga variable na iyon ay walang mga uri"

"Ang JavaScript ay isang dynamic na na-type na wika. Nangangahulugan ito na ang mga variable ay talagang walang mga uri. Ang anumang variable ay maaaring italaga ng isang halaga ng anumang uri (ang mga halaga ay may mga uri). Halimbawa:"

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

"Ngunit pinapataas ng dynamic na pag-type ang panganib ng mga error sa runtime:"

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

"Sa halimbawa sa itaas, ginamit namin ang variable na k (isang integer) sa halip na s (isang String). Sa Java, ang error ay matutukoy sa oras ng pag-compile, ngunit sa JavaScript, hindi ito mahuhuli hanggang sa paglaon ng code. ay tumatakbo."

"Kung gusto mong magdeklara ng variable sa JavaScript, kailangan mong isulat ang «var <name>». Walang mga uri ng variable, at walang mga uri para sa mga pamamaraan/function o ang kanilang mga argumento."

"Ang JavaScript ay may napakakaunting mga mahigpit na panuntunan at maraming kawalan ng pamahalaan."

"Maaari kang magdeklara ng isang function na may 5 argumento at tawagan ito ng dalawa—ang iba ay magiging null lang. Maaari mong ideklara ang isang function na may dalawang argumento, at ipasa ang lima kapag tinawag mo ito. Tatlo ay itatapon lang. May kaunting kontrol sa mga error, typo, at pagbabago."

"Ang pangatlong katotohanan ay ang JavaScript ay may mga pahayag na kung, para sa, at habang"

"Ang JavaScript ay may kung, para sa, at habang. Ito ay magandang balita. Tingnan ang mga halimbawang ito:"

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

"Medyo magkapareho sila. Sa palagay ko ay malalaman ko kung paano gumagana ang code na nakasulat sa JavaScript."

"Ang iyong optimismo ay mabuti."

"Ang ikaapat na katotohanan ay ang JavaScript ay sumusuporta sa try-catch-finally blocks"

" Ang JavaScript ay may mga exception ( Error ) at iyon ay mabuti. Wala itong mga naka-check na exception, tanging mga hindi naka-check na exception na katulad ng isang RuntimeException . Ang try-catch-finally construct ay gumagana katulad ng sa Java. Halimbawa:"

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

"Kapag sinubukan naming kunin ang haba ng String, isang exception ang itatapon dahil null ang variable."

"Ang ikalimang katotohanan ay ang JavaScript ay may mga arrays"

"Magandang balita: May mga array ang JavaScript. Masamang balita: walang mga listahan o koleksyon."

"Ang isa pang magandang balita ay ang mga array ay maaaring dynamic na lumawak kapag ang mga bagong elemento ay idinagdag at bumaba habang ang mga elemento ay inalis. Ito ay mas katulad ng isang hybrid sa pagitan ng isang array at listahan. "

Halimbawa:

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

"Ano ang mga square bracket na iyon sa deklarasyon ng array?"

"Ganyan talaga ang deklarasyon ng array. Upang magdeklara ng array, kailangan mong magsulat ng mga square bracket. Pagkatapos ay ilista mo ang mga elemento ng array sa pagitan ng mga bracket. Idedeklara mo ang isang walang laman na array gamit ang isang pares ng bracket."

var m = [];

"Ang ikaanim na katotohanan ay ang JavaScript ay may mga bagay"

"Ang JavaScript ay may mga bagay. Sa katunayan, lahat ng bagay sa JavaScript ay isang bagay, kahit na mga primitive na uri. Ang bawat bagay ay kinakatawan bilang isang hanay ng mga pares ng key-value. Sa halos pagsasalita, bawat JavaScript object ay katumbas ng isang HashMap sa Java. Narito ang isang halimbawa ng isang deklarasyon ng bagay:"

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

"Upang lumikha ng bagong bagay, kailangan mo lang magsulat ng dalawang kulot na brace: «{}»."

"Sa loob ng braces, maaari mong tukuyin ang object data sa sumusunod na format: «key, colon, value, comma»."

"Maaaring ma-access ang mga field ng object sa dalawang paraan:"

m.age = 45;

m[“age”] = 45;

"Kung ang tinukoy na field ay hindi umiiral, pagkatapos ito ay nilikha."

"My relief valve is overloaded or something. I think we should take a break."

"Ang ikapitong katotohanan ay ang JavaScript ay nilikha upang gumana sa loob ng mga web page."