Avoid calling Object.prototype methods, especially those that are not meant to be polymorphic. These methods may be defined differently in other objects descending from Object.prototype. Use modern JavaScript utilities such as `valueOf()` and `toString()` only if polymorphic, and replace deprecated methods like `defineGetter()` with `Object.defineProperty()`. Replace $propertyIsEnumerable()$ with `Object.getOwnPropertyDescriptor()` and  `isPrototypeOf()` with `instanceof`. If a semantically equivalent static method doesn't exist, call Object.prototype methods directly.

```js
const obj = {
  foo: 1,
  // You should not define such a method on your own object,
  // but you may not be able to prevent it from happening if
  // you are receiving the object from external input
  propertyIsEnumerable() {
    return false;
  }
}

obj.propertyIsEnumerable("foo"); // false; unexpected result
Object.prototype.propertyIsEnumerable.call(obj, "foo"); // true; expected result


```

Object prototype properties

An `AsyncFunction` in JavaScript is a special type of function that is declared with the async keyword.

Unlike regular functions, which return a value or perform an action synchronously, AsyncFunctions return a Promise object and allow for asynchronous programming using the await keyword.

When an `AsyncFunction` is called, it returns a Promise that resolves with the value returned by the function, or rejects with an error thrown by the function.

Here's an example of an AsyncFunction:

javascript
```js
async function getData() {
  const response = await fetch('https://jsonplaceholder.typicode.com/posts');
  const data = await response.json();
  return data;
}

getData()
  .then(data => console.log(data))
  .catch(error => console.error(error));
```

In this example, `getData` is an AsyncFunction that fetches data from a remote API and returns it as a Promise. The await keyword is used to wait for the response from the API before parsing it as JSON and returning the data. The then and catch methods are used to handle the Promise once it resolves or rejects.

AsyncFunction

An object initializer is a comma-delimited list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). Objects can also be initialized using `Object.create()` or by invoking a constructor function with the new operator.
```js
const object1 = { a: 'foo', b: 42, c: {} };

console.log(object1.a);
// Expected output: "foo"

const a = 'foo';
const b = 42;
const c = {};
const object2 = { a: a, b: b, c: c };

console.log(object2.b);
// Expected output: 42


const object3 = { a, b, c };

console.log(object3.a);
// Expected output: "foo"
```

Object initializer 

JavaScript is primarily an object-oriented language, where many built-in features such as arrays and browser APIs are objects themselves. Additionally, developers can create their own objects to organize functions and variables into reusable packages. Understanding the object-based structure of JavaScript is crucial for advancing one's understanding of the language. This module aims to provide a comprehensive overview of object theory, syntax, and how to create custom objects.

Stanford University

when a web page is loaded in a browser, the code (HTML, CSS, and JavaScript) is executed within the browser tab, which acts like a factory that takes in the code and produces the web page. One common use of JavaScript is to change the HTML and CSS in order to update the user interface using the Document Object Model API. It is important to note that the code is generally loaded and executed in the order it appears on the page and errors may occur if JavaScript is run before the related HTML and CSS. 

What is JavaScript doing on your page?

https://developer.mozilla.org/

Arrays are generally described as "list-like objects"; they are basically single objects that contain multiple values stored in a list. Array objects can be stored in variables and dealt with in much the same way as any other type of value, the difference being that we can access each value inside the list individually, and do super useful and efficient things with the list, like loop through it and do the same thing to every value. Maybe we've got a series of product items and their prices stored in an array, and we want to loop through them all and print them out on an invoice, while totaling all the prices together and printing out the total price at the bottom.

What is an array?

Introducing JavaScript objects

The async function* keywords can be used to define an asynchronous generator function inside an expression.
```js
async function* foo() {
  yield await Promise.resolve('a');
  yield await Promise.resolve('b');
  yield await Promise.resolve('c');
}

let str = '';

async function generate() {
  for await (const val of foo()) {
    str = str + val;
  }
  console.log(str);
}

generate();
// Expected output: "abc"
```

Learn Before

Related

Learn After