Section 1.1: Efficiently Resizing and Clearing Arrays

When programming, modifying or clearing an array is a common requirement. The most straightforward approach is using the Array.length property. For example:

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

console.log(array); // 5

array.length--;

console.log(array); // 4

array.length += 15;

console.log(array); // 19

The results from this code snippet would be:

[1, 2, 3, 4, 5]

[1, 2, 3, 4]

[1, 2, 3, 4, ..15 empty]

To remove all elements from an array, simply set its length to zero:

let arr = ['a', 'b', 'c'];

arr.length = 0;

console.log(arr.length); // Output => 0

console.log(arr); // Output => []

Section 1.2: Simplifying Conditional Statements

Often, you may want to execute specific code based on a condition. For instance, you might display a login page for an unauthenticated user and a home page for a logged-in user. This logic can be implemented using traditional conditional statements:

var x = 1;

if (x == 1) {

console.log(x);

} else {

console.log("Error");

}

However, this can be simplified with a ternary operator:

var x = 1;

console.log(x == 1 ? x : "Error"); // Output: 1

Section 2.1: Dynamic Module Imports

While importing modules is usually straightforward, dynamic imports can be useful when you need to load functions conditionally. Use the following syntax to achieve this:

import('some-module')

.then(module => {

// Use module here

})

.catch(err => console.log(err));

This will return a promise that resolves to the module object, which can enhance your application's performance by reducing load times and memory usage.

Section 2.2: Utilizing the Nullish Coalescing Operator

The nullish coalescing operator (??) can save time by allowing you to assign default values when a variable is null or undefined:

const name = null ?? 'Anonymous';

console.log(name); // Output => 'Anonymous'

const age = undefined ?? 18;

console.log(age); // Output => 18

This operator prevents errors and unexpected behaviors, contributing to cleaner code.

Section 2.3: Merging Arrays Efficiently

When merging large datasets, the traditional Array.prototype.concat() method can be memory-intensive. Instead, consider using:

let list1 = ['a', 'b', 'c'];

let list2 = ['a', 'e', 'f'];

list1.push.apply(list1, list2);

console.log(list1); // Output => ["a", "b", "c", "a", "e", "f"]

This approach merges arrays without generating a new one, which is more efficient.

Section 2.4: Minimal Evaluation for Assignments

You might want to ensure that a variable isn’t null before assigning its value to another variable. This can be done succinctly:

var2 = var1 || 'Some value';

This one-liner avoids cumbersome if statements.

Section 2.5: Default Parameter Values in Functions

In functions where users can provide custom values, default parameters simplify the logic:

function calculator(principle = 5000, rate = 6, time = 3) {

// Function logic

}

This way, if no values are provided, the defaults will be used.

Section 2.6: The 'in' Operator for Property Checks

The in operator helps verify whether a property exists within an object or its prototype chain:

const car = { make: 'Honda', model: 'Accord', year: 1998 };

console.log('make' in car); // Expected output: true

This operator can be particularly useful when working with the Document Object Model (DOM).

Section 2.7: Ensuring Mandatory Parameter Values

When certain parameters are essential, checking their existence can be tedious. A more elegant solution involves using default parameter values:

mandatory = () => { throw new Error('Missing parameter'); }

submitName = (name = mandatory()) => { return name; }

This method ensures that if the required parameter isn’t supplied, an error is thrown.