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 రకాలు ఇక్కడ ఉన్నాయి:
# | టైప్ చేయండి | ఉదాహరణ | వివరణ |
---|---|---|---|
1 | సంఖ్య |
|
ఏదైనా సంఖ్యను కలిగి ఉంటుంది |
2 | స్ట్రింగ్ |
|
స్ట్రింగ్ని కలిగి ఉంటుంది |
3 | బూలియన్ |
|
నిజం లేదా తప్పు కలిగి ఉంటుంది |
4 | అమరిక |
|
మూలకాల శ్రేణిని కలిగి ఉంటుంది |
5 | తేదీ |
|
తేదీని కలిగి ఉంటుంది |
6 | వస్తువు |
|
కీ, విలువ జతలను కలిగి ఉన్న వస్తువును కలిగి ఉంటుంది. జావాలోని హాష్మ్యాప్ని పోలి ఉంటుంది |
7 | ఫంక్షన్ |
|
ఫంక్షన్ |
ఆబ్జెక్ట్ రకాన్ని గుర్తించడానికి టైప్ ఆఫ్ కీవర్డ్ ఉపయోగించబడుతుంది, ఉదాహరణకు:
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
GO TO FULL VERSION