शर्तें

docs.scrimba.com

एक प्रोग्राम जो हमेशा एक ही काम करता है, वह बहुत उपयोगी नहीं है। आप एक पृष्ठ चाहते हैं जो एक साइन-इन किए गए आगंतुक को एक संदेश दिखाता है और किसी अजनबी को दूसरा संदेश, एक फॉर्म जो 18 की उम्र स्वीकार करता है लेकिन 12 नहीं, एक गेम जो बताता है कि आप जीते या हारे। इसके लिए सभी को एक प्रश्न पूछने और उत्तर के आधार पर कार्य करने का तरीका चाहिए। शर्तें यही करती हैं: वे आपके कोड को यह चुनने देती हैं कि क्या चलाना है, इस पर आधारित कि कुछ सत्य है या नहीं।

आपके पास पहले से ही टुकड़े हैं। तुलना और तार्किक ऑपरेटर सत्य-या-गलत उत्तर देते हैं, और यह अध्याय उन पर कार्य करने के बारे में है।

केवल तब कोड चलाएँ जब कोई शर्त सत्य हो

एक if statement केवल तब एक कोड ब्लॉक चलाता है जब कोई शर्त सत्य हो। आप शब्द if, कोष्ठकों में एक शर्त, और कर्ली ब्रेसेस में एक ब्लॉक लिखते हैं। यदि शर्त सत्य है, तो ब्लॉक चलता है। यदि नहीं है, तो JavaScript ब्लॉक को छोड़ देता है और आगे बढ़ता है।

const age = 20;

if (age >= 18) {
  console.log("You can enter."); // आप प्रवेश कर सकते हैं।
}

शर्त age >= 18 या तो सत्य है या गलत है। यहाँ age 20 है, इसलिए यह सत्य है, और संदेश प्रिंट होता है। age को 12 में बदलें और शर्त गलत है, इसलिए ब्लॉक छोड़ दिया जाता है और कुछ भी प्रिंट नहीं होता है।

अक्सर आप शर्त गलत होने पर एक विकल्प चाहते हैं। यह else के लिए है:

const age = 12;

if (age >= 18) {
  console.log("You can enter.");
} else {
  console.log("Come back when you are older."); // जब आप बड़े हो जाएँ तो वापस आएँ।
}

बिल्कुल एक ब्लॉक दोनों में से चलता है, कभी दोनों नहीं। जब आपके पास दो से अधिक परिणाम होते हैं, else if आपको दूसरी शर्त की जाँच करने देता है:

const score = 74;

if (score >= 90) {
  console.log("Grade: A");
} else if (score >= 70) {
  console.log("Grade: B"); // Grade: B
} else {
  console.log("Grade: C");
}

JavaScript शीर्ष से प्रत्येक शर्त की जाँच करता है और पहली सत्य शर्त पर रुकता है। 74 का स्कोर >= 90 नहीं है, लेकिन यह >= 70 है, इसलिए यह Grade: B प्रिंट करता है और कभी else को नहीं देखता है।

एक if statement तब एक ब्लॉक चलाता है जब इसकी शर्त सत्य हो, और एक वैकल्पिक else ब्लॉक तब चलता है जब यह नहीं हो। else if से जुड़ना आपको कई शर्तों को क्रम में जाँचने देता है।

const score = 74;

if (score >= 90) {
  console.log("Grade: A");
} else if (score >= 70) {
  console.log("Grade: B"); // Grade: B
} else if (score >= 50) {
  console.log("Grade: C");
} else {
  console.log("Grade: F");
}

क्रम मायने रखता है, और यह वह हिस्सा है जो लोग गलत करते हैं। JavaScript शीर्ष से प्रत्येक शर्त का परीक्षण करता है और पहली सत्य के लिए ब्लॉक चलाता है, फिर बाकी को छोड़ देता है। यही कारण है कि सीमाएँ यहाँ उच्च से निम्न तक जाती हैं: एक बार score >= 70 तक पहुँचने के बाद, 74 मेल खाता है और श्रृंखला रुकती है। यदि आपने score >= 50 पहले लिखा, तो 74 इसके बजाय मेल खाएगा और 50 से ऊपर सभी को C मिलेगा।

शर्त कोई भी expression हो सकती है जो true या false value देती है, इसलिए आप operators से तार्किक ऑपरेटर के साथ जाँच को जोड़ सकते हैं:

const age = 20;
const hasTicket = true;

if (age >= 18 && hasTicket) {
  console.log("Enjoy the show."); // शो का आनंद लें।
} else {
  console.log("Entry refused.");
}

एक if statement एक शर्त का मूल्यांकन करता है और जब परिणाम सत्य हो तो इसका ब्लॉक चलाता है, अन्य मामलों के लिए वैकल्पिक else if और else शाखाओं के साथ। श्रृंखला क्रमबद्ध है: JavaScript शीर्ष से नीचे तक शर्तों का मूल्यांकन करता है और पहले ब्लॉक को निष्पादित करता है जिसकी शर्त सत्य है, फिर पूरी श्रृंखला से बाहर निकलता है।

const score = 74;

if (score >= 90) {
  console.log("Grade: A");
} else if (score >= 70) {
  console.log("Grade: B"); // Grade: B
} else if (score >= 50) {
  console.log("Grade: C");
} else {
  console.log("Grade: F");
}

इस आकार की दो विशेषताएँ पकड़े रखने लायक हैं। पहली, शाखाएँ परस्पर अनन्य हैं: बिल्कुल एक चलती है। यही कारण है कि यहाँ की सीमाओं को केवल एक तरफ की जरूरत है। score >= 70 शाखा को score < 90 की रक्षा की जरूरत नहीं है, क्योंकि उस पंक्ति तक पहुँचना पहले से ही मतलब है कि score >= 90 परीक्षण विफल हो गया। redundant upper bound जोड़ना एक आम वृत्ति है और यह श्रृंखला को पढ़ना कठिन बनाता है, सुरक्षित नहीं।

दूसरा, शर्त को boolean में coerce किया जाता है, इसलिए इसे एक literal comparison होना जरूरी नहीं है। कोई भी expression काम करता है, और JavaScript truthy और falsy नियमों को लागू करता है। यह flexibility उपयोगी है और कभी-कभी एक trap है, यही कारण है कि इस अध्याय का advanced tier नीचे विस्तार से इस पर वापस आता है।

const age = 20;
const hasTicket = true;

if (age >= 18 && hasTicket) {
  console.log("Enjoy the show."); // शो का आनंद लें।
} else {
  console.log("Entry refused.");
}

Junoकेवल तब कोड चलाएँ जब कोई शर्त सत्य हो एक if अपना ब्लॉक केवल तब चलाता है जब कोष्ठक में शर्त सत्य हो, और else आपको तब के लिए एक विकल्प देता है जब यह न हो। जब दो से अधिक परिणाम हों तो else if जोड़ें। JavaScript शीर्ष से जाँच करता है और पहले मेल पर रुकता है, इसलिए अपनी शर्तों को एक क्रम में रखें जो समझ में आता है।

Junoकेवल तब कोड चलाएँ जब कोई शर्त सत्य हो एक if / else if / else श्रृंखला पहली सत्य शर्त के लिए ब्लॉक चलाती है और बाकी को छोड़ देती है, इसलिए क्रम सजावट नहीं है, यह logic है। सीमाएँ उच्च से निम्न तक जाती हैं इसी कारण से। शर्त कोई भी expression हो सकती है जो true या false resolve करती है, इसलिए जब आपको जाँच को जोड़ने की जरूरत हो तो तार्किक ऑपरेटर का उपयोग करें।

Junoकेवल तब कोड चलाएँ जब कोई शर्त सत्य हो श्रृंखला परस्पर अनन्य है और शीर्ष से नीचे तक evaluated है, इसलिए प्रत्येक शाखा को केवल उस सीमा की जरूरत है जो इसके ऊपर की शाखाओं ने पहले से ही rule out नहीं की है। redundant upper bound जोड़ना सावधानी के रूप में पढ़ता है लेकिन वास्तव में केवल शोर है। और शर्त को boolean में coerce किया जाता है, जो एक feature है जब तक एक unexpected value slip through न हो जाए, इसलिए truthy और falsy नियमों को ध्यान में रखें।

Ternary Operator के साथ एक value चुनें

कभी-कभी एक if / else एक छोटी सी चीज करता है: दो values के बीच चुनना। इसके लिए एक shorter form है जिसे ternary operator कहा जाता है। आप एक शर्त, एक ?, जब यह true हो तो use करने के लिए value, एक :, और जब यह false हो तो use करने के लिए value लिखते हैं।

const age = 20;
const message = age >= 18 ? "Welcome" : "Too young";

console.log(message); // स्वागत है

इसे एक सवाल के रूप में पढ़ें: क्या age >= 18 है? यदि हाँ, तो message "Welcome" बन जाता है; यदि नहीं, तो यह "Too young" बन जाता है। यह वही निर्णय है जो एक if / else लेगा, एक पंक्ति में।

Ternary सबसे अच्छा है जब आप एक value को store या print करने के लिए चुन रहे हैं। जब एक शाखा को कई चीजें करने की जरूरत हो, तो एक if statement स्पष्ट है, इसलिए ternary के लिए तभी पहुँचें जब प्रत्येक पक्ष एक single value हो।

Ternary operator एक शर्त के आधार पर दो values के बीच चुनता है: condition ? valueIfTrue : valueIfFalse। एक if statement के विपरीत, यह एक expression है, इसलिए यह एक value देता है जिसे आप assign कर सकते हैं या template literal में सीधे डाल सकते हैं।

const score = 82;
const passed = score >= 60 ? "pass" : "fail";

console.log(`Result: ${passed}`); // Result: pass

यह वह जगह है जहाँ यह अपनी जगह अर्जित करता है। दो values में से एक को एक variable को assign करना एक काम है जो ternary एक पंक्ति में करता है, जबकि if version समान logic को पाँच में फैलाता है और दोनों शाखाओं में assignment को दोहराता है:

// if version इसी काम को अधिक औपचारिकता के साथ करता है:
let passed;
if (score >= 60) {
  passed = "pass";
} else {
  passed = "fail";
}

जहाँ यह मदद करना बंद करता है, वह तब है जब शाखाओं को एक value से अधिक करना होता है। यदि किसी भी पक्ष को कई statements चलाने की जरूरत है, या आप एक ternary को दूसरे के अंदर nest करते हैं, तो readability जो आपने हासिल की है वह चली जाती है। उस बिंदु पर एक if statement स्पष्ट विकल्प है।

Ternary operator JavaScript का एकमात्र ऑपरेटर है जो तीन operands लेता है: condition ? valueIfTrue : valueIfFalse। वह distinction जो इसे उपयोगी बनाता है, वह है कि यह एक statement नहीं एक expression है। यह एक value में evaluate करता है, इसलिए यह उन जगहों में fit करता है जहाँ एक statement नहीं जा सकता: एक assignment का दाईँ पक्ष, एक argument, एक template literal।

const score = 82;
const label = score >= 60 ? "pass" : "fail";

console.log(`Result: ${label}`); // Result: pass

इसका उपयोग तब करें जब पूरी चीज़ दो values के बीच चुनना हो, और एक if को prefer करें क्योंकि यह assignment को एक जगह रखता है दोनों शाखाओं में दोहराने के बजाय। एक ternary तक पहुँचें एक value चुनने के लिए, एक branch चलाने के लिए नहीं।

असफलता mode nesting है। एक ternary जिसकी शाखाएँ स्वयं ternary हैं तकनीकी रूप से काम करता है, लेकिन यह reader को दाईँ से बाईँ parse करने और एक साथ कई शर्तों को याद रखने के लिए बाध्य करता है:

// पढ़ने में मुश्किल है। यहाँ if chain या switch को prefer करें।
const grade = score >= 90 ? "A" : score >= 70 ? "B" : score >= 50 ? "C" : "F";

वह पंक्ति सही उत्तर देता है और अगले reader के लिए असली प्रयास खर्च करता है। जब किसी निर्णय के दो से अधिक परिणाम हैं, तो एक if chain या एक switch इसे कहीं अधिक स्पष्ट रूप से बताता है, जो अगला section है।

JunoTernary Operator के साथ एक value चुनें Ternary दो values के बीच चुनने का एक compact तरीका है: condition ? valueIfTrue : valueIfFalse। यह तब चमकता है जब आप कुछ को store या print करने के लिए चुन रहे हैं। यदि एक शाखा को एक single value से अधिक करने की जरूरत है, तो एक पूरा if use करें, यह अधिक स्पष्ट रूप से पढ़ेगा।

JunoTernary Operator के साथ एक value चुनें एक ternary एक expression है, इसलिए यह एक value देता है जिसे आप assign कर सकते हैं या template literal में डाल सकते हैं, जो एक if statement नहीं कर सकता। यह दो values में से एक चुनने के लिए clean choice बनाता है, क्योंकि if version दोनों शाखाओं में assignment को दोहराता है। एक बार जब शाखाएँ real work करती हैं, या आप ternaries को nest करना शुरू करते हैं, तो एक if पर वापस switch करें।

JunoTernary Operator के साथ एक value चुनें Ternary एक expression है, इसलिए यह उन जगहों पर जाता है जहाँ एक statement नहीं जा सकता: एक assignment, एक argument, एक template literal। एक value चुनने के लिए इसका उपयोग करें, न कि एक branch चलाने के लिए, और यह readable रहता है। एक को दूसरे के अंदर nest करें और यह अपना रास्ता बंद कर देता है, इसलिए एक multi-outcome decision एक if chain या एक switch में रहता है।

Switch के साथ एक value को fixed cases के विरुद्ध compare करें

जब आप एक value को set possibilities की सूची के विरुद्ध check कर रहे हों, तो एक switch statement एक लंबे if / else if chain से अधिक clean हो सकता है। आप इसे check करने के लिए value देते हैं, फिर compare करने के लिए cases की सूची बनाते हैं।

const day = "Tue";

switch (day) {
  case "Sat":
    console.log("Weekend");
    break;
  case "Sun":
    console.log("Weekend");
    break;
  default:
    console.log("Weekday"); // सप्ताह का दिन
}

switch day को प्रत्येक case से तुलना करता है। जब इसे match मिलता है, तो वह case का code चलाता है। break इसे रोकने के लिए कहता है; इसके बिना, JavaScript अगले case में चलता रहता है। default तब fallback है जब कोई case match नहीं होता है, एक chain में final else की तरह।

break भूलना classic switch mistake है। इसे छोड़ दें और आपका code matching case चलाता है फिर हर case नीचे जब तक यह break या अंत को हिट नहीं करता है, जो लगभग कभी भी आपका अर्थ नहीं है।

एक switch statement एक value को fixed cases के set के विरुद्ध compare करता है। जब हर शाखा समान value पर equality के लिए test कर रही हो, तो यह एक लंबे if / else if chain से अधिक स्पष्ट रूप से पढ़ता है।

const status = "shipped";

switch (status) {
  case "pending":
    console.log("Order received.");
    break;
  case "shipped":
    console.log("On its way."); // अपने तरीके पर है।
    break;
  case "delivered":
    console.log("Delivered.");
    break;
  default:
    console.log("Unknown status.");
}

तीन चीजें logic को carry करती हैं। case match करने के लिए एक value को चिन्हित करता है, break matched case को समाप्त करता है, और default कोई unmatched को handle करता है। Match strict equality (===) use करता है, इसलिए case "1" एक number 1 से match नहीं करेगा।

Gotcha fall-through है। एक case बिना break के नहीं रुकता; execution अगले cases में चलता रहता है जब तक यह break या switch के अंत को हिट नहीं करता है। यह आमतौर पर एक bug है, लेकिन यह कभी-कभी भी useful है जब कई cases एक outcome share करते हैं:

const day = "Sat";

switch (day) {
  case "Sat":
  case "Sun":
    console.log("Weekend"); // सप्ताहांत
    break;
  default:
    console.log("Weekday");
}

यहाँ "Sat" match करता है और "Sun" के लिए shared block में fall through करता है, इसलिए दोनों weekend दिन समान line चलाते हैं। यह purposefully उपयोग की गई fall-through है, और यह केवल स्पष्ट रूप से पढ़ता है क्योंकि empty cases directly shared block के ऊपर stack करते हैं।

एक switch statement एक single value लेता है और इसे case labels की series के विरुद्ध compare करता है, पहली matching के block को चलाता है। Comparison strict equality (===) है, जो मायने रखता है: case "1" number 1 से match नहीं करता है, और कोई type coercion नहीं है जो आपको बचाए।

const status = "shipped";

switch (status) {
  case "pending":
    console.log("Order received.");
    break;
  case "shipped":
    console.log("On its way."); // अपने तरीके पर है।
    break;
  case "delivered":
    console.log("Delivered.");
    break;
  default:
    console.log("Unknown status.");
}

जो mechanism लोग underestimate करते हैं वह है fall-through। एक switch एक case चलाता नहीं है और रुकता है; यह matching label पर jump करता है और फिर सीधे नीचे तक execute करता है जब तक यह break या closing brace को हिट नहीं करता है, case boundaries को ignore करते हुए। एक missing break match के नीचे हर case चलाता है। यह अधिकांश switch bugs का स्रोत है, और यह behaviour का भी एक deliberate use है, labels को stack करना ताकि कई values एक block share करें:

const day = "Sat";

switch (day) {
  case "Sat":
  case "Sun":
    console.log("Weekend"); // सप्ताहांत
    break;
  default:
    console.log("Weekday");
}

default को अंत में आना जरूरी नहीं है, हालाँकि अंत में रखना convention है जो switches को readable रखता है। यह भी नोट करें कि एक switch केवल एक value को equality के लिए test करता है, इसलिए range checks की एक chain जैसे पहले का grade example switch नहीं बन सकता। यह limit बिल्कुल वह है जो आपको बताता है कि एक switch सही tool कब है, जो इस tier का आखिरी हिस्सा अलग करता है।

JunoSwitch के साथ एक value को fixed cases के विरुद्ध compare करें एक switch एक value को case options की list के विरुद्ध check करता है और जो match करता है उसे चलाता है, default catch-all के रूप में। हमेशा प्रत्येक case को break से समाप्त करें, या JavaScript इसके नीचे के cases में चलता रहता है। वह missing break वह गलती है जो लगभग हर कोई कम से कम एक बार करता है।

JunoSwitch के साथ एक value को fixed cases के विरुद्ध compare करें एक switch use करें जब हर शाखा fixed cases के विरुद्ध समान value पर equality के लिए test कर रही हो, और याद रखें कि यह === से match करता है, इसलिए "1" एक 1 नहीं है। प्रत्येक case को break की जरूरत है या यह अगले में fall through करता है। वह fall-through default में एक bug है, लेकिन एक shared block के ऊपर empty cases को stack करना वह एक समय है जब आप इसे चाहते हैं।

JunoSwitch के साथ एक value को fixed cases के विरुद्ध compare करें एक switch एक value को strict equality से match करता है और फिर एक break तक नीचे की ओर चलता है, case boundaries को ignore करते हुए, इसलिए एक missing break match के नीचे हर case चलाता है। एक shared block के ऊपर labels को stack करना वह एक deliberate use है। क्योंकि यह केवल एक single value पर equality को test करता है, range checks की एक set एक if chain में रहती है।

सही tool चुनें

अब आपके पास निर्णय लेने के तीन तरीके हैं, और विकल्प ज्यादातर fit के बारे में है। अधिकांश branching के लिए एक if / else if / else chain use करें, विशेषकर जब शर्तें ranges या combinations हों। जब आप एक single value को store या print के लिए दो values में से एक चुन रहे हों तो एक ternary use करें। जब आप एक value को fixed options की handful के विरुद्ध check कर रहे हों तो एक switch use करें।

इनमें से कोई भी दूसरे से अधिक advanced नहीं है। जो आपके निर्णय को सबसे स्पष्ट रूप से बताता है उसके लिए पहुँचें, और यदि आप अनिश्चित हैं, तो एक if statement हमेशा एक safe default है।

तीनों forms overlap करते हैं, इसलिए useful skill निर्णय की shape के लिए tool को match करना है। एक if chain कुछ भी handle कर सकता है, और यह सही call है जब भी शर्तें ranges (score >= 70) या combinations (age >= 18 && hasTicket) हों। एक ternary दो values के बीच चुनने के लिए एक expression में है। एक switch fit करता है जब एक single value को कई fixed cases के विरुद्ध equality के लिए test किया जाता है, जैसे एक status या एक day name।

एक rule बहुत सारे tangled code को रोकता है: सबसे छोटे के बजाय plainest को पढ़ने वाली shape के लिए पहुँचें। एक nested ternary एक if chain से छोटा है और पढ़ने के लिए बदतर है, इसलिए length लक्ष्य नहीं है। अगले person के लिए clarity, जो अक्सर एक महीने में आप हैं।

तीन tools, और उनके बीच की boundaries निर्णय की shape पर निर्भर करती हैं। एक if chain general form है: यह ranges, combinations, और कुछ भी जो एक condition express कर सकता है handle करता है, इसलिए यह default है जब भी शाखाएँ एक value पर सभी equality tests नहीं हैं। एक ternary एक single job तक narrow करता है, दो values में से एक को एक expression के रूप में चुनना, और केवल तब तक काम करता है जब दोनों शाखाएँ simple रहें। एक switch fit करता है जब एक value को fixed cases के set के विरुद्ध equality के लिए compare किया जाता है।

एक fourth option वहाँ है naming के लायक यदि यह यहाँ scope से बाहर है: जब आप एक value को एक result पर map कर रहे हों, एक lookup object अक्सर सभी तीनों को beat करता है। एक switch जो केवल एक case per value assign करता है, या value की एक long if chain value === "x" tests, अक्सर एक plain object के रूप में clearer है जिसे आप index करते हैं। आप उस pattern को meet करेंगे एक बार objects table पर हों; फिलहाल, notice करें जब एक switch वास्तव में disguise में एक table है।

दो और advanced habits इसे round out करते हैं। पहली truthy और falsy values है, क्योंकि एक condition को comparison होना जरूरी नहीं है। JavaScript condition को एक boolean में coerce करता है, और values जो false निकलती हैं वह एक fixed, short set हैं: false, 0, "" (empty string), null, undefined, और NaN। बाकी सब कुछ truthy है। यही कारण है कि if (name) "name is not empty" के लिए एक common shorthand है, और भी यह कारण है कि यह आपको surprise कर सकता है: एक 0 value एक real number है लेकिन एक falsy condition है, इसलिए if (count) block को छोड़ देता है जब count 0 है। Falsy set को जानें और ये checks guesswork बंद हो जाते हैं।

दूसरा guard clause है। जब एक decision वास्तव में जल्दी bail out करने के बारे में है, तो एक deeply nested if exit condition को पहले check करने और रुकने से बदतर पढ़ता है। वह "check the bad case, stop, then continue with the good path" shape guard clause है, और यह main logic को un-indented रखता है बजाय branches के अंदर दफन के। Stopping part आमतौर पर एक function से return करता है, जो अगला chapter है, functions, इसलिए full pattern वहाँ lands। विचार को अभी ले जाने के लिए यह है कि एक decision को exceptional case को पहले handle करके flatten करना लगभग हमेशा normal case को deeper और deeper nest करने से clearer है।

Junoसही tool चुनें अधिकांश decisions के लिए एक if chain use करें, दो values में से एक चुनते समय एक ternary, और एक fixed options के विरुद्ध एक value को match करते समय एक switch। इनमें से कोई भी दूसरे से fancier नहीं है। जो भी आपके decision को सबसे स्पष्ट रूप से बताता है उसे चुनें, और जब आप निश्चित न हों तो if को default करें।

Junoसही tool चुनें Tool को shape से match करें: ranges और combinations के लिए if, दो values में से एक चुनने के लिए एक ternary, fixed cases के विरुद्ध equality के लिए एक switch। सबसे छोटे के बजाय plainest को पढ़ने वाली form के लिए पहुँचें, क्योंकि एक nested ternary short है और follow करने में मुश्किल है। अगला reader अक्सर आप हैं, इसलिए उनके लिए लिखें।

Junoसही tool चुनेंif chain general tool है, ternary दो values में से एक चुनने के लिए है, और switch एक fixed set के विरुद्ध equality के लिए है, एक lookup object अक्सर एक value-mapping switch को beat करता है एक बार जब आपके पास objects हैं। Falsy set को अपने सिर में रखें (false, 0, "", null, undefined, NaN) इसलिए एक bare if (count) आपको surprise न करे जब count zero है। और जब एक decision वास्तव में एक early exit है, तो bad case को पहले handle करें और nesting को flatten करें; full guard clause functions के साथ lands।

जहाँ conditionals यहाँ से जाती हैं

Conditionals यह है कि कैसे एक program एक fixed script होने बंद करता है और अपने input के respond करना शुरू करता है। आप इनका लगातार उपयोग करेंगे, और ये अपने चारों ओर सब कुछ के साथ combine करते हैं: true-or-false answers operators से आते हैं, और जो निर्णय आप यहाँ लेते हैं loops के साथ data के ऊपर repeatedly चलाने के लिए, और functions में package करने के लिए शुरू होते हैं।

अगला chapter, loops, control flow का दूसरा आधा जोड़ता है: न केवल यह चुनना कि code को चलाना है, बल्कि इसे बार-बार चलाना जब तक एक condition आपको बताता है।