JavaScript coding test ଅଭ୍ୟାସ

ପ୍ରକୃତ ପରୀକ୍ଷା ସାଧାରଣତଃ କିପରି ହୋଇଥାଏ

JavaScript ପାଇଁ ଗୋଟିଏ ନିର୍ଦ୍ଦିଷ୍ଟ coding test ନାହିଁ। ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ଏକ testing platform ବାଛନ୍ତି ଏବଂ ନିଜ ପ୍ରଶ୍ନ, କାର୍ଯ୍ୟ ସଂଖ୍ୟା, ସମୟସୀମା ଓ ଅନୁମୋଦିତ ଭାଷା ନିର୍ଦ୍ଧାରଣ କରନ୍ତି। ଆପଣଙ୍କ test invitation ହିଁ ଆପଣଙ୍କ test ବିଷୟରେ ସବୁଠାରୁ ଭଲ ସୂଚନା ଦେବ। ସାର୍ବଜନୀନ ଉଦାହରଣଗୁଡ଼ିକରୁ ଏହାର ଭିନ୍ନତା ଜଣାପଡ଼େ:

• HackerRank. HackerRank ଏହାର JavaScript (Basic) skills testକୁ 2 questions in 1 hour 30 minutes ଭାବେ ତାଲିକାଭୁକ୍ତ କରିଛି। ଏଥିରେ functions ଭଳି ବିଷୟ ରହିଛି (HackerRank)। ଏହାର help centerରେ ନିଯୁକ୍ତିଦାତା testରେ ରଖିପାରୁଥିବା ପ୍ରଶ୍ନ ପ୍ରକାରଗୁଡ଼ିକ ତାଲିକାଭୁକ୍ତ ହୋଇଛି। ସେଥିରେ coding, multiple choice, HTML/CSS/JavaScript, front-end developer, code review ଓ subjective questions ରହିଛି। ନିଯୁକ୍ତିଦାତାମାନେ HackerRankର libraryରୁ ପ୍ରଶ୍ନ ଯୋଡ଼ିପାରିବେ କିମ୍ବା ନିଜେ ପ୍ରଶ୍ନ ଲେଖିପାରିବେ ବୋଲି ଏଥିରେ କୁହାଯାଇଛି (HackerRank Help)।
• TestGorilla. TestGorillaର JavaScript coding tests ପୃଷ୍ଠାରେ କୁହାଯାଇଛି ଯେ ପ୍ରତ୍ୟେକ test 15 ରୁ 45 minutes ମଧ୍ୟରେ ହୋଇଥାଏ। ଏଥିରେ entry-level algorithms test 15 minutesର ବୋଲି ତାଲିକାଭୁକ୍ତ ହୋଇଛି। ପ୍ରାର୍ଥୀମାନେ online editorରେ କାମ କରନ୍ତି ଏବଂ କେଉଁ ଭାଷା ଉପଲବ୍ଧ ରହିବ ତାହା ନିଯୁକ୍ତିଦାତା ବାଛନ୍ତି ବୋଲି ମଧ୍ୟ କୁହାଯାଇଛି (TestGorilla)।

ନିଯୁକ୍ତିଦାତାଙ୍କ JavaScript testରେ ସାଧାରଣତଃ ଥିବା ଅଂଶ:

• Coding tasks: online editorରେ ଏକ function ଲେଖନ୍ତୁ, sample inputs ଦେଇ ଏହା ଚଲାନ୍ତୁ, ତାପରେ ଏହାକୁ submit କରନ୍ତୁ। ଏହାକୁ ଆପଣ ଦେଖିନଥିବା ଅନ୍ୟ test cases ସହିତ ଯାଞ୍ଚ କରାଯାଇପାରେ।
• Multiple choice: JavaScript ଧାରଣା, ଏକ code snippet କ’ଣ log କରେ, ଏବଂ କେଉଁ code ଠିକ୍।
• Debugging କିମ୍ବା code review: ଅନ୍ୟ କେହି ଲେଖିଥିବା codeରେ ସମସ୍ୟା ଖୋଜି ଠିକ୍ କରିବା।
• କେବେ କେବେ ଅଧିକ କିଛି: ଏକ web page ତିଆରି କିମ୍ବା ଠିକ୍ କରିବା, ବଡ଼ front-end କିମ୍ବା back-end project, ଘରେ କରିବାକୁ ଦିଆଯାଇଥିବା assignment, କିମ୍ବା test ସମୟରେ webcam ଓ screen monitoring।

ଆମ mock testରେ କ’ଣ ରହିଛି। ଆମର full mock testରେ 60 minutesରେ 20ଟି ପ୍ରଶ୍ନ ଏବଂ ଚାରିଟି ବିଭାଗ ଅଛି: JavaScript concepts (6), code କ’ଣ log କରେ (6), bug ଖୋଜିବା (5) ଏବଂ solution ତିଆରି କରିବା (3)। ସମସ୍ତ code Node.jsରେ ଚାଲୁଥିବା ଆଧୁନିକ JavaScriptରେ ଅଛି। ଏଥିରେ browser କିମ୍ବା framework code ନାହିଁ। Submit କରିବା ପର୍ଯ୍ୟନ୍ତ ଆପଣ ପଛକୁ ଯାଇପାରିବେ, ଉତ୍ତର ବଦଳାଇପାରିବେ ଏବଂ ପ୍ରଶ୍ନଗୁଡ଼ିକୁ flag କରିପାରିବେ। ଆମ mock testରେ code ପଢ଼ିବା, ଏହା କିପରି ଚାଲେ ତାହା ଅନୁସରଣ କରିବା, debugging କରିବା ଓ code ବାଛିବାର ଅଭ୍ୟାସ ହୁଏ। ଆପଣ ଲେଖିଥିବା code ଏଥିରେ ଚଲେ ନାହିଁ। ଅନେକ ବାସ୍ତବ assessmentରେ ଲୁଚାଇ ରଖାଯାଇଥିବା test cases ଉପରେ ଚାଲୁଥିବା code ଲେଖିବାକୁ କୁହାଯାଏ। ଏହି ଅଭ୍ୟାସ ସେଥିପାଇଁ ଆବଶ୍ୟକ code ପଢ଼ିବା, ଅନୁସରଣ କରିବା ଓ debugging କୌଶଳ ଗଢ଼ିଥାଏ। ତେଣୁ ଏକ ପ୍ରକୃତ editorରେ ସମୟ ଧରି ଅଭ୍ୟାସ ମଧ୍ୟ କରନ୍ତୁ। ଆମ mock testରେ front-end, back-end ଓ full-stack project tasks, proctoring, plagiarism checks, video interviews, ଘରେ କରିବାକୁ ଦିଆଯାଇଥିବା କାମ ଏବଂ ନିଯୁକ୍ତିଦାତାଙ୍କ ଯେକୌଣସି pass mark ନାହିଁ।

ସମାଧାନ ସହ ଉଦାହରଣ ଥିବା ପ୍ରଶ୍ନର ପ୍ରକାର

ପ୍ରତ୍ୟେକ ଅଂଶ ପାଇଁ ଗୋଟିଏ ଉଦାହରଣ, ଯେଉଁଥିରେ ଅଧିକାଂଶ ଲୋକ କରୁଥିବା ଭୁଲଟି ମଧ୍ୟ ଦର୍ଶାଯାଇଛି।

1. JavaScript ଧାରଣା। let ଏବଂ var ମଧ୍ୟରେ ପାର୍ଥକ୍ୟ କ’ଣ? let ନିକଟତମ block, ଯେପରିକି loop body, ମଧ୍ୟରେ ସୀମିତ ରହେ ଏବଂ ଏହାର ଲାଇନ୍ ଚାଲିବା ପୂର୍ବରୁ ବ୍ୟବହାର କରାଯାଇପାରେନାହିଁ। var ସମ୍ପୂର୍ଣ୍ଣ function ମଧ୍ୟରେ ସୀମିତ ରହେ ଏବଂ hoist ହୁଏ, ତେଣୁ ଏହାର ଲାଇନ୍ ଆସିବା ପୂର୍ବରୁ ଏହା undefined ଭାବେ ରହେ। ଫାନ୍ଦ: const ଏକ object କିମ୍ବା array କୁ ବଦଳାଇହେବ ନାହିଁ ବୋଲି ଧରିନେବା। ଏହା କେବଳ ସେହି ନାମକୁ ପୁଣି ଅନ୍ୟ ମୂଲ୍ୟ ଦେବାକୁ ରୋକେ।

2. Code କ’ଣ log କରେ। console.log(typeof null, typeof []) ରେ object object log ହୁଏ। typeof ଅନୁସାରେ ଉଭୟ object; array ଯାଞ୍ଚ କରିବାକୁ Array.isArray ବ୍ୟବହାର କରନ୍ତୁ। Async code ପାଇଁ କ୍ରମଟି ମନେରଖନ୍ତୁ: ପ୍ରଥମେ ସାଧାରଣ code, ତା’ପରେ promise callback, ଶେଷରେ timer। ଫାନ୍ଦ: setTimeout(fn, 0) କୁ "ଏବେ ଚଲାଅ" ବୋଲି ବୁଝିବା। ବର୍ତ୍ତମାନର code ଏବଂ ଅପେକ୍ଷାରତ promise callback ସରିବା ପର୍ଯ୍ୟନ୍ତ ଏହା ସବୁବେଳେ ଅପେକ୍ଷା କରେ।

3. Bug ଖୋଜିବା। ଏକ function ମୋଟ ରାଶି ବଦଳରେ undefined ଫେରାଏ। {} ଥିବା କିନ୍ତୁ return ନଥିବା arrow function ଖୋଜନ୍ତୁ: (a, b) => { a + b } ରେ undefined ଫେରେ, କିନ୍ତୁ (a, b) => a + b ରେ ଯୋଗଫଳ ଫେରେ। ଫାନ୍ଦ: ଅସ୍ୱାଭାବିକ ଦେଖାଯାଉଥିବା ପ୍ରଥମ ଲାଇନ୍‌ଟିକୁ ଠିକ୍ କରିବା। Code ମଧ୍ୟରେ ଏକ ଛୋଟ input ଅନୁସରଣ କରନ୍ତୁ ଏବଂ କେଉଁ ଲାଇନ୍‌ରେ ପ୍ରଥମେ ମୂଲ୍ୟ ଭୁଲ୍ ହେଉଛି ଖୋଜନ୍ତୁ।

4. ସମାଧାନ ତିଆରି କରିବା। Cart ର ମୋଟ ଦାମ ହିସାବ କରିବାକୁ ପଡ଼ିବ। items.reduce((sum, item) => sum + item.price, 0) ଏହା କରେ। ଶେଷରେ 0 ନଥିଲେ ଖାଲି cart ରୁ TypeError ହୁଏ। ଫାନ୍ଦ: ଉଦାହରଣରେ କାମ କରେ, କିନ୍ତୁ ସୀମାନ୍ତ ପରିସ୍ଥିତିରେ ନୁହେଁ, ଏପରି ବିକଳ୍ପ ବାଛିବା। ଖାଲି array, ଗୋଟିଏ item, ପୁନରାବୃତ୍ତି ଏବଂ ନଥିବା ମୂଲ୍ୟ ସହ ପ୍ରତ୍ୟେକ ବିକଳ୍ପ ଯାଞ୍ଚ କରନ୍ତୁ।

କିପରି ପ୍ରସ୍ତୁତି ନେବେ

1. ପ୍ରଥମେ ଆପଣଙ୍କ ଆମନ୍ତ୍ରଣ ପଢ଼ନ୍ତୁ। ଆପଣ କେଉଁ ପ୍ଲାଟଫର୍ମ ବ୍ୟବହାର କରିବେ, କେତୋଟି task ଅଛି, ସମୟ ସୀମା କେତେ, JavaScript ବାଛିପାରିବେ କି ନାହିଁ, front-end task ଅନ୍ତର୍ଭୁକ୍ତ କି ନାହିଁ, ଏବଂ ପରୀକ୍ଷା ନିରୀକ୍ଷଣ ହେବ କି ନାହିଁ, ଜାଣନ୍ତୁ। ପରୀକ୍ଷାର ଢାଞ୍ଚା ଏତେ ଭିନ୍ନ ହୋଇପାରେ ଯେ ଅନୁମାନ କରିବା ଠିକ୍ ନୁହେଁ।
2. ପ୍ଲାଟଫର୍ମରେ ଅଭ୍ୟାସ କରିବା ପାଇଁ ବିଭାଗ ଥିଲେ ତାହା ବ୍ୟବହାର କରନ୍ତୁ। Editor, Run button ଏବଂ sample test case କିପରି ଦେଖାଯାଏ, ସେଥିରେ ଅଭ୍ୟସ୍ତ ହୁଅନ୍ତୁ, ଯାହାଦ୍ୱାରା ପରୀକ୍ଷା ଦିନ ସେହି screen ନୂଆ ଲାଗିବ ନାହିଁ। ଉଦାହରଣ ସ୍ୱରୂପ, HackerRank କହେ ଯେ ପ୍ରାର୍ଥୀମାନେ କାମ କରୁଥିବା ସମୟରେ Run ଉପରେ click କରି test case ଚଲାନ୍ତି (HackerRank Support)।
3. ହାତରେ code ଅନୁସରଣ କରନ୍ତୁ। ଛୋଟ code snippet ପାଇଁ, ପ୍ରତ୍ୟେକ line ପରେ ପ୍ରତ୍ୟେକ variable ର value ଲେଖନ୍ତୁ। Async code ପାଇଁ ତିନୋଟି ତାଲିକା ରଖନ୍ତୁ: ବର୍ତ୍ତମାନ କ'ଣ ଚାଲିବ, promise callback ଏବଂ timer।
4. ଦୈନନ୍ଦିନ ବ୍ୟବହାରର tools ଜାଣନ୍ତୁ। Array ଓ ସେମାନଙ୍କ method (map, filter, reduce, some, find, sort), object, Map ଏବଂ Set, string, destructuring, spread, template literal, async ଏବଂ await।
5. ଉତ୍ତର ଦାଖଲ ପୂର୍ବରୁ edge case ବିଷୟରେ ଭାବନ୍ତୁ। ଖାଲି array ଓ string, ଗୋଟିଏ item, ପୁନରାବୃତ୍ତ value, null ଏବଂ undefined, string ଭାବେ ଦିଆଯାଇଥିବା number। ଲୁକ୍କାୟିତ test case ଗୁଡ଼ିକ ପ୍ରାୟତଃ ଏହିସବୁକୁ ହିଁ ଯାଞ୍ଚ କରେ।
6. ସମୟ ଧରି code ଲେଖନ୍ତୁ। ଆମର mock test ଗୁଡ଼ିକ ପଢ଼ିବା ଓ debugging ର ଅଭ୍ୟାସ କରାଏ। ଚାପରେ code ଲେଖିବା ଓ ଚଲାଇବା ସ୍ୱାଭାବିକ ଲାଗିବା ପାଇଁ timer ଲଗାଇ ପ୍ରକୃତ editor ରେ କିଛି ଛୋଟ ସମସ୍ୟା ମଧ୍ୟ ସମାଧାନ କରନ୍ତୁ।
7. ପ୍ରକୃତ ପରୀକ୍ଷାର ଗତିରେ ଅଭ୍ୟାସ କରନ୍ତୁ। ଆପଣଙ୍କ ପରୀକ୍ଷା HackerRank ର JavaScript (Basic) ଉଦାହରଣ ପରି ହେଲେ, 1 ଘଣ୍ଟା 30 ମିନିଟ୍‌ରେ 2ଟି ପ୍ରଶ୍ନ ଅର୍ଥାତ୍ ପ୍ରତ୍ୟେକ ସମସ୍ୟା ପାଇଁ ପ୍ରାୟ 45 ମିନିଟ୍ (HackerRank)। ସମୟ ନିଜେ ଠିକ୍ ଭାବେ ବାଣ୍ଟିବା ସ୍ୱାଭାବିକ ଲାଗିବା ପାଇଁ ପୂରା timed mock test ଦିଅନ୍ତୁ।

ସାଧାରଣତଃ ସ୍କୋର କିପରି ନିର୍ଣ୍ଣୟ କରାଯାଏ

ସ୍କୋରିଂ ପ୍ଲାଟଫର୍ମ ଏବଂ ନିଯୁକ୍ତିଦାତା ଉପରେ ନିର୍ଭର କରେ। କୌଣସି ସାର୍ବଜନୀନ ସ୍କେଲ୍ କିମ୍ବା ଉତ୍ତୀର୍ଣ୍ଣ ମାନଦଣ୍ଡ ନାହିଁ। କୋଡିଂ ପ୍ରଶ୍ନଗୁଡ଼ିକର ସ୍କୋର ସାଧାରଣତଃ test case ସହ ତୁଳନା କରି ସ୍ୱୟଂଚାଳିତ ଭାବେ ଦିଆଯାଏ। ଦୁଇଟି ସାର୍ବଜନୀନ ବିବରଣୀ:

• HackerRank କହେ ଯେ ସଠିକତା ଏବଂ କାର୍ଯ୍ୟଦକ୍ଷତା ମାପୁଥିବା ପୂର୍ବନିର୍ଦ୍ଧାରିତ test case ମାଧ୍ୟମରେ କୋଡିଂ ପ୍ରଶ୍ନଗୁଡ଼ିକର ମୂଲ୍ୟାୟନ କରାଯାଏ। ପ୍ରତ୍ୟେକ test case ପାଇଁ ଅଲଗା ସ୍କୋର ଥାଏ: କୌଣସି test case ରେ ସଫଳ ହେଉଥିବା କୋଡ୍ ସେହି test case ର ପୂରା ସ୍କୋର ପାଏ, ଏବଂ ବିଫଳ ହେଉଥିବା କୋଡ୍ ଶୂନ୍ୟ ପାଏ। ପ୍ରଶ୍ନର ମୋଟ ସ୍କୋର ହେଉଛି ଉତ୍ତୀର୍ଣ୍ଣ ହୋଇଥିବା test case ଗୁଡ଼ିକର ସ୍କୋରର ଯୋଗଫଳ। ତେଣୁ କିଛି test case ରେ ସଫଳ ହେଉଥିବା ସମାଧାନ ଆଂଶିକ ନମ୍ବର ପାଏ (HackerRank ସହାୟତା). କୋଡିଂ ଏବଂ ବହୁବିକଳ୍ପ ପ୍ରଶ୍ନଗୁଡ଼ିକର ମୂଲ୍ୟାୟନ ସ୍ୱୟଂଚାଳିତ ଭାବେ ହୁଏ। HTML/CSS/JavaScript ପ୍ରଶ୍ନଗୁଡ଼ିକୁ ହାତରେ ମୂଲ୍ୟାୟନ କରାଯାଏ, ଏବଂ front-end ପ୍ରଶ୍ନଗୁଡ଼ିକର ମୂଲ୍ୟାୟନ ସ୍ୱୟଂଚାଳିତ ଭାବେ ହୁଏ, ତେବେ ହାତରେ ଯାଞ୍ଚ କରିବାକୁ ପରାମର୍ଶ ଦିଆଯାଏ (HackerRank ସହାୟତା).
• TestGorilla ସାମଗ୍ରିକ ସଠିକତା ଉପରେ ଆଧାରିତ ପର୍ସେଣ୍ଟାଇଲ୍ ସ୍କୋରିଂ ଏବଂ ପ୍ରତ୍ୟେକ test case ର ଫଳାଫଳ ଦେଖାଉଥିବା ଏକ ରିପୋର୍ଟ ବିଷୟରେ କହେ (TestGorilla).

କେଉଁ ଫଳାଫଳକୁ ଭଲ ବୋଲି ଧରାଯିବ, ତାହା ପ୍ରତ୍ୟେକ ନିଯୁକ୍ତିଦାତା ସ୍ଥିର କରନ୍ତି। ଅନେକ ନିଯୁକ୍ତିଦାତା ସ୍କୋର ସହ ଆପଣଙ୍କ କୋଡ୍‌କୁ ମଧ୍ୟ ଦେଖନ୍ତି।

ଆମର ଅଭ୍ୟାସ ସ୍କୋର ହେଉଛି ଆମର ନିଜ ପ୍ରଶ୍ନଗୁଡ଼ିକ ମଧ୍ୟରୁ ଆପଣ କେତୋଟିର ସଠିକ୍ ଉତ୍ତର ଦେଇଛନ୍ତି, ତାହାର ବିଭାଗ ଅନୁସାରେ ବିବରଣୀ। ଏହା କେଉଁଠି ଧ୍ୟାନ ଦେବାକୁ ପଡ଼ିବ ତାହା ଦେଖାଏ। ଏହା ଏକ ଅଭ୍ୟାସ ସ୍କୋର: ଏହା କୌଣସି ପ୍ଲାଟଫର୍ମର ପରୀକ୍ଷାର ସ୍କୋର ନୁହେଁ ଏବଂ ଆପଣ ଉତ୍ତୀର୍ଣ୍ଣ ହେବେ କି ନାହିଁ ତାହାର ପୂର୍ବାନୁମାନ କରେନାହିଁ।

ସାଧାରଣ ଭୁଲ

• compare function ବ୍ୟବହାର ନକରି ସଂଖ୍ୟାଗୁଡ଼ିକୁ ସଜାଇବା। [10, 9, 1].sort() ସଂଖ୍ୟାଗୁଡ଼ିକୁ ଟେକ୍ସଟ୍ ଭାବେ ସଜାଏ। sort((a, b) => a - b) ବ୍ୟବହାର କରନ୍ତୁ।
• == ବ୍ୟବହାର କରି type conversion ଦେଖି ଆଶ୍ଚର୍ଯ୍ୟ ହେବା। ଏହା ନକରିବାର କୌଣସି କାରଣ ନଥିଲେ === ବ୍ୟବହାର କରନ୍ତୁ।
• forEach ଅପେକ୍ଷା କରେ ନାହିଁ ବୋଲି ଭୁଲିଯିବା। forEach callback ଭିତରେ await ଦେଲେ ବାହାରର function ଅଟକେ ନାହିଁ। for...of କିମ୍ବା Promise.all ବ୍ୟବହାର କରନ୍ତୁ।
• === ଦ୍ୱାରା objects କିମ୍ବା arrays ତୁଳନା କରିବା। ଦୁଇଟି object କେବଳ ସେମାନେ ଏକେ object ହୋଇଥିଲେ ହିଁ ସମାନ। ଆପଣଙ୍କ ପାଇଁ ଜରୁରୀ fields ତୁଳନା କରନ୍ତୁ।
• ଯେଉଁ array ରଖିବାକୁ ଚାହୁଁଥିଲେ, ତାହା ବଦଳାଇଦେବା। sort, reverse ଏବଂ splice array କୁ ସେହି ସ୍ଥାନରେ ବଦଳାଏ। ମୂଳ array ଦରକାର ହେଲେ ପ୍ରଥମେ [...arr] ଦ୍ୱାରା ଏହାର କପି କରନ୍ତୁ।
• କେବଳ ଉଦାହରଣଟି ପରୀକ୍ଷା କରିବା। ଦେଖାଯାଉଥିବା ଉଦାହରଣ ସାଧାରଣତଃ ପାସ୍ ହୁଏ। Hidden test cases ଖାଲି input, ଗୋଟିଏ item, ଏକାଧିକ ସମାନ item ଏବଂ ବଡ଼ input ଯାଞ୍ଚ କରେ।
• ଗୋଟିଏ task ରେ ସମୟ ସରିଯିବା। ଅଟକିଗଲେ, କିଛି test cases ପାସ୍ କରୁଥିବା ଏକ ସରଳ version submit କରନ୍ତୁ, ଆଗକୁ ବଢ଼ନ୍ତୁ, ଏବଂ ସମୟ ଥିଲେ ପରେ ଫେରି ଆସନ୍ତୁ।