జావాస్క్రిప్ట్

"హాయ్, అమిగో!"

"హాయ్, బిలాబో!"

"మిమ్మల్ని చూసినందుకు నాకు చాలా ఆనందంగా ఉంది. ఈరోజు మన దగ్గర చిన్నదైన కానీ చాలా ఇన్ఫర్మేటివ్ పాఠం ఉంది. ఈ రోజు నేను మీకు జావాస్క్రిప్ట్ భాష గురించి చెబుతాను."

"కొత్త భాష? ఎంత ఆసక్తికరం..."

"ఇంటర్నెట్ కారణంగా జావాస్క్రిప్ట్ ప్రస్తుతం జనాదరణ పొందింది. వాస్తవం ఏమిటంటే అన్ని బ్రౌజర్‌లు అమలు చేయగల ఏకైక భాష ఇది. మీరు మీ వెబ్ పేజీకి యానిమేషన్ లేదా లాజిక్‌ని జోడించాలనుకుంటే, మీరు దీన్ని జావాస్క్రిప్ట్‌తో చేయవచ్చు."

"జావాస్క్రిప్ట్ అత్యంత ప్రజాదరణ పొందిన భాష నిజమేనా?"

"అవును, అయితే ఇది అత్యంత జనాదరణ పొందిన 'రెండవ భాష' అని చెప్పడం మరింత ఖచ్చితమైనది. C++, Java, C#, మరియు PHP ప్రోగ్రామర్లు తమ వెబ్‌పేజీలను మెరుగుపరచడానికి JavaScriptలో చిన్న స్క్రిప్ట్‌లను వ్రాయాలి. కానీ, చాలా తక్కువ మంది వ్యక్తులు మాత్రమే జావాస్క్రిప్ట్‌లో కోడ్ రాయండి."

"దీనికి జావాస్క్రిప్ట్ అని ఎందుకు పేరు పెట్టారు? ఇది దాదాపు జావా లాగానే ఉంది."

"వాస్తవానికి, ప్రారంభంలో, దీనిని లైవ్‌స్క్రిప్ట్ అని పిలిచేవారు, కానీ జావా మరింత ప్రజాదరణ పొందడం ప్రారంభించినప్పుడు, దీనికి జావాస్క్రిప్ట్ అని పేరు పెట్టారు."

"జావా మరియు జావాస్క్రిప్ట్ రెండు పూర్తిగా భిన్నమైన భాషలు. వాటిని కంగారు పెట్టవద్దు."

"జావాలా కాకుండా, జావాస్క్రిప్ట్‌కు తరగతులు లేవు మరియు స్టాటిక్ టైపింగ్, మల్టీథ్రెడింగ్ మరియు మరెన్నో మద్దతు ఇవ్వదు. జావా పెద్ద నిర్మాణ సాధనాల వంటిది, అయితే జావాస్క్రిప్ట్ స్విస్ ఆర్మీ కత్తిలా ఉంటుంది. జావాస్క్రిప్ట్ పరిష్కరించడానికి రూపొందించబడింది. చిన్న పనులు, కానీ జావా పెద్ద మరియు చాలా పెద్ద పనులను పరిష్కరించడానికి."

"జావాస్క్రిప్ట్ గురించి ఇక్కడ కొన్ని వాస్తవాలు ఉన్నాయి:"

"మొదటి వాస్తవం ఏమిటంటే జావాస్క్రిప్ట్‌కు విధులు ఉన్నాయి, కానీ తరగతులు లేవు"

"మీరు అనేక ఫంక్షన్లను ఉపయోగించి ప్రోగ్రామ్‌లను వ్రాస్తారు మరియు అంతే. ఉదాహరణకు:"

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;

"పేర్కొన్న ఫీల్డ్ ఉనికిలో లేకుంటే, అది సృష్టించబడుతుంది."

"నా రిలీఫ్ వాల్వ్ ఓవర్‌లోడ్ చేయబడింది లేదా మరేదైనా ఉంది. మనం కొంత విరామం తీసుకోవాలని అనుకుంటున్నాను."

"ఏడవ వాస్తవం ఏమిటంటే జావాస్క్రిప్ట్ వెబ్ పేజీలలో పని చేయడానికి సృష్టించబడింది."