Home

This checklist should provide a comprehensive overview of JavaScript features and techniques commonly used in backend development with Node.js.

Destructuring:

• Understand and use object and array destructuring.

Spread Syntax:

• Learn how to use the spread syntax for arrays and objects.

Array Methods:

• Master the use of map for transforming arrays.

['engineer', 'doctor', 'teacher'].map((career) => {
    // do something
    return career;
})
// this code iterates over the careers list one at a time

• Understand filter for creating subsets of arrays.

['engineer', 'doctor', 'teacher'].filter((career) => career.startsWith('tea'))
/** this code @returns ['teacher'] */ 

• Learn to use reduce for aggregating data in arrays.

['engineer', 'doctor', 'teacher'].reduce((accumulator,career,idx,careers)=>{
//accumulator can be [],{} or any type. In this case its an empty list then we add items to it
console.log(`new_value_so_far: ${accumulator}`) 
console.log(`current_career: ${current_career}`)
console.log(`current_index: ${idx}`)
console.log(`original_array: ${careers}`)
accumulator.push({idx:career})  
/** @returns {[Object]} --> [{0:'engineer'},{1:'doctor'},{2:'teacher'}] */ 
},[])

• Be familiar with forEach for iterating through arrays.

['engineer', 'doctor', 'teacher'].forEach((career)=>{
console.log(career)
})

• Use find and findIndex for searching in arrays.

['engineer', 'doctor', 'teacher'].findIndex((career)=>career==='doctor') 
/** @returns {Number} idx where career === doctor otherwise -1 */

String Methods:

• Explore and use common string methods like split, slice, indexOf, substr, etc.

Nullish Coalescing and Optional Chaining:

• Understand and use nullish coalescing (??) for handling null or undefined values.
• Utilize optional chaining (?.) for concise handling of nested properties.

Arrow Functions:

• Master the use of arrow functions for concise and clear code.

Promises:

• Learn how to work with Promises for handling asynchronous operations.
• Understand the basics of async/await for more readable asynchronous code.

Closures:

• Understand closures and their applications, especially in asynchronous programming.

Modules (ES6):

• Use ES6 module syntax for organizing code.
• Be aware of the import and export statements.

Error Handling:

• Utilize try-catch blocks for effective error handling.

Object-Oriented JavaScript:

• Understand prototypal inheritance in JavaScript.
• Use the class syntax for creating constructor functions.

Functional Programming:

• Embrace functional programming principles.
• Learn to use higher-order functions.

Event Emitters:

• Understand and use event emitters for handling events in Node.js.

WebSockets:

• Learn to implement WebSockets for real-time communication.

Middleware:

• Understand the concept of middleware and how it's used in frameworks like Express.

Template Engines:

• Be familiar with template engines like EJS or Handlebars.

Regular Expressions:

• Learn and use regular expressions for pattern matching.

Async Control Flow:

• Understand techniques for controlling asynchronous flow, such as using Promise.all and Promise.race.

Testing with Jest or Mocha:

• Learn to write unit tests and integration tests.

Logging:

• Implement logging mechanisms for better debugging.

Environment Variables:

• Understand the use of environment variables for configuration.

Security Best Practices:

• Be aware of common security vulnerabilities and best practices.

GraphQL (Optional):

• Explore GraphQL for efficient API development.

Data Validation:

• Implement data validation for user inputs.

NPM Scripts:

• Understand how to use and create custom scripts in package.json.

Functional Array Methods:

• Explore and use functional programming methods like filter, map, and reduce on arrays.

Browser Compatibility:

• Be aware of browser compatibility when working with JavaScript features.

Code Quality Tools:

• Use ESLint for code linting and adhere to coding standards.