# జావాస్క్రిప్ట్ బేసిక్స్: నిర్ణయాలు తీసుకోవడం ![JavaScript Basics - Making decisions](../../../../translated_images/te/webdev101-js-decisions.69e1b20f272dd1f0.webp) > స్కేట్ఛ్‌‌నోట్ [Tomomi Imura](https://twitter.com/girlie_mac) రచన ```mermaid journey title మీ జావాస్క్రిప్ట్ నిర్ణయం తీసుకునే ప్రయాణం section పునాదులు Boolean విలువలు: 5: You పోలిక ఆపరేటర్లు: 4: You తర్క పద్ధతి: 5: You section ప్రాథమిక నిర్ణయాలు If స్టేట్‌మెంట్లు: 4: You If-Else తర్కం: 5: You Switch స్టేట్‌మెంట్లు: 4: You section అధునాతన తర్కం తర్క ఆపరేటర్లు: 5: You సంక్లిష్ట పరిస్థితులు: 4: You టెర్నరీ వ్యక్తీకరణలు: 5: You ``` మీరు ఎప్పుడైనా ఆలోచించారా, యాప్స్ ఎలా తెలివైన నిర్ణయాలు తీసుకుంటాయో? ఉదాహరణకి, ఒక నావిగేషన్ సిస్టమ్ వేగవంతమైన మార్గాన్ని ఎలా ఎంచుకుంటుంది, లేదా ఒక థర్మోస్టాట్ వేడి ఎప్పుడు ప్రారంభించాలో ఎలా నిర్ణయించుకుంటుంది? ఇది ప్రోగ్రామింగ్‌లో నిర్ణయం తీసుకునే ప్రాథమిక భావన. చార్లెస్ బాబేజ్ యొక్క అనలిటికల్ ఇంజిన్ పరిస్థితుల ఆధారంగా వివిధ ఆపరేషన్లు అనుసరిస్తుందని రూపకల్పన చేయబడింది అంటూ, ఆధునిక జావాస్క్రిప్ట్ ప్రోగ్రామ్‌లు వివిధ పరిస్థితులపై ఆధారపడి ఎంపికలు చేయాలి. ఈ శాఖ పద్ధతి, నిర్ణయాలు తీసుకోవడం వల్ల స్థిర కోడ్‌ ను స్పందనాత్మక, తెలివైన యాప్లికేషన్లుగా మారుస్తుంది. ఈ పాఠంలో, మీరు మీ ప్రోగ్రామ్‌లలో షరతు లాజిక్ ఎలా అమలు చేయాలో నేర్చుకుంటారు. షరతు స్టేట్మెంట్లు, పోలిక ఆపరేటర్లు, మరియు తార్కిక వ్యక్తీకరణలను పరిశీలించి, మీ కోడ్ పరిస్థితులను అంచనా వేసి సరిగ్గా స్పందించడానికి వీలు కల్పిస్తాయి. ## ముందస్తు ఉపన్యాస క్విజ్ [ముందస్తు ఉపన్యాస క్విజ్](https://ff-quizzes.netlify.app/web/quiz/11) నిర్ణయాలు తీసుకోవడం మరియు ప్రోగ్రామ్ ప్రవాహాన్ని నియంత్రించడం ప్రోగ్రామింగ్ యొక్క ప్రాథమిక అంశం. ఈ విభాగం బూలియన్ విలువలు మరియు షరతు లాజిక్ ఉపయోగించి మీ జావాస్క్రిప్ట్ ప్రోగ్రామ్‌లు ఎలా అమలు చేయాలో వివరిస్తుంది. [![Making Decisions](https://img.youtube.com/vi/SxTp8j-fMMY/0.jpg)](https://youtube.com/watch?v=SxTp8j-fMMY "Making Decisions") > 🎥 నిర్ణయాలు తీసుకోవడం గురించి వీడియో కోసం పై చిత్రం క్లిక్ చేయండి. > మీరు ఈ పాఠాన్ని [Microsoft Learn](https://docs.microsoft.com/learn/modules/web-development-101-if-else/?WT.mc_id=academic-77807-sagibbon) లో కూడా నేర్చుకోవచ్చు! ```mermaid mindmap root((నిర్ణయం తీసుకోవడం)) Boolean Logic true/false సరిపోలింపు ఫలితాలు లాజికల్ వ్యక్తరణలు Conditional Statements if statements ఒక్క పరిస్థితి కోడ్ అమలు if-else రెండు మార్గాలు ప్రత్యామ్నాయం చర్యలు switch బహుముఖ ఎంపికలు శుభ్రమైన నిర్మాణం Operators Comparison === !== < > <= >= విలువ సంబంధాలు Logical && || ! పరిస్థితులు కలపండి Advanced Patterns Ternary ? : వాక్యరచన పంక్తిలో నిర్ణయాలు Complex Logic కూర్చిన పరిస్థితులు బహుముఖ ప్రమాణాలు ``` ## బూలియన్‌లపై సంక్షిప్త జ్ఞాపకం నిర్ణయాలు తీసుకునే ప్రక్రియను పరిశీలించే ముందు, మన గత పాఠం నుంచి బూలియన్ విలువలను మళ్లీ చూసుకుందాం. గణిత శాస్త్రజ్ఞుడు జార్జ్ బూల్ పేరు మీద ఈ విలువలు binary స్థితులను సూచిస్తాయి – అది `true` లేదా `false` మాత్రమే. ఇందులో ఎటువంటి సందేహం లేదా మధ్యస్థానం ఉండదు. ఈ binary విలువలు అన్ని కంప్యూటేషనల్ లాజిక్ యొక్క పునాది. మీ ప్రోగ్రామ్ తీసుకునే ప్రతి నిర్ణయం తగినంతగా ఒక బూలియన్ అంచనాకే తగ్గుతుంది. బూలియన్ వేరియబుల్స్ సృష్టించడం సులభం: ```javascript let myTrueBool = true; let myFalseBool = false; ``` ఇది స్పష్టమైన బూలియన్ విలువలతో రెండు వేరియబుల్స్ సృష్టిస్తుంది. ✅ బూలియన్‌లు ఇంగ్లీషు గణిత శాస్త్రజ్ఞుడు, తత్త్వవేత్త మరియు తార్కికవేత్త జార్జ్ బూల్ (1815–1864) పేరిట ఉన్నాయి. ## పోలిక ఆపరేటర్లు మరియు బూలియన్‌లు ప్రాక్టికల్‌గా, మీరు బూలియన్ విలువలను వ్యక్తిగతంగా ఇలా సెట్ చేయరు. దీని బదులు, మీరు షరతులను అంచనా వేసి వాటిని ఉత్పత్తి చేస్తారు: "ఈ సంఖ్య ఆ సంఖ్య కంటే ఎక్కువగా ఉందా?" లేదా "ఈ విలువలు సమానంగానేనా?" పోలిక ఆపరేటర్లు ఈ అంచనాలు చేయడానికి ఉపయోగపడతాయి. అవి రెండూ విలువలను పోల్చి ఆపరాండ్ల మధ్య సంబంధం ఆధారంగా బూలియన్ ఫలితాలను ఇస్తాయి. | ప్రతీక | వివరణ | ఉదాహరణ | | ------ | ------------------------------------------------------------------------------------------------------------------------------- | ------------------ | | `<` | **తక్కువ**: రెండు విలువలను పోల్చి ఎడమవైపున ఉన్నది కుడిపక్కన ఉన్నదికంటే తక్కువైతే `true` ఇస్తుంది | `5 < 6 // true` | | `<=` | **తక్కువగా లేదా సమానం**: రెండు విలువలను పోల్చి ఎడమవైపున ఉన్నది కుడిపక్కన ఉన్నదికి తక్కువ లేదా సమానమైతే `true` ఇస్తుంది | `5 <= 6 // true` | | `>` | **గొప్ప**: రెండు విలువలను పోల్చి ఎడమవైపున ఉన్నది కుడిపక్కన ఉన్నదికన్నా ఎక్కువైతే `true` ఇస్తుంది | `5 > 6 // false` | | `>=` | **గొప్ప లేదా సమానం**: రెండు విలువలను పోల్చి ఎడమవైపున ఉన్నది కుడిపక్కన ఉన్నదికి పెద్దది లేదా సమానమైతే `true` ఇస్తుంది | `5 >= 6 // false` | | `===` | **కఠిన సమానత్వం**: రెండు విలువలను పోల్చి కుడి మరియు ఎడమవైపు రెండూ సమానమైన డేటా టైప్ ఉంటే `true` ఇస్తుంది | `5 === 6 // false` | | `!==` | **వేడుకోవడము**: కఠిన సమానత్వ ఆపరేటరు ఇస్తున్న విలువకు విరుద్ధమైన బూలియన్ విలువ ఇస్తుంది | `5 !== 6 // true` | ✅ మీ జ్ఞానాన్ని పరీక్షించేందుకు మీ బ్రౌజర్ కన్సోల్‌లో కొన్ని పోలికలు రాయండి. మీరు ఆశించని డేటా ఎవరైనా వచ్చిందా? ```mermaid flowchart LR A["🔢 విలువలు"] --> B["⚖️ సరిపోలిక"] B --> C["✅ బూలియన్ ఫలితం"] D["5"] --> E["< 6"] E --> F["true"] G["10"] --> H["=== '10'"] H --> I["false"] J["'హలో'"] --> K["!== 'ప్రపంచం'"] K --> L["true"] M["📋 ఆపరేటర్ రకాలు"] --> M1["సమానత: === !=="] M --> M2["సంబంధిత: < > <= >="] M --> M3["కఠినమైన vs సడలించిన"] style A fill:#e3f2fd style C fill:#e8f5e8 style M fill:#fff3e0 ``` ### 🧠 **పోలిక నైపుణ్యం పరీక్ష: బూలియన్ లాజిక్ అర్థం చేసుకోడం** **మీ పోలిక అర్థం చేసుకున్నదా పరీక్షించండి:** - మీరు ఎందుకు `===` (కఠిన సమానత్వం) ను సాధారణంగా `==` (కొద్దిగా సమానత్వం) కంటే ఇష్టపడతారు? - `5 === '5'` ఎం వస్తుందో ఊహించగలరా? అలాగే `5 == '5'`? - `!==` మరియు `!=` మధ్య తేడా ఏమిటి? ```mermaid stateDiagram-v2 [*] --> Comparison: రెండు విలువలు Comparison --> StrictEqual: === లేదా !== Comparison --> Relational: < > <= >= StrictEqual --> TypeCheck: టైపు మరియు విలువను చూడండి Relational --> NumberCompare: సంఖ్యలుగా మార్చండి TypeCheck --> BooleanResult: true లేదా false NumberCompare --> BooleanResult note right of StrictEqual ప్రాధాన్యమైన విధానం టైపు మార్పిడి లేదు end note note right of Relational పరిధులకు ఉపయోగపడుతోంది సంఖ్యాత్మక పోలికలు end note ``` > **ప్రో చిట్కా**: టైపు మార్పిడి అవసరం లేకపోతే ఎప్పుడూ సమానత్వం పరీక్షలకు `===` మరియు `!==` వాడండి. ఇది అనూహ్య ప్రవర్తనలను నివారిస్తుంది! ## If స్టేట్మెంట్ `if` స్టేట్మెంట్ మీ కోడ్‌లో ఒక ప్రశ్న అడిగినట్టే. "ఈ షరతు true అయితే, ఈ పని చేయు." ఇది జావాస్క్రిప్ట్‌లో నిర్ణయాలు తీసుకునేందుకు అత్యంత ముఖ్యమైన పరికరం. ఇలా పనిచేస్తుంది: ```javascript if (condition) { // పరిస్థితి నిజం. ఈ బ్లాక్‌లో కోడ్ అమలవుతుంది. } ``` షరతు ప్రముఖంగా కోసుపైన ఉంచబడుతుంది, అది `true` అయితే, జావాస్క్రిప్ట్ కర్లీ బ్రేసెస్ లోని కోడ్‌ను నడుపుతుంది. `false` అయితే, ఆ బ్లాక్ మొత్తాన్ని స్కిప్ చేస్తుంది. మీరు తరచుగా ఈ షరతులను సృష్టించడానికి పోలిక ఆపరేటర్లను వాడతారు. ప్రావీట్ ఉదాహరణ చూద్దాం: ```javascript let currentMoney = 1000; let laptopPrice = 800; if (currentMoney >= laptopPrice) { // షరతు నిజం. ఈ బ్లాక్‌లోని కోడ్ నడుస్తుంది. console.log("Getting a new laptop!"); } ``` `1000 >= 800` సత్యం కావడంతో, బ్లాక్‌లోని కోడ్ పనిచేస్తుంది, కన్సోల్‌లో "Getting a new laptop!" ప్రదర్శిస్తుంది. ```mermaid flowchart TD A["🚀 ప్రోగ్రామ్ ప్రారంభం"] --> B{"💰 currentMoney >= laptopPrice?"} B -->|true| C["🎉 'కొత్త లాప్‌టాప్ పొందడం!'"] B -->|false| D["⏭️ కోడ్ బ్లాక్ దాటవేయండి"] C --> E["📋 ప్రోగ్రామ్ కొనసాగించండి"] D --> E F["📊 If స్టేట్‌మెంట్ నిర్మాణం"] --> F1["if (condition) {"] F1 --> F2[" // నిజమైతే నడపవలసిన కోడ్"] F2 --> F3["}"] style B fill:#fff3e0 style C fill:#e8f5e8 style D fill:#ffebee style F fill:#e3f2fd ``` ## If..Else స్టేట్మెంట్ కానీ షరతు false అయినప్పుడు మీ ప్రోగ్రామ్ వేరే పని చేయాలని అనుకున్నట్లయితే? అప్పుడు `else` వస్తుంది – ఇది బ్యాక్‌అప్ ప్లాన్ లాంటి కొరుక్క. `else` స్టేట్మెంట్ అంటే "ఈ షరతు సత్యం కాదు అయితే, మరీచిన్న పని చేయు" అర్థం. ```javascript let currentMoney = 500; let laptopPrice = 800; if (currentMoney >= laptopPrice) { // పరిస్థితి నిజం. ఈ బ్లాక్‌లో ఉన్న కోడ్ చేయబడుతుంది. console.log("Getting a new laptop!"); } else { // పరిస్థితి తప్పు. ఈ బ్లాక్‌లో ఉన్న కోడ్ చేయబడుతుంది. console.log("Can't afford a new laptop, yet!"); } ``` ఇప్పుడు `500 >= 800` false కాబట్టి, జావాస్క్రిప్ట్ మొదటి బ్లాక్‌ ఖాళీ చేసి, `else` బ్లాక్ నడుపుతుంది. కన్సోల్‌లో "Can't afford a new laptop, yet!" కనిపిస్తుంది. ✅ ఈ కోడ్ మరియు క్రింద ఇవ్వబడిన కోడ్ మీ బ్రౌజర్ కన్సోల్ లో నడుపుతూ మీ అవగాహనను పరీక్షించండి. `currentMoney` మరియు `laptopPrice` వేరియబుల్స్ విలువలు మార్చి `console.log()` లో వేరే ఫలితాన్ని పొందండి. ### 🎯 **If-Else లాజిక్ పరీక్ష: శాఖలు** **మీ షరతుల గురించి అర్థం చేసుకోవడం నిర్వహించుకోండి:** - `currentMoney` సరియైనదిగా `laptopPrice` కి సమానం అయితే ఏం జరుగుతుంది? - నిజ జీవిత పరిస్థితిలో if-else లాజిక్ ఉపయోగించే ఎటువంటి ఉదాహరణ చెప్పగలరా? - మీరు ఈ[src]ను ఎట్లా విస్తరించవచ్చు, బహుళ ధర పరిధుల నిర్వహణ కోసం? ```mermaid flowchart TD A["🔍 షరతును మూల్యాంకనం చేయండి"] --> B{"షరతు సత్యమా?"} B -->|అవును| C["📤 IF బ్లాక్ అమలు చేయండి"] B -->|కాదు| D["📥 ELSE బ్లాక్ అమలు చేయండి"] C --> E["✅ ఒక మార్గం తీసుకోబడింది"] D --> E F["🌐 వాస్తవ ప్రపంచ ఉదాహరణలు"] --> F1["వినియోగదారు లాగిన్ స్థితి"] F --> F2["వయస్సు నిర్ధారణ"] F --> F3["ఫారమ్ ధృవీకరణ"] F --> F4["గేమ్ స్థితి మార్పులు"] style B fill:#fff3e0 style C fill:#e8f5e8 style D fill:#e3f2fd style F fill:#f3e5f5 ``` > **ముఖ్య అనుభవం**: If-else పద్ధతితో ఖచ్చితంగా ఒక్క దారి తీసుకుంటారు. ఇది మీ ప్రోగ్రామ్ ఎప్పుడూ ఏదైనా షరతుపై స్పందన కలిగి ఉండటం నిర్ధారిస్తుంది! ## Switch స్టేట్మెంట్ కొన్నిసార్లు మీరు ఒక విలువను బహుళ ఎంపికలతో పోల్చుకోవలసి ఉంటుంది. మీరు అనేక `if..else` స్టేట్మెంట్లను జత చేయవచ్చు కానీ అది స్తంభించిపోతుంది. `switch` స్టేట్మెంట్ బహుళ తేడా ఉన్న విలువల నిర్వహణకు క్లీన్ నిర్మాణం అందిస్తుంది. ఈ భావన తొలున్న టెలిఫోన్ ఎక్స్చేంజ్‌లలో ఉపయోగించిన మెకానికల్ స్విచ్చింగ్ వ్యవస్థకు సమానం – ఒక ఇన్‌పుట్ విలువ ఏ ప్రత్యేక మార్గాన్ని ఎంచుకోవాలనేదాన్ని నిర్ణయిస్తుంది. ```javascript switch (expression) { case x: // కోడ్ బ్లాక్ break; case y: // కోడ్ బ్లాక్ break; default: // కోడ్ బ్లాక్ } ``` దీని నిర్మాణం ఇలా ఉంటుంది: - జావాస్క్రిప్ట్ ఒకసారి వ్యక్తీకరణని (expression) అంచనా వేస్తుంది - ప్రతి `case` ని చూసి సరిపోలడం చూసుకుంటుంది - సరిపడ్డప్పుడు ఆ కోడ్ బ్లాక్ నడుపుతుంది - `break` జావాస్క్రిప్ట్‌ని ఆపి switch నుండి బయటకు పంపుతుంది - ఎట్టిపరిస్థితిలో cases సరిపోకుండా ఉంటే, `default` బ్లాక్ నడుస్తుంది (మీ దగ్గర ఉంటే) ```javascript // వారపు రోజుకు స్విచ్ స్టేట్మెంట్ ఉపయోగించి ప్రోగ్రాం let dayNumber = 2; let dayName; switch (dayNumber) { case 1: dayName = "Monday"; break; case 2: dayName = "Tuesday"; break; case 3: dayName = "Wednesday"; break; default: dayName = "Unknown day"; break; } console.log(`Today is ${dayName}`); ``` ఈ ఉదాహరణలో, జావాస్క్రిప్ట్ `dayNumber` ని 2 గా గుర్తించి, `case 2` కనుగొని, `dayName` ని "Tuesday" గా సెట్ చేస్తుంది, ఆపై switch నుండి బయటికెక్కుతుంది. ఫలితం: "Today is Tuesday" కన్సోల్ లో ప్రదర్శించబడింది. ```mermaid flowchart TD A["📥 స్విచ్(వ్యక్తీకరణ)"] --> B["🔍 ఒక్కసారి మూల్యాంకనం"] B --> C{"కేసు 1 సరిపోతుందా?"} C -->|Yes| D["📋 కేసు 1 అమలు చేయండి"] C -->|No| E{"కేసు 2 సరిపోతుందా?"} E -->|Yes| F["📋 కేసు 2 అమలు చేయండి"] E -->|No| G{"కేసు 3 సరిపోతుందా?"} G -->|Yes| H["📋 కేసు 3 అమలు చేయండి"] G -->|No| I["📋 డిఫాల్ట్ అమలు చేయండి"] D --> J["🛑 బ్రేక్"] F --> K["🛑 బ్రేక్"] H --> L["🛑 బ్రేక్"] J --> M["✅ స్విచ్ నుండి నిష్క్రమించు"] K --> M L --> M I --> M style A fill:#e3f2fd style B fill:#fff3e0 style M fill:#e8f5e8 ``` ✅ ఈ కోడ్ మరియు క్రింది కోడ్ లోని బదిలీ కోసం బ్రౌజర్ కన్సోల్ లో పరీక్షించండి. వేరియబుల్ `a` విలువలని మార్చి `console.log()` లో ఫలితాన్ని గమనించండి. ### 🔄 **Switch స్టేట్మెంట్ నైపుణ్యం: బహుళ ఎంపికలు** **మీ switch అర్థం చేసుకోవడాన్ని పరీక్షించండి:** - మీరు `break` స్టేట్మెంట్ మర్చిపోయినట్లయితే ఏం జరుగుతుంది? - మీరు ఎప్పుడు బహుళ `if-else` బదులు `switch` వాడతారు? - మీరు అన్ని అవకాశాలను కప్పుకున్నట్టు అనుకున్నా, ఎందుకు `default` వాడడం మంచిది? ```mermaid pie title "ప్రతి నిర్ణయ నిర్మాణాన్ని ఎప్పుడు ఉపయోగించాలి" "సింపుల్ if-else" : 40 "సంక్లిష్ట if-else చైన్లు" : 25 "స్విచ్ స్టేట్మెంట్లు" : 20 "టెర్నరీ ఆపరేటర్స్" : 15 ``` > **మంచి ప్రాక్టీస్**: ఒక వేరియబుల్‌ను బహుళ ప్రత్యేక విలువలతో పోల్చేటప్పుడు `switch` ఉపయోగించండి. పర్యాయాలను పరీక్షించేటప్పుడు లేదా క్లిష్ట పరిస్థితుల కోసం `if-else` వాడండి! ## తార్కిక ఆపరేటర్లు మరియు బూలియన్‌లు క్లిష్ట నిర్ణయాలకు ఒకేసారి పలు పరిస్థితులను అంచనా వేసోవలసి ఉంటుంది. బూలియన్ బోధనలో మత్తుగా లాజికల్ వ్యక్తీకరణలను కలుపుతూ, ప్రోగ్రామింగ్‌లో తార్కిక ఆపరేటర్లు పలు బూలియన్ షరతులను కలుపుతాయి. ఈ ఆపరేటర్లు సరళమైన సత్య/అసత్య అంచనాలను సంయోజించి మెలుకువైన షరతు లాజిక్ సృష్టించడానికి వీలు కల్పిస్తాయి. | ప్రతీక | వివరణ | ఉదాహరణ | | ------ | ------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------- | | `&&` | **తార్కిక AND**: రెండు బూలియన్ వ్యక్తీకరణలను పోల్చి రెండూ true అయితే మాత్రమే true ఇస్తుంది | `(5 > 3) && (5 < 10) // రెండూ true కాబట్టి true ఇస్తుంది` | | `\|\|` | **తార్కిక OR**: రెండు బూలియన్ వ్యక్తీకరణలను పోల్చి కనీసం ఒకటి true అయితే true ఇస్తుంది | `(5 > 10) \|\| (5 < 10) // ఒకటి false, ఇంకోటి true కావడం వల్ల true ఇస్తుంది` | | `!` | **తార్కిక NOT**: ఒక బూలియన్ వ్యక్తీకరణకు వ్యతిరేకమైన విలువ ఇస్తుంది | `!(5 > 10) // 5 పెద్దది కాదు కాబట్టి "!" తో true అవుతుంది` | ఈ ఆపరేటర్లతో మీరు పరిస్థితులను ఈ విదంగా కలుపుకోవచ్చు: - AND (`&&`) అంటే రెండు పరిస్థితులు నిజం కావాలి - OR (`||`) అంటే కనీసం ఒకటి నిజం కావాలి - NOT (`!`) నిజం ని అబద్ధంగా, అబద్ధాన్ని నిజంగా మార్చుతుంది ```mermaid flowchart LR A["🔗 లాజికల్ ఆపరేటర్లు"] --> B["&& మరియు"] A --> C["|| లేదా"] A --> D["! కాదు"] B --> B1["రెండు కూడా నిజం కావాలి"] B --> B2["true && true = true"] B --> B3["true && false = false"] C --> C1["కనీసం ఒకటి నిజం"] C --> C2["true || false = true"] C --> C3["false || false = false"] D --> D1["విలువను మళ్లించు"] D --> D2["!true = false"] D --> D3["!false = true"] E["🌍 వాస్తవ ఉదాహరణలు"] --> E1["వయస్సు >= 18 && లైసెన్స్ ఉందా"] E --> E2["isWeekend || isHoliday"] E --> E3["!isLoggedIn"] style A fill:#e3f2fd style B fill:#e8f5e8 style C fill:#fff3e0 style D fill:#f3e5f5 style E fill:#e0f2f1 ``` ## తార్కిక ఆపరేటర్లతో షరతులు మరియు నిర్ణయాలు మామూలు ఉదాహరణతో ఈ తార్కిక ఆపరేటర్లను చూద్దాం: ```javascript let currentMoney = 600; let laptopPrice = 800; let laptopDiscountPrice = laptopPrice - (laptopPrice * 0.2); // ల్యాప్‌టాప్ ధర 20 శాతం తగ్గింపు if (currentMoney >= laptopPrice || currentMoney >= laptopDiscountPrice) { // పరిస్థితి సత్యం. ఈ బ్లాక్‌లోని కోడ్ అమలు అవుతుంది. console.log("Getting a new laptop!"); } else { // పరిస్థితి అబద్ధం. ఈ బ్లాక్‌లోని కోడ్ అమలు అవుతుంది. console.log("Can't afford a new laptop, yet!"); } ``` ఈ ఉదాహరణలో: మనం 20% డిస్కౌంట్ ధర (640) లెక్కించాము, తరువాత మన అందుబాటులో ఉన్న డబ్బు సంపూర్ణ ధర లేదా తగ్గింపు ధర అందుబాటులో ఉందో అంచనా వేస్తాం. 600 తగ్గింపు ధర 640 కి తక్కువగా ఉండటం వల్ల షరతు సత్యం అవుతుంది. ### 🧮 **తార్కిక ఆపరేటర్స్ పరీక్ష: షరతులను కలపడం** **మీ తార్కిక ఆపరేటర్ అవగాహనని పరీక్షించండి:** - `A && B` లో A false అయితే ఏం జరుగుతుంది? B అంచనా వేస్తేనా? - మీరు ఎప్పుడైతే మూడు ఆపరేటర్ల (&&, ||, !) అవసరం అవుతుందో ఒక పరిస్థితిని ఊహించగలరా? - `!user.isActive` మరియు `user.isActive !== true` మధ్య తేడా ఏమిటి? ```mermaid stateDiagram-v2 [*] --> EvaluateA: A && B EvaluateA --> CheckB: A నిజం EvaluateA --> ReturnFalse: A తప్పు CheckB --> ReturnTrue: B నిజం CheckB --> ReturnFalse: B తప్పు [*] --> EvaluateC: A || B EvaluateC --> ReturnTrue: A నిజం EvaluateC --> CheckD: A తప్పు CheckD --> ReturnTrue: B నిజం CheckD --> ReturnFalse: B తప్పు note right of EvaluateA షార్ట్-సిర్క్యూట్ మూల్యాంకనం: A తప్పు అయితే, B ని ఎప్పుడూ తనిఖీ చేయరు end note ``` > **పనితీరు చిట్కా**: జావాస్క్రిప్ట్ "షార్ట్-సర్జిట్ అంచన" ఉపయోగిస్తుంది - `A && B` లో, A false అయితే B అంచనా వేయబడదు. దీనిని మీ ప్రయోజనానికి ఉపయోగించండి! ### విరోధి ఆపరేటర్ ఎప్పుడో మాట, మీరు ఎప్పుడో విషయం నిజం కాకపోవడాన్ని విలువచేయాలనుకోవచ్చు. ఉదాహరణకు "వాడుకరి లాగిన్ అయ్యారా?" అడగకుండా "వాడుకరి లాగిన్ కాలేదా?" అని అడగడం. సూచిక గుర్తు (`!`) ఆ తీరు లాజిక్‌ను కొంత తేలికగా మార్చిస్తుంది. ```javascript if (!condition) { // నిబంధన తప్పు అయితే నడుస్తుంది } else { // నిబంధన సత్యం అయితే నడుస్తుంది } ``` `!` ఆపరేటర్ అంటే "వ్యతిరేకం" – ఏదైతే `true` అయితే `!` వదిలితే `false` అవుతుంది, మరియు ఉల్టా కూడా. ### టెర్నరీ వ్యక్తీకరణలు సరళమైన షరతు విధానాల కోసం, జావాస్క్రిప్ట్ **టెర్నరీ ఆపరేటర్** అందిస్తుంది. ఈ సంక్షిప్త సింటాక్స్ ఒక్క లైనులో షరతు బాధ్యతను వ్రాయడానికి ఉపయుక్తం, ఇది ఒక షరతు ఆధారంగా రెండు విలువల మధ్య ఒకదాన్ని కేటాయించడానికి ఉపయోగపడుతుంది. ```javascript let variable = condition ? returnThisIfTrue : returnThisIfFalse; ``` ఇది ఒక ప్రశ్నలా చదవండి: "ఈ షరతు true అయితే ఈ విలువ వాడు. false అయితే ఆ విలువ వాడు." క్రింది ఉదాహరణ చూడండి: ```javascript let firstNumber = 20; let secondNumber = 10; let biggestNumber = firstNumber > secondNumber ? firstNumber : secondNumber; ``` ✅ కొంచెం సమయం తీసుకుని ఈ కోడ్ పునరుద్ఘహరించండి. ఈ ఆపరేటర్లు ఎలా పని చేస్తున్నాయో మీకు అర్థమవుతుందా? ఈ లైన్ ఇలా చెప్పటం: "`firstNumber` `secondNumber` కంటే ఎక్కువనా? అవును అయితే `biggestNumber` లో `firstNumber` ఉంచు. లేదంటే `biggestNumber` లో `secondNumber` ఉంచు." టెర్నరీ ఆపరేటర్ కింది సంప్రదాయ `if..else` స్టేట్మెంట్ కంటే కేవలం సంక్షిప్త రూపం: ```javascript let biggestNumber; if (firstNumber > secondNumber) { biggestNumber = firstNumber; } else { biggestNumber = secondNumber; } ``` రెండు పద్ధతులు ఒకే ఫలితాన్ని ఇస్తాయి. టెర్నరీ ఆపరేటర్ సంక్షిప్తంగా ఉంటుంది, సాంప్రదాయ if-else కంటే క్లిష్ట పరిస్థితులలో చదవటానికి కొంత సులభమే. ```mermaid flowchart LR A["🤔 త్రిముఖ ఆపరేటర్"] --> B["నిబంధన ?"] B --> C["సత్యమైతే విలువ :"] C --> D["అసత్యమైతే విలువ"] E["📝 సంప్రదాయ If-Else"] --> F["if (నిబంధన) {"] F --> G[" return సత్యమైతే విలువు"] G --> H["} else {"] H --> I[" return అసత్యమైతే విలువు"] I --> J["}"] K["⚡ ఎప్పుడు ఉపయోగించాలి"] --> K1["సాధారణ ఆమోదాలు"] K --> K2["చిన్న నిబంధనలు"] K --> K3["ఇన్‌లైన్ నిర్ణయాలు"] K --> K4["return స్టేట్మెంట్లు"] style A fill:#e3f2fd style E fill:#fff3e0 style K fill:#e8f5e8 ``` --- ## 🚀 సవాలు మొదట తార్కిక ఆపరేటర్లు వాడి, తరువాత టెర్నరీ వ్యక్తీకరణ వాడి వ్రాసిన ఒక ప్రోగ్రామ్ తయారు చేయండి. మీకు ఇష్టమైన సింటాక్స్ ఏది? --- ## GitHub Copilot ఏజెంట్ సవాలు 🚀 ఈ సవాలను పూర్తి చేయడానికి ఏజెంట్ మోడ్ ఉపయోగించండి: **వివరణ:** ఈ పాఠంలో నిర్ణయాలు తీసుకునే అనేక భావాలను చూపించే సమగ్ర గ్రేడ్ లెక్కింపు ప్రోగ్రామ్ రాయండి, ఇందులో if-else స్టేట్మెంట్లు, switch స్టేట్మెంట్లు, తార్కిక ఆపరేటర్లు మరియు టెర్నరీ వ్యక్తీకరణలు ఉంటాయి. **ప్రాంప్ట్:** ఒక విద్యార్థి సంఖ్యాత్మక స్కోర్ (0-100) ను తీసుకుని, క్రింది ప్రమాణాల ప్రకారం వారి లెటర్ గ్రేడ్ నిర్ణయించే జావాస్క్రిప్ట్ ప్రోగ్రామ్ వ్రాయండి: - A: 90-100 - B: 80-89 - C: 70-79 - D: 60-69 - F: 60 కి దిగువన అవసరాలు: 1. లెటర్ గ్రేడ్ నిర్ణయానికి if-else స్టేట్మెంట్ ఉపయోగించండి 2. విద్యార్థి ఉత్తీర్ణత సాధించినట్టునో (గ్రేడ్ >= 60) మరియు ఆర్డర్లు ఉన్నాయో (గ్రేడ్ >= 90) చెక్ చేయడానికి లాజికల్ ఆపరేటర్లను వాడండి 3. ప్రతి లెటర్ గ్రేడ్ కొరకు నిర్దిష్ట అభిప్రాయాన్ని పంచేందుకు స్విచ్ స్టేట్‌మెంట్‌ను వాడండి 4. తదుపరి కోర్సుకు విద్యార్థి అర్హుడా అనేదాన్ని నిర్ణయించడానికి టెర్నరీ ఆపరేటర్ వాడండి (గ్రేడ్ >= 70) 5. స్కోరు 0 మరియు 100 మధ్య ఉందని నిర్ధారించడానికి ఇన్‌పుట్ చెలామణీని చేర్చండి ముఖ్య సంఘర్షణలుగా 59, 60, 89, 90 మరియు చెలామణి కాని ఇన్‌పుట్‌లతో మీ ప్రోగ్రామ్ను పరీక్షించండి. ఇంకా సమాచారం కోసం [agent mode](https://code.visualstudio.com/blogs/2025/02/24/introducing-copilot-agent-mode) ఇక్కడ చూడండి. ## పోస్ట్-లెక్చర్ క్విజ్ [Post-lecture quiz](https://ff-quizzes.netlify.app/web/quiz/12) ## సమీక్ష & స్వీయ అధ్యయనం యూజర్‌కు అందుబాటులో ఉన్న అనేక ఆపరేటర్లు గురించి మరింత తెలుసుకోండి [MDNలో](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Operators). జోష్ కామౌ యొక్క అద్భుతమైన [ఆపరేటర్ లుకప్](https://joshwcomeau.com/operator-lookup/)ని గమనించండి! ## అసైన్మెంట్ [Operators](assignment.md) --- ## 🧠 **మీ నిర్ణయ-making టూల్‌కిట్ సారాంశం** ```mermaid graph TD A["🎯 జావాస్క్రిప్ట్ నిర్ణయాలు"] --> B["🔍 బూలియన్ లాజిక్"] A --> C["📊 షరతుల స్టేట్మెంట్లు"] A --> D["🔗 లాజికల్ ఆపరేటర్లు"] A --> E["⚡ అభివృద్ధి చెందిన నమూనాలు"] B --> B1["true/false విలువలు"] B --> B2["తులనా ఆపరేటర్లు"] B --> B3["సత్యత్వ సిద్ధాంతాలు"] C --> C1["if స్టేట్మెంట్లు"] C --> C2["if-else గొలుసులు"] C --> C3["switch స్టేట్మెంట్లు"] D --> D1["&& (AND)"] D --> D2["|| (OR)"] D --> D3["! (NOT)"] E --> E1["టెర్నరీ ఆపరేటర్"] E --> E2["షార్ట్-సర్క్యూట్ మూల్యాంకనం"] E --> E3["సంక్లిష్ట షరతులు"] F["💡 కీలక సూత్రాలు"] --> F1["స్పష్టమైన చదవదగిన షరతులు"] F --> F2["అనువైన తులన శైలి"] F --> F3["శ్రేయోన్నత ఆపరేటర్ ప్రాధాన్యత"] F --> F4["ప్రభావవంతమైన మూల్యాంకన క్రమం"] style A fill:#e3f2fd style B fill:#e8f5e8 style C fill:#fff3e0 style D fill:#f3e5f5 style E fill:#e0f2f1 style F fill:#fce4ec ``` --- ## 🚀 మీ జావాస్క్రిప్ట్ నిర్ణయ-making మాస్టరీ టైమ్‌లైన్ ### ⚡ **మరుసటి 5 నిమిషాల్లో మీరు చేయగలవు** - [ ] మీ బ్రౌజర్ కన్సోల్‌లో పోలిక ఆపరేటర్లతో అభ్యాసం చేయండి - [ ] మీ వయస్సును చెక్ చేసే సాధారణ if-else స్టేట్‌మెంట్ రాయండి - [ ] ఒక if-else ను టెర్నరీ ఆపరేటర్ ఉపయోగించి మళ్లీ రాయడాన్ని ప్రయత్నించండి - [ ] వేర్వేరు “ట్రూతీ” మరియు “ఫాల్సీ” విలువలతో ఏమి జరుగుతుందో పరీక్షించండి ### 🎯 **ఈ గంటలో మీరు సాధించగలిగేది** - [ ] పోస్ట్-పాఠం క్విజ్ పూర్తి చేసి ఏదైనా చిక్కిన భావనలను సమీక్షించండి - [ ] GitHub Copilot ఛాలెంజ్ నుండి సమగ్ర గ్రేడ్ క్యాలిక్యులేటర్ నిర్మించండి - [ ] నిజ జీవిత పరిస్థితికి సరళమైన నిర్ణయ మొక్క (decision tree) సృష్టించండి (ఉదాహరణకు ఏమి ధరిస్తామో ఎంచుకోవడం) - [ ] అనేక పరిస్థితులను లాజికల్ ఆపరేటర్లతో కలిపి అభ్యాసం చేయండి - [ ] వేర్వేరు ఉపయోగాల కొరకు స్విచ్ స్టేట్మెంట్లను ప్రయోగించండి ### 📅 **మీ వారాంతపు లాజిక్ మాస్టరీ** - [ ] సృజనాత్మక ఉదాహరణలతో ఆపరేటర్ల అసైన్మెంట్ పూర్తి చేయండి - [ ] వేర్వేరు షరతుల నిర్మాణాలతో మినీ క్విజ్ అప్లికేషన్ రూపొందించండి - [ ] అనేక ఇన్‌పుట్ షరతులను చెక్ చేసే ఫారమ్ వాలిడేటర్ సృష్టించండి - [ ] జోష్ కామౌ యొక్క [ఆపరేటర్ లుకప్](https://joshwcomeau.com/operator-lookup/) వ్యాయామాలను అభ్యసించండి - [ ] ప్రస్తుతం ఉన్న కోడ్‌ను మరింత తగిన షరతుల నిర్మాణాల కోసం పునఃరూపకల్పన చేయండి - [ ] షార్ట్-సర్క్యూట్ ఇవాల్యుషన్ మరియు పనితీరు ప్రభావాలను అధ్యయనం చేయండి ### 🌟 **మీ నెలపాటు పరివర్తనం** - [ ] సంక్లిష్టమైన nested షరతులను సంపూర్ణంగా ఆలస్యం లేకుండా నేర్చుకోండి మరియు కోడ్ చదవటానికి సులభతరం చేయండి - [ ] నైపుణ్యమయిన నిర్ణయ-making లాజిక్‌తో అప్లికేషన్ నిర్మించండి - [ ] ప్రస్తుత ప్రాజెక్టులలో షరతుల లాజిక్ మెరుగుపరచుతూ ఓపెన్ సోర్స్‌కు సహాయం చేయండి - [ ] ఇతరులకు వేర్వేరు షరతుల నిర్మాణాలు మరియు వాటిని ఎప్పుడు వాడాలో బోధించండి - [ ] షరతుల లాజిక్‌కు ఫంక్షనల్ ప్రోగ్రామింగ్ దారులను అన్వేషించండి - [ ] షరతుల ఉత్తమ విధానాల కోసం వ్యక్తిగత సూచిక గైడ్ సృష్టించండి ### 🏆 **దశాంతమైన నిర్ణయ-making ఛాంపియన్ చెక్-ఇన్** **మీ లాజికల్ ఆలోచన మాస్టరీని సంబరంగా జరుపుకోండి:** - మీరు విజయవంతంగా అమలు చేసిన అత్యంత సంక్లిష్టమైన నిర్ణయ లాజిక్ ఏమిటి? - ఏ షరతుల నిర్మాణం మీకు అత్యంత సహజంగా అర్థమవుతుంది మరియు ఎందుకు? - లాజికల్ ఆపరేటర్ల గురించి నేర్చుకున్నことで మీ సమస్య పరిష్కార దశపై ఎలా ప్రభావం వచ్చింది? - ఏ నిజ జీవిత అప్లికేషన్ నైపుణ్యపూర్వక నిర్ణయ-making లాజిక్ నుంచి ప్రయోజనం పొందుతుంది? ```mermaid journey title మీ లాజికల్ ఆలోచన అభివృద్ధి section ఈ రోజు బూలియన్ గందరగోళం: 3: You ఇఫ్-ఎల్స్ అవగాహన: 4: You ఆపరేటర్ పరిచయం: 5: You section ఈ వారము సంక్లిష్ట పరిస్థితులు: 4: You స్విచ్ నైపుణ్యం: 5: You తార్కిక మిశ్రమాలు: 5: You section వచ్చే నెల అధునాతన నమూనాలు: 5: You కార్యపాటవ గుర్తింపు: 5: You ఇతరులను బోధించడం: 5: You ``` > 🧠 **మీరు డిజిటల్ నిర్ణయ-making కళను నైపుణ్యంగా ఆర్జించారు!** ప్రతి ఇంటరాక్టివ్ అప్లికేషన్ వినియోగదారుల చర్యలు మరియు మార్పుల పరిస్థితులకు తెలివిగా స్పందించడానికి షరతుల లాజిక్ పై ఆధారపడి ఉంటుంది. ఇప్పుడు మీరు తెలుసుకున్నారు మీ ప్రోగ్రామ్లు ఎలా ఆలోచించాలో, మూల్యాంకన చేయాలో, మరియు సరైన ప్రతిస్పందనలను ఎంపిక చేసుకోవాలో. ఈ లాజికల్ పునాది మీ నిర్మించే ప్రతీ డైనమిక్ అప్లికేషన్‌కు శక్తినిస్తుంది! 🎉 --- **అస్పష్టత**: ఈ పత్రాన్ని AI అనువాద సేవ [Co-op Translator](https://github.com/Azure/co-op-translator) ఉపయోగించి అనువదించారు. మేము సంతృప్తికరమైన ఖచ్చితత్వం కోసం ప్రయత్నించినప్పటికీ, స్వయంచాలక అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. స్వదేశీ భాషలోని అసలు పత్రం అధికారిక మూలంగా తీసుకోవాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదాన్ని సూచించబడతుంది. ఈ అనువాద ఉపయోగంలో నుంచే వచ్చిన ఏదైనా అపార్థాలు లేదా తప్పుదారులు కారణంగా మేము బాధ్యులు కాదు.