Run a mock round

You need to check browser support for web workers before using it

    if (typeof Worker !== "undefined") {
      // code for Web worker support.
    } else {
      // Sorry! No Web Worker support..
    }
    

There are three types of errors:

1. Load time errors: Errors that come up when loading a web page, like improper syntax errors, are known as Load time errors and generate the errors dynamically.
2. Runtime errors: Errors that come due to misuse of the command inside the HTML language.
3. Logical errors: These are the errors that occur due to the bad logic performed on a function with a different operation.

Since the listener listens for any message, an attacker can trick the application by sending a message from the attacker’s origin, which gives an impression that the receiver received the message from the actual sender’s window. You can avoid this issue by validating the origin of the message on the receiver's end using the “message.origin” attribute.

For example, let's check the sender's origin http://www.some-sender.com on receiver side [www.some-receiver.com](www.some-receiver.com),

      //Listener on http://www.some-receiver.com/
      window.addEventListener("message", function(message){
          if(/^http://www\.some-sender\.com$/.test(message.origin)){
               console.log('You received the data from valid sender', message.data);
         }
      });
      

We can add properties and methods to an object's prototype by using the constructor function's prototype property. To add a property, simply assign a value to a property on the prototype object. To add a method, define a function and assign it to a property on the prototype object.

MyConstructor.prototype.myProperty = "some value";

An operator is capable of manipulating(mathematical and logical computations) a certain value or operand. There are various operators supported by JavaScript as below,

1. Arithmetic Operators: Includes + (Addition), – (Subtraction), \* (Multiplication), / (Division), % (Modulus), ++ (Increment) and – – (Decrement)
2. Comparison Operators: Includes == (Equal), != (Not Equal), === (Equal with type), > (Greater than), >= (Greater than or Equal to), < (Less than), <= (Less than or Equal to)
3. Logical Operators: Includes && (Logical AND), || (Logical OR), ! (Logical NOT)
4. Assignment Operators: Includes = (Assignment Operator), += (Add and Assignment Operator), –= (Subtract and Assignment Operator), \*= (Multiply and Assignment), /= (Divide and Assignment), %= (Modules and Assignment)
5. Ternary Operators: It includes conditional(: ?) Operator
6. typeof Operator: It uses to find type of variable. The syntax looks like typeof variable

In ES6, JavaScript classes are primarily syntactic sugar over JavaScript’s existing prototype-based inheritance.
For example, the prototype based inheritance written in function expression as below,

    function Bike(model, color) {
      this.model = model;
      this.color = color;
    }

    Bike.prototype.getDetails = function () {
      return this.model + " bike has" + this.color + " color";
    };
    

Whereas ES6 classes can be defined as an alternative

    class Bike {
      constructor(color, model) {
        this.color = color;
        this.model = model;
      }

      getDetails() {
        return this.model + " bike has" + this.color + " color";
      }
    }
    

Method chaining is a pattern where multiple methods are called on the same object sequentially by returning this from each method.

     class Calculator {
       constructor(value = 0) {
         this.value = value;
       }

       add(num) {
         this.value += num;
         return this; // Enable chaining
       }

       subtract(num) {
         this.value -= num;
         return this;
       }

       multiply(num) {
         this.value *= num;
         return this;
       }

       divide(num) {
         this.value /= num;
         return this;
       }

       getResult() {
         return this.value;
       }
     }

     const result = new Calculator(10)
       .add(5)
       .multiply(2)
       .subtract(3)
       .getResult();

     console.log(result); // 27
     

Advanced pattern with error handling:

     class QueryBuilder {
       constructor() {
         this.query = '';
         this.params = [];
       }

       select(...fields) {
         this.query = `SELECT ${fields.join(', ')}`;
         return this;
       }

       from(table) {
         this.query += ` FROM ${table}`;
         return this;
       }

       where(condition, ...params) {
         this.query += ` WHERE ${condition}`;
         this.params.push(...params);
         return this;
       }

       build() {
         return { query: this.query, params: this.params };
       }
     }

     const query = new QueryBuilder()
       .select('id', 'name', 'email')
       .from('users')
       .where('age > ?', 18)
       .build();
     

Immutable chaining pattern:

     class ImmutableArray {
       constructor(arr = []) {
         this.arr = arr;
       }

       map(fn) {
         return new ImmutableArray(this.arr.map(fn));
       }

       filter(fn) {
         return new ImmutableArray(this.arr.filter(fn));
       }

       value() {
         return this.arr;
       }
     }

     const result = new ImmutableArray([1, 2, 3, 4])
       .map(x => x * 2)
       .filter(x => x > 4)
       .value(); // [6, 8]
     

Circular references occur when an object references itself directly or indirectly, causing JSON.stringify() to throw an error.

Problem:

     const obj = { name: 'John' };
     obj.self = obj; // Circular reference

     // JSON.stringify(obj); // Throws: TypeError: Converting circular structure to JSON
     

Solution 1: Custom replacer function:

     function stringifyWithCircular(obj) {
       const seen = new WeakSet();
       return JSON.stringify(obj, (key, value) => {
         if (typeof value === 'object' && value !== null) {
           if (seen.has(value)) {
             return '[Circular]';
           }
           seen.add(value);
         }
         return value;
       });
     }

     const obj = { name: 'John' };
     obj.self = obj;
     console.log(stringifyWithCircular(obj));
     // {"name":"John","self":"[Circular]"}
     

Solution 2: flatted library (preserves structure):

     import { stringify, parse } from 'flatted';

     const obj = { name: 'John' };
     obj.self = obj;

     const serialized = stringify(obj);
     const deserialized = parse(serialized);
     console.log(deserialized.self === deserialized); // true
     

Solution 3: Manual tracking with paths:

     function safeStringify(obj, space) {
       const seen = new Map();
       let index = 0;

       return JSON.stringify(obj, function(key, value) {
         if (typeof value === 'object' && value !== null) {
           if (seen.has(value)) {
             return `[Circular:${seen.get(value)}]`;
           }
           seen.set(value, index++);
         }
         return value;
       }, space);
     }
     

Solution 4: Remove circular references:

     function removeCircular(obj) {
       const seen = new WeakSet();

       function detect(obj) {
         if (typeof obj === 'object' && obj !== null) {
           if (seen.has(obj)) {
             return undefined;
           }
           seen.add(obj);

           if (Array.isArray(obj)) {
             return obj.map(detect).filter(x => x !== undefined);
           }

           const cleaned = {};
           for (const [key, value] of Object.entries(obj)) {
             const cleaned value = detect(value);
             if (cleanedValue !== undefined) {
               cleaned[key] = cleanedValue;
             }
           }
           return cleaned;
         }
         return obj;
       }

       return detect(obj);
     }

     const obj = { name: 'John', child: { name: 'Jane' } };
     obj.child.parent = obj;
     const clean = removeCircular(obj);
     console.log(JSON.stringify(clean));
     

Solution 5: Using toJSON method:

     class Node {
       constructor(name) {
         this.name = name;
         this.parent = null;
         this.children = [];
       }

       toJSON() {
         return {
           name: this.name,
           children: this.children,
           // Exclude parent to avoid circular reference
         };
       }
     }

     const root = new Node('root');
     const child = new Node('child');
     root.children.push(child);
     child.parent = root;

     console.log(JSON.stringify(root)); // Works fine
     

A first-order function is a function that doesn’t accept another function as an argument and doesn’t return a function as its return value. i.e, It's a regular function that works with primitive or non-function values.

    const firstOrder = () => console.log("I am a first order function!");