జావాస్క్రిప్ట్‌లో ప్రాథమిక అంశాలు

2.1 వేరియబుల్స్ మరియు నొప్పి

అత్యంత ఆసక్తికరమైన దానితో ప్రారంభిద్దాం. జావాస్క్రిప్ట్‌లో వేరియబుల్స్ ఉన్నాయి, కానీ ఆ వేరియబుల్స్‌కు రకం లేదు. ఏదైనా వేరియబుల్ ఖచ్చితంగా ఏదైనా విలువను కేటాయించవచ్చు. మీకు రకాలు అవసరమైనంత వరకు హానికరం లేదా సులభమైనదిగా కనిపిస్తుంది.

వేరియబుల్‌ని ప్రకటించడానికి కీవర్డ్ ఉపయోగించబడుతుంది var:

var name;
var name = value;

జావాస్క్రిప్ట్‌లో వేరియబుల్స్‌తో పని చేసే ఉదాహరణలు:

var a = 10, b = 20;
var c = a*a + b*b;

var s = "Diagonal equals:";
console.log( s + Math.sqrt(c));

గొప్ప మరియు స్పష్టమైన కోడ్, కాదా? మీరు అందమైన మరియు అర్థమయ్యే జావాస్క్రిప్ట్ కోడ్‌ని చూసినప్పుడు బహుశా ఇది మీ జీవితంలో చివరిసారి కావచ్చు. ఈ క్షణం గుర్తుంచుకో :)

2.2 జావాస్క్రిప్ట్‌లో టైప్ చేయడం

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

var pi = 3.14;

var s = "Hello!";

var result = true;

var arr = [1, 2, 3, 4, 5];

var current = new Date();

var o = {
   width: 100,
   height: 200
}

function sqr(var x) {
   return x*x;
}

ఆబ్జెక్ట్ రకాన్ని గుర్తించడానికి టైప్ ఆఫ్ కీవర్డ్ ఉపయోగించబడుతుంది, ఉదాహరణకు:

var s = "134";
var x = (typeof s == "String") ? s*1 : s;

2.3 విధులు మరియు రాబడి

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

function name(a, b, c) {
  // function code
   return result;
}

ఫంక్షన్‌కు రకం లేదు. భాషలోనే టైప్ కంపాటబిలిటీ కంట్రోల్ లేకపోతే ఎందుకు? ఫంక్షన్ పారామితులు కూడా లేకపోవచ్చు. కాబట్టి రిటర్న్ కమాండ్ ఉంది, ఇది విలువను తిరిగి ఇస్తుంది.

ఫంక్షన్‌కి కాల్ చేస్తున్నప్పుడు, మీరు ఏ రకమైన పారామితులనైనా పాస్ చేయవచ్చు . అదనపు విస్మరించబడుతుంది, తప్పిపోయినవి సమానంగా ఉంటాయి null.

ఫంక్షన్ ఉదాహరణలు:

function getValue(name)
{
    return this[name];
}

function setValue(name, value)
{
    this[name] = value;
}

2.4 జావాస్క్రిప్ట్‌లో శ్రేణులు

జావాస్క్రిప్ట్‌లోని శ్రేణులు జావాలోని శ్రేణుల మాదిరిగానే ఉంటాయి. ఉదాహరణలు:

var array = [1, 2, 3, 4, 5];
array[3] = array[2];
console.log (array[0]);

వారు ఏ రకమైన విలువలను కలిగి ఉండవచ్చు, ఇతర శ్రేణులు కూడా:

var array = [1, "Hello", 3.14, [4, 5] ];
array[3] = array[2];
console.log (array[0]);

అదనంగా, శ్రేణులు కూడా సేకరణల వలె ప్రవర్తిస్తాయి - మీరు వాటికి ఎలిమెంట్‌లను డైనమిక్‌గా జోడించవచ్చు:

var array = [];
array.push(100);
array.push(101);
array.push(102);

array[1] = array[2];
console.log (array[0]);

2.5 జావాస్క్రిప్ట్‌లోని వస్తువులు

జావాస్క్రిప్ట్‌లోని ఆబ్జెక్ట్‌లు జావాలోని హాష్‌మ్యాప్‌తో సమానంగా ఉంటాయి: అవి కీ-విలువ జతలను కలిగి ఉంటాయి. ఉదాహరణ:

var obj = {
 name: "Bill Gates",
 age: 67,
 company: "Microsoft"
};

console.log (obj.age);

ఆబ్జెక్ట్ ఫీల్డ్‌లను రెండు రకాలుగా యాక్సెస్ చేయవచ్చు:

var x = obj.age;
var x = obj["age"];

HashMap వలె, ఫీల్డ్‌లను సృష్టించవచ్చు మరియు తొలగించవచ్చు. ఉదాహరణ:

var obj = {};
obj.name = "Bill Gates";
obj.age = 67;
obj.company = "Microsoft";

delete obj.age;  //remove field