Destructuring Assignments

Destructuring Assignments: The destructuring assignment syntax in JavaScript makes it possible to unpack values from arrays or properties from objects into distinct variables.


Example:

```

// Array destructuring

const arr = [1, 2, 3];

const [a, b, c] = arr;

console.log(a, b, c); // 1 2 3


// Object destructuring

const obj = {x: "X", y: "Y"};

const {x, y} = obj;

console.log(x, y); // X Y

```

In both examples, the variables a, b, c, x, and y are assigned new values from the array or object on the right side of the assignment.

Comments

Post a Comment

Popular posts from this blog

Abstract Classes and Interfaces

Copied as is from  https://www.quickstart.com/software-engineering/when-and-how-to-use-abstract-class-and-interface/#:~:text=An%20interface%20in%20OOP%20is,return%20types)%20without%20any%20implementation. Understanding Abstract Classes An abstract class, in essence, is a class that cannot be instantiated on its own but serves as a foundation for other classes to be derived from. It acts as a template or a prototype, defining a common structure and a set of methods that must be implemented by its subclasses.  The primary purpose of abstract classes is to provide a blueprint or a skeletal framework for derived classes. They outline the essential attributes and methods that any class inheriting from them must include. By doing so, abstract classes enforce a certain structure and consistency among the derived classes, ensuring that they adhere to a specific design pattern or interface. Abstract classes find their utility in various scenarios within software development, serving a...
Read more

Optional Chaining

Optional Chaining: This feature allows you to access deeply nested property paths in an object without checking the existence of each level. Instead of writing multiple conditions to avoid getting undefined in case a property doesn’t exist, you can use optional chaining that automatically checks if the value is not undefined or null. For example: const car = { model: { name: 'BMW' } }; console.log(car?.model?.name); // "BMW" console.log(car?.manufacturer?.name); // undefined
Read more

Logical Or operator || vs Nullish Coalescing

 In JavaScript and TypeScript, the `||` operator is often used to provide a default value in case a variable is "falsy", meaning it's `undefined`, `null`, `0`, `NaN`, empty string `''`, or `false`. For example: let value = userDefinedValue || 'default'; In this snippet, if `userDefinedValue` is `undefined`, `null`, or any other falsy value, `value` will be set to `'default'`. However, this can be problematic. For instance, if a user intentionally sets `userDefinedValue` to `0` or `''`, this logic will still replace `userDefinedValue` with `'default'`, which is probably not what the user intended. Enter nullish coalescing operator `??`. It's similar to `||`, but it only returns the right-hand side if the left-hand side is `null` or `undefined`. Example: let value = userDefinedValue ?? 'default'; Now, `value` will only be set to `default` if `userDefinedValue` is `undefined` or `null`. This way, intentioned falsy values (s...
Read more