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"
```

Stanford University

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.

Introducing JavaScript objects

https://developer.mozilla.org/

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.

Learn Before

Related