జావాస్క్రిప్ట్ డేటా టైప్
- ముంది పేజీ జెఎస్ అసిగ్న్మెంట్
- తరువాతి పేజీ జెఎస్ ఫంక్షన్స్
పదబంధం విలువలు, సంఖ్యలు, బుల్ విలువలు, అర్రేలు, ఆబ్జెక్ట్లు.
జావాస్క్రిప్ట్ డేటా టైప్
JavaScript వేరు వేరు డాటా రకాలను నిర్వహించగలదు:డాటా రకంవిలువలు, పదబంధం విలువలు, అర్రేలు, ఆబ్జెక్ట్లు మొదలైన విషయాలు మొదలైన విషయాలు ఇలా ఉంటాయి:
var length = 7; // సంఖ్య
var lastName = "Gates"; // పదబంధం
var cars = ["Porsche", "Volvo", "BMW"]; // అర్రే
var x = {firstName:"Bill", lastName:"Gates"}; // ఆబ్జెక్ట్
డాటా రకం సంకేతం:
ప్రోగ్రామింగ్ ప్రక్రియలో డాటా రకం ఒక ముఖ్యమైన సంకేతం ఉంది:
వేరు వేరు డాటా రకాలను కేవలం ఆపరేషన్ చేయడానికి డాటా రకం గుర్తింపు ముఖ్యం కాదు:
డాటా రకం లేకపోతే కంప్యూటర్ ఈ సమస్యను సురక్షితంగా పరిష్కరించలేదు:
var x = 911 + "Porsche";
పోర్ష్చే కు 911 చేర్చాలి లేదా ఇది విఫలం అవుతుందా లేదా ఫలితాన్ని ఇస్తుంది అని తెలుసుకోవాలి కాదా?
JavaScript ఇలా ప్రామాణించబడుతుంది:
var x = "911" + "Porsche";
సంఖ్యలు మరియు పదార్థాలను జోడించినప్పుడు, JavaScript సంఖ్యలను పదార్థంగా పరిగణిస్తుంది.
实例
var x = 911 + "Porsche";
实例
var x = "Porsche" + 911;
JavaScript ఎడమ నుండి కుడికి అనుకూలంగా వ్యాఖ్యానిస్తుంది. వేర్వేరు క్రమాలు వేర్వేరు ఫలితాలను ప్రదర్శిస్తాయి:
JavaScript：
var x = 911 + 7 + "Porsche";
ఫలితం:
918Porsche
JavaScript：
var x = "Porsche" + 911 + 7;
ఫలితం:
Porsche9117
మొదటి ఉదాహరణలో, JavaScript 911 మరియు 7 సంఖ్యలుగా పరిగణించింది, అయితే "Porsche" కనుగొన్నప్పుడు పదార్థంగా మారింది.
రెండవ ఉదాహరణలో, మొదటి ఆపరేంట్ పదార్థం అయినప్పుడు, అన్ని ఆపరేంట్లు పదార్థంగా పరిగణించబడతాయి.
JavaScript సాంకేతిక రకం కలిగి ఉంటుంది
JavaScript సాంకేతిక రకం కలిగి ఉంటుంది. ఇది అర్థం చేస్తుంది కొన్ని వేర్వేరు రకాలు కొన్ని వేర్వేరు రకాలు వాడవచ్చు:
实例
var x; // ఇప్పుడు x అనిశ్చితం var x = 7; // ఇప్పుడు x సంఖ్యలు var x = "Bill"; // ఇప్పుడు x పదార్థపదం
JavaScript పదార్థపదం
పదార్థం (లేదా టెక్స్ట్ పదార్థం) అనేది ఒక పదార్థం సరికొత్త పదార్థం (ఉదాహరణకు "Bill Gates")
పదార్థం చిరునామాలతో చుట్టబడి ఉంటుంది. మీరు చిన్న లేదా పెద్ద చిరునామాలను వాడవచ్చు:
实例
var carName = "Porsche 911"; // పెద్ద చిరునామా వాడుతున్నారు var carName = 'Porsche 911'; // చిన్న చిరునామా వాడుతున్నారు
పదార్థంలో మీరు చిరునామాలను వాడవచ్చు, ఈ చిరునామాలు పదార్థం చుట్టూ ఉన్న చిరునామాలకు సరిపోయేటట్టు ఉండాలి:
实例
var answer = "It's alright"; // పెద్ద చిరునామా లో చిన్న చిరునామా var answer = "He is called 'Bill'"; // పెద్ద చిరునామా లో చిన్న చిరునామా var answer = 'He is called "Bill"'; // ఒక చిన్న చిరునామా లో పెద్ద చిరునామా
ఈ పాఠ్యక్రమంలో మీరు కొన్ని పదార్థాలను కనుగొంటారు.
JavaScript సంఖ్యలు
JavaScript లో ఒక మాత్రపదం రకం ఉంది.
సంఖ్యలను వ్రాయటంలో సమీపం ఉండాలా లేదా లేదు చెప్పవచ్చు:
实例
var x1 = 34.00; // సమీపం ఉంది var x2 = 34; // లేదా సమీపం లేదు
పెద్ద లేదా చిన్న సంఖ్యలను వైజ్ఞానిక పద్ధతిలో వ్రాయవచ్చు:
实例
var y = 123e5; // 12300000 var z = 123e-5; // 0.00123
మీరు ఈ శిక్షణలో మరిన్ని విషయాలను నేర్చుకునేవారు ఉంటారు.
జావాస్క్రిప్ట్ బుల్ విలువలు
బుల్ విలువలు రెండు విలువలు ఉన్నాయి:true లేదా false。
实例
var x = true; var y = false;
బుల్ విలువలు సాధారణంగా పరిస్థితి పరికరాలలో ఉపయోగించబడతాయి.
మీరు ఈ శిక్షణలో మరిన్ని విషయాలను నేర్చుకునేవారు ఉంటారు.
జావాస్క్రిప్ట్ అరేయా
జావాస్క్రిప్ట్ అర్థాలు బిగ్గర కొమత్తులతో రాయబడతాయి.
అర్థం ప్రాజెక్టులు కామస్క్రిప్ట్‌తో వేరు వేరు.
ఈ కోడు పేరు cars అనే అర్థాన్ని ప్రకటించి (సృష్టించి) మూడు ప్రాజెక్ట్లను (కారు బ్రాండ్లను) కలిగి ఉంది:
实例
var cars = ["Porsche", "Volvo", "BMW"];
అర్థం సంఖ్యలు ప్రారంభం నుండి ఉన్నాయి, ఇది అర్థం మొదటి ప్రాజెక్ట్ ఉంది [0], రెండవ ప్రాజెక్ట్ ఉంది [1], ఇలా కొనసాగుతుంది.
మీరు ఈ శిక్షణలో మరిన్ని విషయాలను నేర్చుకునేవారు ఉంటారు.
జావాస్క్రిప్ట్ ఆబ్జెక్ట్
జావాస్క్రిప్ట్ అర్థాలు కొమత్తులతో రాయబడతాయి.
అర్థం అనునాయికలు ఉన్నాయి name:value అయినా, కామస్క్రిప్ట్‌తో వేరు వేరు.
实例
var person = {firstName:"Bill", lastName:"Gates", age:62, eyeColor:"blue"};
పై ఉదాహరణలో ఉన్న అర్థం (person) నాలుగు అనునాయికలు ఉన్నాయి: firstName, lastName, age మరియు eyeColor.
ఈ శిక్షణలో మీరు అర్థాలపై మరిన్ని విషయాలను నేర్చుకునేవారు ఉంటారు.
typeof ఆపరేటర్
మీరు జావాస్క్రిప్ట్లో మరిన్ని విషయాలను నేర్చుకునేవారు ఉంటారు. typeof జావాస్క్రిప్ట్ వేరు విలువ రకం తెలుసుకోవడానికి ఉపయోగించవచ్చు:
typeof ఆపరేటర్ వేరు లేదా అభ్యాసం విలువ లేది విలువ అనే రకం ఉంది:
实例
typeof "" // అర్థం "string" typeof "Bill" // స్ట్రింగ్ typeof "Bill Gates" // అర్థం "string"
实例
typeof 0 // అర్థం "number" typeof 314 // అర్థం "number" typeof 3.14 // నంబర్ typeof (7) // అర్థం "number" typeof (7 + 8) // అర్థం "number"
typeof ఆపరేటర్ అర్థంలో కరస్తుంది "object" అని, ఎందుకంటే జావాస్క్రిప్ట్లో అర్థంలో అర్థాలు ఉన్నాయి.
సంక్షిప్తంగా లేదు
జావాస్క్రిప్ట్లో, విలువ లేని వేరు, దాని విలువ ఉంది undefined。typeof కూడా తిరిగి ఇస్తుంది undefined。
实例
var person; // విలువ సంక్షిప్తంగా లేదు, రకం సంక్షిప్తంగా లేదు。
ఏ వ్యక్తిగతినైనా విలువను అందించవచ్చు ద్వారా: undefined శుభ్రం చేయడానికి ద్వారా విలువ కూడా శుభ్రం అవుతుంది. undefined。
实例
person = undefined; // విలువ సంక్షిప్తంగా లేదు, రకం సంక్షిప్తంగా లేదు.
శుభ్రమైన విలువ
శుభ్రమైన విలువ మరియు undefined ఇది ఒక విషయం కాదు.
శుభ్రమైన స్ట్రింగ్ వ్యక్తిగతి అనేది విలువ కలిగినది మరియు రకం కలిగినది.
实例
var car = ""; // విలువ సంక్షిప్తంగా లేదు, రకం స్ట్రింగ్
నల్ల మూత్రం
నల్ల మూత్రంnull జావాస్క్రిప్ట్లో,
దురదర్శనకరంగా, జావాస్క్రిప్ట్లో సంక్షిప్తంగా లేదు అనేది "నథింగ్". ఇది లేని విషయంగా చూస్తారు.null అనుసరించి రకం ఆప్లికేషన్ ఉంది.
మీరు అలాగే దిగువన ఉన్న డాటా రకాన్ని అందించవచ్చు ద్వారా: null జావాస్క్రిప్ట్లో ఆప్లికేషన్ అనేది ఒక బగ్. ఇది ఉండాలి అని ఆశించారు: null。
మీరు అలాగే విలువను అందించవచ్చు ద్వారా: null పరిధిని శుభ్రం చేయండి:
实例
var person = null; // విలువ నల్ల మూత్రం, కానీ రకం ఆప్లికేషన్ ఉంది
మీరు అలాగే విలువను అందించవచ్చు ద్వారా: undefined పరిధిని శుభ్రం చేయండి:
实例
var person = undefined; // విలువ సంక్షిప్తంగా లేదు, రకం సంక్షిప్తంగా లేదు.
సంక్షిప్తంగా లేదు మరియు నల్ల మూత్రం మధ్య తేడా
సంక్షిప్తంగా లేదు మరియు null విలువలు సమానం కాని రకాలు ఉన్నాయి:
typeof undefined // సంక్షిప్తంగా లేదు typeof null // ఆప్లికేషన్ null === undefined // సమానం కాదు null == undefined // సంక్షిప్తంగా సమానం
మూల డాటా విలువ
మూల డాటా విలువ అదనపు అంశాలు మరియు మంచిని లేని ఒక సరళమైన డాటా విలువ రూపం ఉంటుంది。
typeof ఆపరేటర్స్ దిగువన ఒక మూల రకాన్ని తిరిగి ఇస్తాయి:
- string
- number
- boolean
- undefined
实例
typeof "Bill" // స్ట్రింగ్ typeof 3.14 // నంబర్ typeof true // బ్లూన్ typeof false // బ్లూన్ typeof x // 返回 "undefined" (假如 x 没有值)
复杂数据
typeof 运算符可返回以下两种类型之一：
- function
- ఆబ్జెక్ట్
typeof 运算符把对象、数组或 null 返回 ఆబ్జెక్ట్。
typeof 运算符不会把函数返回 ఆబ్జెక్ట్。
实例
typeof {name:'Bill', age:62} // 返回 "object"
typeof [1,2,3,4] // తిరిగి "object" (కానీ "array" కాదు, క్రింది కార్యాచరణను చూడండి)
typeof null // తిరిగి "object"
typeof function myFunc(){} // తిరిగి "function"
typeof ఆపరేటర్ అర్రేయ్ అనేది పద్ధతిని అనుసరించబడుతుంది “ఆబ్జెక్ట్“ఎందుకంటే జావాస్క్రిప్ట్ లో అర్రేయ్ అనేది ఆబ్జెక్ట్ కాగా ఉంటుంది.”
బయటి చదనం
జావాస్క్రిప్ట్ అధునాతన శిక్షణాలు:
- ముంది పేజీ జెఎస్ అసిగ్న్మెంట్
- తరువాతి పేజీ జెఎస్ ఫంక్షన్స్
