JavaScript కోడింగ్ టెస్ట్ ప్రాక్టీస్

అసలు పరీక్ష సాధారణంగా ఎలా ఉంటుంది

ఒకే రకమైన JavaScript coding test అంటూ లేదు. ప్రతి యజమాని ఒక testing platform‌ను ఎంచుకుని, తనకు తగిన questions, tasks సంఖ్య, సమయ పరిమితి, అనుమతించే languages‌ను నిర్ణయిస్తారు. మీ test ఎలా ఉంటుందో తెలుసుకోవడానికి test ఆహ్వానమే ఉత్తమ మార్గదర్శకం. బహిరంగంగా అందుబాటులో ఉన్న ఉదాహరణలు ఈ వైవిధ్యాన్ని చూపిస్తాయి:

• HackerRank. HackerRank తన JavaScript (Basic) skills test‌లో 1 hour 30 minutes‌లో 2 questions ఉంటాయని, functions వంటి అంశాలు అందులో ఉంటాయని పేర్కొంటుంది (HackerRank). యజమానులు test‌లో coding, multiple choice, HTML/CSS/JavaScript, front-end developer, code review, subjective questions వంటి ప్రశ్నల రకాలను చేర్చవచ్చని దాని help center జాబితా చేస్తుంది. యజమానులు HackerRank library నుంచి questions జోడించవచ్చని లేదా సొంతంగా రాయవచ్చని కూడా చెబుతుంది (HackerRank Help).
• TestGorilla. TestGorilla JavaScript coding tests పేజీ ప్రకారం, ఒక్కో test‌కు 15 నుంచి 45 minutes పడుతుంది. ప్రారంభ స్థాయి algorithms test‌కు 15 minutes అని పేర్కొంటుంది. అభ్యర్థులు online editor‌లో పని చేస్తారని, అందుబాటులో ఉండే languages‌ను యజమానులు ఎంచుకుంటారని కూడా చెబుతుంది (TestGorilla).

యజమానుల JavaScript tests‌లో సాధారణంగా కనిపించే భాగాలు:

• Coding tasks: online editor‌లో function రాయడం, sample inputs‌తో దాన్ని run చేయడం, ఆపై మీరు చూడలేని మరిన్ని test cases‌తో తనిఖీ చేయడానికి సమర్పించడం.
• Multiple choice: JavaScript భావనలు, code snippet ఏమి log చేస్తుంది, ఏ code సరైనది వంటి ప్రశ్నలు.
• Debugging లేదా code review: మరొకరు రాసిన code‌లోని సమస్యను గుర్తించి పరిష్కరించడం.
• కొన్నిసార్లు అదనంగా: web page‌ను రూపొందించడం లేదా సరిచేయడం, పెద్ద front-end లేదా back-end project, ఇంటి వద్ద పూర్తి చేయాల్సిన assignment, లేదా test సమయంలో webcam మరియు screen‌ను పర్యవేక్షించడం.

మా mock tests‌లో ఏముంటుంది. మా పూర్తి mock tests‌లో నాలుగు విభాగాలుగా 60 minutes‌లో 20 questions ఉంటాయి: JavaScript భావనలు (6), code ఏమి log చేస్తుంది (6), bug‌ను గుర్తించడం (5), పరిష్కారాన్ని రూపొందించడం (3). Browser లేదా framework code లేకుండా, Node.js‌లో నడిచే ఆధునిక JavaScript‌ను code అంతటా ఉపయోగిస్తాం. సమర్పించే వరకు మీరు వెనక్కి వెళ్లి సమాధానాన్ని మార్చవచ్చు, questions‌ను flag చేయవచ్చు. మా mock tests code చదవడం, దాని అమలును దశలవారీగా అనుసరించడం, debugging చేయడం, code‌ను ఎంచుకోవడం వంటి నైపుణ్యాలను సాధన చేయిస్తాయి. మీరు రాసే code‌ను ఇవి run చేయవు. చాలా నిజమైన assessments‌లో కనిపించని test cases‌తో run అయ్యేలా code రాయాల్సి ఉంటుంది. ఈ సాధన దానికి అవసరమైన code చదవడం, అమలును అనుసరించడం, debugging నైపుణ్యాలను పెంచుతుంది. కాబట్టి నిజమైన editor‌లో కూడా సమయ పరిమితితో సాధన చేయండి. మా mock tests‌లో front-end, back-end, full-stack project tasks, proctoring, plagiarism తనిఖీలు, video interviews, ఇంటి వద్ద చేయాల్సిన tasks, అలాగే యజమాని నిర్ణయించే pass mark ఉండవు.

వివరణాత్మక ఉదాహరణలతో ప్రశ్నల రకాలు

ప్రతి విభాగానికి ఒక ఉదాహరణ, చాలామంది చేసే పొరపాటుతో సహా.

1. JavaScript భావనలు. letకు, varకు మధ్య తేడా ఏమిటి? let అనేది దగ్గరలోని block పరిధిలో మాత్రమే ఉంటుంది. ఉదాహరణకు, loop bodyలో ఉంటుంది. దాని లైన్ అమలయ్యే ముందు దాన్ని ఉపయోగించలేరు. var అనేది మొత్తం function పరిధిలో ఉంటుంది, అలాగే hoist అవుతుంది. అందువల్ల దాని లైన్ అమలయ్యే ముందు అది undefinedగా ఉంటుంది. పొరపాటు: const object లేదా arrayను మార్చలేనిదిగా చేస్తుందని అనుకోవడం. ఇది ఆ పేరుకు మళ్లీ వేరే విలువను కేటాయించకుండా మాత్రమే ఆపుతుంది.

2. కోడ్ ఏమి లాగ్ చేస్తుంది. console.log(typeof null, typeof []) అనేది object objectను లాగ్ చేస్తుంది. typeof ప్రకారం రెండూ objects. arrayనా కాదా అని తనిఖీ చేయడానికి Array.isArray ఉపయోగించండి. async కోడ్‌లో క్రమాన్ని గుర్తుంచుకోండి: ముందుగా సాధారణ కోడ్, తర్వాత promise callbacks, ఆపై timers. పొరపాటు: setTimeout(fn, 0)ను "ఇప్పుడే అమలు చేయి" అని అర్థం చేసుకోవడం. ప్రస్తుత కోడ్, పెండింగ్‌లో ఉన్న promise callbacks పూర్తయ్యే వరకు ఇది ఎప్పుడూ వేచి ఉంటుంది.

3. బగ్‌ను కనుగొనడం. ఒక function మొత్తం విలువకు బదులుగా undefinedను ఇస్తోంది. braces ఉన్నా return లేని arrow function ఉందేమో చూడండి: (a, b) => { a + b } అనేది undefinedను ఇస్తుంది. (a, b) => a + b మాత్రం మొత్తాన్ని ఇస్తుంది. పొరపాటు: వింతగా కనిపించే మొదటి లైన్‌ను సరిచేయడం. చిన్న inputను కోడ్‌లో అనుసరించి, విలువ తప్పుగా మారే మొదటి లైన్‌ను కనుగొనండి.

4. పరిష్కారాన్ని రూపొందించడం. cartలోని వస్తువుల మొత్తం ధర కావాలి. items.reduce((sum, item) => sum + item.price, 0)తో అది లభిస్తుంది. చివర్లో 0 లేకపోతే, ఖాళీ cart TypeErrorను ఇస్తుంది. పొరపాటు: ఉదాహరణలో పనిచేసి, అంచు సందర్భాల్లో పనిచేయని ఎంపికను ఎంచుకోవడం. ఖాళీ array, ఒక్క item, పునరావృత విలువలు, మిస్సింగ్ విలువలతో ప్రతి ఎంపికను పరీక్షించండి.

ఎలా సిద్ధం కావాలి

1. ముందుగా మీ ఆహ్వానాన్ని చదవండి. మీరు ఏ ప్లాట్‌ఫారమ్‌ను ఉపయోగించాలి, ఎన్ని tasks ఉన్నాయి, సమయ పరిమితి ఎంత, JavaScript ఎంచుకోవచ్చా, front-end tasks ఉంటాయా, అలాగే పరీక్ష పర్యవేక్షణలో జరుగుతుందా అనే విషయాలు తెలుసుకోండి. పరీక్షల రూపాలు చాలా భిన్నంగా ఉంటాయి, కాబట్టి ముందే ఊహించకండి.
2. ప్లాట్‌ఫారమ్‌లో practice area ఉంటే ప్రయత్నించండి. Editor, Run button, sample test cases ఎలా చూపిస్తారో ముందే తెలుసుకోండి. అప్పుడు పరీక్ష రోజున ఆ screen కొత్తగా అనిపించదు. ఉదాహరణకు, HackerRankలో అభ్యర్థులు పని చేస్తున్నప్పుడు Run నొక్కి test cases అమలు చేయవచ్చని వివరించారు (HackerRank Support).
3. Code‌ను చేతితో అనుసరించండి. చిన్న snippets కోసం, ప్రతి line తర్వాత ప్రతి variable విలువను రాసుకోండి. Async code కోసం మూడు జాబితాలు పెట్టుకోండి: ఇప్పుడే అమలయ్యేవి, promise callbacks, timers.
4. రోజువారీగా ఉపయోగించే tools తెలుసుకోండి. Arrays మరియు వాటి methods (map, filter, reduce, some, find, sort), objects, Map మరియు Set, strings, destructuring, spread, template literals, async, await.
5. సమర్పించే ముందు edge cases గురించి ఆలోచించండి. ఖాళీ arrays, strings, ఒక item, పునరావృతమయ్యే విలువలు, null, undefined, strings‌గా ఇచ్చిన numbers. Hidden test cases తరచుగా వీటినే తనిఖీ చేస్తాయి.
6. సమయ పరిమితిలో code రాయండి. మా mock tests చదవడం, debugging సాధనకు సహాయపడతాయి. ఒత్తిడిలో code రాయడం, అమలు చేయడం సహజంగా అనిపించేలా, timer పెట్టుకుని నిజమైన editor‌లో కొన్ని చిన్న problems కూడా పరిష్కరించండి.
7. నిజమైన వేగంతో సాధన చేయండి. మీ పరీక్ష HackerRank JavaScript (Basic) ఉదాహరణలా ఉంటే, 1 గంట 30 నిమిషాల్లో 2 ప్రశ్నలు అంటే ఒక్కో problem‌కు సుమారు 45 నిమిషాలు లభిస్తాయి (HackerRank). మీ సమయాన్ని నిర్వహించడం సహజంగా అనిపించేలా, సమయ పరిమితి ఉన్న పూర్తి mock tests తీసుకోండి.

సాధారణంగా స్కోరింగ్ ఎలా జరుగుతుంది

స్కోరింగ్ ప్లాట్‌ఫారమ్ మరియు యజమానిపై ఆధారపడి ఉంటుంది. అందరికీ వర్తించే స్కేల్ లేదా ఉత్తీర్ణత మార్కు లేదు. Coding ప్రశ్నలకు సాధారణంగా test cases ఆధారంగా స్వయంచాలకంగా స్కోర్ ఇస్తారు. రెండు బహిరంగ వివరణలు:

• HackerRank ప్రకారం, సరైనత మరియు సామర్థ్యాన్ని కొలిచే ముందే నిర్ణయించిన test cases ద్వారా coding ప్రశ్నలను అంచనా వేస్తారు. ప్రతి test case‌కు ప్రత్యేక స్కోర్ ఉంటుంది: ఒక test case‌లో ఉత్తీర్ణమైన code‌కు ఆ test case‌కు కేటాయించిన పూర్తి స్కోర్ వస్తుంది. విఫలమైన code‌కు సున్నా వస్తుంది. ప్రశ్నకు వచ్చిన మొత్తం స్కోర్ అనేది ఉత్తీర్ణమైన test cases స్కోర్ల మొత్తం. కాబట్టి, కొన్ని test cases‌లో ఉత్తీర్ణమైన పరిష్కారానికి పాక్షిక స్కోర్ వస్తుంది (HackerRank Support). Coding మరియు multiple choice ప్రశ్నలను స్వయంచాలకంగా అంచనా వేస్తారు. HTML/CSS/JavaScript ప్రశ్నలను చేతితో అంచనా వేస్తారు. Front-end ప్రశ్నలను స్వయంచాలకంగా అంచనా వేస్తారు, అయితే చేతితో సమీక్షించాలని సిఫార్సు చేస్తారు (HackerRank Help).
• TestGorilla మొత్తం సమాధానాల సరైనత ఆధారంగా percentile స్కోరింగ్ ఇస్తామని, ప్రతి test case ఫలితాన్ని చూపించే నివేదికను అందిస్తామని చెబుతోంది (TestGorilla).

మంచి ఫలితం అంటే ఏమిటో ప్రతి యజమాని నిర్ణయిస్తారు. చాలామంది స్కోర్‌తో పాటు మీ code‌ను కూడా పరిశీలిస్తారు.

మా ప్రాక్టీస్ స్కోర్ అంటే, మా ప్రశ్నల్లో మీరు సరిగ్గా సమాధానం ఇచ్చిన ప్రశ్నల సంఖ్య. ఏ అంశంపై దృష్టి పెట్టాలో తెలుసుకునేందుకు, విభాగాల వారీగా వివరాలు కూడా చూపిస్తాం. ఇది ప్రాక్టీస్ స్కోర్ మాత్రమే: ఇది ఏ ప్లాట్‌ఫారమ్ test‌లో వచ్చిన స్కోర్ కాదు, మీరు ఉత్తీర్ణులవుతారో లేదో కూడా సూచించదు.

సాధారణ తప్పులు

• compare function లేకుండా numbers‌ను sort చేయడం. [10, 9, 1].sort() వాటిని text‌లా sort చేస్తుంది. sort((a, b) => a - b) ఉపయోగించండి.
• == ఉపయోగించి, type conversion వల్ల ఆశ్చర్యపోవడం. వేరేలా చేయడానికి కారణం లేకపోతే === ఉపయోగించండి.
• forEach వేచి ఉండదనే విషయాన్ని మర్చిపోవడం. forEach callback‌లోని await బయట function‌ను ఆపదు. for...of లేదా Promise.all ఉపయోగించండి.
• objects లేదా arrays‌ను ===తో పోల్చడం. రెండు objects ఒకే object అయితేనే సమానంగా ఉంటాయి. మీకు అవసరమైన fields‌ను పోల్చండి.
• అలాగే ఉంచాలనుకున్న array‌ను మార్చడం. sort, reverse, splice array‌ను ఉన్నచోటే మారుస్తాయి. అసలైన array అవసరమైనప్పుడు ముందుగా [...arr]తో కాపీ చేయండి.
• ఉదాహరణను మాత్రమే పరీక్షించడం. కనిపించే ఉదాహరణ సాధారణంగా విజయవంతమవుతుంది. ఖాళీ input, ఒకే item, duplicates, పెద్ద input‌లను hidden test cases తనిఖీ చేస్తాయి.
• ఒక task‌పైనే సమయం అయిపోవడం. ఇరుక్కుపోతే, కొన్ని test cases‌లో ఉత్తీర్ణమయ్యే సరళమైన version‌ను submit చేసి, ముందుకు వెళ్లండి. సమయం ఉంటే తర్వాత తిరిగి రండి.