Summary of features worth learning in Javascript

Optional Chaining Operator

The optional chain operator allows us to directly return undefined when the property value of an object is empty or undefined, without throwing errors such as "Cannot read property 'xxx' of undefined". This advantage is that it can simplify the code and avoid cumbersome judgment logic. For example:

const person = {
  name: 'Tom',
  age: 18,
  address: {
    city: 'Shanghai'
  }
};

// Ordinary writingif (person &&  && ) {
  ();
} else {
  ('unknown');
}

// Optional link writing method(person?.address?.city ?? 'unknown');

In the above code, we use the optional chain operator (?) and the nullish merge operator (??), reducing the code that originally required multiple judgments to one line. If person, address, or city does not exist, undefined or 'unknown' will be returned directly.

Nullish Coalescing Operator

The null value merge operator allows us to directly return the default value when the variable is empty or undefined. Unlike the traditional || operator, it will only return the default value when the variable is null or undefined, rather than when the variable is 0, empty string, or false. For example:

const name = '';

// Ordinary writingconst username = name || 'unknown';

// null value merging writing methodconst username = name ?? 'unknown';

In the above code, we used the null value merge operator (??) to simplify the code that originally required tedious judgment to one line. If the name is empty or undefined, 'unknown' will be returned.

()

The () method can receive an array composed of Promise objects, wait for all Promise objects to be executed, and return an array containing the state information (fulfilled/rejected) and result value (value/reason) of all Promise objects. Unlike (), even if one of the Promise is rejected, () will still wait for the other Promise objects to be executed before returning the result. For example:

const promises = [
  (1),
  (new Error('fail')),
  (3)
];

(promises).then(results => {
  (result => {
    (, );
  });
});

In the above code, we use the() method to obtain the state information and result values ​​of all Promise objects, and use forEach to traverse to output their state (fulfilled/rejected) and result values ​​(value/reason).

BigInt Type

The BigInt type is a new data type introduced by ES2020, which is used to represent integers of arbitrary precision. Compared to the Number type, it can handle larger integers, avoiding overflow and precision loss problems. For example:

const x = BigInt(Number.MAX_SAFE_INTEGER);
const y = BigInt('9007199254740993');
const z = x + y;

(z); // 9007199254740994n

In the above code, we use the BigInt type to represent larger integers and add them to the + operator.

The above is a detailed summary of the features worth learning in Javascript. For more information about Javascript features, please pay attention to my other related articles!