Day 5: new, Object.create, and Object.assign
Tags: javascript, 100daysofcode, day5
Published: 2023-07-14 12:30:00



## `Object.assign`: 
It is a method used to copy the values of all enumerable own properties from one or more source objects to a target object. It performs a shallow copy, meaning that nested objects or arrays are copied by reference rather than creating new instances. The target object is returned after the properties have been assigned to it.

```javascript
const target = { a: 1 };
const source = { b: 2 };
const result = Object.assign(target, source);
console.log(result); // { a: 1, b: 2 }
```


## `Object.create`: 
It is a method used to create a new object with a specified prototype object and optional properties. The newly created object inherits properties from the prototype object. It allows you to establish a prototype chain, where the created object can access properties and methods from its prototype.

```javascript
const person = {
  sayHello() {
    console.log('Hello!');
  }
};

const john = Object.create(person);
john.sayHello(); // Hello!
```

## `new` operator: 

It is used to create an instance of an object by calling a constructor function with the new keyword. The new operator creates a new object, sets the prototype of that object to the constructor function's prototype, and executes the constructor function within the context of the newly created object. It allows the created object to inherit properties and methods from the constructor function's prototype.

```javascript
function Person(name) {
  this.name = name;
}

Person.prototype.sayHello = function() {
  console.log('Hello, my name is ' + this.name);
};

const john = new Person('John');
john.sayHello(); // Hello, my name is John

```
## `Object.assign/Object.create`

These methods are not used to create instances of objects with constructors. Instead, they are used to copy properties from one object to another or create new objects with a specific prototype. They do not involve executing a constructor function or establishing a constructor-prototype relationship.



##  Polyfill for `new`:
```javascript
if (!Object.new) {
  Object.new = function (constructor, ...args) {
    const obj = Object.create(constructor.prototype);
    const result = constructor.apply(obj, args);
    return result !== null && typeof result === 'object' ? result : obj;
  };
}

```

## Polyfill for `Object.create`:

```javascript
if (!Object.create) {
  Object.create = function (proto, propertiesObject) {
    if (typeof proto !== 'object' && typeof proto !== 'function') {
      throw new TypeError('Object prototype may only be an Object or null');
    }
    function F() {}
    F.prototype = proto;
    const obj = new F();
    if (propertiesObject !== undefined) {
      Object.defineProperties(obj, propertiesObject);
    }
    return obj;
  };
}
```

## Polyfill for `Object.assign`:

```javascript
if (!Object.assign) {
  Object.assign = function (target, ...sources) {
    if (target === null || target === undefined) {
      throw new TypeError('Cannot convert undefined or null to object');
    }
    const to = Object(target);
    sources.forEach(source => {
      if (source !== null && source !== undefined) {
        for (const key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            to[key] = source[key];
          }
        }
      }
    });
    return to;
  };
}

```