Methods in String, Array, Object, Set, Map, Proxy, Reflect

Introduction

This blog post summarizes the methods in String, Array, Object, Set, Map, Proxy, Reflect in JavaScript.

• 1.String
• 2.Array
• 3.Object
• 4.Set
• 5.Map
• 6.Promise
• 7.Proxy
• 8.Reflect
• 9.Number
• 10.Boolean
• 11.Function
• 12.Date
• 13.RegExp
• 14.WeakSet
• 15.WeakMap
• 16.Error
• 17.Symbol
• 18.ArrayBuffer
• 19.TypedArray (Int8Array, Uint8Array, Float32Array, etc.)
• 20.JSON
• 21.BigInt
• 22.Math
• 23.SharedArrayBuffer
• 24.Atomics
• 25.DataView
• 26.Generator
• 27.GeneratorFunction
• 28.AsyncFunction
• 29.Intl
• 30.WebAssembly
• 31.FinalizationRegistry
• Summary

1.String

Here's a list of String methods in JavaScript along with examples:

1. charAt(index)

   "Hello".charAt(1); // 'e'
   

2. charCodeAt(index)

   "Hello".charCodeAt(1); // 101
   

3. codePointAt(index)

   "😄".codePointAt(0); // 128516
   

4. concat(str1, str2, ...)

   "Hello".concat(" ", "World"); // "Hello World"
   

5. endsWith(searchString, length)

   "Hello World".endsWith("World"); // true
   

6. includes(searchString, position)

   "Hello World".includes("World"); // true
   

7. indexOf(searchValue, fromIndex)

   "Hello World".indexOf("o"); // 4
   

8. lastIndexOf(searchValue, fromIndex)

   "Hello World".lastIndexOf("o"); // 7
   

9. localeCompare(compareString, locales, options)

   "a".localeCompare("b"); // -1
   

10. match(regexp)

    "Hello World".match(/[A-Z]/g); // ['H', 'W']
    

11. matchAll(regexp)

    [..."Hello World".matchAll(/[A-Z]/g)]; // [['H'], ['W']]
    

12. normalize(form)

    "é".normalize('NFC') === "é".normalize('NFD'); // false
    

13. padEnd(targetLength, padString)

    "Hello".padEnd(10, "."); // "Hello....."
    

14. padStart(targetLength, padString)

    "Hello".padStart(10, "."); // ".....Hello"
    

15. repeat(count)

    "Ha".repeat(3); // "HaHaHa"
    

16. replace(searchFor, replaceWith)

    "Hello World".replace("World", "JavaScript"); // "Hello JavaScript"
    

17. replaceAll(searchFor, replaceWith)

    "Hello World World".replaceAll("World", "JavaScript"); // "Hello JavaScript JavaScript"
    

18. search(regexp)

    "Hello World".search(/World/); // 6
    

19. slice(beginIndex, endIndex)

    "Hello World".slice(6); // "World"
    

20. split(separator, limit)

    "Hello World".split(" "); // ["Hello", "World"]
    

21. startsWith(searchString, position)

    "Hello World".startsWith("Hello"); // true
    

22. substring(indexStart, indexEnd)

    "Hello World".substring(6, 11); // "World"
    

23. toLowerCase()

    "Hello World".toLowerCase(); // "hello world"
    

24. toUpperCase()

    "Hello World".toUpperCase(); // "HELLO WORLD"
    

25. trim()

    "  Hello World  ".trim(); // "Hello World"
    

26. trimStart() / trimLeft()

    "  Hello World  ".trimStart(); // "Hello World  "
    

27. trimEnd() / trimRight()

    "  Hello World  ".trimEnd(); // "  Hello World"
    

28. valueOf()

    "Hello World".valueOf(); // "Hello World"
    

29. at(index) (ES2022)

    "Hello".at(-1); // "o"
    

Static methods:

30. String.fromCharCode(num1, num2, ...)

    String.fromCharCode(72, 101, 108, 108, 111); // "Hello"
    

31. String.fromCodePoint(num1, num2, ...)

    String.fromCodePoint(128516); // "😄"
    

32. String.raw(template, ...substitutions)

    String.raw`Hello\nWorld`; // "Hello\\nWorld"
    

Property:

33. length

    "Hello".length; // 5
    

Remember, strings in JavaScript are immutable, so these methods return new strings rather than modifying the original.

2.Array

Certainly! Here's a comprehensive list of Array methods in JavaScript along with examples:

1. push()

   let arr = [1, 2];
   arr.push(3); // arr is now [1, 2, 3]
   

2. pop()

   let arr = [1, 2, 3];
   let last = arr.pop(); // last = 3, arr is now [1, 2]
   

3. unshift()

   let arr = [1, 2];
   arr.unshift(0); // arr is now [0, 1, 2]
   

4. shift()

   let arr = [1, 2, 3];
   let first = arr.shift(); // first = 1, arr is now [2, 3]
   

5. concat()

   let arr1 = [1, 2];
   let arr2 = [3, 4];
   let newArr = arr1.concat(arr2); // newArr is [1, 2, 3, 4]
   

6. join()

   let arr = ['Hello', 'World'];
   let str = arr.join(' '); // str is "Hello World"
   

7. slice()

   let arr = [1, 2, 3, 4, 5];
   let sliced = arr.slice(1, 4); // sliced is [2, 3, 4]
   

8. splice()

   let arr = [1, 2, 3, 4];
   arr.splice(1, 2, 'a', 'b'); // arr is now [1, 'a', 'b', 4]
   

9. indexOf()

   let arr = [1, 2, 3, 2];
   let index = arr.indexOf(2); // index is 1
   

10. lastIndexOf()

    let arr = [1, 2, 3, 2];
    let lastIndex = arr.lastIndexOf(2); // lastIndex is 3
    

11. forEach()

    let arr = [1, 2, 3];
    arr.forEach(item => console.log(item)); // logs 1, 2, 3
    

12. map()

    let arr = [1, 2, 3];
    let doubled = arr.map(item => item * 2); // doubled is [2, 4, 6]
    

13. filter()

    let arr = [1, 2, 3, 4, 5];
    let evens = arr.filter(item => item % 2 === 0); // evens is [2, 4]
    

14. reduce()

    let arr = [1, 2, 3, 4];
    let sum = arr.reduce((acc, cur) => acc + cur, 0); // sum is 10
    

15. some()

    let arr = [1, 2, 3, 4, 5];
    let hasEven = arr.some(item => item % 2 === 0); // hasEven is true
    

16. every()

    let arr = [2, 4, 6, 8];
    let allEven = arr.every(item => item % 2 === 0); // allEven is true
    

17. find()

    let arr = [1, 2, 3, 4, 5];
    let found = arr.find(item => item > 3); // found is 4
    

18. findIndex()

    let arr = [1, 2, 3, 4, 5];
    let foundIndex = arr.findIndex(item => item > 3); // foundIndex is 3
    

19. includes()

    let arr = [1, 2, 3];
    let includes2 = arr.includes(2); // includes2 is true
    

20. sort()

    let arr = [3, 1, 4, 1, 5];
    arr.sort((a, b) => a - b); // arr is now [1, 1, 3, 4, 5]
    

21. reverse()

    let arr = [1, 2, 3];
    arr.reverse(); // arr is now [3, 2, 1]
    

22. fill()

    let arr = [1, 2, 3, 4];
    arr.fill(0, 1, 3); // arr is now [1, 0, 0, 4]
    

23. copyWithin()

    let arr = [1, 2, 3, 4, 5];
    arr.copyWithin(0, 3, 5); // arr is now [4, 5, 3, 4, 5]
    

24. flat()

    let arr = [1, [2, [3, 4]]];
    let flattened = arr.flat(2); // flattened is [1, 2, 3, 4]
    

25. flatMap()

    let arr = [1, 2, 3];
    let result = arr.flatMap(x => [x, x * 2]); // result is [1, 2, 2, 4, 3, 6]
    

26. from() (static method)

    let arrFromString = Array.from('hello'); // arrFromString is ['h', 'e', 'l', 'l', 'o']
    

27. isArray() (static method)

    let isArr = Array.isArray([1, 2, 3]); // isArr is true
    

28. of() (static method)

    let arr = Array.of(1, 2, 3); // arr is [1, 2, 3]
    

29. entries()

    let arr = ['a', 'b', 'c'];
    let iterator = arr.entries();
    console.log(iterator.next().value); // [0, 'a']
    

30. from()

    let arrFromSet = Array.from(new Set([1, 2, 3, 2])); // [1, 2, 3]
    

31. keys()

    let arr = ['a', 'b', 'c'];
    let iterator = arr.keys();
    console.log(iterator.next().value); // 0
    

32. reduceRight()

    let arr = [[0, 1], [2, 3], [4, 5]];
    let flattened = arr.reduceRight((acc, cur) => acc.concat(cur), []);
    // flattened is [4, 5, 2, 3, 0, 1]
    

33. toLocaleString()

    let arr = [1, 'a', new Date('21 Dec 1997 14:12:00 UTC')];
    console.log(arr.toLocaleString('en', { timeZone: 'UTC' }));
    // "1,a,12/21/1997, 2:12:00 PM" (output may vary based on locale)
    

34. toString()

    let arr = [1, 2, 'a', '1a'];
    console.log(arr.toString()); // "1,2,a,1a"
    

35. values()

    let arr = ['a', 'b', 'c'];
    let iterator = arr.values();
    console.log(iterator.next().value); // 'a'
    

These are the standard methods available on the Array object in JavaScript. Additionally, there are some methods available on Array.prototype, such as Symbol.iterator, Symbol.species, Symbol.unscopables, and [@@unscopables], which are used for internal purposes or special cases.

3.Object

The Object in JavaScript is a built-in constructor for creating objects, and it has several methods associated with it. Here are the commonly used methods:

1. Object.assign() Copies the values of all enumerable own properties from one or more source objects to a target object.

   const target = { a: 1, b: 2 };
   const source = { b: 3, c: 4 };
   const returnedTarget = Object.assign(target, source);
   console.log(target); // { a: 1, b: 3, c: 4 }
   

2. Object.create() Creates a new object with the specified prototype object and properties.

   const person = {
     isHuman: false,
     printIntroduction: function() {
       console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
     }
   };
   const me = Object.create(person);
   me.name = 'Matthew';
   me.isHuman = true;
   me.printIntroduction(); // "My name is Matthew. Am I human? true"
   

3. Object.defineProperty() Defines a new property directly on an object or modifies an existing property, and returns the object.

   const object1 = {};
   Object.defineProperty(object1, 'property1', {
     value: 42,
     writable: false
   });
   object1.property1 = 77; // Throws an error in strict mode
   console.log(object1.property1); // 42
   

4. Object.defineProperties() Defines new or modifies existing properties directly on an object, returning the object.

   const object1 = {};
   Object.defineProperties(object1, {
     property1: { value: 42, writable: true },
     property2: {}
   });
   console.log(object1.property1); // 42
   

5. Object.entries() Returns an array of key-value pairs from an object's own enumerable string-keyed properties.

   const object1 = { a: 'somestring', b: 42 };
   console.log(Object.entries(object1)); // [['a', 'somestring'], ['b', 42]]
   

6. Object.freeze() Freezes an object, preventing new properties from being added to it and existing properties from being modified or removed.

   const obj = { prop: 42 };
   Object.freeze(obj);
   obj.prop = 33; // Throws an error in strict mode
   console.log(obj.prop); // 42
   

7. Object.fromEntries() Returns a new object from an iterable of key-value pairs (e.g., array) or iterable entries.

   const entries = new Map([['foo', 'bar'], ['baz', 42]]);
   const obj = Object.fromEntries(entries);
   console.log(obj); // { foo: "bar", baz: 42 }
   

8. Object.getOwnPropertyDescriptor() Returns an object describing the configuration of a specific property on a given object.

   const object1 = { property1: 42 };
   const descriptor1 = Object.getOwnPropertyDescriptor(object1, 'property1');
   console.log(descriptor1.configurable); // true
   console.log(descriptor1.value); // 42
   

9. Object.getOwnPropertyDescriptors() Returns an object containing all own property descriptors for an object.

   const object1 = { property1: 42 };
   const descriptors1 = Object.getOwnPropertyDescriptors(object1);
   console.log(descriptors1.property1.writable); // true
   console.log(descriptors1.property1.value); // 42
   

10. Object.getOwnPropertyNames() Returns an array of all properties (enumerable or not) found directly upon a given object.

    const object1 = { a: 1, b: 2, c: 3 };
    console.log(Object.getOwnPropertyNames(object1)); // ["a", "b", "c"]
    

11. Object.getOwnPropertySymbols() Returns an array of all symbol properties found directly upon a given object.

    const obj = {};
    const a = Symbol('a');
    const b = Symbol.for('b');
    obj[a] = 'localSymbol';
    obj[b] = 'globalSymbol';
    const objectSymbols = Object.getOwnPropertySymbols(obj);
    console.log(objectSymbols.length); // 2
    

12. Object.getPrototypeOf() Returns the prototype (internal [[Prototype]] property) of the specified object.

    const prototype1 = {};
    const object1 = Object.create(prototype1);
    console.log(Object.getPrototypeOf(object1) === prototype1); // true
    

13. Object.is() Determines whether two values are the same value. === will fail for NaN===NaN and 0 !== -0.

    console.log(Object.is('foo', 'foo')); // true
    console.log(Object.is(window, window)); // true
    console.log(Object.is('foo', 'bar')); // false
    console.log(Object.is([], [])); // false
    

14. Object.isExtensible() Determines if an object is extensible (whether it can have new properties added to it).

    const object1 = {};
    console.log(Object.isExtensible(object1)); // true
    Object.preventExtensions(object1);
    console.log(Object.isExtensible(object1)); // false
    

15. Object.isFrozen() Determines if an object is frozen.

    const object1 = { property1: 42 };
    console.log(Object.isFrozen(object1)); // false
    Object.freeze(object1);
    console.log(Object.isFrozen(object1)); // true
    

16. Object.isSealed() Determines if an object is sealed.

    const object1 = { property1: 42 };
    console.log(Object.isSealed(object1)); // false
    Object.seal(object1);
    console.log(Object.isSealed(object1)); // true
    

17. Object.keys() Returns an array of a given object's own enumerable property names.

    const object1 = { a: 'somestring', b: 42, c: false };
    console.log(Object.keys(object1)); // ["a", "b", "c"]
    

18. Object.preventExtensions() Prevents any extensions of an object.

    const object1 = {};
    Object.preventExtensions(object1);
    try {
      Object.defineProperty(object1, 'property1', { value: 42 });
    } catch (e) {
      console.log(e); // TypeError: Cannot define property property1, object is not extensible
    }
    

19. Object.seal() Prevents new properties from being added to an object and marks all existing properties as non-configurable.

    const object1 = { property1: 42 };
    Object.seal(object1);
    object1.property1 = 33;
    console.log(object1.property1); // 33
    delete object1.property1; // fails silently in non-strict mode
    console.log(object1.property1); // 33
    

20. Object.setPrototypeOf() Sets the prototype (i.e., the internal [[Prototype]] property) of a specified object to another object or null.

    const obj = { a: 1 };
    const parent = { b: 2 };
    Object.setPrototypeOf(obj, parent);
    console.log(obj.b); // 2
    

21. Object.values() Returns an array of a given object's own enumerable property values.

    const object1 = { a: 'somestring', b: 42, c: false };
    console.log(Object.values(object1)); // ["somestring", 42, false]
    

These methods provide various functionalities for working with objects in JavaScript.

4.Set

Here are the new Set methods in JavaScript:

1. Set constructor

   let set1 = new Set([1, 2, 3, 4, 5]);
   let set2 = new Set("hello");
   

2. add()

   let mySet = new Set();
   mySet.add(1);
   mySet.add(5);
   mySet.add("some text");
   console.log(mySet); // Set(3) {1, 5, "some text"}
   

3. delete()

   let mySet = new Set([1, 2, 3, 4]);
   mySet.delete(3);
   console.log(mySet); // Set(3) {1, 2, 4}
   

4. has()

   let mySet = new Set([1, 2, 3, 4]);
   console.log(mySet.has(3)); // true
   console.log(mySet.has(5)); // false
   

5. clear()

   let mySet = new Set([1, 2, 3]);
   mySet.clear();
   console.log(mySet); // Set(0) {}
   

6. size

   let mySet = new Set([1, 2, 3, 4]);
   console.log(mySet.size); // 4
   

7. forEach()

   let mySet = new Set([1, 2, 3]);
   mySet.forEach(value => console.log(value));
   // Output:
   // 1
   // 2
   // 3
   

8. values()

   let mySet = new Set([1, 2, 3]);
   let iterator = mySet.values();
   console.log(iterator.next().value); // 1
   console.log(iterator.next().value); // 2
   

9. keys()

   let mySet = new Set([1, 2, 3]);
   let iterator = mySet.keys();
   console.log(iterator.next().value); // 1
   console.log(iterator.next().value); // 2
   

   Note: keys() is the same as values() for Set objects.

10. entries()

    let mySet = new Set([1, 2, 3]);
    let iterator = mySet.entries();
    console.log(iterator.next().value); // [1, 1]
    console.log(iterator.next().value); // [2, 2]
    

11. [Symbol.iterator]

    let mySet = new Set([1, 2, 3]);
    for (let item of mySet) {
      console.log(item);
    }
    // Output:
    // 1
    // 2
    // 3
    

12. Set.prototype@@iterator

    let mySet = new Set([1, 2, 3]);
    let iterator = mySet[Symbol.iterator]();
    console.log(iterator.next().value); // 1
    console.log(iterator.next().value); // 2
    

Additional utility methods (not part of the Set prototype, but useful for Set operations):

13. Union of sets

    let set1 = new Set([1, 2, 3]);
    let set2 = new Set([3, 4, 5]);
    let union = new Set([...set1, ...set2]);
    console.log(union); // Set(5) {1, 2, 3, 4, 5}
    

14. Intersection of sets

    let set1 = new Set([1, 2, 3]);
    let set2 = new Set([3, 4, 5]);
    let intersection = new Set([...set1].filter(x => set2.has(x)));
    console.log(intersection); // Set(1) {3}
    

15. Difference of sets

    let set1 = new Set([1, 2, 3]);
    let set2 = new Set([3, 4, 5]);
    let difference = new Set([...set1].filter(x => !set2.has(x)));
    console.log(difference); // Set(2) {1, 2}
    

16. Set.prototype.intersection() (Stage 3 proposal)

    let set1 = new Set([1, 2, 3]);
    let set2 = new Set([2, 3, 4]);
    let intersection = set1.intersection(set2);
    console.log(intersection); // Set(2) {2, 3}
    

17. Set.prototype.union() (Stage 3 proposal)

    let set1 = new Set([1, 2, 3]);
    let set2 = new Set([3, 4, 5]);
    let union = set1.union(set2);
    console.log(union); // Set(5) {1, 2, 3, 4, 5}
    

18. Set.prototype.difference() (Stage 3 proposal)

    let set1 = new Set([1, 2, 3]);
    let set2 = new Set([2, 3, 4]);
    let difference = set1.difference(set2);
    console.log(difference); // Set(1) {1}
    

19. Set.prototype.symmetricDifference() (Stage 3 proposal)

    let set1 = new Set([1, 2, 3]);
    let set2 = new Set([2, 3, 4]);
    let symDifference = set1.symmetricDifference(set2);
    console.log(symDifference); // Set(2) {1, 4}
    

20. Set.prototype.isSubsetOf() (Stage 3 proposal)

    let set1 = new Set([1, 2]);
    let set2 = new Set([1, 2, 3, 4]);
    console.log(set1.isSubsetOf(set2)); // true
    

21. Set.prototype.isSupersetOf() (Stage 3 proposal)

    let set1 = new Set([1, 2, 3, 4]);
    let set2 = new Set([2, 3]);
    console.log(set1.isSupersetOf(set2)); // true
    

22. Set.prototype.isDisjointFrom() (Stage 3 proposal)

    let set1 = new Set([1, 2]);
    let set2 = new Set([3, 4]);
    console.log(set1.isDisjointFrom(set2)); // true
    

5.Map

The Map object in JavaScript is a collection of key-value pairs, and it has several methods for manipulating those pairs. Here's a list of all the methods available on the Map object:

1. Map constructor

   let map1 = new Map([['key1', 'value1'], ['key2', 'value2']]);
   let map2 = new Map();
   

2. set(key, value)

   let myMap = new Map();
   myMap.set('key1', 'value1');
   myMap.set(42, 'answer');
   console.log(myMap); // Map(2) {"key1" => "value1", 42 => "answer"}
   

3. get(key)

   let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
   console.log(myMap.get('key1')); // "value1"
   console.log(myMap.get('key3')); // undefined
   

4. has(key)

   let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
   console.log(myMap.has('key1')); // true
   console.log(myMap.has('key3')); // false
   

5. delete(key)

   let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
   myMap.delete('key1');
   console.log(myMap); // Map(1) {"key2" => "value2"}
   

6. clear()

   let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
   myMap.clear();
   console.log(myMap); // Map(0) {}
   

7. size

   let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
   console.log(myMap.size); // 2
   

8. forEach(callbackFn[, thisArg])

   let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
   myMap.forEach((value, key) => {
     console.log(key + ' = ' + value);
   });
   // Output:
   // key1 = value1
   // key2 = value2
   

9. keys()

   let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
   let iterator = myMap.keys();
   console.log(iterator.next().value); // "key1"
   console.log(iterator.next().value); // "key2"
   

10. values()

    let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
    let iterator = myMap.values();
    console.log(iterator.next().value); // "value1"
    console.log(iterator.next().value); // "value2"
    

11. entries()

    let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
    let iterator = myMap.entries();
    console.log(iterator.next().value); // ["key1", "value1"]
    console.log(iterator.next().value); // ["key2", "value2"]
    

12. [Symbol.iterator]

    let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
    for (let [key, value] of myMap) {
      console.log(key + ' = ' + value);
    }
    // Output:
    // key1 = value1
    // key2 = value2
    

13. Map.prototype@@iterator

    let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
    let iterator = myMap[Symbol.iterator]();
    console.log(iterator.next().value); // ["key1", "value1"]
    console.log(iterator.next().value); // ["key2", "value2"]
    

Additional utility methods (not part of the Map prototype, but useful for Map operations):

14. Creating a Map from an Object

    let obj = { key1: 'value1', key2: 'value2' };
    let map = new Map(Object.entries(obj));
    console.log(map); // Map(2) {"key1" => "value1", "key2" => "value2"}
    

15. Converting a Map to an Object

    let myMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
    let obj = Object.fromEntries(myMap);
    console.log(obj); // { key1: "value1", key2: "value2" }
    

16. Merging two Maps

    let map1 = new Map([['key1', 'value1'], ['key2', 'value2']]);
    let map2 = new Map([['key2', 'newValue2'], ['key3', 'value3']]);
    let mergedMap = new Map([...map1, ...map2]);
    console.log(mergedMap);
    // Map(3) {"key1" => "value1", "key2" => "newValue2", "key3" => "value3"}
    

Remember that Maps in JavaScript maintain insertion order, can use any value (including objects) as keys, and are iterable. They're often preferred over plain objects when you need a simple key/value store with more predictable behavior.

6.Promise

In JavaScript, the Promise object has several methods that are used for handling asynchronous operations. Here are the methods available on the Promise class:

1. Promise constructor

   let promise = new Promise((resolve, reject) => {
     setTimeout(() => {
       resolve("Success!");
     }, 1000);
   });
   

2. Promise.resolve()

   let resolvedPromise = Promise.resolve("Already resolved");
   resolvedPromise.then(value => console.log(value)); // "Already resolved"
   

3. Promise.reject()

   let rejectedPromise = Promise.reject(new Error("Failure"));
   rejectedPromise.catch(error => console.log(error.message)); // "Failure"
   

4. then()

   let promise = Promise.resolve("Success");
   promise.then(
     value => console.log(value), // "Success"
     error => console.log(error)
   );
   

5. catch()

   let promise = Promise.reject(new Error("Failure"));
   promise.catch(error => console.log(error.message)); // "Failure"
   

6. finally()

   let promise = Promise.resolve("Success");
   promise
     .finally(() => console.log("This runs regardless of success or failure"))
     .then(value => console.log(value));
   

7. Promise.all()

   let promise1 = Promise.resolve(1);
   let promise2 = Promise.resolve(2);
   let promise3 = Promise.resolve(3);
   
   Promise.all([promise1, promise2, promise3])
     .then(values => console.log(values)); // [1, 2, 3]
   

8. Promise.race()

   let promise1 = new Promise(resolve => setTimeout(() => resolve("one"), 500));
   let promise2 = new Promise(resolve => setTimeout(() => resolve("two"), 100));
   
   Promise.race([promise1, promise2])
     .then(value => console.log(value)); // "two"
   

9. Promise.allSettled()

   let promise1 = Promise.resolve(1);
   let promise2 = Promise.reject("error");
   let promise3 = Promise.resolve(3);
   
   Promise.allSettled([promise1, promise2, promise3])
     .then(results => console.log(results));
   // [
   //   { status: "fulfilled", value: 1 },
   //   { status: "rejected", reason: "error" },
   //   { status: "fulfilled", value: 3 }
   // ]
   

10. Promise.any()

    let promise1 = Promise.reject("error");
    let promise2 = new Promise(resolve => setTimeout(() => resolve("slow"), 500));
    let promise3 = Promise.resolve("quick");
    
    Promise.any([promise1, promise2, promise3])
      .then(value => console.log(value)); // "quick"
    

11. Promise chaining

    new Promise((resolve, reject) => {
      setTimeout(() => resolve(1), 1000);
    }).then(result => {
      console.log(result); // 1
      return result * 2;
    }).then(result => {
      console.log(result); // 2
      return result * 2;
    }).then(result => {
      console.log(result); // 4
    });
    

12. Async/Await (syntactic sugar for Promises)

    async function fetchData() {
      try {
        let response = await fetch('https://api.example.com/data');
        let data = await response.json();
        console.log(data);
      } catch (error) {
        console.log('Error:', error);
      }
    }
    
    fetchData();
    

13. Promise.prototype.then() vs. Promise.prototype.catch()

    Promise.reject('error')
      .then(() => console.log('Success'),
            error => console.log('Error:', error))
      .catch(error => console.log('Caught:', error));
    // Output: "Error: error"
    

14. Using Promise.resolve() to create a Promise from a value

    let cache = new Map();
    function getCachedData(key) {
      if (cache.has(key)) {
        return Promise.resolve(cache.get(key));
      }
      // Fetch data if not in cache
      return fetchDataFromServer(key);
    }
    

Remember that Promises are a powerful tool for handling asynchronous operations in JavaScript. They provide a cleaner and more manageable way to work with callbacks and help avoid the "callback hell" problem. The introduction of async/await syntax has made working with Promises even more straightforward in many cases.

7.Proxy

Proxy handlers are objects that define custom behavior for fundamental operations (e.g., property lookup, assignment, enumeration, etc.). Here are some of the most commonly used Proxy handlers:

Certainly! Here's a comprehensive list of methods (traps) in the Proxy class in JavaScript, along with explanations and examples:

1. Proxy Constructor Explanation: Creates a new Proxy object that wraps a target object and can intercept fundamental operations.

   Example:

   let target = {};
   let handler = {};
   let proxy = new Proxy(target, handler);
   

2. get Explanation: Intercepts property access operations.

   Example:

   let target = { name: 'John' };
   let handler = {
     get: function(target, prop) {
       console.log(`Accessing property: ${prop}`);
       return prop in target ? target[prop] : 'Not found';
     }
   };
   let proxy = new Proxy(target, handler);
   console.log(proxy.name); // Logs: "Accessing property: name", then "John"
   console.log(proxy.age);  // Logs: "Accessing property: age", then "Not found"
   

3. set Explanation: Intercepts property assignment operations.

   Example:

   let target = {};
   let handler = {
     set: function(target, prop, value) {
       if (typeof value !== 'number') {
         throw new TypeError('The value must be a number');
       }
       target[prop] = value;
       return true;
     }
   };
   let proxy = new Proxy(target, handler);
   proxy.age = 30; // Works fine
   proxy.name = 'John'; // Throws TypeError
   

4. has Explanation: Intercepts the 'in' operator.

   Example:

   let target = { name: 'John', age: 30 };
   let handler = {
     has: function(target, prop) {
       console.log(`Checking for property: ${prop}`);
       return prop in target;
     }
   };
   let proxy = new Proxy(target, handler);
   console.log('name' in proxy); // Logs: "Checking for property: name", then true
   

5. deleteProperty Explanation: Intercepts the 'delete' operator.

   Example:

   let target = { name: 'John', age: 30 };
   let handler = {
     deleteProperty: function(target, prop) {
       console.log(`Attempting to delete: ${prop}`);
       if (prop === 'name') return false;
       delete target[prop];
       return true;
     }
   };
   let proxy = new Proxy(target, handler);
   delete proxy.age; // Logs: "Attempting to delete: age", returns true
   delete proxy.name; // Logs: "Attempting to delete: name", returns false
   

6. apply Explanation: Intercepts function calls.

   Example:

   function sum(a, b) { return a + b; }
   let handler = {
     apply: function(target, thisArg, argumentsList) {
       console.log(`Calling function with args: ${argumentsList}`);
       return target.apply(thisArg, argumentsList);
     }
   };
   let proxy = new Proxy(sum, handler);
   console.log(proxy(1, 2)); // Logs: "Calling function with args: 1,2", then 3
   

7. construct Explanation: Intercepts 'new' operations.

   Example:

   function User(name) { this.name = name; }
   let handler = {
     construct: function(target, args) {
       console.log(`Creating new instance with args: ${args}`);
       return new target(...args);
     }
   };
   let UserProxy = new Proxy(User, handler);
   let user = new UserProxy('John'); // Logs: "Creating new instance with args: John"
   

8. getOwnPropertyDescriptor Explanation: Intercepts Object.getOwnPropertyDescriptor.

   Example:

   let target = { name: 'John' };
   let handler = {
     getOwnPropertyDescriptor: function(target, prop) {
       console.log(`Getting descriptor for: ${prop}`);
       return { configurable: true, enumerable: true, value: target[prop] };
     }
   };
   let proxy = new Proxy(target, handler);
   console.log(Object.getOwnPropertyDescriptor(proxy, 'name'));
   // Logs: "Getting descriptor for: name", then the descriptor object
   

9. defineProperty Explanation: Intercepts Object.defineProperty.

   Example:

   let target = {};
   let handler = {
     defineProperty: function(target, prop, descriptor) {
       console.log(`Defining property: ${prop}`);
       return Object.defineProperty(target, prop, descriptor);
     }
   };
   let proxy = new Proxy(target, handler);
   Object.defineProperty(proxy, 'name', { value: 'John' });
   // Logs: "Defining property: name"
   

10. getPrototypeOf Explanation: Intercepts Object.getPrototypeOf.

    Example:

    let target = {};
    let handler = {
      getPrototypeOf: function(target) {
        console.log('Getting prototype');
        return Array.prototype;
      }
    };
    let proxy = new Proxy(target, handler);
    console.log(Object.getPrototypeOf(proxy) === Array.prototype);
    // Logs: "Getting prototype", then true
    

11. setPrototypeOf Explanation: Intercepts Object.setPrototypeOf.

    Example:

    let target = {};
    let handler = {
      setPrototypeOf: function(target, proto) {
        console.log(`Setting prototype to: ${proto}`);
        return Object.setPrototypeOf(target, proto);
      }
    };
    let proxy = new Proxy(target, handler);
    Object.setPrototypeOf(proxy, Array.prototype);
    // Logs: "Setting prototype to: [object Array]"
    

12. isExtensible Explanation: Intercepts Object.isExtensible.

    Example:

    let target = {};
    let handler = {
      isExtensible: function(target) {
        console.log('Checking if object is extensible');
        return Object.isExtensible(target);
      }
    };
    let proxy = new Proxy(target, handler);
    console.log(Object.isExtensible(proxy));
    // Logs: "Checking if object is extensible", then true
    

13. preventExtensions Explanation: Intercepts Object.preventExtensions.

    Example:

    let target = {};
    let handler = {
      preventExtensions: function(target) {
        console.log('Preventing extensions');
        Object.preventExtensions(target);
        return true;
      }
    };
    let proxy = new Proxy(target, handler);
    Object.preventExtensions(proxy);
    // Logs: "Preventing extensions"
    

14. ownKeys Explanation: Intercepts Object.getOwnPropertyNames and Object.getOwnPropertySymbols.

    Example:

    let target = { a: 1, b: 2, c: 3 };
    let handler = {
      ownKeys: function(target) {
        console.log('Getting own keys');
        return ['a', 'c'];
      }
    };
    let proxy = new Proxy(target, handler);
    console.log(Object.keys(proxy));
    // Logs: "Getting own keys", then ['a', 'c']
    

These Proxy traps provide powerful ways to intercept and customize fundamental operations on objects, enabling advanced patterns like validation, logging, access control, and more.

These methods allow developers to create powerful abstractions and implement complex behaviors:

• Validation: You can validate data before it's set or returned.
• Default Values: Implement automatic default values for non-existent properties.
• Logging/Debugging: Log all accesses, modifications, or method calls on an object.
• Lazy Loading: Load properties only when they're accessed.
• Access Control: Implement read-only or write-only properties, or restrict access based on conditions.
• Virtual Properties: Create computed properties that don't actually exist on the target object.
• Data Binding: Automatically update UI or trigger events when data changes.
• Meta-Programming: Implement powerful meta-programming techniques by intercepting fundamental object operations.

Proxies provide a powerful way to customize object behavior at a fundamental level, enabling patterns and techniques that would be difficult or impossible to implement otherwise.

8.Reflect

Reflect provides methods to perform default operations for those same fundamental operations. Here are some of the most commonly used Reflect methods:

The Reflect object in JavaScript provides methods for interceptable JavaScript operations. Here's a list of methods in the Reflect class, along with explanations and examples:

1. Reflect.apply(target, thisArgument, argumentsList) Explanation: Calls a target function with given this value and arguments.

   Example:

   function sum(a, b) { return a + b; }
   console.log(Reflect.apply(sum, null, [1, 2])); // 3
   

2. Reflect.construct(target, argumentsList[, newTarget]) Explanation: Acts like the new operator, but as a function. It is equivalent to calling new target(...argumentsList).

   Example:

   function User(name) { this.name = name; }
   let user = Reflect.construct(User, ['John']);
   console.log(user.name); // "John"
   

3. Reflect.defineProperty(target, propertyKey, attributes) Explanation: Similar to Object.defineProperty(), but returns a Boolean.

   Example:

   let obj = {};
   Reflect.defineProperty(obj, 'name', { value: 'John', writable: false });
   console.log(obj.name); // "John"
   obj.name = 'Jane'; // Won't change
   console.log(obj.name); // Still "John"
   

4. Reflect.deleteProperty(target, propertyKey) Explanation: The delete operator as a function. Equivalent to delete target[propertyKey].

   Example:

   let obj = { x: 1, y: 2 };
   Reflect.deleteProperty(obj, 'x');
   console.log(obj); // { y: 2 }
   

5. Reflect.get(target, propertyKey[, receiver]) Explanation: Returns the value of the property. Works like getting a property from an object (target[propertyKey]) as a function.

   Example:

   let obj = { x: 1, y: 2 };
   console.log(Reflect.get(obj, 'x')); // 1
   

6. Reflect.getOwnPropertyDescriptor(target, propertyKey) Explanation: Similar to Object.getOwnPropertyDescriptor(). Returns a property descriptor of the given property if it exists on the object, undefined otherwise.

   Example:

   let obj = { x: 1 };
   console.log(Reflect.getOwnPropertyDescriptor(obj, 'x'));
   // { value: 1, writable: true, enumerable: true, configurable: true }
   

7. Reflect.getPrototypeOf(target) Explanation: Same as Object.getPrototypeOf().

   Example:

   let arr = [];
   console.log(Reflect.getPrototypeOf(arr) === Array.prototype); // true
   

8. Reflect.has(target, propertyKey) Explanation: Works like the in operator as a function. Returns a boolean indicating whether the property exists.

   Example:

   let obj = { x: 1 };
   console.log(Reflect.has(obj, 'x')); // true
   console.log(Reflect.has(obj, 'y')); // false
   

9. Reflect.isExtensible(target) Explanation: Same as Object.isExtensible(). Determines if an object is extensible.

   Example:

   let obj = {};
   console.log(Reflect.isExtensible(obj)); // true
   Object.freeze(obj);
   console.log(Reflect.isExtensible(obj)); // false
   

10. Reflect.ownKeys(target) Explanation: Returns an array of the target object's own property keys.

    Example:

    let obj = { x: 1, y: 2 };
    console.log(Reflect.ownKeys(obj)); // ['x', 'y']
    

11. Reflect.preventExtensions(target) Explanation: Similar to Object.preventExtensions(). Prevents new properties from ever being added to an object.

    Example:

    let obj = { x: 1 };
    Reflect.preventExtensions(obj);
    obj.y = 2; // This won't work
    console.log(obj); // { x: 1 }
    

12. Reflect.set(target, propertyKey, value[, receiver]) Explanation: A function that assigns values to properties. Returns a boolean that is true if the update was successful.

    Example:

    let obj = { x: 1 };
    Reflect.set(obj, 'y', 2);
    console.log(obj); // { x: 1, y: 2 }
    

13. Reflect.setPrototypeOf(target, prototype) Explanation: Sets the prototype of a specified object to another object or null. Returns a boolean indicating whether the operation was successful.

    Example:

    let obj = {};
    Reflect.setPrototypeOf(obj, Array.prototype);
    obj.push(1);
    console.log(obj); // [1]
    

These Reflect methods provide a way to control object behavior that is more consistent with other parts of the language. They're often used in conjunction with Proxies to implement custom object behaviors and can be particularly useful in meta-programming scenarios.

9.Number

Here's a list of key methods available in the Number class in JavaScript, along with explanations and examples:

1. Number.isFinite(value) Determines whether a value is a finite number.

   Example:

   console.log(Number.isFinite(42)); // true
   console.log(Number.isFinite(Infinity)); // false
   console.log(Number.isFinite(NaN)); // false
   

2. Number.isInteger(value) Determines whether a value is an integer.

   Example:

   console.log(Number.isInteger(5)); // true
   console.log(Number.isInteger(5.5)); // false
   

3. Number.isNaN(value) Determines whether a value is NaN (Not-a-Number).

   Example:

   console.log(Number.isNaN(NaN)); // true
   console.log(Number.isNaN(5)); // false
   

4. Number.parseFloat(string) Parses a string argument and returns a floating-point number.

   Example:

   console.log(Number.parseFloat('3.14')); // 3.14
   console.log(Number.parseFloat('3.14abc')); // 3.14
   

5. Number.parseInt(string, radix) Parses a string argument and returns an integer of the specified radix or base.

   Example:

   console.log(Number.parseInt('42', 10)); // 42
   console.log(Number.parseInt('0xFF', 16)); // 255
   

6. Number.prototype.toFixed(digits) Formats a number using fixed-point notation.

   Example:

   const num = 3.14159;
   console.log(num.toFixed(2)); // "3.14"
   

7. Number.prototype.toPrecision(precision) Returns a string representing the number to the specified precision.

   Example:

   const num = 123.456;
   console.log(num.toPrecision(4)); // "123.5"
   

8. Number.prototype.toString(radix) Returns a string representing the number in the specified radix (base).

   Example:

   const num = 255;
   console.log(num.toString(16)); // "ff"
   

9. Number.prototype.toExponential(fractionDigits) Returns a string representing the number in exponential notation.

   Example:

   const num = 123456;
   console.log(num.toExponential(2)); // "1.23e+5"
   

These methods cover the main functionality provided by the Number class in JavaScript. Would you like me to elaborate on any of these methods or provide more examples?

10.Boolean

The Boolean class in JavaScript is relatively simple and has fewer methods compared to other primitive types. Here's a list of the key methods and properties available for Boolean objects, along with explanations and examples:

1. Boolean(value) This is actually a function that can be used to convert a value to a boolean.

   Example:

   console.log(Boolean(1)); // true
   console.log(Boolean(0)); // false
   console.log(Boolean('')); // false
   console.log(Boolean('hello')); // true
   

2. Boolean.prototype.toString() Returns a string representation of the boolean.

   Example:

   const bool = new Boolean(true);
   console.log(bool.toString()); // "true"
   
   const bool2 = false;
   console.log(bool2.toString()); // "false"
   

3. Boolean.prototype.valueOf() Returns the primitive value of the Boolean object.

   Example:

   const bool = new Boolean(true);
   console.log(bool.valueOf()); // true
   
   const bool2 = new Boolean(false);
   console.log(bool2.valueOf()); // false
   

It's important to note that while these methods exist, it's generally not recommended to use the Boolean object constructor (new Boolean()) in practice. Instead, it's better to use boolean primitives (true and false) directly.

Here's an example illustrating why:

const x = new Boolean(false);
if (x) {
  console.log("This will be executed, even though x was created with false!");
}

In this case, the condition is true because x is an object, and all objects are truthy in JavaScript. This can lead to confusing behavior.

Instead, you should use boolean primitives:

const x = false;
if (x) {
  console.log("This won't be executed");
} else {
  console.log("This will be executed");
}

While the Boolean class has fewer methods compared to other JavaScript classes, understanding these methods and the behavior of Boolean objects versus boolean primitives is crucial for writing clear and correct JavaScript code.

Would you like me to elaborate on any aspect of working with booleans in JavaScript?

11.Function

The Function class in JavaScript is fundamental to the language's design, as functions are first-class objects. Here's a list of key methods and properties available for Function objects, along with explanations and examples:

1. Function.prototype.apply(thisArg, [argsArray]) Calls a function with a given this value and arguments provided as an array.

   Example:

   function greet(greeting, punctuation) {
     console.log(greeting + ', ' + this.name + punctuation);
   }
   
   const person = { name: 'Alice' };
   greet.apply(person, ['Hello', '!']); // Output: Hello, Alice!
   

2. Function.prototype.call(thisArg, arg1, arg2, ...) Similar to apply(), but arguments are passed individually.

   Example:

   function greet(greeting, punctuation) {
     console.log(greeting + ', ' + this.name + punctuation);
   }
   
   const person = { name: 'Bob' };
   greet.call(person, 'Hi', '?'); // Output: Hi, Bob?
   

3. Function.prototype.bind(thisArg, arg1, arg2, ...) Creates a new function with a fixed this value and optionally preset arguments.

   Example:

   function greet(greeting) {
     console.log(greeting + ', ' + this.name);
   }
   
   const person = { name: 'Charlie' };
   const greetCharlie = greet.bind(person);
   greetCharlie('Hello'); // Output: Hello, Charlie
   

4. Function.prototype.toString() Returns a string representing the source code of the function.

   Example:

   function add(a, b) { return a + b; }
   console.log(add.toString());
   // Output: function add(a, b) { return a + b; }
   

5. Function.prototype.length Returns the number of parameters expected by the function.

   Example:

   function func1(a) {}
   function func2(a, b) {}
   console.log(func1.length); // 1
   console.log(func2.length); // 2
   

6. Function.prototype.name Returns the name of the function.

   Example:

   function myFunction() {}
   console.log(myFunction.name); // "myFunction"
   
   const myArrowFunction = () => {};
   console.log(myArrowFunction.name); // "myArrowFunction"
   

7. Function.prototype[@@hasInstance] Determines if a constructor object recognizes an object as its instance.

   Example:

   class MyClass {}
   const obj = new MyClass();
   console.log(MyClass[Symbol.hasInstance](obj)); // true
   

8. new Function([arg1[, arg2[, ...argN]],] functionBody) Creates a new Function object from a string.

   Example:

   const sum = new Function('a', 'b', 'return a + b');
   console.log(sum(2, 3)); // 5
   

It's worth noting that while the new Function() constructor exists, it's generally not recommended for regular use due to security and performance concerns. It's better to declare functions using function declarations or expressions.

These methods and properties provide powerful ways to work with functions in JavaScript, enabling dynamic function creation, context binding, and introspection. They're particularly useful in advanced scenarios involving meta-programming or when working with libraries that make heavy use of function manipulation.

Would you like me to elaborate on any of these methods or provide more complex examples of their usage?

12.Date

The Date class in JavaScript provides a wide range of methods for working with dates and times. Here's a list of key methods available in the Date class, along with explanations and examples:

1. Date.now() Returns the number of milliseconds elapsed since January 1, 1970.

   Example:

   console.log(Date.now()); // e.g., 1631234567890
   

2. Date.parse(dateString) Parses a date string and returns the number of milliseconds since January 1, 1970.

   Example:

   console.log(Date.parse('2023-09-07T12:00:00Z')); // 1694088000000
   

3. new Date() (constructor) Creates a new Date object.

   Example:

   const now = new Date();
   const specific = new Date('2023-09-07T12:00:00Z');
   console.log(now);
   console.log(specific);
   

4. Date.prototype.getFullYear() Returns the year of the date.

   Example:

   const date = new Date('2023-09-07');
   console.log(date.getFullYear()); // 2023
   

5. Date.prototype.getMonth() Returns the month (0-11) of the date.

   Example:

   const date = new Date('2023-09-07');
   console.log(date.getMonth()); // 8 (September is month 8)
   

6. Date.prototype.getDate() Returns the day of the month (1-31).

   Example:

   const date = new Date('2023-09-07');
   console.log(date.getDate()); // 7
   

7. Date.prototype.getDay() Returns the day of the week (0-6, where 0 is Sunday).

   Example:

   const date = new Date('2023-09-07');
   console.log(date.getDay()); // 4 (Thursday)
   

8. Date.prototype.getHours() Returns the hour (0-23) of the date.

   Example:

   const date = new Date('2023-09-07T15:30:00');
   console.log(date.getHours()); // 15
   

9. Date.prototype.getMinutes() Returns the minutes (0-59) of the date.

   Example:

   const date = new Date('2023-09-07T15:30:00');
   console.log(date.getMinutes()); // 30
   

10. Date.prototype.getSeconds() Returns the seconds (0-59) of the date.

    Example:

    const date = new Date('2023-09-07T15:30:45');
    console.log(date.getSeconds()); // 45
    

11. Date.prototype.getTime() Returns the number of milliseconds since January 1, 1970.

    Example:

    const date = new Date('2023-09-07T12:00:00Z');
    console.log(date.getTime()); // 1694088000000
    

12. Date.prototype.setFullYear(year[, month[, day]]) Sets the year of the date.

    Example:

    const date = new Date('2023-09-07');
    date.setFullYear(2024);
    console.log(date); // 2024-09-07T00:00:00.000Z
    

13. Date.prototype.toISOString() Returns a string representation of the date in ISO format.

    Example:

    const date = new Date('2023-09-07T12:30:00Z');
    console.log(date.toISOString()); // "2023-09-07T12:30:00.000Z"
    

14. Date.prototype.toLocaleString() Returns a string with a language-sensitive representation of the date.

    Example:

    const date = new Date('2023-09-07T12:30:00');
    console.log(date.toLocaleString('en-US')); // "9/7/2023, 12:30:00 PM"