"Hello".charAt(4)
    "Hello".concat("", "world")
    "Hello".startsWith("H")
    "Hello".endsWith("o")
    "Hello".includes("x")
    "Hello".indexOf("l")
    "Hello".lastIndexOf("l")
    "Hello".match([A-Z/g])
    "Hello".padStart(6, "?")
    "Hello".padEnd(6, "?")
    "Hello".repeat(3)
    "Hello".replace("llo", "y")
    "Hello".search("e")
    "Hello".slice(1, 3)
    "Hello".split("")
    "Hello".substring(2, 4)
    "Hello".toLowerCase()
    "Hello".toUpperCase()
    " Hello ".trim()
    " Hello ".trimStart()
    " Hello ".trimEnd()

    // Object Methods Cheat Sheet

    // 1. Object.create(proto, [propertiesObject])
    // Creates a new object with the specified prototype object and optional properties.
    const obj1 = Object.create(null);
    
    // 2. Object.keys(obj)
    // Returns an array of a given object's own enumerable property names.
    const keys = Object.keys(obj);
    
    // 3. Object.values(obj)
    // Returns an array of a given object's own enumerable property values.
    const values = Object.values(obj);
    
    // 4. Object.entries(obj)
    // Returns an array of a given object's own enumerable property [key, value] pairs.
    const entries = Object.entries(obj);
    
    // 5. Object.assign(target, ...sources)
    // Copies the values of all enumerable properties from one or more source objects to a target object.
    const target = {};
    Object.assign(target, obj1, obj2);
    
    // 6. Object.hasOwnProperty(prop)
    // Returns a boolean indicating whether the object has the specified property as its own property (not inherited).
    const hasProp = obj.hasOwnProperty("property");
    
    // 7. Object.is(obj1, obj2)
    // Determines whether two values are the same value.
    const isSame = Object.is(obj1, obj2);
    
    // 8. Object.freeze(obj)
    // Freezes an object: other code cannot delete or modify its properties.
    const frozenObj = Object.freeze(obj);
    
    // 9. Object.seal(obj)
    // Seals an object: other code cannot add/delete properties, but can modify existing properties.
    const sealedObj = Object.seal(obj);
    
    // 10. Object.getPrototypeOf(obj)
    // Returns the prototype of the specified object.
    const proto = Object.getPrototypeOf(obj);
    
    // 11. Object.setPrototypeOf(obj, proto)
    // Sets the prototype of the specified object.
    Object.setPrototypeOf(obj, proto);
    
    // 12. Object.defineProperty(obj, prop, descriptor)
    // Adds the named property described by a given descriptor to an object.
    Object.defineProperty(obj, "property", {
      value: "value",
      writable: false,
      enumerable: true,
      configurable: true,
    });
    
    // 13. Object.getOwnPropertyDescriptor(obj, prop)
    // Returns a property descriptor for a named property on an object.
    const descriptor = Object.getOwnPropertyDescriptor(obj, "property");
    
    // 14. Object.getOwnPropertyNames(obj)
    // Returns an array of all properties (including non-enumerable properties except for those which use Symbol) found directly in a given object.
    const propertyNames = Object.getOwnPropertyNames(obj);
    
    // 15. Object.getOwnPropertySymbols(obj)
    // Returns an array of all symbol properties found directly in a given object.
    const symbols = Object.getOwnPropertySymbols(obj);
    
    // 16. Object.toString()
    // Returns a string representation of the object.
    const str = Object.toString();
    
    // Object Methods Cheat Sheet (Continued)
    
    // 17. Object.hasOwnProperty(prop)
    // Returns a boolean indicating whether the object has the specified property as its own property (not inherited).
    const hasProp = obj.hasOwnProperty("property");
    
    // 18. Object.isExtensible(obj)
    // Determines if an object is extensible (i.e., if new properties can be added to it).
    const isExtensible = Object.isExtensible(obj);
    
    // 19. Object.preventExtensions(obj)
    // Prevents any extensions of an object (i.e., prevents new properties from being added to it).
    Object.preventExtensions(obj);
    
    // 20. Object.isSealed(obj)
    // Determines if an object is sealed (i.e., if it is neither extensible nor properties can be deleted).
    const isSealed = Object.isSealed(obj);
    
    // 21. Object.isFrozen(obj)
    // Determines if an object is frozen (i.e., if it is neither extensible, properties can be deleted, nor properties can be modified).
    const isFrozen = Object.isFrozen(obj);
    
    // 22. Object.keys(obj)
    // Returns an array of a given object's own enumerable property names.
    const keys = Object.keys(obj);
    
    // 23. Object.values(obj)
    // Returns an array of a given object's own enumerable property values.
    const values = Object.values(obj);
    
    // 24. Object.entries(obj)
    // Returns an array of a given object's own enumerable property [key, value] pairs.
    const entries = Object.entries(obj);
    
    // 25. Object.fromEntries(entries)
    // Transforms a list of key-value pairs into an object.
    const transformedObj = Object.fromEntries(entries);
    
    // 26. Object.prototype.hasOwnProperty(prop)
    // Returns a boolean indicating whether the object or its prototype chain has the specified property.
    const hasPropInChain = obj.hasOwnProperty("property");
    
    // 27. Object.prototype.toString()
    // Returns a string representation of the object.
    const str = obj.toString();
    
    // 28. Object.prototype.valueOf()
    // Returns the primitive value of the object.
    const value = obj.valueOf();
    
    // 29. Object.prototype.isPrototypeOf(obj)
    // Checks if an object exists in another object's prototype chain.
    const isProto = prototypeObj.isPrototypeOf(obj);
    
    // 30. Object.prototype.propertyIsEnumerable(prop)
    // Returns a boolean indicating whether the specified property is enumerable.
    const isEnumerable = obj.propertyIsEnumerable("property");
    
    // Object Methods Cheat Sheet (Continued)
    
    // 31. Object.getOwnPropertyDescriptors(obj)
    // Returns an object containing all own property descriptors of an object.
    const descriptors = Object.getOwnPropertyDescriptors(obj);
    
    // 32. Object.isPrototypeOf(obj)
    // Checks if an object is in the prototype chain of another object.
    const isProto = Object.isPrototypeOf(protoObj);
    
    // 33. Object.values(obj)
    // Returns an array of a given object's own enumerable property values.
    const values = Object.values(obj);
    
    // 34. Object.entries(obj)
    // Returns an array of a given object's own enumerable property [key, value] pairs.
    const entries = Object.entries(obj);
    
    // 35. Object.keys(obj)
    // Returns an array of a given object's own enumerable property names.
    const keys = Object.keys(obj);
    
    // 36. Object.defineProperties(obj, descriptors)
    // Defines new or modifies existing properties directly on an object, returning the object.
    Object.defineProperties(obj, {
      property1: {
        value: "value1",
        writable: true,
        enumerable: true,
        configurable: true,
      },
      property2: {
        value: "value2",
        writable: false,
        enumerable: true,
        configurable: true,
      },
    });
    
    // 37. Object.getOwnPropertyNames(obj)
    // Returns an array of all properties (including non-enumerable properties except for those which use Symbol) found directly in a given object.
    const propertyNames = Object.getOwnPropertyNames(obj);
    
    // 38. Object.getOwnPropertySymbols(obj)
    // Returns an array of all symbol properties found directly in a given object.
    const symbols = Object.getOwnPropertySymbols(obj);
    
    // 39. Object.toString()
    // Returns a string representation of the object.
    const str = Object.toString();
    
    // 40. Object.valueOf()
    // Returns the primitive value of the object.
    const value = obj.valueOf();

    isNaN(12.4); // false
    isFinite(12.4); // true
    Number.isInteger (12.4); // false
    Number.isSafeInteger(12.4); // false
    parseFloat(12.4); // 12.4
    parseInt(12.4); // 12
    const num = 12.4;
    num.toExponential(); // "1.24e+1"
    num.toFixed(); // 12
    num.toPrecision(3); // "12.4"
    num.toString(10); // "12.4"
    num.valueOf(); // 12.4
    let today = new Date(); today.toLocaleString('en-IN'); // "1/9/2022, 11:03:17 am"

    console.log("Hello, world!");
    alert("Hello, world!");
    let name = prompt("What is your name?");
    let number = parseInt("42");
    let number = parseFloat("3.14");
    let str = String(42);
    let num = Number("42");
    typeof "Hello"; // returns "string"
    Array.isArray([1, 2, 3]); // returns true
    let strLength = "Hello".length; // returns 5
    let uppercaseStr = "hello".toUpperCase(); // returns "HELLO"
    let lowercaseStr = "HELLO".toLowerCase(); // returns "hello"
    let fullName = "John".concat(" ", "Doe"); // returns "John Doe"
    let str = ["Hello", "world"].join(" "); // returns "Hello world"
    // -----------------------------------
    let arr = [1, 2, 3];
    arr.push(4);
    // -----------------------------------
    let arr = [1, 2, 3];
    let lastElement = arr.pop(); // returns 3
    // -----------------------------------
    let arr = [1, 2, 3];
    let firstElement = arr.shift(); // returns 1
    // -----------------------------------
    let arr = [2, 3, 4];
    arr.unshift(1);
    // -----------------------------------
    let arr = [1, 2, 3, 4, 5];
    let subArray = arr.slice(2, 4); // returns [3, 4]
    // -----------------------------------
    let arr = [1, 2, 3, 4, 5];
    arr.splice(2, 1, "hello");
    // -----------------------------------
    let arr = [1, 2, 3, 4, 5];
    let index = arr;
    
    // ---------- STRING METHODS---------
    // -----------------------------------
    let str = "Hello, world!";
    
    // Length of the string
    let length = str.length;
    console.log(length); // Output: 13
    
    // Convert to uppercase
    let uppercase = str.toUpperCase();
    console.log(uppercase); // Output: HELLO, WORLD!
    
    // Convert to lowercase
    let lowercase = str.toLowerCase();
    console.log(lowercase); // Output: hello, world!
    
    // Check if a string includes a substring
    let includesSubstring = str.includes("world");
    console.log(includesSubstring); // Output: true
    
    // Extract a substring
    let substring = str.substring(7, 12);
    console.log(substring); // Output: world
    
    // Split a string into an array of substrings
    let splitted = str.split(", ");
    console.log(splitted); // Output: ['Hello', 'world!']
    
    // Trim leading and trailing whitespace
    let trimmed = str.trim();
    console.log(trimmed); // Output: Hello, world!
    
    // Replace a substring with another string
    let replaced = str.replace("world", "JavaScript");
    console.log(replaced); // Output: Hello, JavaScript!
    
    // Concatenate strings
    let str1 = "Hello";
    let str2 = "JavaScript";
    let concatenated = str1.concat(", ", str2, "!");
    console.log(concatenated); // Output: Hello, JavaScript!
    
    let str = "Hello, world!";
    
    // Check if a string starts with a specific substring
    let startsWith = str.startsWith("Hello");
    console.log(startsWith); // Output: true
    
    // Check if a string ends with a specific substring
    let endsWith = str.endsWith("world!");
    console.log(endsWith); // Output: true
    
    // Find the index of a substring
    let indexOfSubstring = str.indexOf("world");
    console.log(indexOfSubstring); // Output: 7
    
    // Find the last index of a substring
    let lastIndexOfSubstring = str.lastIndexOf("o");
    console.log(lastIndexOfSubstring); // Output: 8
    
    // Repeat a string a certain number of times
    let repeated = str.repeat(3);
    console.log(repeated); // Output: Hello, world!Hello, world!Hello, world!
    
    // Extract a character at a specific index
    let charAt = str.charAt(4);
    console.log(charAt); // Output: o
    
    // Get the Unicode value of a character at a specific index
    let charCode = str.charCodeAt(4);
    console.log(charCode); // Output: 111
    
    // Check if a string contains only numeric characters
    let isNumeric = str.match(/^\d+$/);
    console.log(isNumeric); // Output: null (if the string is not numeric)
    
    // Split a string into an array of characters
    let characters = str.split("");
    console.log(characters); // Output:
     ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']
    
    // Reverse a string
    let reversed = str.split("").reverse().join("");
    console.log(reversed); // Output: !dlrow ,olleH
    
    // Extract a substring using regular expressions
    let regexSubstring = str.match(/world/g);
    console.log(regexSubstring); // Output: ['world']
    
    let str = "Hello, world!";
    
    // Check if a string is empty
    let isEmpty = str.length === 0;
    console.log(isEmpty); // Output: false
    
    // Check if a string is a palindrome
    let isPalindrome = str === str.split("").reverse().join("");
    console.log(isPalindrome); // Output: false
    
    // Extract a substring using substr
    let substr = str.substr(7, 5);
    console.log(substr); // Output: world
    
    // Pad a string with a specified character
    let padded = str.padStart(20, "*");
    console.log(padded); // Output: ****Hello, world!
    
    // Extract the first character of a string
    let firstChar = str.charAt(0);
    console.log(firstChar); // Output: H
    
    // Extract the last character of a string
    let lastChar = str.charAt(str.length - 1);
    console.log(lastChar); // Output: !
    
    // Convert a string to an array of words
    let words = str.split(" ");
    console.log(words); // Output: ['Hello,', 'world!']
    
    // Replace multiple occurrences of a substring with another string
    let replacedAll = str.replaceAll("o", "*");
    console.log(replacedAll); // Output: Hell*, w*rld!
    
    // Check if a string matches a regular expression
    let matchesRegex = str.match(/Hello/g);
    console.log(matchesRegex); // Output: ['Hello']
    
    // Remove leading and trailing whitespace
    let trimmedWhitespace = str.trim();
    console.log(trimmedWhitespace); // Output: Hello, world!
    
    let str = "Hello, world!";
    
    // Convert the first character to uppercase
    let capitalized = str.charAt(0).toUpperCase() + str.slice(1);
    console.log(capitalized); // Output: Hello, world!
    
    // Check if a string contains only alphabetic characters
    let isAlpha = /^[a-zA-Z]+$/.test(str);
    console.log(isAlpha); // Output: false
    
    // Extract a substring between two indices
    let substringBetweenIndices = str.substring(7, 12);
    console.log(substringBetweenIndices); // Output: world
    
    // Check if a string is a valid email address
    let isValidEmail = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
    console.log(isValidEmail); // Output: false
    
    // Convert a string to an array of characters using Array.from
    let charactersArray = Array.from(str);
    console.log(charactersArray); // Output:
     ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']
    
    // Remove a specific substring from a string
    let removedSubstring = str.replace("Hello, ", "");
    console.log(removedSubstring); // Output: world!
    
    // Convert a string to title case
    let titleCase = str.replace(/\w\S*/g, function (text) {
      return text.charAt(0).toUpperCase() + text.substr(1).toLowerCase();
    });
    console.log(titleCase); // Output: Hello, World!
    
    // Split a string into an array of words and count the number of words
    let wordsArray = str.split(" ");
    let wordCount = wordsArray.length;
    console.log(wordCount); // Output: 2
    
    // Reverse the words in a string
    let reversedWords = wordsArray.reverse().join(" ");
    console.log(reversedWords); // Output: world! Hello,
    
    // Convert a string to a slug (lowercase, hyphen-separated words)
    let slug = str.toLowerCase().replace(/\s+/g, "-");
    console.log(slug); // Output: hello,-world!
    
    let str = "Hello, world!";
    
    // Convert a string to an array of words and capitalize each word
    let capitalizedWords = str
      .split(" ")
      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
      .join(" ");
    console.log(capitalizedWords); // Output: Hello, World!
    
    // Check if a string contains only numeric characters
    let isNumeric = /^[0-9]+$/.test(str);
    console.log(isNumeric); // Output: false
    
    // Count the occurrences of a substring in a string
    let substringCount = str.split("o").length - 1;
    console.log(substringCount); // Output: 2
    
    // Remove leading whitespace from a string
    let trimmedLeft = str.trimStart();
    console.log(trimmedLeft); // Output: Hello, world!
    
    // Remove trailing whitespace from a string
    let trimmedRight = str.trimEnd();
    console.log(trimmedRight); // Output: Hello, world!
    
    // Repeat a string with a separator in between
    let repeatedWithSeparator = str.repeat(3).split("").join("-");
    console.log(repeatedWithSeparator); // 
    Output: H-e-l-l-o-,- -w-o-r-l-d-!-H-e-l-l-o-,
    - -w-o-r-l-d-!-H-e-l-l-o-,- -w-o-r-l-d-!
    
    // Check if a string is a valid URL
    let isValidURL = /^(http|https):\/\/([\w.]+\/?)\S*$/.test(str);
    console.log(isValidURL); // Output: false
    
    // Replace multiple substrings using a map of replacements
    let replacements = new Map([
      ["Hello", "Hola"],
      ["world", "mundo"],
    ]);
    let replacedMultiple = str.replace(/Hello|world/g, (match) =>
      replacements.get(match)
    );
    console.log(replacedMultiple); // Output: Hola, mundo!
    
    // Split a string into an array of lines
    let linesArray = str.split(/\r?\n/);
    console.log(linesArray); // Output: ['Hello, world!']
    
    // Convert a string to kebab case (lowercase, hyphen-separated words)
    let kebabCase = str.toLowerCase().replace(/\s+/g, "-");
    console.log(kebabCase); // Output: hello,-world-
    
    let str = "Hello, world!";
    
    // Convert a string to camel case
    let camelCase = str
      .replace(/(?:^\w|[A-Z]|\b\w)/g, (letter, index) => {
        return index === 0 ? letter.toLowerCase() : letter.toUpperCase();
      })
      .replace(/\s+/g, "");
    console.log(camelCase); // Output: helloWorld!
    
    // Check if a string is a valid date in the format "YYYY-MM-DD"
    let isValidDate = /^\d{4}-\d{2}-\d{2}$/.test(str);
    console.log(isValidDate); // Output: false
    
    // Get the Unicode value of a character at a specific index (codePointAt)
    let unicodeValue = str.codePointAt(4);
    console.log(unicodeValue); // Output: 111
    
    // Repeat a string a certain number of times with a separator in between
    let repeatedWithSeparator = str.repeat(3).split("").join("-");
    console.log(repeatedWithSeparator); // 
    Output: H-e-l-l-o-,- -w-o-r-l-d-!-H-e-l-l-o-,
    - -w-o-r-l-d-!-H-e-l-l-o-,- -w-o-r-l-d-!
    
    // Check if a string contains only alphanumeric characters
    let isAlphanumeric = /^[a-zA-Z0-9]+$/.test(str);
    console.log(isAlphanumeric); // Output: false
    
    // Remove all occurrences of a substring from a string
    let removedAll = str.replace(/o/g, "");
    console.log(removedAll); // Output: Hell, wrld!
    
    // Convert a string to an array of characters using spread operator
    let charactersArray = [...str];
    console.log(charactersArray); // Output:
     ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!']
    
    // Check if a string contains only whitespace characters
    let isWhitespace = /^\s+$/.test(str);
    console.log(isWhitespace); // Output: false
    
    // Check if a string is a valid JSON
    let isValidJSON = (str) => {
      try {
        JSON.parse(str);
        return true;
      } catch (error) {
        return false;
      }
    };
    console.log(isValidJSON(str)); // Output: false
    
    // ------------- number methods-----------
    let num = 42;
    
    // Convert a number to a string
    let numToString = num.toString();
    console.log(numToString); // Output: "42"
    
    // Convert a string to a number
    let stringToNum = parseInt("42");
    console.log(stringToNum); // Output: 42
    
    // Get the number of decimal places
    let decimalPlaces = num.toString().split(".")[1]?.length || 0;
    console.log(decimalPlaces); // Output: 0
    
    // Round a number to a specified number of decimal places
    let rounded = num.toFixed(2);
    console.log(rounded); // Output: "42.00"
    
    // Convert a number to exponential notation
    let exponential = num.toExponential(2);
    console.log(exponential); // Output: "4.20e+1"
    
    // Check if a number is an integer
    let isInteger = Number.isInteger(num);
    console.log(isInteger); // Output: true
    
    // Get the absolute value of a number
    let absoluteValue = Math.abs(num);
    console.log(absoluteValue); // Output: 42
    
    // Check if a number is NaN (Not a Number)
    let isNan = Number.isNaN(num);
    console.log(isNan); // Output: false
    
    // Get the maximum value among a list of numbers
    let max = Math.max(10, 20, 30, 40, 50);
    console.log(max); // Output: 50
    
    // Get the minimum value among a list of numbers
    let min = Math.min(10, 20, 30, 40, 50);
    console.log(min); // Output: 10
    
    // Generate a random number between a specified range
    let random = Math.random() * (10 - 5) + 5;
    console.log(random); // Output: a random number between 5 and 10
    
    // Check if a number is finite
    let isFiniteNum = isFinite(num);
    console.log(isFiniteNum); // Output: true
    
    let num = 42;
    
    // Check if a number is positive infinity
    let isPositiveInfinity =
      Number.isFinite(num) && num === Number.POSITIVE_INFINITY;
    console.log(isPositiveInfinity); // Output: false
    
    // Check if a number is negative infinity
    let isNegativeInfinity =
      Number.isFinite(num) && num === Number.NEGATIVE_INFINITY;
    console.log(isNegativeInfinity); // Output: false
    
    // Check if a number is a safe integer
    let isSafeInteger = Number.isSafeInteger(num);
    console.log(isSafeInteger); // Output: true
    
    // Convert a number to a fixed number of digits
    let fixedDigits = num.toFixed(5);
    console.log(fixedDigits); // Output: "42.00000"
    
    // Get the square root of a number
    let squareRoot = Math.sqrt(num);
    console.log(squareRoot); // Output: 6.48074069840786
    
    // Get the cube root of a number
    let cubeRoot = Math.cbrt(num);
    console.log(cubeRoot); // Output: 3.476026644159999
    
    // Get the value of a number rounded to the nearest integer
    let roundedNearestInt = Math.round(num);
    console.log(roundedNearestInt); // Output: 42
    
    // Get the value of a number rounded up to the nearest integer
    let roundedUp = Math.ceil(num);
    console.log(roundedUp); // Output: 42
    
    // Get the value of a number rounded down to the nearest integer
    let roundedDown = Math.floor(num);
    console.log(roundedDown); // Output: 42
    
    // Get the value of a number raised to a power
    let power = Math.pow(num, 2);
    console.log(power); // Output: 1764
    
    // Generate a random integer between a specified range
    let randomInteger = Math.floor(Math.random() * (10 - 5 + 1)) + 5;
    console.log(randomInteger); // Output: a random integer between 5 and 10
    
    // Check if a number is divisible by another number
    let isDivisibleBy = num % 5 === 0;
    console.log(isDivisibleBy); // Output: true
    
    let num = 42;
    
    // Get the value of a number rounded to a specified number of decimal places
    let roundedDecimal = parseFloat(num.toFixed(3));
    console.log(roundedDecimal); // Output: 42.000
    
    // Get the value of a number as a binary string
    let binaryString = num.toString(2);
    console.log(binaryString); // Output: "101010"
    
    // Get the value of a number as an octal string
    let octalString = num.toString(8);
    console.log(octalString); // Output: "52"
    
    // Get the value of a number as a hexadecimal string
    let hexString = num.toString(16);
    console.log(hexString); // Output: "2a"
    
    // Get the value of a number as a percentage string
    let percentageString = (num * 100).toFixed(2) + "%";
    console.log(percentageString); // Output: "4200.00%"
    
    // Check if a number is within a specific range
    let isInRange = num >= 0 && num <= 100;
    console.log(isInRange); // Output: true
    
    // Get the absolute difference between two numbers
    let diff = Math.abs(10 - 20);
    console.log(diff); // Output: 10
    
    // Get the smallest integer greater than or equal to a number
    let ceil = Math.ceil(num);
    console.log(ceil); // Output: 42
    
    // Get the largest integer less than or equal to a number
    let floor = Math.floor(num);
    console.log(floor); // Output: 42
    
    // Convert degrees to radians
    let degrees = 90;
    let radians = (degrees * Math.PI) / 180;
    console.log(radians); // Output: 1.5707963267948966
    
    // Get the maximum value among an array of numbers
    let max = Math.max(10, 20, 30, 40, 50);
    console.log(max); // Output: 50
    
    // Get the minimum value among an array of numbers
    let min = Math.min(10, 20, 30, 40, 50);
    console.log(min); // Output: 10
    
    // Calculate the sum of an array of numbers
    let sum = [1, 2, 3, 4, 5].reduce((acc, val) => acc + val, 0);
    console.log(sum); // Output: 15
    
    // Calculate the average of an array of numbers
    let average = sum / [1, 2, 3, 4, 5].length;
    console.log(average); // Output: 3
    
    let num = 42;
    
    // Check if a number is divisible by another number
    let isDivisibleBy = num % 5 === 0;
    console.log(isDivisibleBy); // Output: true
    
    // Get the value of a number rounded to the nearest multiple of another number
    let nearestMultiple = Math.round(num / 10) * 10;
    console.log(nearestMultiple); // Output: 40
    
    // Convert a number to a string with a specific base (radix)
    let binaryString = num.toString(2);
    console.log(binaryString); // Output: "101010"
    
    // Get the number of digits in a number
    let numDigits = Math.floor(Math.log10(Math.abs(num))) + 1;
    console.log(numDigits); // Output: 2
    
    // Check if a number is a prime number
    let isPrime = isPrimeNumber(num);
    console.log(isPrime); // Output: true
    
    function isPrimeNumber(number) {
      if (number < 2) {
        return false;
      }
      for (let i = 2; i <= Math.sqrt(number); i++) {
        if (number % i === 0) {
          return false;
        }
      }
      return true;
    }
    
    // Get the factorial of a number
    let factorial = getFactorial(num);
    console.log(factorial); // Output: 
    1405006117752879898543142606244511569936384000000000
    
    function getFactorial(number) {
      if (number === 0 || number === 1) {
        return 1;
      }
      let result = 1;
      for (let i = 2; i <= number; i++) {
        result *= i;
      }
      return result;
    }
    
    // Convert degrees to radians
    let degrees = 90;
    let radians = degrees * (Math.PI / 180);
    console.log(radians); // Output: 1.5707963267948966
    
    // Calculate the power of a number
    let power = Math.pow(num, 3);
    console.log(power); // Output: 74088
    
    // Check if a number is within a specific range
    let isInRange = num >= 0 && num <= 100;
    console.log(isInRange); // Output: true
    
    // Calculate the sum of an array of numbers using reduce
    let sum = [1, 2, 3, 4, 5].reduce((acc, val) => acc + val, 0);
    console.log(sum); // Output: 15
    
    // Calculate the average of an array of numbers
    let average = sum / [1, 2, 3, 4, 5].length;
    console.log(average); // Output: 3
    
    // -------------Boolean-------------
    let bool = true;
    
    // Convert a value to a Boolean
    let convertedBool = Boolean(0);
    console.log(convertedBool); // Output: false
    
    // Negate a Boolean value
    let negatedBool = !bool;
    console.log(negatedBool); // Output: false
    
    // Check if a value is truthy (not false, 0, '', null, undefined, NaN)
    let isTruthy = !!0;
    console.log(isTruthy); // Output: false
    
    // Check if a value is falsy (false, 0, '', null, undefined, NaN)
    let isFalsy = !"";
    console.log(isFalsy); // Output: true
    
    // Perform logical AND operation
    let resultAnd = true && false;
    console.log(resultAnd); // Output: false
    
    // Perform logical OR operation
    let resultOr = true || false;
    console.log(resultOr); // Output: true
    
    // Perform logical NOT operation
    let resultNot = !true;
    console.log(resultNot); // Output: false
    
    // Check if a value is equal to another value (strict equality)
    let isEqual = 5 === 5;
    console.log(isEqual); // Output: true
    
    // Check if a value is not equal to another value (strict inequality)
    let isNotEqual = 5 !== 10;
    console.log(isNotEqual); // Output: true
    
    let bool = true;
    
    // Check if a value is equal to another value (loose equality)
    let isEqualLoose = "5" == 5;
    console.log(isEqualLoose); // Output: true
    
    // Check if a value is not equal to another value (loose inequality)
    let isNotEqualLoose = "5" != 10;
    console.log(isNotEqualLoose); // Output: true
    
    // Check if a value is greater than another value
    let isGreater = 10 > 5;
    console.log(isGreater); // Output: true
    
    // Check if a value is less than another value
    let isLess = 5 < 10;
    console.log(isLess); // Output: true
    
    // Check if a value is greater than or equal to another value
    let isGreaterOrEqual = 10 >= 10;
    console.log(isGreaterOrEqual); // Output: true
    
    // Check if a value is less than or equal to another value
    let isLessOrEqual = 5 <= 10;
    console.log(isLessOrEqual); // Output: true
    
    // Perform logical XOR (exclusive OR) operation
    let resultXor = true ^ false;
    console.log(resultXor); // Output: true
    
    // Perform logical NAND operation
    let resultNand = !(true && true);
    console.log(resultNand); // Output: false
    
    // Perform logical NOR operation
    let resultNor = !(true || true);
    console.log(resultNor); // Output: false
    
    // Check if a value is an instance of a specific type or class
    let isInstanceOf = "Hello" instanceof String;
    console.log(isInstanceOf); // Output: false
    
    let bool = true;
    
    // Check if a value is strictly greater than another value
    let isStrictlyGreater = 10 > 5;
    console.log(isStrictlyGreater); // Output: true
    
    // Check if a value is strictly less than another value
    let isStrictlyLess = 5 < 10;
    console.log(isStrictlyLess); // Output: true
    
    // Check if a value is strictly greater than or equal to another value
    let isStrictlyGreaterOrEqual = 10 >= 10;
    console.log(isStrictlyGreaterOrEqual); // Output: true
    
    // Check if a value is strictly less than or equal to another value
    let isStrictlyLessOrEqual = 5 <= 10;
    console.log(isStrictlyLessOrEqual); // Output: true
    
    // Check if a value is truthy using double negation
    let isTruthy = !!"Hello";
    console.log(isTruthy); // Output: true
    
    // Check if a value is falsy using double negation
    let isFalsy = !!null;
    console.log(isFalsy); // Output: false
    
    // Check if all values in an array are truthy
    let areAllTruthy = [true, 1, "Hello"].every(Boolean);
    console.log(areAllTruthy); // Output: true
    
    // Check if any value in an array is truthy
    let isAnyTruthy = [false, 0, "Hello"].some(Boolean);
    console.log(isAnyTruthy); // Output: true
    
    // Check if a value is NaN (Not a Number)
    let isNaNValue = isNaN("Hello");
    console.log(isNaNValue); // Output: true
    
    // Check if a value is finite (not NaN, Infinity, or -Infinity)
    let isFiniteValue = isFinite(42);
    console.log(isFiniteValue); // Output: true
    
    // -------------Objects-------------
    let person = {
      name: "John",
      age: 30,
      occupation: "Developer",
    };
    
    // Get the keys of an object
    let keys = Object.keys(person);
    console.log(keys); // Output: ["name", "age", "occupation"]
    
    // Get the values of an object
    let values = Object.values(person);
    console.log(values); // Output: ["John", 30, "Developer"]
    
    // Get the entries of an object
    let entries = Object.entries(person);
    console.log(entries);
    // Output: [["name", "John"], ["age", 30], ["occupation", "Developer"]]
    
    // Check if an object has a specific property
    let hasProperty = person.hasOwnProperty("age");
    console.log(hasProperty); // Output: true
    
    // Merge two or more objects into a new object
    let otherInfo = {
      gender: "Male",
      city: "New York",
    };
    
    let mergedObject = { ...person, ...otherInfo };
    console.log(mergedObject);
    // Output: { name: "John", age: 30, occupation: 
    "Developer", gender: "Male", city: "New York" }
    
    // Clone an object (shallow copy)
    let clonedObject = { ...person };
    console.log(clonedObject === person); // Output: false
    
    // Access a property value using a dynamic key
    let propertyName = "age";
    let propertyValue = person[propertyName];
    console.log(propertyValue); // Output: 30
    
    // Delete a property from an object
    delete person.occupation;
    console.log(person); // Output: { name: "John", age: 30 }
    
    // Check if an object is empty
    let isEmpty = Object.keys(person).length === 0;
    console.log(isEmpty); // Output: false
    
    // Get the number of properties in an object
    let numProperties = Object.keys(person).length;
    console.log(numProperties); // Output: 2
    
    let person = {
      name: "John",
      age: 30,
      occupation: "Developer",
    };
    
    // Check if an object has a specific value
    let hasValue = Object.values(person).includes("Developer");
    console.log(hasValue); // Output: true
    
    // Check if an object is an instance of a specific type or class
    let isInstanceOf = person instanceof Object;
    console.log(isInstanceOf); // Output: true
    
    // Get a shallow copy of an object with selected properties
    let selectedProperties = ["name", "age"];
    let selectedObject = Object.fromEntries(
      Object.entries(person).filter(([key]) => selectedProperties.includes(key))
    );
    console.log(selectedObject); // Output: { name: "John", age: 30 }
    
    // Determine if two objects have the same property values
    let otherPerson = {
      name: "John",
      age: 30,
      occupation: "Developer",
    };
    
    let hasSameValues = JSON.stringify(person) === JSON.stringify(otherPerson);
    console.log(hasSameValues); // Output: true
    
    // Get the prototype of an object
    let prototype = Object.getPrototypeOf(person);
    console.log(prototype); // Output: {}
    
    // Set the prototype of an object
    let newPrototype = { country: "USA" };
    Object.setPrototypeOf(person, newPrototype);
    console.log(person); // Output: { name: "John", age: 30, occupation: "Developer" }
    
    // Iterate over the properties of an object
    for (let key in person) {
      console.log(`${key}: ${person[key]}`);
    }
    // Output:
    // name: John
    // age: 30
    // occupation: Developer
    let person = {
      name: "John",
      age: 30,
      occupation: "Developer",
    };
    
    // Check if an object has a specific property, including inherited properties
    let hasProperty = "name" in person;
    console.log(hasProperty); // Output: true
    
    // Get the descriptor of a property in an object
    let propertyDescriptor = Object.getOwnPropertyDescriptor(person, "name");
    console.log(propertyDescriptor);
    // Output: { value: "John", writable: true, enumerable: true, configurable: true }
    
    // Define or modify a property descriptor of an object
    Object.defineProperty(person, "name", {
      value: "Jane",
      writable: false,
      enumerable: false,
      configurable: false,
    });
    console.log(person.name); // Output: "Jane"
    
    // Get the prototype of an object
    let prototype = Object.getPrototypeOf(person);
    console.log(prototype); // Output: {}
    
    // Set the prototype of an object
    let newPrototype = { country: "USA" };
    Object.setPrototypeOf(person, newPrototype);
    console.log(person); // Output: { name: "Jane", age: 30, occupation: "Developer" }
    
    // Get all property names of an object, including inherited properties
    let allProperties = [];
    let currentObject = person;
    while (currentObject !== null) {
      allProperties.push(...Object.getOwnPropertyNames(currentObject));
      currentObject = Object.getPrototypeOf(currentObject);
    }
    console.log(allProperties); // Output: ["name", "age", "occupation", "country"]
    
    // Freeze an object to make it immutable
    Object.freeze(person);
    person.name = "Bob";
    console.log(person.name); // Output: "Jane"
    
    // Seal an object to prevent adding or deleting properties,
     but allow modifying existing ones
    Object.seal(person);
    delete person.age;
    console.log(person.age); // Output: 30
    
    // Prevent extensions of an object, disallowing adding new properties
    Object.preventExtensions(person);
    person.gender = "Male";
    console.log(person.gender); // Output: undefined
    //   ------------ Array----------
    // push: Adds one or more elements to the end of an array.
    // pop: Removes the last element from an array and returns it.
    // shift: Removes the first element from an array and returns it.
    // unshift: Adds one or more elements to the beginning of an array.
    // concat: Combines two or more arrays and returns a new array.
    // slice: Extracts a portion of an array into a new array.
    // splice: Changes the contents of an array by removing, replacing, or adding elements.
    // indexOf: Returns the first index at which a specified element is found in an array.
    // lastIndexOf: Returns the last index at which a specified element is found in an array.
    // includes: Determines whether an array includes a certain element, returning true or false.
    // join: Joins all elements of an array into a string.
    // reverse: Reverses the order of the elements in an array.
    // sort: Sorts the elements of an array in place.
    // filter: Creates a new array with all elements that pass a test.
    // map: Creates a new array by applying a function to each element of an existing array.
    // reduce: Applies a function to reduce the elements of an array to a single value.
    // forEach: Executes a provided function once for each array element.
    // some: Tests whether at least one element in the array passes a test.
    // every: Tests whether all elements in the array pass a test.
    // find: Returns the first element in the array that satisfies a provided testing function.
    // findIndex: Returns the index of the first element in the array that satisfies a provided testing function.
    // fill: Fills all or a portion of an array with a static value.
    // isArray: Determines whether the passed value is an array.
    // length: Property that returns the number of elements in an array.
    let numbers = [1, 2, 3, 4, 5];
    
    // push: Adds an element to the end of the array
    numbers.push(6);
    console.log(numbers); // Output: [1, 2, 3, 4, 5, 6]
    
    // pop: Removes the last element from the array
    let poppedElement = numbers.pop();
    console.log(poppedElement); // Output: 6
    console.log(numbers); // Output: [1, 2, 3, 4, 5]
    
    // shift: Removes the first element from the array
    let shiftedElement = numbers.shift();
    console.log(shiftedElement); // Output: 1
    console.log(numbers); // Output: [2, 3, 4, 5]
    
    // unshift: Adds an element to the beginning of the array
    numbers.unshift(0);
    console.log(numbers); // Output: [0, 2, 3, 4, 5]
    
    // concat: Combines two arrays
    let otherNumbers = [6, 7, 8];
    let combinedArray = numbers.concat(otherNumbers);
    console.log(combinedArray); // Output: [0, 2, 3, 4, 5, 6, 7, 8]
    
    // slice: Extracts a portion of an array
    let slicedArray = combinedArray.slice(2, 5);
    console.log(slicedArray); // Output: [3, 4, 5]
    
    // splice: Changes the contents of an array
    let splicedArray = combinedArray.splice(2, 3, "a", "b", "c");
    console.log(splicedArray); // Output: [3, 4, 5]
    console.log(combinedArray); // Output: [0, 2, "a", "b", "c", 6, 7, 8]
    
    // indexOf: Returns the index of an element in the array
    let index = combinedArray.indexOf("c");
    console.log(index); // Output: 4
    
    // lastIndexOf: Returns the last index of an element in the array
    let lastIndex = combinedArray.lastIndexOf("c");
    console.log(lastIndex); // Output: 4
    
    // includes: Checks if an element exists in the array
    let includesElement = combinedArray.includes(6);
    console.log(includesElement); // Output: true
    
    // join: Joins array elements into a string
    let joinedString = combinedArray.join("-");
    console.log(joinedString); // Output: "0-2-a-b-c-6-7-8"
    
    // reverse: Reverses the order of elements in the array
    combinedArray.reverse();
    console.log(combinedArray); // Output: [8, 7, 6, "c", "b", "a", 2, 0]
    
    // sort: Sorts the array elements
    combinedArray.sort();
    console.log(combinedArray); // Output: [0, 2, 6, 7, 8, "a", "b", "c"]
    
    // filter: Creates a new array with filtered elements
    let filteredArray = combinedArray.filter(
      (element) => typeof element === "number"
    );
    console.log(filteredArray); // Output: [0, 2, 6, 7, 8]
    
    // map: Creates a new array by performing a function on each element
    let mappedArray = combinedArray.map((element) => element * 2);
    console.log(mappedArray); // Output: [0, 4, 12, 14, 16, NaN, NaN, NaN]
    
    // reduce: Applies a function to reduce
    
    let numbers = [1, 2, 3, 4, 5];
    
    // forEach: Executes a provided function for each array element
    numbers.forEach((element) => {
      console.log(element);
    });
    // Output:
    // 1
    // 2
    // 3
    // 4
    // 5
    
    // some: Checks if at least one element satisfies a condition
    let hasEvenNumber = numbers.some((element) => element % 2 === 0);
    console.log(hasEvenNumber); // Output: true
    
    // every: Checks if all elements satisfy a condition
    let allEvenNumbers = numbers.every((element) => element % 2 === 0);
    console.log(allEvenNumbers); // Output: false
    
    // find: Returns the first element that satisfies a condition
    let foundElement = numbers.find((element) => element > 3);
    console.log(foundElement); // Output: 4
    
    // findIndex: Returns the index of the first element that satisfies a condition
    let foundIndex = numbers.findIndex((element) => element > 3);
    console.log(foundIndex); // Output: 3
    
    // fill: Fills the array with a static value
    numbers.fill(0);
    console.log(numbers); // Output: [0, 0, 0, 0, 0]
    
    // isArray: Checks if a value is an array
    let isArray = Array.isArray(numbers);
    console.log(isArray); // Output: true
    
    // length: Property that returns the number of elements in the array
    let length = numbers.length;
    console.log(length); // Output: 5
    
    let numbers = [1, 2, 3, 4, 5];
    
    // reduce: Applies a function to reduce the elements of an array to a single value
    let sum = numbers.reduce(
      (accumulator, currentValue) => accumulator + currentValue
    );
    console.log(sum); // Output: 15
    
    // flat: Creates a new array with all sub-array elements concatenated recursively
    let nestedArray = [1, [2, [3, [4, [5]]]]];
    let flattenedArray = nestedArray.flat(Infinity);
    console.log(flattenedArray); // Output: [1, 2, 3, 4, 5]
    
    // flatMap: Maps each element and flattens the result into a new array
    let mappedAndFlattenedArray = numbers.flatMap((element) => [element * 2]);
    console.log(mappedAndFlattenedArray); // Output: [2, 4, 6, 8, 10]
    
    // from: Creates a new array from an array-like or iterable object
    let arrayLikeObject = "Hello";
    let newArray = Array.from(arrayLikeObject);
    console.log(newArray); // Output: ["H", "e", "l", "l", "o"]
    
    // reverse: Reverses the order of elements in the array
    numbers.reverse();
    console.log(numbers); // Output: [5, 4, 3, 2, 1]
    
    // sort: Sorts the array elements
    numbers.sort();
    console.log(numbers); // Output: [1, 2, 3, 4, 5]
    
    // slice: Extracts a portion of an array into a new array
    let slicedArray = numbers.slice(2, 4);
    console.log(slicedArray); // Output: [3, 4]
    
    // filter: Creates a new array with all elements that pass a test
    let filteredArray = numbers.filter((element) => element % 2 === 0);
    console.log(filteredArray); // Output: [2, 4]
    
    // map: Creates a new array by applying a function to each element
    let mappedArray = numbers.map((element) => element * 2);
    console.log(mappedArray); // Output: [2, 4, 6, 8, 10]
    
    // find: Returns the first element that satisfies a condition
    let foundElement = numbers.find((element) => element > 3);
    console.log(foundElement); // Output: 4
    
    // includes: Determines whether an array includes a certain element
    let includesElement = numbers.includes(3);
    console.log(includesElement); // Output: true
    
    // indexOf: Returns the first index at which a specified element is found
    let index = numbers.indexOf(2);
    console.log(index); // Output: 1
    
    // lastIndexOf: Returns the last index at which a specified element is found
    let lastIndex = numbers.lastIndexOf(2);
    console.log(lastIndex); // Output: 1
    
    let numbers = [1, 2, 3, 4, 5];
    
    // every: Checks if all elements satisfy a condition
    let allGreaterThanZero = numbers.every((element) => element > 0);
    console.log(allGreaterThanZero); // Output: true
    
    // some: Checks if at least one element satisfies a condition
    let someGreaterThanThree = numbers.some((element) => element > 3);
    console.log(someGreaterThanThree); // Output: true
    
    // findIndex: Returns the index of the first element that satisfies a condition
    let index = numbers.findIndex((element) => element === 3);
    console.log(index); // Output: 2
    
    // fill: Fills the array with a static value from a start index to an end index
    numbers.fill(0, 1, 3);
    console.log(numbers); // Output: [1, 0, 0, 4, 5]
    
    // join: Joins all elements of an array into a string
    let joinedString = numbers.join("-");
    console.log(joinedString); // Output: "1-0-0-4-5"
    
    // reverse: Reverses the order of elements in the array
    numbers.reverse();
    console.log(numbers); // Output: [5, 4, 0, 0, 1]
    
    // sort: Sorts the array elements
    numbers.sort();
    console.log(numbers); // Output: [0, 0, 1, 4, 5]
    
    // isArray: Checks if a value is an array
    let isArray = Array.isArray(numbers);
    console.log(isArray); // Output: true
    
    // length: Property that returns the number of elements in the array
    let length = numbers.length;
    console.log(length); // Output: 5

// Variables and Data Types
let myNumber = 42;
const myString = "Hello, World!";
var myVar = "Old way of declaring variables";

// Conditional Statements
if (myNumber === 42) {
console.log("It's the answer to the Ultimate Question of Life,
 the Universe, and Everything.");
} else {
console.log("It's not the answer.");
}

// Loops
for (let i = 0; i < 5; i++) {
console.log("Loop iteration: " + i);
}

// Arrays
const myArray = [1, 2, 3, 4, 5];

// Functions
function add(a, b) {
return a + b;
}

// Objects
const myObject = {
name: "John",
age: 30,
sayHello: function() {
console.log("Hello, " + this.name);
}
};

// Classes (ES6)
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}

sayHello() {
console.log("Hello, " + this.name);
}
}

// Promises (Async/Await)
async function fetchData() {
try {
const response = await fetch('https://api.example.com/data');
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}
}

// Modules (ES6)
import {
myFunction
} from './myModule.js';

// Event Handling
document.getElementById("myButton").addEventListener("click", function() {
console.log("Button clicked!");
});

// Try-Catch for Error Handling
try {
// Code that might throw an error
} catch (error) {
console.error(error);
}

// Callbacks
function doSomething(callback) {
// Perform some task
callback();
}

doSomething(function() {
console.log("Callback executed!");
});

// And more...

// This example covers many JavaScript structures,
 but there are more advanced concepts and libraries to explore 
 based on your specific needs.

/* -----------------TABLE-------------- */

let info1 = [
["ABC"],
["Front-end dev"],
["JavaScript"]
];

console.table(info1);
/* -----------------TABLE END-------------- */

/* -----------------DIR-------------- */
let info2 = {
"name": "ABC",
"designation": "Frontend Engineer",
"social": "@javascript.js"
}

console.dir(info2)
/* -----------------DIR END-------------- */

/* -----------------COUNT-------------- */
console.count("Hey")
console.count("Hey")
console.count("Hey")
console.count("Hey")
/* -----------------COUNT END-------------- */

/* -----------------TIME-------------- */
console.time("Time")
let l = 0;
for (let i = 0; i < 5; i++) {
l += i
}
console.log("total", l);
console.timeEnd("Time")
/* -----------------TIME END-------------- */

    const today = new Date() //today 2020-08-09T61:40:51.0172
    today.getDate() // 9
    today.getDay() // 0 sunday
    today.getMonth() // 7 (0 is jan)
    today.getFullYear() // 2020 
    today.getYear() // 120 ?
    today.getHours() // 11
    today.getMinutes() // 40
    today.getSeconds() //51
    today.getMilliseconds() // 24
    today.getTime() // 1596937251025
    today.getTimezoneOffset() // -600
    today.getUTCDate() // 9
    today.getUTCDay() // 8 
    today.getUTCMonth() // 7
    today.getUTCFullYear() // 2020
    today.getUTCHours() // 1
    today.getUTCMinutes() // 40
    today.getUTCSeconds() // 51
    today.getUTCMilliseconds() // 31
    today.setDate(5)
    today.setMonth(5)
    today.setFullYear(2022)
    today.setYear(100)
    today.setHours(12)
    today.setMinutes(5)
    today.setSeconds(8)
    today.setMilliseconds(45)
    today.setTime(34)
    today.setUTCDate(11)
    today.setUTCMonth(5)
    today.setUTCFullYear(2022)
    today.setUTCHours(5)
    today.setUTCMinutes(10)
    today.setUTCSeconds(24)
    today.setUTCMilliseconds(22)
    const today = new Date();
    today.toString() // Sun Aug 09 2020 16: 44: 29 GMT + 1000
     (Australian Eastern Standard Time)
    today.toLocaleString() // 09/08/2020, 16:44:29"
    today.toGMTString() // Sun, 09 Aug 2020 06: 44: 29 GMT
    today.toUTCString() // Sun, 69 Aug 2020 06: 44: 29 GMT
    Date.parse('9 Aug 2020') // 1596895200800
    //reurns number milliseconds since January 1, 1970 Returns NaN if invalid
    let utcDate = new Date(Date.UTC(2028, 7, 9, 0, 0, 0));
    utcDate // 2020-88-09T00:00:00.000Z
    utcDate.valueOf() // 1596895200000 (same as parse)

    

    "abc".match(/./) // .  => any char
    "abc".match(/b/) // b => must be present
    "abc".match(/ab/) // ab => must be present
    "abc".match(/a|z/) //alz=> a or z must be present
    "abc".match(/z/) // z* => 0 or more times
    "abc".match(/z+/) //  z+ =>  1 or more times
    "abc".match(/z?/) // z? => 0 or 1 times
    "abc".match(/(ab)/) // 11 => group, ab should present
    "zta".match(/[ab-e]/) // match any char a, b, c, d, e
    "ztf".match(/[^ab-e]/) // NOT any char a, b, c, d, e
    "ab5".match(/\d/) // d => one digit
    "ab5".match(/\D/) // D=> one non-digit
    "355".match(/\D/) // fail bcoz all are digits
    "ab c".match(/\s/)  // \s => one whitespace
    "ab c".match(/\S/) // \S => one non-whitespace
    "".match(/\S/) // fail bcoz only whitespace
    "abcd" .match(/\w/) // \w one word char
    "ab cd".match(/\w/) // \w non word char fine
    "abcd" .match(/\W/) // \W=> fail not a non-word char
    "ab cd".match(/\W/) // \W=> pass one non-word char (" ")
    "abc".match(/^a/)  // ^ => start of string
    "abc".match(/c$/)  // $ => end of string
    ()  // =>  group with parenthesis
    \t  // =>  tab
    \n  // => line breaks
    \r  // => CR
    \0 // =>  null character
    a{5}  // => match a for 5 occurences
    a{3,5}  // => match a for min 2 & max 5 times
    a{3,} // => match a for min 3 & more times
    // REGEX flag
    g   // => global match
    i  // => ignore cases

    5 == 5 //true
    5 == '5' //true
    5 === 5 //true
    5 === '5'//false
    ---------------------------
    5 != 5 //false
    5 != '5' //false
    5 !== 5 //false
    5 !== '5'//true
    --------------------------
    2 + 2  // 4
    4-2 // 2
    2* 3 // 6
    4 / 2 // 2
    -------------------------
    let a = 10; log(++a, a); // 11 11
    let b = 10; log(b++, b); // 10 11 
    let c = 10; log(--c, c); // 9 9
    let d = 10; log(d--, d); // 10 9
    let a = 20; a += 5; // a = 25
    let b = 20; b -= 5; // b = 15 
    let c = 20; c *= 5; // c=100 
    let d = 20; d / 5; // d = 4
    let e = 20; e %= 5; // e = 0
    (5 === 5) ? 'a' : 'b' // a
    3 > 2 && 1 < 2 // true
    3 > 2 | 5 < 2 // true
    !true // false
    3 > 3 // false
    3 < 3 // false
    3 >= 3 // true
    3 <= 3 // true
    5 % 2 // 1

    //single element defined by id
    const app = document.getElementById('app')
    //multiple elements (arrays) defined by class name
    const hero = document.getElementsByClassName('hero')
    //multiple elements based on html tag
    const h1 = document.getElementsByTagName('h1')
    //first element based on selector
    const hero = document.querySelector(".hero")
    //multiple elements based on selector
    const heroes = document.querySelectorAll(".hero")
    h1.insertAdjacentHTML ("beforebegin", "cool")
    app.classList.remove('dark')
    //remove class
    // beforebegin => placed before hi as a sibling
    // afterbegin => placed inside h1 as a first child
    // beforeend >> placed inside h1 as a last child
    // afterend => placed after h1 as a sibling
    app.classList.remove('dark') // renove class
    app.classList.add('light') // add class
    app.classList.toggle("visible") // toggle class
    app.classList.contains('app') // true if app present
    app.childNodes // retrieve all child nodes
    app.parentNode // return parent
    //create html element of tag 
 
    let para = document.createElement('p')
    //create text node
    let text = document.createTextNode('Hello') // 
Hello
    //add text node to the para element
    para.appendChild(text)
    //insert h2 before h1
    app.insertBefore(h2, h1)
        

        Mouse Events
        click: //Triggered when a mouse click occurs.
        dblclick: //Triggered when a mouse double click occurs.
        mousedown: //Triggered when the mouse button is pressed down.
        mouseup: //Triggered when the mouse button is released.
        mousemove: //Triggered when the mouse pointer moves over an element.
        mouseover: //Triggered when the mouse pointer enters an element.
        mouseout: //Triggered when the mouse pointer leaves an element.
        mouseenter: //Similar to mouseover, but doesn't bubble.
        mouseleave: //Similar to mouseout, but doesn't bubble.
        contextmenu: //Triggered when the right mouse button is clicked.
        
        Keyboard Events:
        keydown: //Triggered when a key is pressed down.
        keyup: //Triggered when a key is released.
        keypress: //Triggered when a key is pressed and released 
        (not all keys trigger this event).
        
        Form Events:
        submit: //Triggered when a form is submitted.
        reset: //Triggered when a form is reset.
        input: //Triggered when the value of an input field changes.
        change: //Triggered when the value of a form element changes 
        (input, select, textarea).
        focus: //Triggered when an element receives focus.
        blur: //Triggered when an element loses focus.
        
        Window and Document Events:
        load: //Triggered when the page finishes loading.
        unload: //Triggered when the user leaves the page.
        resize: //Triggered when the window is resized.
        scroll: //Triggered when the user scrolls the page.
        DOMContentLoaded: //Triggered when the DOM is fully loaded, 
        even if other resources like images are still loading.
        
        Drag and Drop Events:
        dragstart: //Triggered when an element is dragged.
        dragend: //Triggered when the dragging operation is completed.
        dragenter: //Triggered when a dragged element enters a valid drop target.
        dragover: //Triggered when a dragged element is over a valid drop target.
        dragleave: //Triggered when a dragged element leaves a valid drop target.
        drop: //Triggered when a dragged element is dropped on a valid drop target.
        
        Media Events:
        play: //Triggered when media playback starts.
        pause: //Triggered when media playback is paused.
        ended: //Triggered when media playback finishes.
        
        Touch Events (for mobile devices):
        touchstart: //Triggered when a finger touches the screen.
        touchmove: //Triggered when a finger moves on the screen.
        touchend: //Triggered when a finger is lifted from the screen.
        Custom Events: //You can also create custom events using
         the CustomEvent constructor and dispatch them on DOM elements.

async function getCurrencies() {
    const response = await fetch(
        "https://asatryanhov.github.io/data_exchanges/"
    );
    const data = await response.json();
    
    return data;
    }
    
    getCurrencies()
    .then((data) => {
        const x = data;
        return x;
    })
    .then((x) => {
        console.log(x);
    });

    try {
        let num = 5 * 5;
      console.log("Script is working")
      } catch ({name,message}) {
        console.log(name); 
        console.log(message); 
      }
      

    // For Loop
for (let i = 0; i < 5; i++) {
  console.log("For Loop:", i);
}

// While Loop
let j = 0;
while (j < 5) {
  console.log("While Loop:", j);
  j++;
}

// Do-While Loop
let k = 0;
do {
  console.log("Do-While Loop:", k);
  k++;
} while (k < 5);

// For-In Loop (Object)
const person = { name: "John", age: 30 };
for (const key in person) {
  console.log("For-In Loop (Object):", key, person[key]);
}

// For-Of Loop (Array)
const colors = ["red", "green", "blue"];
for (const color of colors) {
  console.log("For-Of Loop (Array):", color);
}

// For-Each Method (Array)
const numbers = [1, 2, 3];
numbers.forEach((number) => {
  console.log("For-Each Method (Array):", number);
});

// For-Of Loop with Entries (Array)
for (const [index, color] of colors.entries()) {
  console.log("For-Of Loop with Entries (Array):", index, color);
}

// For-Of Loop with Keys and Values (Object)
for (const [key, value] of Object.entries(person)) {
  console.log("For-Of Loop with Keys and Values (Object):", key, value);
}

// For-Of Loop with Keys (Object)
for (const key of Object.keys(person)) {
  console.log("For-Of Loop with Keys (Object):", key);
}

	// math.js
    export function add(a, b) {
    return a + b;
    }

    export function subtract(a, b) {
    return a - b;
    }

    // main.js
    import { add, subtract } from './math.js';

    console.log(add(5, 3)); // 8
    console.log(subtract(10, 4)); // 6

    // person.js
    const person = {
    name: 'John',
    age: 30,
    };

    export default person;

    // main.js
    import person from './person.js';

    console.log(person.name); // 'John'

    // main.js
    import { add as addition, subtract as subtraction } from './math.js';

    console.log(addition(5, 3)); // 8
    console.log(subtraction(10, 4)); // 6

    // myModule.js
    export default function myFunction() {
    console.log('Default export');
    }

    export function namedFunction() {
    console.log('Named export');
    }

    // main.js
    import myFunction, { namedFunction } from './myModule.js';

    myFunction(); // Default export
    namedFunction(); // Named export




	

    const input = document.querySelector("input");
    const defaultText = document.getElementById("default");
    const debounceText = document.getElementById("debounce");
    const throttleText = document.getElementById("throttle");

    // Throttle
    const updateThrottleText = throttle((text) => {
    // throttleText.textContent = text;
    incrementCount(throttleText);
    }, 100)

    const updateDebounceText = debounce((text) => {
    // debounceText.textContent = text;
    incrementCount(debounceText);
    })

    // input.addEventListener("input", e => {
    //   defaultText.textContent = e.target.value;

    //   updateDebounceText(e.target.value);
    //   updateThrottleText(e.target.value);
    // });


    function debounce(callBack, delay = 1000) {
    let timeout;

    return (arg) => {
        clearInterval(timeout);

        timeout = setTimeout(() => {
        callBack(arg);
        }, delay);

    }
    }

    function throttle(callBack, delay = 1000) {
    let isPaused = false;

    return (...arg) => {
        if (isPaused) return;

        callBack(...arg);
        isPaused = true;

        setTimeout(() => {
        isPaused = false;
        }, delay);
    }
    }

    function incrementCount(element) {
    element.textContent = (parseInt(element.innerText) || 0) + 1;
    }

    document.addEventListener('mousemove', (event) => {
    incrementCount(defaultText);
    updateDebounceText()
    updateThrottleText()
    })

Object methods

    // .entries() for Object:
const user = {
  firstName: "Yauhen",
  lastName: "Kavalchuk",
};

Object.entries(user); // [ [ 'firstName', "Yauhen" ], [ 'lastName', "Kavalchuk" ] ];

// .entries() for Array:
const name = ['Y', 'a', 'u', 'h', 'e', 'n'];

Object.entries(name); // [ [ '0', 'Y' ], [ '1', 'a' ], [ '2', 'u' ], [ '3', 'h' ], [ '4', 'e' ], [ '5', 'n' ] ];

// .entries() ignore Symbol key:
const admin = {
  [Symbol('password')]: '123pass',
  name: 'Yauhen',
};

Object.entries(admin); // [ [ 'name', 'Yauhen' ] ];

// .fromEntries() using:
const arr = [['one', 1], ['two', 2], ['three', 3]];

Object.fromEntries(arr); // { one: 1, two: 2, three: 3 }

// .values() using:
const user = {
  firstName: "Yauhen",
  lastName: "Kavalchuk",
};

Object.values(user); // [ "Yauhen", "Kavalchuk" ] ];

get Own Property Descriptors

    // Base object with properties, get and set:
    const person = {
      name: 'Max',
      age: 30,
      set personName(name) {
        this.name = name;
      },
      get password() {
        return `${this.name}${this.age}`;
      },
    };
    
    console.log(person); // {name: "Max", age: 30}
    console.log(person.password); // "Max30"
    
    // Get property descriptors:
    console.log(Object.getOwnPropertyDescriptors(person));
    /*
      age: {value: 30, writable: true, enumerable: true, configurable: true}
      name: {value: "Max", writable: true, enumerable: true, configurable: true}
      password: {get: ƒ, set: undefined, enumerable: true, configurable: true}
      personName: {get: undefined, set: ƒ, enumerable: true, configurable: true}
    */
    
    // Clone object:
    // Using assign()
    const admin = Object.assign({}, person);
    // Using destructuring
    const admin = { ...person };
    
    console.log(admin); // {name: "Max", age: 30, personName: undefined, password: "Max30"}
    
    console.log(Object.getOwnPropertyDescriptors(admin));
    /*
      age: {value: 30, writable: true, enumerable: true, configurable: true}
      name: {value: "Max", writable: true, enumerable: true, configurable: true}
      password: {value: "Max30", writable: true, enumerable: true, configurable: true}
      personName: {value: undefined, writable: true, enumerable: true, configurable: true}
    */
    
    // Clone object:
    // Using .getOwnPropertyDescriptors()
    const superAdmin = Object.defineProperties({}, Object.getOwnPropertyDescriptors(person));
    
    console.log(Object.getOwnPropertyDescriptors(superAdmin));
    /*
      age: {value: 30, writable: true, enumerable: true, configurable: true}
      name: {value: "Max", writable: true, enumerable: true, configurable: true}
      password: {get: ƒ, set: undefined, enumerable: true, configurable: true}
      personName: {get: undefined, set: ƒ, enumerable: true, configurable: true}
    */

Minor enhancers

    // Math.pow():
    Math.pow(7, 2) // 49
    
    // Exponentiation operator:
    7**2 // 49
    5**3 // 125
    2**4 // 16
    
    // Complecated math operation
    // Old:
    Math.pow(7, 2) + Math.pow(5, 3) / Math.pow(2, 4);
    // New version:
    7**2 + 5**3 / 2**4;
    // New version with braces:
    (7**2) + (5**3) / (2**4);
    
    // Base Object:
    const user = {
      firstName: "Yauhen",
      lastName: "Kavalchuk"
    };
    
    // Base function constructor:
    function Person(
      name,
      age
    ) {
      this.name = name;
      this.age = age;
    };
    
    // Added property for Object:
    const user = {
      firstName: "Yauhen",
      lastName: "Kavalchuk",
      age: 30
    };
    
    // Added argument for function constructor:
    function Person(
      name,
      age,
      city
    ) {
      this.name = name;
      this.age = age;
      this.city = city;
    };
    
    // The same changes, but with trailing commas:
    const user = {
      firstName: "Yauhen",
      lastName: "Kavalchuk",
      age: 30,
    };
    
    function Person(
      name,
      age,
      city,
    ) {
      this.name = name;
      this.age = age;
      this.city = city;
    };

Async_functions

    // Base async function:
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
      const fetchedText = await fetchText();
      console.log(`This is a feature of ${fetchedText}`);
    };
    
    showText(); // This is a feature of ES8
    
    // Work sync with async functionality:
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = () => {
      const fetchedText = fetchText();
      console.log(`This is feature a of ${fetchedText}`);
    };
    
    showText(); // This is a feature of [object Promise]
    
    // Async function always return Promise
    // We can handle result:
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
      const fetchedText = await fetchText();
      return `This is feature a of ${fetchedText}`;
    };
    
    showText().then(data => console.log(data)); // This is a feature of ES8
     
    // if async function return simple value,
    // this value still be in Promise
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
      const fetchedText = await fetchText();
      return 10;
    };
    
    console.log(showText()); // Promise
    showText().then(data => console.log(data)); // 10
    
    
    // Execute of 2 and more async functions:
    const fetchDescrText = () => new Promise(resolve => { setTimeout(() => resolve('This is a feature of'), 2000); });
    const fetchEsText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
      const fetchedDescrText = await fetchDescrText();
      const fetchedEsText = await fetchEsText();
      return `${fetchedDescrText} ${fetchedEsText}`;
    };
    
    // Receive result after ~4000ms
    showText().then(data => console.log(data)); // This is a feature of ES8
    
    
    // Parallel execute of async functions:
    const showText = async () => {
      const [fetchedDescrText, fetchedEsText] = await Promise.all([fetchDescrText(), fetchEsText()]);
      return `${fetchedDescrText} ${fetchedEsText}`;
    };
    
    // Receive result after ~2000ms
    showText().then(data => console.log(data)); // This is a feature of ES8

Async errors handling

    // Base async functional:
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
      const fetchedText = await fetchText();
      console.log(`This is a feature of ${fetchedText}`); // This is a feature of ES8
    };
    
    showText();
    
    
    // Error handling with 'try/catch':
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
      try {
        const fetchedText = await fetchText();
        console.log(`This is a feature of ${fetchedText}`);
      } catch (e) {
        console.log(e);
      }
    };
    
    showText();
    
    
    // Argument 'e' (error object) in 'catch' is not nessesary anymore
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
      try {
        const fetchedText = await fetchText();
        console.log(`This is a feature of ${fetchedText}`);
      } catch {
        console.log('Something going wrong...');
      }
    };
    
    showText();
    
    
    // Error handling with 'catch' in 'await' function:
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
        const fetchedText = await fetchText().catch(e => console.log(e));
        console.log(`This is a feature of ${fetchedText}`);
    };
    
    showText();
    
    
    // Error handling with 'catch' for full async function:
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
        const fetchedText = await fetchText();
        console.log(`This is a feature of ${fetchedText}`);
    };
    
    showText()
      .then(console.log('Everything is OK!'))
      .catch(e => console.log(e));
    
    
    // Using 'finally' as a 3rd step of 'try/catch':
    const fetchText = () => new Promise(resolve => { setTimeout(() => resolve('ES8'), 2000); });
    
    const showText = async () => {
      try {
        showSpiner = true;
        const fetchedText = await fetchText();
        console.log(`This is a feature of ${fetchedText}`);
      } catch {
        console.log('Something going wrong...');
      } finally {
        showSpiner = false;
      }
    }
    
    showText();

Async iterators

    // Base Array (iterable instance):
    const names = ['Jack', 'Max', 'Leo'];
    // 'for-of' iteration:
    for(let name of names) {
      console.log(name); // 'Jack', 'Max', 'Leo'
    }
    
    
    // Base async Array:
    const names = [
      new Promise(resolve => resolve('Jack')),
      new Promise(resolve => resolve('Max')),
      new Promise(resolve => resolve('Leo')),
    ];
    
    // Async function for iteration with 'for-of':
    const showNames = async () => {
      for (name of names) {
        console.log(name);
      }
    };
    showNames(); // Promise, Promise, Promise
    
    // Async function for iteration with 'for-await-of':
    const showNames = async () => {
      for await (name of names) {
        console.log(name);
      }
    };
    showNames(); // 'Jack', 'Max', 'Leo'
    
    
    // Async generator function:
    async function* readLines(path) {
      let file = await fileOpen(path);
    
      try {
        while (!file.EOF) {
          yield await file.readLine();
        }
      } finally {
        await file.close();
      }
    };
    
    
    // Async iteration of async generator function results:
    for await (const line of readLines(filePath)) {
      console.log(line);
    };

Array methods

// Base Array:
const arr = [1,2,3,4, 'five', NaN];

// Find element using .indexOf:
if(arr.indexOf(3) >= 0) {
  console.log(true); // true
}
// Find element using .includes:
if(arr.includes(3)) {
  console.log(true); // true
}


// Find NaN in Array:
const index = arr.findIndex(Number.isNaN);
console.log(index); // 5

// Difference in finding NaN in Array:
arr.indexOf(NaN); // -1
arr.includes(NaN); // true


// .flat() of 1st level:
const arr1 = [1, 2, [3, 4]];
arr1.flat(); // [1, 2, 3, 4]

const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat(); // [1, 2, 3, 4, [5, 6]]

// .flat() of 2nd level:
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2); // [1, 2, 3, 4, 5, 6]

// .flat() of Infinity level:
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]


// .flat() remove empty values:
const arr5 = [1, 2, , 4, 5];
arr5.flat(); // [1, 2, 4, 5]

// .flat() remove empty values from 1st & 2nd levels of Array:
const arr6 = [1, 2, , 4, 5, [6, , 8]];
arr6.flat(); // [1, 2, 4, 5, 6, 8]


// Using of .flatMap():
const arr7 = [[1], [2], [3], [4]];
arr7.flatMap(x => [x * 2]); // [2, 4, 6, 8]

String methods

    // Base String:
    const str = "test";
    
    // .padStart() with argument:
    str.padStart(10, '~'); // '~~~~~~test'
    str.padEnd(10, '~'); // 'test~~~~~~'
    // .padStart() without of argument:
    str.padStart(10); // '      test'
    str.padEnd(10); // 'test      '
    
    
    // Base String:
    const str = "Hello, my name is Yauhen";
    
    // .startsWith() using:
    str.startsWith("Hello"); // true
    str.startsWith("Hi"); // false
    // .endsWith() using:
    str.endsWith("Yauhen"); // true
    str.endsWith("Jack"); // false
    
    // Base String:
    const str = "Hello, my name is Yauhen";
    
    // The resulting string after .startsWith() is "my name is Yauhen":
    str.startsWith("my", 7); // true
    
    // The resulting string after .startsWith() is "my name is Yauhen":
    str.startsWith("name", 7); // false
    
    // The resulting string after .endsWith() is "Hello, my name":
    str.endsWith("name", 14); // true
    
    // The resulting string after .endsWith() is "Hello, my name":
    str.endsWith("name", 10); // false
    
    
    // Base String:
    const str = "    Just test string     ";
    
    // base string after .trim():
    str.trim(); // "Just test string"
    
    
    // Base String:
    const str = "    Just test string     ";
    
    // Base string after .trimStart():
    str.trimStart(); // "Just test string     "
    
    // Base string after .trimEnd():
    str.trimEnd(); // "    Just test string"

Minor enhancers 2

    // Base function:
    function /* just a comment */ test () {}
    
    // Difference between old and new versions of .toString():
    // Old version:
    test.toString(); // 'function test() {}'
    // New version:
    test.toString(); // 'function /* just a comment */ test () {}'
    
    // Base function:
    function greeting() {
      const name = 'webDev';
      console.log(`hello from ${name}`);
    };
    // Difference between old and new versions of .toString():
    // Old version:
    test.toString(); //'function greeting() {\nconst name = \'webDev\'\nconsole.log(`hello from ${name} //`)\n}'
    // New version:
    test.toString();
    /*  'function greeting() {\n' +
        "  const name = 'webDev'\n" +
        '  console.log(`hello from ${name}`)\n' +
        '}'
    */
    
    
    // Symbol creation:
    const mySymbol = Symbol('Symbol description');
    // Define Symbol description
    String(mySymbol) === 'Symbol(Symbol description)'; // true
    
    // Define Symbol description using property description:
    mySymbol.description; // 'Symbol description'
    mySymbol.description === 'Symbol description'; // true
    
    // If Symbol was created without description
    // default value for property is 'undefined':
    const myNewSymbol = Symbol();
    myNewSymbol.description; // undefined
    
    
    // Difference between old and new versions of .stringify():
    // Old version:
    JSON.stringify("\uD800"); // '"�"'
    // New version:
    JSON.stringify("\uD800"); // '"\\ud800"'

Reg Exp

    // Difference between old and new versions of 'dot' behavior:
    // Old version:
    /one.two/.test('one\ntwo'); // false
    // New version (dotAll)
    // with flag /s:
    /one.two/s.test('one\ntwo'); // true
    
    
    // Base RegEx to work with date:
    const regEx = /(\d{4})-(\d{2})-(\d{2})/;
    
    const result = regEx.exec('2019-08-23');
    
    console.log(result); // ["2019-08-23", "2019", "08", "23", index: 0, input: "2019-08-23", groups: undefined]
    
    // RegExp with named groups - (?...):
    const regEx = /(?\d{4})-(?\d{2})-(?\d{2})/;
    
    const result = regEx.exec('2019-08-23');
    
    console.log(result); // ["2019-08-23", "2019", "08", "23", index: 0, input: "2019-08-23", groups: {...}];
    
    console.log(result.groups); // { year: "2019", month: "08", day: "23" }
    
    
    // RegExp named groups and .replace():
    const str = 'Kavalchuk Yauhen';
    
    const repl = /(?[A-Za-z]+) (?[A-Za-z]+$)/u;
    
    const newStr = str.replace(repl, '$, $');
    
    console.log(newStr); // "Yauhen, Kavalchuk"
    
    
    // Using named groups inside RegExp - \k:
    let sameWords = /(?apple|orange) === \k/u;
    
    sameWords.test('apple === apple');  //true
    sameWords.test('orange === orange');  //true
    sameWords.test('apple === orange');  //false
    
    
    // Positive lookbehind (?<=[symbol]):
    /(?<=#).*/.test('#frontend'); // true
    /(?<=#).*/.test('frontend'); // false
    
    // Difference between old and new approaches:
    // Old
    '#frontend'.match(/#.*/)[0]; // '#frontend'
    // New
    '#frontend'.match(/(?<=#).*/)[0]; // 'frontend'
    
    
    // Negative lookbehind (?>![symbol]):
    'course coasts $20'.match(/(?