Object-Methods✅

Author: suhailroushan13

9. Object-Methods/1. Object.assign.js

@@ -0,0 +1,16 @@
+let a1 = {
+  name: "Suhail",
+  age: 20,
+};
+
+let newA1 = {};
+
+let copy = Object.assign(newA1, a1);
+console.log(newA1);//{ name: 'Suhail', age: 20 }
+newA1.ok = "Hi"
+console.log(newA1); //{ name: 'Suhail', age: 20, ok: 'Hi' }
+
+console.log(copy == newA1); // true
+console.log(copy); //{ name: 'Suhail', age: 20, ok: 'Hi' }
+
+// It copies whole object into an new Object with a referncene one

9. Object-Methods/10. Object getOwnPropertyNames().js

@@ -0,0 +1,49 @@
+/*
+JavaScript Object getOwnPropertyNames()
+The JavaScript Object.getOwnPropertyNames() method returns an array of all properties found in a given object.
+
+The syntax of the getOwnPropertyNames() method is:
+
+Object.getOwnPropertyNames(obj)
+The getOwnPropertyNames() method, being a static method, is called using the Object class name.
+
+getOwnPropertyNames() Parameters
+The getOwnPropertyNames() method takes in:
+
+obj - The object whose enumerable and non-enumerable properties are to be returned.
+Return value from getOwnPropertyNames()
+Returns an array of strings that corresponds to the properties found directly in the given object.
+Note: Object.getOwnPropertyNames() returns all own properties of the object while Object.keys() returns all enumerable own properties.
+
+Example: Using getOwnPropertyNames()
+// array object
+let arr = ["a", "b", "c"];
+console.log(Object.getOwnPropertyNames(arr)); // [ '0', '1', '2', 'length' ]
+
+// array-like objects
+let obj = { 65: "A", 66: "B", 67: "C" };
+console.log(Object.getOwnPropertyNames(obj)); // [ '65', '66', '67' ]
+
+// non-enumerable properties are also returned
+let obj1 = Object.create(
+  {},
+  {
+    getValue: {
+      value: function () {
+        return this.value;
+      },
+      enumerable: false,
+    },
+  }
+);
+obj1.value = 45;
+
+console.log(Object.getOwnPropertyNames(obj1)); // [ 'getValue', 'value' ]
+
+ 
+ 
+ 
+ 
+ 
+ 
+*/

9. Object-Methods/11. Object getOwnPropertySymbols().js

@@ -0,0 +1,38 @@
+/*
+JavaScript Object getOwnPropertySymbols()
+The JavaScript Object.getOwnPropertySymbols() method returns an array of all symbol properties found in a given object.
+
+The syntax of the getOwnPropertySymbols() method is:
+
+Object.getOwnPropertySymbols(obj)
+The getOwnPropertySymbols() method, being a static method, is called using the Object class name.
+
+getOwnPropertySymbols() Parameters
+The getOwnPropertySymbols() method takes in:
+
+obj - The object whose symbol properties are to be returned.
+Return value from getOwnPropertySymbols()
+Returns an array of all symbol properties found directly upon the given object.
+Note: Object.getOwnPropertySymbols() returns all symbol properties of the object while Object.getOwnPropertyNames() returns the string properties
+
+Example: Using getOwnPropertySymbols()
+let obj = {};
+let a = Symbol("a");
+let b = Symbol.for("b");
+
+obj[a] = "localSymbolValue";
+obj[b] = "globalSymbolValue";
+
+// returns an array of symbol
+let objectSymbols = Object.getOwnPropertySymbols(obj);
+
+console.log(objectSymbols.length); // 2
+console.log(objectSymbols); // [Symbol(a), Symbol(b)]
+console.log(objectSymbols[0]); // Symbol(a)
+ 
+ 
+ 
+ 
+ 
+ 
+*/

9. Object-Methods/12. Object.getPrototypeOf().js

@@ -0,0 +1,41 @@
+/*
+Javascript Object.getPrototypeOf()
+The JavaScript Object.getPrototypeOf() method returns the prototype of the specified object.
+
+The syntax of the getPrototypeOf() method is:
+
+Object.getPrototypeOf(obj)
+The getPrototypeOf() method, being a static method, is called using the Object class name.
+
+getPrototypeOf() Parameters
+The getPrototypeOf() method takes in:
+
+obj - The object whose prototype is to be returned.
+Return value from getPrototypeOf()
+Returns prototype of the given object.
+Returns null If there are no inherited properties.
+Example: Using Object.getPrototypeOf()
+let proto = {};
+let obj = Object.create(proto);
+
+console.log(Object.getPrototypeOf(obj) === proto); // true
+
+console.log(Object.getPrototypeOf("JavaScript"));
+
+// function
+let func1 = function () {};
+
+// creating object from function
+let object1 = Object.create(func1);
+
+console.log(Object.getPrototypeOf(func1) === Object.getPrototypeOf(object1)); // false
+
+// Object.create() creates object with given object as prototype
+console.log(func1 === Object.getPrototypeOf(object1)); // true
+ 
+ 
+ 
+ 
+ 
+ 
+*/

9. Object-Methods/13. Object hasOwnProperty().js

@@ -0,0 +1,36 @@
+/*
+JavaScript Object hasOwnProperty()
+The JavaScript Object hasOwnProperty() method checks if the object has the given property as its own property.
+
+The syntax of the hasOwnProperty() method is:
+
+obj.hasOwnProperty(prop)
+Here, obj is an object.
+
+hasOwnProperty() Parameters
+The hasOwnProperty() method takes in:
+
+prop - The String name or Symbol of the property to test.
+Return value from hasOwnProperty()
+Returns a Boolean indicating whether or not the object has the specified property as its own property.
+Notes:
+
+Unlike the in operator, this method does not check for a property in the object's prototype chain.
+hasOwnProperty returns true even if the value of the property is null or undefined.
+Example: Using hasOwnProperty()
+const obj = {};
+obj.property1 = 42;
+
+console.log(obj.hasOwnProperty("property1")); // true
+
+console.log(obj.hasOwnProperty("property2")); // false
+
+// Inherited properties return false
+console.log(obj.hasOwnProperty("toString")); // false
+ 
+ 
+ 
+ 
+ 
+ 
+*/

9. Object-Methods/14. Object.is().js

@@ -0,0 +1,54 @@
+/*
+Javascript Object.is()
+The JavaScript Object.is() method checks if two values are the same value.
+
+The syntax of the is() method is:
+
+Object.is(value1, value2)
+The is() method, being a static method, is called using the Object class name.
+
+is() Parameters
+The is() method takes in:
+
+value1 - The first value to compare.
+value2 - The second value to compare.
+Return value from is()
+Returns a Boolean indicating whether or not the two arguments are the same value.
+Two values are the same if one of the following holds:
+
+both undefined
+both null
+both true or both false
+both strings of the same length with the same characters in the same order
+both the same object (means both object have same reference)
+both numbers and
+both +0
+both -0
+both NaN
+or both non-zero and both not NaN and both have the same value
+Example: Using Object.is()
+// Objects with the same values
+console.log(Object.is("JavaScript", "JavaScript")); // true
+// Objects with different values
+console.log(Object.is("JavaScript", "javascript")); // false
+
+console.log(Object.is([], [])); // false
+
+let obj1 = { a: 1 };
+let obj2 = { a: 1 };
+console.log(Object.is(obj1, obj1)); // true
+console.log(Object.is(obj1, obj2)); // false
+
+console.log(Object.is(null, null)); // true
+
+// Special Cases
+console.log(Object.is(0, -0)); // false
+console.log(Object.is(-0, -0)); // true
+console.log(Object.is(NaN, 0 / 0)); // true
+ 
+ 
+ 
+ 
+ 
+ 
+*/

9. Object-Methods/15. Object.isExtensible().js

@@ -0,0 +1,39 @@
+/*
+JavaScript Object.isExtensible()
+The JavaScript Object.isExtensible() method checks if an object is extensible i.e. new properties can be added to it.
+
+The syntax of the isExtensible() method is:
+
+Object.isExtensible(obj)
+The isExtensible() method, being a static method, is called using the Object class name.
+
+isExtensible() Parameters
+The isExtensible() method takes in:
+
+obj - The object which should be checked.
+Return value from isExtensible()
+Returns a Boolean indicating whether or not the given object is extensible.
+Note: An object can be marked as non-extensible using Object.preventExtensions(), Object.seal(), or Object.freeze().
+
+Example: Using isExtensible()
+// New objects are extensible.
+let empty = {};
+console.log(Object.isExtensible(empty)); // true
+
+Object.preventExtensions(empty);
+console.log(Object.isExtensible(empty)); // false
+
+// Sealed objects are by definition non-extensible.
+let sealed = Object.seal({});
+console.log(Object.isExtensible(sealed)); // false
+
+// Frozen objects are also by definition non-extensible.
+let frozen = Object.freeze({});
+console.log(Object.isExtensible(frozen)); // false
+ 
+ 
+ 
+ 
+ 
+ 
+*/

9. Object-Methods/16. Object.isFrozen().js

@@ -0,0 +1,57 @@
+/*
+Javascript Object.isFrozen()
+The JavaScript Object.isFrozen() checks if an object is frozen.
+
+A frozen object can no longer be changed. Freezing an object prevents:
+
+New properties from being added to the object.
+Existing properties to be removed from the object.
+Changing the enumerability, configurability, or writability of existing properties.
+Changing values of the existing object properties and prototype.
+The syntax of the isFrozen() method is:
+
+Object.isFrozen(obj)
+The isFrozen() method, being a static method, is called using the Object class name.
+
+isFrozen() Parameters
+The isFrozen() method takes in:
+
+obj - The object which should be checked.
+Return value from isFrozen()
+Returns a Boolean indicating whether or not the given object is frozen.
+Example: Using isFrozen()
+// new objects are extensible, so not frozen
+console.log(Object.isFrozen({ name: "JavaScript" })); // false
+
+// preventing extensions only does not make frozen
+// property is still configurable
+let obj = { a: 1 };
+Object.preventExtensions(obj);
+console.log(Object.isFrozen(obj)); // false
+
+// deleting property
+delete obj.a;
+console.log(Object.isFrozen(obj)); // true -> vacuously frozen
+
+let newObj = { b: 2 };
+// make non-extensible
+Object.preventExtensions(newObj);
+// make non-writable
+Object.defineProperty(newObj, "b", {
+  writable: false,
+});
+// properties are still configurable
+console.log(Object.isFrozen(newObj)); // false
+
+// using freeze()
+let frozen = { 65: "A" };
+
+Object.freeze(frozen);
+console.log(Object.isFrozen(frozen)); // true
+ 
+ 
+ 
+ 
+ 
+ 
+*/

9. Object-Methods/17. Object.isPrototypeOf().js

@@ -0,0 +1,50 @@
+/*
+Javascript Object.isPrototypeOf()
+The JavaScript Object.isPrototypeOf() method checks if an object exists in another object's prototype chain.
+
+The syntax of the isPrototypeOf() method is:
+
+prototypeObj.isPrototypeOf(object)
+Here, prototypeObj is an object.
+
+isPrototypeOf() Parameters
+The isPrototypeOf() method takes in:
+
+object - The object whose prototype chain will be searched.
+Return value from isPrototypeOf()
+Returns a Boolean indicating whether the calling object lies in the prototype chain of the specified object.
+Note: isPrototypeOf() differs from instanceof operator as it checks the object prototype chain against prototypeObj not prototypeObj.prototype.
+
+Example: Using Object.isPrototypeOf()
+let obj = new Object();
+console.log(Object.prototype.isPrototypeOf(obj)); // true
+console.log(Function.prototype.isPrototypeOf(obj.toString)); // true
+
+console.log(Array.prototype.isPrototypeOf([2, 4, 8])); // true
+
+// define object
+let Animal = {
+  makeSound() {
+    console.log(`${this.name}, ${this.sound}!`);
+  },
+};
+
+// new object
+function Dog(name) {
+  this.name = name;
+  this.sound = "bark";
+
+  // setting prototype using setPrototypeOf()
+  Object.setPrototypeOf(this, Animal);
+}
+
+dog1 = new Dog("Marcus");
+
+console.log(Animal.isPrototypeOf(dog1)); // true
+ 
+ 
+ 
+ 
+ 
+ 
+*/