जावास्क्रिप्ट लूप ठराविक वेळा प्ले करा. JavaScript मधील लूपसाठी

|

while आणि do...while सशर्त असल्याने, दिलेले विधान सत्य असल्याचे मूल्यमापन केल्यावर ते कार्यान्वित केले जातात. स्टेटमेंट फॉर स्टेटमेंट देखील अटींवर आधारित आहे, परंतु ते अतिरिक्त वैशिष्ट्ये प्रदान करते जसे की लूप काउंटर, जे तुम्हाला लूपच्या पुनरावृत्तीची संख्या आधीच सेट करण्याची परवानगी देते.

हे ट्यूटोरियल तुम्हाला जावास्क्रिप्टमधील प्रोग्रामिंगचे अविभाज्य घटक असलेल्या लूपसाठी, साठी...साठी आणि...साठी कसे वापरायचे ते शिकवेल.

लूपसाठी

लूपसाठी A कोडचा ब्लॉक वारंवार कार्यान्वित करण्यासाठी तीन पर्यायी अभिव्यक्ती वापरू शकतो.

चला लूप सिंटॅक्स पाहू.

साठी (प्रारंभ; स्थिती; अंतिम अभिव्यक्ती) (
// कोड अंमलात आणायचा आहे
}

• इनिशियलायझेशन (निर्दिष्ट असल्यास) काउंटर सुरू करते आणि व्हेरिएबल्स घोषित करते.
• अट पुढील प्रक्रिया आहे. खरे असल्यास, प्रोग्राम खालील कोड कार्यान्वित करेल; जर ते खोटे असेल तर, लूप खंडित होईल.
• मग ज्या कोडची अंमलबजावणी करणे आवश्यक आहे त्यावर प्रक्रिया केली जाते.
• जर अंतिम अभिव्यक्ती निर्दिष्ट केली असेल, तर ती अद्यतनित केली जाते, त्यानंतर लूप स्थितीवर प्रक्रिया करण्यासाठी परत येतो.

हे कसे कार्य करते हे समजून घेण्यासाठी, एक मूलभूत उदाहरण पाहू.

साठी (i = 0; i< 4; i++) {
// कन्सोलवर प्रत्येक पुनरावृत्ती मुद्रित करा
console.log(i);
}

तुम्ही हा कोड चालवल्यास, तुम्हाला हा परिणाम मिळेल:

0
1
2
3

वरील उदाहरणात, फॉर लूप let i = 0 या व्हेरिएबलने सुरू होतो, जो लूपला 0 व्हॅल्यूने सुरू करेल. लूपमधील स्थिती i आहे.< 4, а это означает, что до тех пор, пока значение i меньше 4, цикл будет продолжать работу. Финальное выражение i++ определяет счетчик для каждой итерации цикла. console.log(i) выводит числа, начиная с 0, и останавливается, как только i равняется 4.

लूपशिवाय, समान गोष्ट करणारा कोड असेल:

// प्रारंभिक व्हेरिएबल 0 वर सेट करा
let i = 0;
// मॅन्युअली व्हेरिएबल 1 ने चार वेळा वाढवा
console.log(i++);
console.log(i++);
console.log(i++);
console.log(i++);

लूपशिवाय, कोडच्या ब्लॉकमध्ये अधिक ओळी असतात. अंकांची संख्या वाढवण्यासाठी, आपल्याला कोडमध्ये आणखी ओळी जोडणे आवश्यक आहे.

लूपमधील प्रत्येक अभिव्यक्ती पाहू.

आरंभ करणे

लूपमधील पहिली अभिव्यक्ती आरंभिकरण आहे.

हे let कीवर्ड वापरून एक व्हेरिएबल i घोषित करते (तुम्ही var कीवर्ड देखील वापरू शकता) आणि त्यास 0 मूल्य नियुक्त करते. तुम्ही तुमच्या लूपमध्ये कोणतेही व्हेरिएबलचे नाव वापरू शकता, परंतु व्हेरिएबल i "पुनरावृत्ती" या शब्दाशी संबंधित आहे आणि नाही. कोड ओव्हरलोड करा.

अट

जसे while and do...while loops, for loops ला सहसा एक अट असते. या उदाहरणात ते आहे:

याचा अर्थ जोपर्यंत i चे मूल्य 4 पेक्षा कमी आहे तोपर्यंत अभिव्यक्तीचे मूल्यमापन सत्य होते.

अंतिम अभिव्यक्ती

ही एक अभिव्यक्ती आहे जी प्रत्येक लूपच्या शेवटी अंमलात आणली जाते. हे बहुधा व्हेरिएबलचे मूल्य वाढवण्यासाठी किंवा कमी करण्यासाठी वापरले जाते, परंतु ते इतर कारणांसाठी वापरले जाऊ शकते.

या उदाहरणात, लूप व्हेरिएबलला एकाने वाढवतो. i++ ही अभिव्यक्ती i = i + 1 प्रमाणेच करते.

प्रारंभ आणि स्थितीच्या विपरीत, अंतिम अभिव्यक्ती अर्धविरामाने समाप्त होत नाही.

लूप बॉडी

आता तुम्हाला a for loop चे सर्व घटक माहित आहेत. चला कोड पुन्हा पाहू.

// 5 पुनरावृत्त्यांसह विधानासाठी एक आरंभ करा
साठी (i = 0; i< 4; i++) {
console.log(i);
}

पहिली अभिव्यक्ती व्हेरिएबलचे प्रारंभिक मूल्य (0) सेट करते, दुसरी स्थिती निर्धारित करते (i 4 पेक्षा कमी असताना लूप कार्यान्वित केला जातो) आणि तिसरा प्रत्येक पुनरावृत्तीची पायरी सेट करतो (या प्रकरणात मूल्य वाढेल 1).

कन्सोल मूल्ये आउटपुट करेल: 0, 1, 2 आणि 3. नंतर लूप खंडित होईल.

पर्यायी अभिव्यक्ती

लूप एक्सप्रेशनसाठी सर्व पर्यायी आहेत. उदाहरणार्थ, तुम्ही लूपसाठी तेच लिहू शकता, परंतु इनिशियलायझेशन वगळू शकता आणि लूपच्या बाहेर व्हेरिएबल सुरू करू शकता.

let i = 0;
// लूप सुरू करा
साठी(; i< 4; i++) {
console.log(i);
}
0
1
2
3

या प्रकरणात, पहिला अर्धविराम सूचित करतो की सुरुवात गहाळ आहे.

टीप: जरी तुम्ही अभिव्यक्तीपैकी एक वापरत नसला तरीही, तुम्ही अर्धविराम समाविष्ट करणे आवश्यक आहे, अन्यथा लूपचा चुकीचा अर्थ लावला जाईल.

तसेच, उदाहरण म्हणून, तुम्ही लूपमधून अट काढू शकता. जेव्हा व्हेरिएबलचे मूल्य 3 पेक्षा मोठे होते तेव्हा लूप थांबवण्यासाठी if आणि break वापरा.

// लूपच्या बाहेर व्हेरिएबल घोषित करा
let i = 0;
// आरंभ आणि स्थिती वगळा
साठी (;; i++) (
जर (i > 3) (
खंडित;
}
console.log(i);
}
0
1
2
3

महत्वाचे! अटीशिवाय लूपमध्ये, तुम्ही ब्रेक स्टेटमेंट वापरणे आवश्यक आहे. अन्यथा, लूप व्यत्यय आणू शकणार नाही (अशा लूपला अंतहीन म्हटले जाते) आणि ब्राउझर क्रॅश होईल.

आपण लूपमधून अंतिम अभिव्यक्ती देखील काढू शकता. चरण लूप कोडच्या शेवटी निर्दिष्ट केले जाऊ शकते. या प्रकरणात, आपण दोन्ही ";" वर्ण कंसात सोडले पाहिजेत, अन्यथा लूप कार्य करणार नाही.

// लूपच्या बाहेर व्हेरिएबल घोषित करा
let i = 0;
//सर्व विधाने वगळा
साठी (;;) (
जर (i > 3) (
खंडित;
}
console.log(i);
i++;
}
0
1
2
3

तुम्ही बघू शकता, लूप एक्सप्रेशन्स सर्वात संक्षिप्त आणि वाचनीय कोड तयार करतात.

ॲरे बदलत आहे

ए फॉर लूप ॲरे सुधारण्यासाठी वापरला जाऊ शकतो.

खाली दिलेले उदाहरण लूप काउंटर वापरून रिक्त ॲरे कसे तयार करायचे आणि व्हेरिएबल्सने कसे भरायचे ते दाखवते. modifyArray.js फाइल तयार करा आणि त्यात खालील कोड जोडा:

// रिक्त ॲरे सुरू करा
arrayExample = ;
// 3 वेळा चालविण्यासाठी लूप सुरू करा
साठी (i = 0; i< 3; i++) {
// व्हेरिएबल व्हॅल्यूसह ॲरे अपडेट करा
arrayExample.push(i);
console.log(arrayExample);
}

कार्यक्रम लाँच करा. ते आउटपुट करेल:

[ 0 ]
[ 0, 1 ]
[ 0, 1, 2 ]

दिलेला लूप i पर्यंत कार्यान्वित केला जातो< 3 перестанет быть истинным. Массив arrayExample выводится в консоль в конце каждой итерации. Так вы можете увидеть, как массив пополняется новыми значениями.

ॲरे लांबी

कधीकधी लूप अनेक वेळा कार्यान्वित करणे आवश्यक असते, परंतु पुनरावृत्तीची आवश्यक संख्या निश्चित करणे कठीण असते. मागील उदाहरणांप्रमाणे, पुनरावृत्तीची संख्या घोषित करण्याऐवजी, ॲरेमध्ये जितक्या वेळा घटक आहेत तितक्या वेळा लूप चालवण्यासाठी तुम्ही लांबी गुणधर्म वापरू शकता.

// 3 आयटमसह ॲरे घोषित करा
let fish = [ "फ्लंडर", "सॅल्मन", "पाईक"];
ॲरेच्या एकूण लांबीसाठी चालण्यासाठी //लूप सुरू करा
साठी (i = 0; i< fish.length; i++) {
// कन्सोलवर प्रत्येक आयटम मुद्रित करा
console.log(fish[i]);
}

असा कार्यक्रम परिणाम देईल:

फसवणूक
सॅल्मन
पाईक

हे लूप फिश[i] वापरून प्रत्येक ॲरे इंडेक्समधून पुनरावृत्ती होते. यामुळे प्रत्येक पुनरावृत्तीसह निर्देशांक गतिमानपणे अद्यतनित केला जातो.

लूप हे एकापेक्षा जास्त वेळा काहीतरी करण्याचा एक सोपा मार्ग आहे. JavaScript मार्गदर्शकाचा हा धडा तुम्हाला JavaScript मध्ये उपलब्ध असलेल्या विविध ऑपरेटरशी ओळख करून देईल.

तुम्ही लूपला गेमची संगणकीकृत आवृत्ती म्हणून विचार करू शकता जिथे तुम्ही एखाद्याला एका दिशेने X पावले उचलण्यास सांगता, नंतर Y पावले दुसऱ्या दिशेने; उदाहरणार्थ, "5 पावले पूर्वेकडे चाला" या खेळाची कल्पना लूप म्हणून व्यक्त केली जाऊ शकते:

वर पायरी; साठी (चरण = 0; चरण< 5; step++) { // Запускается 5 раз, с шагом от 0 до 4. console.log("Идём 1 шаг на восток"); }

अनेक प्रकारचे लूप आहेत, परंतु ते सर्व मूलत: समान कार्य करतात: ते काही क्रिया अनेक वेळा पुनरावृत्ती करतात (शून्य पुनरावृत्ती वेळेबद्दल विसरू नका, ॲरेमधील मोजणी 0 पासून सुरू होते). वेगवेगळ्या संरचनेची सायकल सायकलची सुरुवात आणि शेवट ठरवण्यासाठी वेगवेगळे मार्ग देतात. विविध प्रोग्रामिंग कार्यांचे स्वतःचे लूप ऑपरेटर असतात, ज्याच्या मदतीने ते बरेच सोपे सोडवता येतात.

JavaScript मध्ये लूप आयोजित करण्यासाठी डिझाइन केलेले ऑपरेटर:

लूपसाठी

काही विशेष लूप संपुष्टात येईपर्यंत लूप क्रियांची पुनरावृत्ती करते. जावास्क्रिप्टमधील फॉर स्टेटमेंट हे जावा आणि सी मधील फॉर स्टेटमेंट सारखेच आहे. फॉर स्टेटमेंटची घोषणा खालीलप्रमाणे आहे:

([प्रारंभ]; [अट]; [चरण]) अभिव्यक्तीसाठी

जेव्हा ते अंमलात आणले जाते, तेव्हा पुढील गोष्टी घडतात:

निर्दिष्ट केल्यास, प्रारंभ अभिव्यक्ती कार्यान्वित केली जाते. ही अभिव्यक्ती सामान्यत: एक किंवा अधिक काउंटर सुरू करते, परंतु वाक्यरचना अभिव्यक्तीला कोणत्याही जटिलतेची अनुमती देते. व्हेरिएबल्स घोषित करण्यासाठी देखील वापरले जाते.

अट पाळली जाते. अट सत्य असल्यास, अभिव्यक्ती अंमलात आणल्या जातात. ते असत्य असल्यास, फॉर लूप तुटतो. जर अट पूर्णपणे वगळली असेल तर ती सत्य मानली जाते.

अभिव्यक्ती अंमलात आणल्या जातात. एकाधिक अभिव्यक्ती कार्यान्वित करण्यासाठी, ब्लॉक अभिव्यक्ती ( ... ) अभिव्यक्ती गट करण्यासाठी वापरली जातात.

एक असल्यास चरण अद्यतनित केले जाते आणि नंतर नियंत्रण चरण 2 वर परत येते.

उदाहरण

खालील फंक्शनमध्ये एक लूप आहे जो स्क्रोल सूचीमधील निवडलेल्या शैलींची संख्या मोजतो (जो घटक तुम्हाला एकाधिक आयटम निवडण्याची परवानगी देतो). फॉर लूप एक व्हेरिएबल i घोषित करतो आणि त्याचे मूल्य 0 वर सेट करतो. हे देखील तपासते की i घटक मधील घटकांच्या संख्येपेक्षा कमी आहे, if स्टेटमेंट कार्यान्वित करते आणि प्रत्येक लूपमधून गेल्यानंतर i एक-एक करून वाढवते.

संगीताच्या काही शैली निवडा आणि नंतर खालील बटणावर क्लिक करा: R&B Jazz Blues New Age Classical Opera

फंक्शन howMany(selectObject) ( var numberSelected = 0; for (var i = 0; i< selectObject.options.length; i++) { if (selectObject.options[i].selected) { numberSelected++; } } return numberSelected; } var btn = document.getElementById("btn"); btn.addEventListener("click", function(){ alert("Выбрано элементов: " + howMany(document.selectForm.musicTypes)) });

do...while loop

do...while loop जोपर्यंत दिलेली स्थिती सत्य आहे तोपर्यंत पुनरावृत्ती होते. करा...तर विधान असे दिसते:

अभिव्यक्ती करा (स्थिती);

जोपर्यंत स्थिती सत्य आहे तोपर्यंत अभिव्यक्ती अंमलात आणल्या जातात. एकाधिक अभिव्यक्ती वापरण्यासाठी, त्यांना गटबद्ध करण्यासाठी ब्लॉक अभिव्यक्ती ( ... ) वापरा. अट सत्य असल्यास, अभिव्यक्ती पुन्हा कार्यान्वित केली जातील. प्रत्येक पासच्या शेवटी स्थिती तपासली जाते. अट चुकीची असल्यास, अंमलबजावणी निलंबित केली जाते आणि do...while नंतर नियंत्रण अभिव्यक्तीवर हस्तांतरित केले जाते.

उदाहरण

खालील उदाहरणात, do लूप किमान 1 वेळा कार्यान्वित होईल आणि i 5 पेक्षा कमी असेल तोपर्यंत पुन्हा चालेल.

करा ( i += 1; console.log(i); ) असताना (i< 5);

पळवाट असताना

कंडिशन सत्य असेपर्यंत व्हेल लूप एक्स्प्रेशन चालवते. हे असे दिसते:

तर (अट) भाव

कंडिशन असत्य झाल्यास, लूपमधील अभिव्यक्ती कार्यान्वित होणे थांबवतात आणि नियंत्रण लूपनंतर अभिव्यक्तीकडे जाते.

लूपमधील अभिव्यक्ती कार्यान्वित होण्यापूर्वी स्थिती सत्य असल्याचे तपासले जाते. जर स्थिती सत्य असेल तर, अभिव्यक्ती अंमलात आणल्या जातात आणि नंतर स्थितीची पुन्हा चाचणी केली जाते. अट चुकीची असल्यास, अंमलबजावणी निलंबित केली जाते आणि नियंत्रण काही काळानंतर अभिव्यक्तीकडे जाते.

एकाधिक अभिव्यक्ती वापरण्यासाठी, त्यांना गटबद्ध करण्यासाठी अभिव्यक्ती ( ... ) ब्लॉक वापरा.

उदाहरण १

n तीनपेक्षा कमी आहे तोपर्यंत खालील लूप चालतो:

वर n = 0; var x = 0; असताना (एन< 3) { n++; x += n; }

प्रत्येक पुनरावृत्तीसह, लूप n वाढतो आणि ते मूल्य x मध्ये जोडतो. म्हणून, x आणि n खालील मूल्ये मिळवा:

• पहिल्या पास नंतर: n = 1 आणि x = 1
• दुसऱ्या नंतर: n = 2 आणि x = 3
• तिसरा पास झाल्यानंतर: n = 3 आणि x = 6

तिसरी पास झाल्यानंतर अट एन< 3 становится ложным, поэтому цикл прерывается.

उदाहरण २

अंतहीन पळवाट टाळा. लूपची स्थिती अखेरीस खोटी असल्याचे सुनिश्चित करा; अन्यथा, सायकल कधीही खंडित होणार नाही. पुढील while लूपमधील भाव कायमचे चालतील कारण स्थिती कधीही खोटी होणार नाही:

असताना (सत्य) ( console.log("हॅलो, वर्ल्ड");)

लेबल

लेबल हे एक आयडेंटिफायर असलेले विधान आहे जे तुम्हाला तुमच्या प्रोग्राममधील एखाद्या ठिकाणाचा संदर्भ घेऊ देते. उदाहरणार्थ, तुम्ही लूप दर्शविण्यासाठी लेबल वापरू शकता आणि नंतर ब्रेक किंवा कंटिन्यू स्टेटमेंट्स वापरू शकता हे सूचित करण्यासाठी की प्रोग्रामने लूप खंडित केला पाहिजे किंवा ते कार्यान्वित करणे सुरू ठेवावे.

लेबल वाक्यरचना खालीलप्रमाणे आहे:

टॅग: ऑपरेटर

अर्थ टॅगकोणताही वैध JavaScript अभिज्ञापक असू शकतो जो आरक्षित शब्द नाही. ऑपरेटर , तुम्ही लेबल नंतर निर्दिष्ट केलेले कोणतेही अभिव्यक्ती असू शकते.

उदाहरण

या उदाहरणात, markLoop एक while loop दर्शवते.

मार्कलूप: तर (theMark == true) ( ​​doSomething();)

खंडित

लूप तोडण्यासाठी, नियंत्रण बदलण्यासाठी किंवा लेबल स्टेटमेंटच्या संयोजनात ब्रेक स्टेटमेंट वापरा.

• जेव्हा तुम्ही लेबलशिवाय ब्रेक वापरता, तेव्हा ते while , do-while , आणि लूपसाठी ब्रेक करते किंवा ताबडतोब पुढील अभिव्यक्तीवर नियंत्रण स्विच करते.
• जेव्हा तुम्ही चिन्हासह ब्रेक वापरता, तेव्हा ते विशेष चिन्हांकित अभिव्यक्ती तोडते.

ऑपरेटर वाक्यरचना असू शकते:

खंडित;

खंडित लेबल;

वाक्यरचनाचा पहिला प्रकार लूप पूर्णपणे तोडतो किंवा नियंत्रण स्विच करतो; दुसरा विशेषतः नियुक्त केलेल्या अभिव्यक्तीमध्ये व्यत्यय आणतो.

उदाहरण १

खालील उदाहरण ॲरेमधील घटकांद्वारे पुनरावृत्ती होते जोपर्यंत त्याला एक घटक सापडत नाही ज्याचे मूल्य theValue आहे:

साठी (i = 0; i< a.length; i++) { if (a[i] == theValue) { break; } }

उदाहरण 2: लेबल इंटरप्ट var x = 0; var z = 0 लेबलCancelLoops: तर (true) ( ​​console.log("बाह्य लूप: " + x); x += 1; z = 1; तर (true) ( ​​console.log("इनर लूप: " + z) ; z += 1; जर (z === 10 && x === 10) (ब्रेक लेबलCancelLoops; ) अन्यथा (z === 10) (ब्रेक; ) ) सुरू ठेवा

कंटिन्यू स्टेटमेंटचा वापर करताना, डू-व्हाइल, लूपसाठी किंवा लेबलवर जाण्यासाठी पुढे जाण्यासाठी केला जातो.

• जेव्हा तुम्ही लेबलशिवाय कंटिन्यू वापरता, तेव्हा ते while , do-while आणि लूपसाठीचे वर्तमान पुनरावृत्ती खंडित करते आणि पुढील पुनरावृत्तीपासून लूप सुरू ठेवते. ब्रेकच्या विपरीत, सुरू ठेवल्याने लूपच्या अंमलबजावणीमध्ये पूर्णपणे व्यत्यय येत नाही. while loop मध्ये ते कंडिशनवर उडी मारते. आणि त्यासाठी पायरी वाढते.
• तुम्ही लेबलसह सुरू ठेवता तेव्हा ते त्या लेबलसह लूपवर लागू केले जाते.

कंटिन्यू सिंटॅक्स यासारखे दिसू शकते:

सुरू ठेवा;

सुरू ठेवा लेबल ;

उदाहरण १

पुढील उदाहरण कंटिन्यू स्टेटमेंटसह एक while लूप दाखवते जे i चे मूल्य 3 असताना फायर होते. अशा प्रकारे, n ला 1, 3, 7 आणि 12 ही मूल्ये मिळतात.

Var i = 0; var n = 0; तर (i< 5) { i++; if (i == 3) { continue; } n += i; }

उदाहरण २

अभिव्यक्ती चिन्हांकित checkiandjचिन्हांकित अभिव्यक्ती समाविष्टीत आहे चेकजे. सुरू ठेवताना, प्रोग्राम वर्तमान पुनरावृत्ती रद्द करतो चेकजेआणि पुढील पुनरावृत्ती सुरू करते. प्रत्येक वेळी तुमचा सामना सुरू ठेवा, चेकजेजोपर्यंत स्थिती चुकीची परत येत नाही तोपर्यंत पुढील पुनरावृत्ती चालू राहते. जेव्हा भागाकाराच्या उरलेल्या भागाची गणना केल्यानंतर असत्य परत केले जाते checkiandj, checkiandjजोपर्यंत त्याची स्थिती चुकीची परत येत नाही तोपर्यंत पुढील पुनरावृत्तीपर्यंत चालू राहते. खोटे परत केल्यावर, नंतरच्या अभिव्यक्तीसह प्रोग्राम कार्यान्वित करणे सुरू ठेवते checkiandj.

सुरू ठेवल्यास चिन्हांकित केले आहे checkiandj, कार्यक्रम चिन्हाच्या सुरुवातीपासून सुरू ठेवू शकतो checkiandj.

Checkiandj: असताना (i< 4) { console.log(i); i += 1; checkj: while (j >4) ( console.log(j); j -= 1; जर ((j % 2) != 0) ( checkj चालू ठेवा; ) console.log(j + "अगदी."); ) console.log("i = " + i);

console.log("j = " + j);

)

साठी...मध्ये

फॉर... इन स्टेटमेंट ऑब्जेक्टच्या सर्व असंख्य गुणधर्मांद्वारे पुनरावृत्ती होते. JavaScript प्रत्येक वैयक्तिक मालमत्तेसाठी निर्दिष्ट अभिव्यक्ती कार्यान्वित करेल. फॉर...इन लूप असे दिसते:

साठी (ऑब्जेक्टमध्ये चल) (अभिव्यक्ती)

उदाहरण
खालील फंक्शन ऑब्जेक्ट आणि त्याचे नाव वितर्क म्हणून घेते. ते नंतर ऑब्जेक्टच्या सर्व गुणधर्मांद्वारे पुनरावृत्ती करते आणि गुणधर्मांची नावे आणि त्यांची मूल्ये असलेली स्ट्रिंग परत करते.

फंक्शन dump_props(obj, obj_name) ( var परिणाम = ""; साठी (var i in obj) (परिणाम += obj_name + "." + i + " = " + obj[i] + " ";) परिणाम += ""; परतावा परिणाम;)मेक आणि मॉडेल गुणधर्म असलेल्या कार ऑब्जेक्टसाठी,

परिणाम

होईल:

Car.make = Ford car.model = Mustang

उदाहरण क्रमांक २

तुम्ही की द्वारे मूल्य देखील प्रदर्शित करू शकता:

obj = (मॉडेल: "AUDI A8", वर्ष: "2019", रंग: "तपकिरी") (obj मधील की) साठी द्या ( console.log(`$(key) = $(obj)`); ) // मॉडेल = AUDI A8 // वर्ष = 2019 // रंग = तपकिरी

ॲरे ॲरेच्या सर्व घटकांद्वारे पुनरावृत्ती करण्याचा मार्ग म्हणून...in साठी वापरणे मोहक असले तरी, हा ऑपरेटर अंकीय निर्देशांकांव्यतिरिक्त वापरकर्ता-परिभाषित गुणधर्मांचे नाव परत करतो. अशा प्रकारे, ॲरेसह संवाद साधताना अंकीय निर्देशांकांसाठी मानक वापरणे चांगले आहे, कारण तुम्ही ॲरेमध्ये बदल केल्यास ॲरे घटकांव्यतिरिक्त, फॉर...इन स्टेटमेंट वापरकर्त्याने परिभाषित केलेल्या गुणधर्मांवर पुनरावृत्ती होते, जसे की गुणधर्म आणि पद्धती जोडणे.साठी( चल) { च्या}

वस्तू

अभिव्यक्ती

खालील उदाहरण for...of आणि for...in loops मधील फरक दाखवते. तर... मालमत्तेच्या नावांवर पुनरावृत्ती करण्यासाठी, मालमत्ता मूल्यांवर पुनरावृत्तीच्या... साठी:

कंडिशनल स्टेटमेंट्सचा प्रभाव समजून घेण्यासाठी, आम्ही त्यांना जावास्क्रिप्ट इंटरप्रिटर ज्या रस्त्याने फिरतो त्या रस्त्याच्या काट्यांप्रमाणे कल्पना करण्याचा सल्ला दिला. लूपचा विचार केला जाऊ शकतो तो रस्त्यातील एक यू-टर्न जो तुम्हाला परत घेऊन जातो, दुभाष्याला त्याच कोडच्या तुकड्यातून पुन्हा पुन्हा जाण्यास भाग पाडतो.

JavaScript मध्ये चार लूप आहेत: करताना, do/while, for, आणि for/in. खालीलपैकी एक उपविभाग त्या प्रत्येकासाठी समर्पित आहे. लूपचा एक सामान्य वापर म्हणजे ॲरेच्या घटकांना ट्रॅव्हर्स करणे.

पळवाट असताना

if स्टेटमेंट हे JavaScript मधील बेसिक कंडिशनल स्टेटमेंट आहे आणि JavaScript साठी बेसिक लूप हे while लूप आहे. यात खालील वाक्यरचना आहे:

असताना (अभिव्यक्ती) (सूचना)

व्हेल लूपची सुरुवात अभिव्यक्तीचे मूल्यमापन करून होते. जर या अभिव्यक्तीचे मूल्यमापन असत्य असेल तर, दुभाष्याने लूपचा मुख्य भाग बनवणारे विधान वगळले आणि प्रोग्राममधील पुढील विधानाकडे जा. जर अभिव्यक्तीचे मूल्यमापन सत्य असेल, तर लूपचा मुख्य भाग बनवणारे विधान कार्यान्वित केले जाते, नंतर नियंत्रण लूपच्या सुरूवातीस हस्तांतरित केले जाते आणि अभिव्यक्तीचे पुन्हा मूल्यमापन केले जाते. दुसऱ्या शब्दांत, जोपर्यंत अभिव्यक्तीचे मूल्य खरे राहते तोपर्यंत इंटरप्रिटर लूप बॉडी सूचना पुन्हा पुन्हा कार्यान्वित करतो. कृपया लक्षात घ्या की while(true) सिंटॅक्स वापरून अनंत लूप तयार करणे शक्य आहे.

सामान्यत: तुम्हाला JavaScript दुभाष्याने तेच ऑपरेशन पुन्हा पुन्हा करावेसे वाटत नाही. जवळजवळ प्रत्येक लूपमध्ये, लूपच्या प्रत्येक पुनरावृत्तीसह, एक किंवा अधिक चल त्यांची मूल्ये बदलतात. व्हेरिएबल बदलल्यामुळे, प्रत्येक वेळी लूप बॉडीमधून जाताना सूचना काय करते ते वेगळे असू शकते.

याव्यतिरिक्त, जर बदलले जाणारे चल(चे) अभिव्यक्तीमध्ये उपस्थित असतील, तर लूपच्या प्रत्येक पाससह अभिव्यक्तीचे मूल्य बदलू शकते. हे महत्वाचे आहे कारण अन्यथा ज्या अभिव्यक्तीचे मूल्य खरे होते ते कधीही बदलणार नाही आणि लूप कधीही संपणार नाही! खाली 0 ते 9 पर्यंत अंक मुद्रित करणाऱ्या वळण लूपचे उदाहरण आहे:

वर संख्या = 0; तर (गणना

तुम्ही बघू शकता, काउंट व्हेरिएबल सुरवातीला 0 वर सेट केले आहे, आणि नंतर प्रत्येक वेळी लूपचा मुख्य भाग कार्यान्वित केल्यावर त्याचे मूल्य वाढवले ​​जाते. लूप 10 वेळा कार्यान्वित केल्यानंतर, अभिव्यक्ती चुकीची परत येईल (म्हणजेच, काउंट व्हेरिएबल 10 पेक्षा कमी नाही), while स्टेटमेंट समाप्त होईल आणि इंटरप्रिटर प्रोग्राममधील पुढील विधानाकडे जाईल. बहुतेक लूपमध्ये काउंटर व्हेरिएबल्स गणनेप्रमाणे असतात. बऱ्याचदा, i, j, आणि k नावाची व्हेरिएबल्स लूप काउंटर म्हणून काम करतात, जरी प्रोग्राम कोड अधिक समजण्यायोग्य बनवण्यासाठी, तुम्ही काउंटरना अधिक वर्णनात्मक नावे द्यावीत.

do/while लूप

do/while लूप हे अनेक प्रकारे a while loop सारखेच असते, शिवाय लूप एक्सप्रेशनची सुरवातीपेक्षा शेवटी चाचणी केली जाते. याचा अर्थ असा की लूपचा मुख्य भाग नेहमी किमान एकदाच अंमलात आणला जातो. या निर्देशामध्ये खालील वाक्यरचना आहे:

do (विधान) करताना (अभिव्यक्ती);

do/while लूप लूप करताना त्याच्या बहिणीपेक्षा कमी वारंवार वापरला जातो. वस्तुस्थिती अशी आहे की सराव मध्ये, जेव्हा आपल्याला आगाऊ खात्री असते की आपल्याला कमीतकमी एकदा लूपचे मुख्य भाग कार्यान्वित करावे लागेल अशी परिस्थिती थोडीशी असामान्य आहे. खाली do/while लूप वापरण्याचे उदाहरण आहे:

फंक्शन printArray(a) ( var len = a.length, i = 0; if (len == 0) console.log("रिक्त ॲरे"); बाकी ( do ( console.log(a[i]); ) तर (++i

डू/व्हाइल लूप आणि रेग्युलर व्हाइल लूपमध्ये दोन फरक आहेत. प्रथम, डू लूपसाठी do कीवर्ड (लूपची सुरूवात चिन्हांकित करण्यासाठी) आणि while कीवर्ड (लूपचा शेवट चिन्हांकित करण्यासाठी आणि एक अट निर्दिष्ट करण्यासाठी) दोन्ही आवश्यक आहेत. दुसरे, while लूपच्या विपरीत, डू लूप अर्धविरामाने संपतो. जर लूपचा मुख्य भाग कुरळे ब्रेसेसमध्ये बंद असेल तर एक while लूप अर्धविरामाने संपण्याची गरज नाही.

लूपसाठी

ए फॉर लूप हे एक लूप कन्स्ट्रक्ट आहे जे काही वेळा लूपपेक्षा अधिक सोयीचे असते. फॉर लूप बहुतेक लूपसाठी सामान्य पॅटर्नचे अनुसरण करणारे लूप तयार करणे सोपे करते. बहुतेक लूपमध्ये काही प्रकारचे काउंटर व्हेरिएबल असतात. हे व्हेरिएबल लूप सुरू होण्यापूर्वी सुरू केले जाते आणि प्रत्येक पुनरावृत्तीपूर्वी तपासले जाते. शेवटी, काउंटर व्हेरिएबल वाढवले ​​जाते किंवा लूप बॉडीच्या शेवटी बदलले जाते, व्हेरिएबल पुन्हा तपासण्यापूर्वी. इनिशियलायझेशन, व्हेरिफिकेशन आणि अपडेट ही तीन प्रमुख ऑपरेशन्स लूप व्हेरिएबलवर केली जातात. फॉर स्टेटमेंट या तीन पायऱ्या लूप सिंटॅक्सचा स्पष्ट भाग बनवते:

साठी (सुरुवात; तपासणी; वाढ) (सूचना)

इनिशियलाइज, चेक आणि इन्क्रिमेंट ही तीन एक्स्प्रेशन्स आहेत (सेमीकॉलनद्वारे विभक्त केलेली) जी लूप व्हेरिएबल सुरू करण्यासाठी, तपासण्यासाठी आणि वाढवण्यासाठी जबाबदार असतात. त्यांना लूपच्या पहिल्या ओळीवर ठेवल्याने फॉर लूप काय करत आहे हे समजणे सोपे होते आणि लूप व्हेरिएबल सुरू करणे किंवा वाढवणे विसरण्यापासून प्रतिबंधित करते.

फॉर लूप समजावून सांगण्याचा सर्वात सोपा मार्ग म्हणजे लूप असताना समतुल्य दर्शवणे:

आरंभ करणे; असताना(तपासणे) (सूचना; वाढ;)

दुसऱ्या शब्दांत, लूप सुरू होण्यापूर्वी एकदा आरंभिक अभिव्यक्तीचे मूल्यमापन केले जाते. ही अभिव्यक्ती सामान्यत: साइड इफेक्ट्स (सामान्यतः असाइनमेंट) असलेली अभिव्यक्ती असते. JavaScript इनिशिएलायझेशन एक्स्प्रेशनला var व्हेरिएबल डिक्लेरेशन स्टेटमेंट बनवण्याची परवानगी देते, त्यामुळे एकाच वेळी लूप काउंटर घोषित करणे आणि आरंभ करणे शक्य आहे.

प्रत्येक पुनरावृत्तीपूर्वी चाचणी अभिव्यक्तीचे मूल्यमापन केले जाते आणि लूपचा मुख्य भाग कार्यान्वित केला जाईल की नाही हे निर्धारित करते. चाचणीचा निकाल खरा असल्यास, लूपचा मुख्य भाग असलेली सूचना अंमलात आणली जाते. लूपच्या शेवटी, वाढीव अभिव्यक्तीचे मूल्यांकन केले जाते. ही अभिव्यक्ती अर्थपूर्ण होण्यासाठी, ती दुष्परिणामांसह अभिव्यक्ती असणे आवश्यक आहे. सामान्यतः हे एकतर असाइनमेंट अभिव्यक्ती किंवा ++ किंवा -- ऑपरेटर वापरून अभिव्यक्ती असते.

तुम्ही 0 ते 9 पर्यंत लूप वापरून अंक मुद्रित करू शकता, खाली दर्शविल्याप्रमाणे, आधीच्या उदाहरणात दर्शविलेल्या समतुल्य while लूपच्या विरूद्ध:

साठी (var संख्या = 0; गणना

अर्थात, या सोप्या उदाहरणांपेक्षा लूप अधिक जटिल असू शकतात आणि काहीवेळा लूपच्या प्रत्येक पुनरावृत्तीमध्ये अनेक व्हेरिएबल्स बदलतात. JavaScript मध्ये ही परिस्थिती एकमेव आहे जिथे स्वल्पविराम ऑपरेटरचा वापर केला जातो - ते तुम्हाला एकल अभिव्यक्तीमध्ये एकाधिक आरंभीकरण आणि वाढीव अभिव्यक्ती एकत्र करण्यास अनुमती देते जे लूपमध्ये वापरण्यासाठी योग्य आहे:

Var i,j; साठी (i = 0, j = 0; i

साठी/इन लूप

फॉर/इन लूप फॉर कीवर्ड वापरतो, परंतु ते नेहमीच्या लूपपेक्षा पूर्णपणे वेगळे असते. फॉर/इन लूपमध्ये खालील वाक्यरचना आहे:

साठी (वस्तूमध्ये चल) (विधान)

येथे व्हेरिएबल हे सहसा व्हेरिएबलचे नाव असते, परंतु तुम्ही var स्टेटमेंट देखील वापरू शकता, जे एकल व्हेरिएबल घोषित करते. ऑब्जेक्ट पॅरामीटर एक अभिव्यक्ती आहे जी ऑब्जेक्ट परत करते. आणि नेहमीप्रमाणे, सूचना म्हणजे सूचना किंवा सूचनांचा ब्लॉक जो लूपचा मुख्य भाग बनवतो.

ॲरेच्या घटकांवर जाण्यासाठी, रेग्युलर फॉर लूप वापरणे स्वाभाविक आहे:

वर arr = ; साठी (var i = 0; i

फॉर/इन स्टेटमेंट नैसर्गिकरित्या तुम्हाला ऑब्जेक्टच्या गुणधर्मांवर जाण्याची परवानगी देते:

// नवीन ऑब्जेक्ट तयार करा var obj = (नाव: "ॲलेक्स", पासवर्ड:"12345" ); साठी (var i in obj) ( // प्रत्येक ऑब्जेक्ट प्रॉपर्टीचे मूल्य मुद्रित करा console.log(obj[i]);)

स्टेटमेंट फॉर/इन कार्यान्वित करण्यासाठी, जावास्क्रिप्ट इंटरप्रिटर प्रथम एक्सप्रेशन ऑब्जेक्टचे मूल्यांकन करतो. जर ते शून्य किंवा अपरिभाषित परत आले, तर दुभाष्याने लूप वगळला आणि पुढील विधानाकडे जा. जर अभिव्यक्ती एक साधे मूल्य परत करते, तर ते समतुल्य रॅपर ऑब्जेक्टमध्ये रूपांतरित केले जाते. अन्यथा, अभिव्यक्ती ऑब्जेक्ट परत करते. इंटरप्रिटर नंतर ऑब्जेक्टच्या प्रत्येक संख्यात्मक गुणधर्मासाठी लूपची एक पुनरावृत्ती कार्यान्वित करतो. प्रत्येक पुनरावृत्तीपूर्वी, दुभाषी अभिव्यक्तीच्या मूल्याचे मूल्यमापन करतो, ते व्हेरिएबलमध्ये संग्रहित करतो आणि त्यास गुणधर्म नाव (स्ट्रिंग मूल्य) नियुक्त करतो.

प्रोग्रामिंगमधील सर्वात महत्त्वाचे साधन म्हणजे लूप. ते अशा प्रकरणांमध्ये उपयुक्त आहेत जिथे तुम्हाला काही ठराविक वेळा करण्याची आवश्यकता आहे.

असे कार्य असल्यास, उदाहरणार्थ, “हॅलो एव्हरीन” ही ओळ 1000 वेळा प्रदर्शित करणे. मग, सायकल न वापरता, प्रथम यास खूप वेळ लागेल आणि दुसरे म्हणजे ते फारसे छान दिसणार नाही. म्हणून, आपल्याला चक्र खूप चांगले माहित असणे आवश्यक आहे, कारण ते खूप वेळा वापरले जातात.

प्रोग्रामिंगमध्ये चार लूप आहेत, करताना, डू-व्हाइल, फॉर आणि फोरच. त्यांच्यापैकी प्रत्येकाची स्वतःची वाक्यरचना आहे आणि प्रत्येक विशिष्ट प्रकरणांमध्ये वापरली जाते.

सर्वात सामान्यपणे वापरले जाणारे लूप फॉर आणि फॉरीच असतात, त्यानंतर व्हॉल आणि डू-व्हाइल लूप फार दुर्मिळ असतात.

आणि आपण थोडा वेळ लूपने सुरुवात करू.

व्हेल लूपची वाक्यरचना खालीलप्रमाणे आहे:

प्रथम, आपण व्हेरिएबल i घोषित करतो, जो एक काउंटर आहे आणि लूपच्या आत आपण हे काउंटर वाढवतो. कंसाच्या आत आपण लूपमध्ये प्रवेश/बाहेर पडण्याची अट लिहितो.

टिप्पणी! निर्गमन स्थिती योग्यरित्या लिहा, अन्यथा तुम्हाला अंतहीन लूप मिळू शकेल आणि नंतर स्क्रिप्ट गोठवेल. असे चक्र घडू शकते जर, उदाहरणार्थ, आम्ही फक्त बाहेर पडण्याच्या स्थितीत सत्य लिहितो.

उदाहरणार्थ, "सर्वांना नमस्कार!" स्ट्रिंग मुद्रित करूया! 10 वेळा.

Var i = 0; असताना(i"); i++;)

व्हेरिएबल i 0 किंवा 1 किंवा इतर कोणत्याही संख्येपासून सुरू करू शकतो.

बाहेर पडण्याची अट त्याच वेळी प्रवेशाची अट आहे. लूप खालीलप्रमाणे कार्य करते: प्रथम, ते i व्हेरिएबल 10 पेक्षा कमी आहे का ते तपासते आणि जर कंडिशन सत्य असेल तर आपण लूप प्रविष्ट करू, अन्यथा नाही. या प्रकरणात, जर i व्हेरिएबल 30 च्या समान असेल, उदाहरणार्थ, लूप कार्यान्वित होणार नाही, कारण 30 10 पेक्षा कमी नाही.

आम्ही सायकलमध्ये प्रवेश केला, “हॅलो एव्हरीन” ही ओळ मुद्रित केली, काउंटर वाढवला आणि पुन्हा कंडिशनवर गेलो, जिथे आपण i व्हेरिएबलचे मूल्य 10 पेक्षा कमी आहे का ते पुन्हा तपासू, नंतर आपण सायकलमध्ये प्रवेश केला, अन्यथा आपण त्यातून बाहेर पडू. आणि हे घडते तोपर्यंत जेव्हा एंट्री कंडिशन खोटी होते, म्हणजेच i व्हेरिएबलची व्हॅल्यू 10 असेल. 10 10 पेक्षा कमी नाही, त्यामुळे आपण यापुढे लूपमध्ये प्रवेश करणार नाही, परंतु पुढे जाऊ.

टिप्पणी! काउंटर (i++) वाढवायला विसरू नका, अन्यथा तुम्हाला अनंत लूप मिळेल.

आपण while लूप हाताळले आहे, आता do-while लूपकडे वळू.

do-while लूपचे वाक्यरचना खालीलप्रमाणे आहे:

व्हाईल लूप आणि डू-व्हाइल लूपमधला फरक असा आहे की कंडिशनची पर्वा न करता डू-व्हाइल लूप किमान एकदा अंमलात आणला जाऊ शकतो, तर कंडिशन असत्य असल्यास व्हाईल लूप अजिबात चालवला जाणार नाही.

टिप्पणी! while loop प्रमाणे, i counter वाढवायला विसरू नका.

चला सरावाकडे वळूया. उदाहरणार्थ, 1 ते 10 पर्यंतच्या संख्येच्या गुणाकाराची गणना करू.

Var i = 1; var उत्पादन = 1; do(उत्पादन *= i; i++; )तर(i

परिणाम क्रमांक 3628800 असेल. पहिल्या टप्प्यावर, आम्ही लगेच लूपमध्ये प्रवेश केला, त्याची स्थिती असूनही, जेथे ऑपरेशन उत्पादन *= i केले गेले होते (हे उत्पादन = उत्पादन * 1 सारखे आहे). मग आम्ही काउंटर वाढवतो. वाढीनंतर, त्याचे मूल्य 2 आहे. आणि शेवटी आपण स्थिती तपासतो, जर काउंटर मूल्य 10 पेक्षा कमी किंवा समान असेल, तर आपण लूपच्या पुढील पुनरावृत्तीकडे जाऊ, अन्यथा आपण लूपमधून बाहेर पडू आणि पुढे जाऊ. .

लूपसाठी

मी वर लिहिल्याप्रमाणे, फॉर लूप बऱ्याचदा आढळतो, म्हणून तुम्हाला ते चांगले माहित असणे आवश्यक आहे.

फॉर लूपसाठी वाक्यरचना आहे:

अधिक चांगल्या प्रकारे समजून घेण्यासाठी, एक साधी समस्या सोडवूया. समजा लूप वापरून 1 ते 1000 पर्यंतच्या संख्यांची बेरीज काढायची आहे.

वर बेरीज = 0; साठी(var i = 1; i

आम्ही दस्तऐवज जतन करतो, तो ब्राउझरमध्ये उघडतो आणि पाहतो की परिणाम 500500 आहे.

टिप्पणी! जर लूपमध्ये फक्त एक विधान असेल, तर कुरळे ब्रेसेस आवश्यक नाहीत.

प्रदर्शित करण्यासाठी, स्क्रीनवर काही स्ट्रिंग 5 वेळा प्रदर्शित करू, उदाहरणार्थ “हॅलो!”

साठी(var i = 1; i

टिप्पणी! लूप कार्यान्वित झाल्यानंतर, शेवटचे मूल्य व्हेरिएबल i मध्ये राहते.

आता समस्या थोडी अधिक क्लिष्ट सोडवूया, उदाहरणार्थ आपल्याला "हॅलो" स्ट्रिंग 100 वेळा मुद्रित करणे आवश्यक आहे. आणि जेणेकरून हे सर्व एका ओळीत दिसू नये, मग प्रत्येक 10 व्या पुनरावृत्तीनंतर, आम्ही नवीन ओळीवर जाऊ. आणि शेवटी आपण i व्हेरिएबलची व्हॅल्यू प्रिंट करू.

साठी(var i = 1; i