JavaScript’s power and flexibility are shown through its wide array of libraries and frameworks, which include Angular, Node.js, React, and more. Each takes different approaches to empower the various goals of software engineers.

In this course, you’ll be introduced to the various processes of these unique frameworks as you develop a new open-source solution: Assma.js. You’ll become acquainted with compilation theory before defining logical operators. Next, you’ll delimit functions by creating production rules and define the elements of the programming language, including the syntax and semantics in the framework. You’ll finalize the core of the framework using DOM and tree structures before bundling the packages into a plugin component to manage future projects.

By the end of the course, you’ll have a deep understanding of core functions, design theories, and the creation of JavaScript frameworks from conception to deployment.

Discover: JavaScript Frameworks Behind the Scenes

# The NOT operator
In this lesson, we'll try to simulate the <strong>NOT</strong> operator in the parsing process. This operator can be useful when we need to analyze portions from the input string different from some predefined string values. We need to implement a method that takes an array of strings as a parameter and returns a function that takes the input string and the cursor. Below is the implementation of the method. 
> Note: We can enter any string value as an input at the bottom of the widget to run the code.

#concept=Not# Details #concept#

export class NotAsExpected {
  constructor(expected, cursor) {
    this.expected = expected;
    this.cursor = cursor;
  }
}

export class AST {
  constructor(value, cursor) {
    this.value = value;
    this.cursor = cursor;
  }
}

import { AST, NotAsExpected } from "./util";
import { run } from "./stdin";

/**
 * A function to simulate the not operator.
 *
 * @param {Array} strings Input strings.
 * @return {function} A function that takes the input string to parse.
 */
function not(strings) {
  /**
   * @param {string} input Input string.
   * @param {int} cursor A point from where to start parsing.
   * @return {object} An abstract syntax tree.
   */
  return (input, cursor) => {
    if (cursor < input.length) {
      for (let i = 0; i < strings.length; i++) {
        const string = strings[i];
        if (input.slice(cursor, cursor + string.length) === string) {
          return new NotAsExpected(`not "${string}"`, cursor);
        }
      }
      return new AST(input[cursor], cursor + 1);
    } else {
      return new NotAsExpected(`not ${strings.map(JSON.stringify).join(", ")}`, cursor);
    }
  };
}

/* Begin main */
run(not(["span", "div", "p"]));

If we look at the body of the `not` method, we can see that a first check on the length of the input string is necessary. If it's greater than the cursor, we should a ```NotAsExpected``` object because there's no further input to check on. Otherwise, we need to check on each string of the array and compare it with the input string. If all elements are different from the input, it should return an ```AST``` object. 

Learn methods that simulate logical operators which are used to parse sentences.

Course

Logical Operators

The NOT operator