ஜாவாஸ்கிரிப்ட்

"ஹாய், அமிகோ!"

"வணக்கம், பிலாபோ!"

"உங்களைப் பார்த்ததில் மகிழ்ச்சி அடைகிறேன். இன்று எங்களிடம் ஒரு சிறிய ஆனால் மிகவும் தகவலறிந்த பாடம் உள்ளது. இன்று நான் உங்களுக்கு ஜாவாஸ்கிரிப்ட் மொழியைப் பற்றி சொல்கிறேன்."

"புதிய மொழியா? எவ்வளவு சுவாரஸ்யமானது..."

"இணையத்திற்கு நன்றி ஜாவாஸ்கிரிப்ட் தற்போது பிரபலமாக உள்ளது. எல்லா உலாவிகளும் இயக்கக்கூடிய ஒரே மொழி இதுவாகும். உங்கள் வலைப்பக்கத்தில் அனிமேஷன் அல்லது லாஜிக் சேர்க்க விரும்பினால், அதை ஜாவாஸ்கிரிப்ட் மூலம் செய்யலாம்."

"ஜாவாஸ்கிரிப்ட் மிகவும் பிரபலமான மொழி என்பது உண்மையா?"

"ஆம், ஆனால் இது மிகவும் பிரபலமான 'இரண்டாம் மொழி' என்று கூறுவது மிகவும் துல்லியமாக இருக்கும். C++, Java, C# மற்றும் PHP புரோகிராமர்கள் தங்கள் வலைப்பக்கங்களை மேம்படுத்த ஜாவாஸ்கிரிப்ட்டில் சிறிய ஸ்கிரிப்ட்களை எழுத வேண்டும். ஆனால், மிகக் குறைவான நபர்கள் மட்டுமே ஜாவாஸ்கிரிப்டில் குறியீட்டை எழுதவும்."

"ஏன் இதற்கு ஜாவாஸ்கிரிப்ட் என்று பெயரிடப்பட்டது? கிட்டத்தட்ட ஜாவாவைப் போல் தெரிகிறது."

"உண்மையில், ஆரம்பத்தில், இது லைவ்ஸ்கிரிப்ட் என்று அழைக்கப்பட்டது, ஆனால் ஜாவா மிகவும் பிரபலமாகத் தொடங்கியபோது, ​​அது ஜாவாஸ்கிரிப்ட் என மறுபெயரிடப்பட்டது."

"ஜாவா மற்றும் ஜாவாஸ்கிரிப்ட் இரண்டும் முற்றிலும் வேறுபட்ட மொழிகள். அவற்றைக் குழப்ப வேண்டாம்."

"ஜாவாவைப் போலல்லாமல், ஜாவாஸ்கிரிப்ட்டில் வகுப்புகள் இல்லை, மேலும் நிலையான தட்டச்சு, மல்டித்ரெடிங் மற்றும் பலவற்றை ஆதரிக்காது. ஜாவா என்பது ஒரு பெரிய கட்டுமான கருவிகளைப் போன்றது, ஜாவாஸ்கிரிப்ட் சுவிஸ் இராணுவ கத்தி போன்றது. ஜாவாஸ்கிரிப்ட் தீர்க்க வடிவமைக்கப்பட்டுள்ளது. சிறிய பணிகள், ஆனால் ஜாவா பெரிய மற்றும் மிகப் பெரிய பணிகளைத் தீர்ப்பதற்கானது."

"ஜாவாஸ்கிரிப்ட் பற்றிய சில உண்மைகள் இங்கே:"

"முதல் உண்மை என்னவென்றால், ஜாவாஸ்கிரிப்ட் செயல்பாடுகளைக் கொண்டுள்ளது, ஆனால் வகுப்புகள் இல்லை"

"நீங்கள் பல செயல்பாடுகளைப் பயன்படுத்தி நிரல்களை எழுதுகிறீர்கள், அவ்வளவுதான். எடுத்துக்காட்டாக:"

function min(a, b)
{
 return a
}

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

"செயல்பாடு <பெயர்>" ஐப் பயன்படுத்தி புதிய செயல்பாடுகள் அறிவிக்கப்படுகின்றன.

"மற்றொரு உதாரணம்:"

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

"இரண்டாவது உண்மை என்னவென்றால், ஜாவாஸ்கிரிப்ட்டில் மாறிகள் உள்ளன, ஆனால் அந்த மாறிகளுக்கு வகைகள் இல்லை"

"ஜாவாஸ்கிரிப்ட் என்பது மாறும் வகையில் தட்டச்சு செய்யப்பட்ட மொழியாகும். இதன் பொருள் மாறிகள் உண்மையில் வகைகள் இல்லை. எந்த மாறிக்கும் எந்த வகையின் மதிப்பையும் ஒதுக்கலாம் (மதிப்புகளில் வகைகள் உள்ளன). எடுத்துக்காட்டாக:"

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

"ஆனால் டைனமிக் தட்டச்சு இயக்க நேர பிழைகளின் அபாயத்தை அதிகரிக்கிறது:"

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

"மேலே உள்ள எடுத்துக்காட்டில், s (ஒரு சரம்) க்கு பதிலாக k (ஒரு முழு எண்) என்ற மாறியைப் பயன்படுத்தினோம். ஜாவாவில், தொகுக்கும் நேரத்தில் பிழை கண்டறியப்படும், ஆனால் ஜாவாஸ்கிரிப்டில், குறியீடு வரும் வரை அது பிடிக்கப்படாது. ஓடிக்கொண்டிருக்கிறது."

"நீங்கள் ஜாவாஸ்கிரிப்டில் ஒரு மாறியை அறிவிக்க விரும்பினால், நீங்கள் «var <name>» என்று எழுத வேண்டும். மாறி வகைகள் எதுவும் இல்லை, மேலும் முறைகள்/செயல்பாடுகள் அல்லது அவற்றின் வாதங்களுக்கு வகைகள் இல்லை."

"ஜாவாஸ்கிரிப்ட்டில் மிகக் குறைவான கடுமையான விதிகள் மற்றும் நிறைய அராஜகம் உள்ளது."

"நீங்கள் 5 வாதங்களுடன் ஒரு செயல்பாட்டை அறிவிக்கலாம் மற்றும் அதை இரண்டில் அழைக்கலாம் - மீதமுள்ளவை பூஜ்யமாக இருக்கும். நீங்கள் ஒரு செயல்பாட்டை இரண்டு வாதங்களுடன் அறிவிக்கலாம், நீங்கள் அதை அழைக்கும்போது ஐந்தைக் கடக்கலாம். மூன்று வெறுமனே தூக்கி எறியப்படும். குறைந்தபட்ச கட்டுப்பாடு உள்ளது. பிழைகள், எழுத்துப்பிழைகள் மற்றும் மாற்றங்களுக்கு மேல்."

"மூன்றாவது உண்மை என்னவென்றால், ஜாவாஸ்கிரிப்ட் என்றால், அதற்கு, மற்றும் போது அறிக்கைகள் உள்ளன"

"ஜாவாஸ்கிரிப்ட் இஃப், ஃபார், மற்றும் எப்போது உள்ளது. இது ஒரு சிறந்த செய்தி. இந்த உதாரணங்களைப் பாருங்கள்:"

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

"அவை மிகவும் ஒத்தவை. ஜாவாஸ்கிரிப்ட்டில் எழுதப்பட்ட குறியீடு எவ்வாறு செயல்படுகிறது என்பதை என்னால் கண்டுபிடிக்க முடியும் என்று நினைக்கிறேன்."

"உங்கள் நம்பிக்கை நன்றாக உள்ளது."

"நான்காவது உண்மை என்னவென்றால், ஜாவாஸ்கிரிப்ட் முயற்சி-பிடிப்பு-இறுதியில் தொகுதிகளை ஆதரிக்கிறது"

" ஜாவாஸ்கிரிப்ட்டில் விதிவிலக்குகள் உள்ளன ( பிழை ) அது நல்லது. இதில் சரிபார்க்கப்பட்ட விதிவிலக்குகள் இல்லை , RuntimeException போன்ற தேர்வு செய்யப்படாத விதிவிலக்குகள் மட்டுமே . முயற்சி-பிடிப்பு-இறுதியாக கன்ஸ்ட்ரக்ட் ஜாவாவில் உள்ளதைப் போலவே செயல்படுகிறது. எடுத்துக்காட்டாக:"

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

"நாம் சரத்தின் நீளத்தைப் பெற முயற்சிக்கும்போது, ​​மாறி பூஜ்யமாக இருப்பதால் விதிவிலக்கு அளிக்கப்படும்."

"ஐந்தாவது உண்மை என்னவென்றால், ஜாவாஸ்கிரிப்ட்டில் வரிசைகள் உள்ளன"

"நல்ல செய்தி: JavaScript வரிசைகளைக் கொண்டுள்ளது. மோசமான செய்தி: பட்டியல்கள் அல்லது சேகரிப்புகள் எதுவும் இல்லை."

"மற்றொரு நல்ல செய்தி என்னவென்றால், புதிய கூறுகள் சேர்க்கப்படும்போது வரிசைகள் மாறும் வகையில் விரிவடையும் மற்றும் உறுப்புகள் அகற்றப்படும்போது குறையும். இது வரிசை மற்றும் பட்டியலுக்கு இடையே ஒரு கலப்பினத்தைப் போன்றது. "

உதாரணத்திற்கு:

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

"அரே பிரகடனத்தில் அந்த சதுர அடைப்புக்குறிகள் என்ன?"

"அரே டிக்ளரேஷன் என்றால் அதுதான். ஒரு வரிசையை அறிவிக்க, நீங்கள் சதுர அடைப்புக்குறிகளை எழுத வேண்டும். பின்னர் அடைப்புக்குறிகளுக்கு இடையில் அணிவரிசையின் கூறுகளை பட்டியலிடவும். வெற்று வரிசையை ஒரு ஜோடி அடைப்புக்குறிகளுடன் வெறுமனே அறிவிக்கவும்."

var m = [];

"ஆறாவது உண்மை என்னவென்றால், ஜாவாஸ்கிரிப்ட் பொருள்களைக் கொண்டுள்ளது"

"ஜாவாஸ்கிரிப்டில் ஆப்ஜெக்ட்கள் உள்ளன. உண்மையில், ஜாவாஸ்கிரிப்டில் உள்ள அனைத்தும் ஒரு பொருள், பழமையான வகைகளும் கூட. ஒவ்வொரு பொருளும் முக்கிய மதிப்பு ஜோடிகளின் தொகுப்பாகக் குறிப்பிடப்படுகின்றன. தோராயமாகச் சொன்னால், ஒவ்வொரு ஜாவாஸ்கிரிப்ட் பொருளும் ஜாவாவில் உள்ள ஹாஷ்மேப்பிற்குச் சமம். இதோ ஒரு உதாரணம் ஒரு பொருள் அறிவிப்பு:"

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

"புதிய பொருளை உருவாக்க, நீங்கள் இரண்டு சுருள் பிரேஸ்களை எழுத வேண்டும்: «{}»."

"பிரேஸ்களுக்குள், நீங்கள் பின்வரும் வடிவத்தில் பொருள் தரவைக் குறிப்பிடலாம்: «விசை, பெருங்குடல், மதிப்பு, கமா»."

"பொருள் புலங்களை இரண்டு வழிகளில் அணுகலாம்:"

m.age = 45;

m[“age”] = 45;

"குறிப்பிட்ட புலம் இல்லை என்றால், அது உருவாக்கப்பட்டது."

"எனது நிவாரண வால்வில் அதிக சுமை உள்ளது அல்லது ஏதோ ஒன்று. நாம் ஓய்வு எடுக்க வேண்டும் என்று நினைக்கிறேன்."

"ஏழாவது உண்மை என்னவென்றால், வலைப்பக்கங்களுக்குள் வேலை செய்ய ஜாவாஸ்கிரிப்ட் உருவாக்கப்பட்டது."