Fastly JS Compute Runtime

When you call setInterval(), it returns a non-zero numeric intervalID. To cancel the recurring execution, pass this ID to clearInterval().

While setInterval() and setTimeout() share the same pool of IDs—meaning clearInterval() and clearTimeout() can technically be used interchangeably—it is best practice to match them correctly (setInterval with clearInterval) to maintain code clarity.

Because substr() is non-standard, its behavior differs from slice() and substring() when handling negative lengths or specific indices.

When str = "01234", a = 1, and l = -2:

• substr(a, l) returns "" (empty string).
• slice(a, a + l) returns "123".
• substring(a, a + l) returns "0".

When refactoring legacy code that uses substr(), you cannot simply swap it for slice() or substring() without verifying the range of the start and length arguments, as the results may differ.

The Symbol.matchAll well-known symbol specifies the method used to return an iterator that yields all matches of a regular expression against a string. This symbol is specifically used by the String.prototype.matchAll() method to identify how the regular expression should perform its matching logic.

When implementing custom matching behavior for a regular expression object, you can define a method on the RegExp.prototype using this symbol.

The SubtleCrypto interface provides low-level cryptographic primitives. You can access these features through the crypto.subtle property on the global crypto object.

// Accessing the SubtleCrypto interface
const subtle = crypto.subtle;

When comparing large numbers of strings (such as sorting large arrays), using String.prototype.localeCompare() repeatedly can be less efficient because it may recreate collation logic on every call.

For better performance, create an Intl.Collator object once and use its .compare() method for the sorting operation.

// Instead of this:
largeArray.sort((a, b) => a.localeCompare(b, 'en'));

// Do this for better performance:
const collator = new Intl.Collator('en');
largeArray.sort(collator.compare);

The Symbol.asyncIterator well-known symbol specifies the default async iterator for an object. If an object has this property set, it is considered an async iterable. This allows the object to be consumed using a for await...of loop, which is useful for handling streams or other asynchronous data sources where each iteration might involve a Promise.

// Example of an async iterable object
const asyncIterable = {
  [Symbol.asyncIterator]() {
    return {
      next() {
        return Promise.resolve({
          value: 'data',
          done: false
        });
      }
    };
  }
};

// Consuming the async iterable
for await (const item of asyncIterable) {
  console.log(item);
}

The Symbol.replace well-known symbol specifies the method used to replace matched substrings within a string. This method is automatically invoked by the String.prototype.replace() method when the first argument passed to replace() is an object that implements this symbol.

By implementing [Symbol.replace] on a custom object, you can define specialized replacement behavior that goes beyond standard regular expression matching.

When comparing values in the JS Compute Runtime, choose the appropriate equality check based on how you want to handle type coercion and special numeric values:

Object.is()

• No coercion: Does not convert types before comparing.
• NaN handling: Considers NaN equal to NaN.
• Signed zeros: Distinguishes between +0 and -0 (treats them as different).

Strict Equality (===)

• No coercion: Does not convert types before comparing.
• NaN handling: Considers NaN not equal to NaN.
• Signed zeros: Treats +0 and -0 as equal.

Equality Operator (==)

• Coercion: Applies type coercion to both sides if they are not the same type (e.g., "" == false is true).
• NaN handling: Considers NaN not equal to NaN.
• Signed zeros: Treats +0 and -0 as equal.

The SimpleCache class provides a high-level, static interface for interacting with Fastly's Cache. It is designed to simplify the process of inserting and retrieving entries without managing the underlying cache storage mechanics manually.

Key characteristics:

• All methods are static; you do not instantiate the class.
• It is imported from the fastly:cache module.
• A common pattern is using SimpleCache.getOrSet to implement a 'cache-aside' pattern: attempt to retrieve a value, and if it is missing, execute a provided asynchronous function to generate the value and store it with a specified Time-To-Live (TTL).

import { SimpleCache } from 'fastly:cache';

// Example of the getOrSet pattern
const data = await SimpleCache.getOrSet(key, async () => {
  return {
    value: await fetchData(),
    ttl: 60 // Store for 60 seconds
  };
});