Apply ES6

[alang-dev]

Essential ES6 features with examples for each:

1. Variable Declarations (let and const):

• Problem with var: Before ES6, var was the primary way to declare variables. However, it can lead to scope issues where variables declared within loops or blocks might unintentionally leak into the outer scope.
• Solution with let and const:
  • let creates block-scoped variables, meaning they are only accessible within the block (like an if statement or loop) where they are declared.
  • const creates constant variables, whose values cannot be changed after assignment.

// Old way with var (can lead to scope issues)
if (true) {
  var age = 30;
}
console.log(age); // Outputs 30, even though age was declared inside the if block

// New way with let (block-scoped)
if (true) {
  let age = 30;
}
console.log(age); // ReferenceError: age is not defined (because age is not accessible outside the if block)

// Using const for constants
const PI = 3.14159;
PI = 10; // This will cause a TypeError because PI is constant

2. Arrow Functions:

• Concise Syntax: Arrow functions provide a shorter way to write functions, especially useful for callbacks and simple functions.
• Example:

// Traditional function
function greet(name) {
  return "Hello, " + name;
}

// Arrow function (equivalent to the above)
const greet = (name) => "Hello, " + name;

console.log(greet("Alice")); // Outputs "Hello, Alice"

3. Template Literals:

• Readable Strings: Template literals allow for embedded expressions and multi-line strings within backticks (`).
• Example:

// Old way (string concatenation)
const name = "Bob";
const greeting = "Hello, " + name + "!";

// Template literal (more readable)
const greeting = `Hello, ${name}!`;

console.log(greeting); // Outputs "Hello, Bob!"

4. Destructuring Assignment:

• Structured Extractions: Extract values from arrays or objects in a more organized way.
• Example:

// Old way
const numbers = [10, 20, 30];
const firstNumber = numbers[0];
const secondNumber = numbers[1];

// Destructuring assignment (cleaner)
const [firstNumber, secondNumber] = numbers;

console.log(firstNumber, secondNumber); // Outputs 10 20

5. Spread Operator (...):

• Expanding Iterables: Efficiently expand iterables (like arrays) and objects within function calls or assignments.
• Example:

// Combining arrays
const numbers1 = [1, 2, 3];
const numbers2 = [4, 5, 6];
const allNumbers = [...numbers1, ...numbers2];

console.log(allNumbers); // Outputs [1, 2, 3, 4, 5, 6]

// Spreading object properties
const person = { name: "Alice" };
const details = { age: 30, city: "New York" };
const combined = { ...person, ...details };

console.log(combined); // Outputs { name: "Alice", age: 30, city: "New York" }

6. Default Parameters:

• Flexible Function Arguments: Assign default values to function parameters, making code more adaptable and reducing the need for conditional checks within the function body.
• Example:

function greet(name = "World") { // "World" is the default value
  return "Hello, " + name;
}

console.log(greet());    // Outputs "Hello, World" (default name used)
console.log(greet("Bob")); // Outputs "Hello, Bob"

7. Rest Parameters (...):

• Indefinite Arguments: Collect an indefinite number of arguments into an array within functions.
• Example:

function sum(...numbers) { // ...numbers collects remaining arguments into an array
  let total = 0;
  for (const num of numbers) {
    total += num;
  }
  return total;
}

console.log(sum(1, 2, 3));     // Outputs 6
console.log(sum(10, 20, 30, 40)); // Outputs 100

8. Classes:

• Object-Oriented Programming: Introduce a more familiar class-based syntax for object-oriented programming in JavaScript.
• Example:

class Car {
  constructor(model, year) {
    this.model = model;
    this.year = year;
  }

  getInfo() {
    return `This is a ${this.year} ${this.model} car.`;
  }
}

const myCar = new Car("Tesla Model S", 2024);
console.log(myCar.getInfo()); // Outputs "This is a 2024 Tesla Model S car."

9. Modules:

• Reusable Code: Organize code into reusable modules, improving maintainability and promoting modularity.
  • There are two main module systems in ES6: CommonJS (CJS) and ES Modules (ESM). The syntax and usage differ slightly between them, but the concept remains the same.

10. Promises:

• Asynchronous Handling: Handle asynchronous operations (like fetching data from a server) in a more structured and readable manner, reducing callback hell.
• Example (using the Fetch API):

fetch('https://api.example.com/data')
  .then(response => response.json()) // Parse the JSON response
  .then(data => console.log(data)) // Process the data
  .catch(error => console.error(error)); // Handle errors

11. Iterators and for...of Loops:

• Efficient Iteration: Work with iterables (like arrays and strings) more efficiently using iterators and the for...of loop for concise iteration.
• Example:

const numbers = [1, 2, 3, 4, 5];

// Using for...of loop
for (const number of numbers) {
  console.log(number);
}

// Using iterator (less common, but more versatile)
const numbersIterator = numbers[Symbol.iterator]();
let next = numbersIterator.next();
while (!next.done) {
  console.log(next.value);
  next = numbersIterator.next();
}

12. Enhanced Object Literals:

• Concise Object Creation: Provide shorthand properties, computed property names, and method definitions within object literals.
• Example:

const name = "Alice";
const age = 30;

// Old way
const person = {
  name: name,
  age: age
};

// New way (shorthand properties)
const person = { name, age };

// Computed property names
const key = "city";
const city = "New York";
const personWithCity = { [key]: city }; // personWithCity = { city: "New York" }

// Method definitions
const personWithGreet = {
  name: "Bob",
  greet() {
    return "Hello, " + this.name;
  }
};

console.log(personWithGreet.greet()); // Outputs "Hello, Bob"

13. String and Array Methods:

• Built-in Functionality: Utilize built-in methods like includes(), startsWith(), endsWith(), map(), filter(), reduce(), and more for common string and array operations. Refer to the Mozilla Developer Network (MDN)

[alang-dev]

• [x] Variable Declarations (let and const)
  • [x] Arrow Functions
  • [x] Template Literals
  • [x] Destructuring Assignment
  • [ ] Spread Operator (...)
  • [x] Default Parameters
  • [x] Rest Parameters (...)
  • [ ] Classes
  • [x] Modules
  • [ ] Promises
  • [ ] Iterators and for...of Loops
  • [ ] Enhanced Object Literals
  • [ ] String and Array Methods

[alang-dev]

• Try to apply as much as possible of ES6 features
• Replace all module.export, required by use export/export default and import
• group all related gross-to-net to one folder. Rename files and functions.
• Double check naming of gross-to-net related codes
• Extract test of findInsurancePolicy.js and mock it in the files that use.