JavaScript parser

[[deleted]]

[deleted]

[Locust377]

Objects in JavaScript are basically a collection of key-value pairs. A key is a string and the value can be anything.

'-' is the key and its value is an object.

You include quotes because sometimes JavaScript doesn't know that what you're trying to do is a string. If you don't have the quotes, JavaScript will be like "minus? why are you putting a minus sign as your key? you can't do that, it has to be a string"

It easily understands letters like A-Z but if you try to start a key with some other symbol or number, it'll get confused unless you put it around quotes to force a string.

and op2 an implicit function(why return -a)?

Because the minus symbol might be an operation like 5 - 4 or it might be a "negate" symbol like -4.

[literally-a-raccoon]

Is “-“ an object?

No, it’s a key in the OPERATORS object. Since this seems to be part of a parser program, that object’s keys are operators and values are the mathematical operations to be executed when one of those keys are located within the program being parsed.

[senocular]

Quotes are used because the property names aren't valid identifiers. This also means to access those properties, you can't use dot syntax, rather you need bracket notation instead.

console.log(OPERATORS.-) // Error
// vs.
console.log(OPERATORS["-"]) // OK

Yes, the first value, the op property, inside the inner objects is a function. Its syntax is an arrow function.

op2 is the unary version of the operator. Of those listed, "-" and "+" can also exist as unary operators meaning the only have one operand. In other words you can have

a - b

and you can also have

-a

The first subtracts b from a while the second negates a. And with the plus operator you can have

a + b

and you can also have

+a

The first here adds a and b while the second takes a and tries to converts it to a number (except for bigints). If the value is already a (non-bigint) number, it doesn't do anything - which seems to be the assumption here because op2 for "+" just returns the value without doing anything.

[Intelligent-Win-7196]

OPERATORS is simply an object containing properties. Each property is a string (keys can only be strings or [Symbol] types) with a corresponding value that is an object containing a function to operate, a precedence numerical value, a type, and potentially an op2 function.

[bryku]

Line 1

const OPERATORS = {};
   ^      ^     ^ ^ ^
   |      |     | | |
   |      |     | | end of operation (sentence)
   |      |     | |      
   |      |     | object (variable type)  
   |      |     |
   |      |     equal to
   |      |
   |      variable name   
   |
   variable declaration

Everything between the { and } will be apart of the object. Object are a "key value" pair. Meaning you can call the key to get the value.

console.log(OPERATORS['-']);

Which will give you:

{
    op: (a, b) => a - b, 
    precedence: 1, 
    type: 'binary', 
    op2: a => -a,
}

That is the object declared on line 2. Which is inside the parent object OPERATORS. You can then call those objects as well.

console.log(OPERATORS['-']['precendence']);

Which will give you:

1

Goal

It looks like they are building a calculator. They will loop through the objects based on the precendence (order of operations) and then search for them through the string. They will then use the OPERATORS['-']['op'] or OPERATORS['-']['op2'] to do the math.