assignment operator overloading in javascript

HatchJS.com

Cracking the Shell of Mystery

Operator Overloading in JavaScript: A Guide for Beginners

Operator overloading in JavaScript: A powerful tool for developers

JavaScript is a versatile language that can be used for a wide variety of tasks, from simple web pages to complex applications. One of the things that makes JavaScript so powerful is its support for operator overloading. Operator overloading allows developers to define new meanings for existing operators, which can extend the capabilities of the language and make it more expressive.

In this article, we’ll take a closer look at operator overloading in JavaScript. We’ll discuss what it is, how it works, and how you can use it to improve your code. We’ll also provide some examples of operator overloading in action.

By the end of this article, you’ll have a solid understanding of operator overloading and how you can use it to make your JavaScript code more concise, readable, and powerful.

What is operator overloading?

Operator overloading is a feature of some programming languages that allows developers to define new meanings for existing operators. This means that you can use the same operators with different types of data, or with data in different ways.

For example, the `+` operator is typically used to add two numbers together. However, with operator overloading, you can also use the `+` operator to concatenate two strings, or to add an object to an array.

Operator overloading can be a powerful tool for developers, as it can allow them to write more concise and readable code. However, it’s important to use operator overloading carefully, as it can also make your code more difficult to understand.

How does operator overloading work?

Operator overloading works by defining new functions that are associated with specific operators. For example, to overload the `+` operator for strings, you would define a function like this:

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

console.log(“Hello” + ” world”); // “Hello world”

When the `+` operator is used with two strings, JavaScript will automatically call the `add` function. This function will then concatenate the two strings and return the result.

You can also overload operators for objects. To do this, you would define a function that takes the object as its first argument, and any other arguments as normal. For example, the following function overloads the `+` operator for objects:

function add(a, b) { return Object.assign(a, b); }

const obj1 = { foo: “bar” }; const obj2 = { baz: “qux” };

console.log(obj1 + obj2); // { foo: “bar”, baz: “qux” }

How can you use operator overloading?

Operator overloading can be used to improve the readability and conciseness of your code. For example, you can use operator overloading to:

• Add objects together
• Concatenate strings
• Compare objects
• Perform mathematical operations on objects

Here are some examples of operator overloading in action:

// Add two objects together const obj1 = { foo: “bar” }; const obj2 = { baz: “qux” };

const obj3 = obj1 + obj2;

console.log(obj3); // { foo: “bar”, baz: “qux” }

// Concatenate two strings const str1 = “Hello”; const str2 = ” world”;

const str3 = str1 + str2;

console.log(str3); // “Hello world”

// Compare two objects const obj4 = { foo: “bar” }; const obj5 = { foo: “bar” };

console.log(obj4 == obj5); // true

// Perform mathematical operations on objects const obj6 = { x: 1, y: 2 };

const obj7 = obj6 + obj6;

console.log(obj7); // { x: 2, y: 4 }

Operator overloading is a powerful tool that can be used to improve the readability, conciseness, and flexibility of your JavaScript code. However, it’s important to use operator overloading carefully, as it can also make your code more difficult to understand.

If you’re not sure whether or not you should use operator overloading, it’s always best to err on the side of caution and avoid it. However, if you’re confident that you can use operator overloading correctly, it can be a valuable tool in your JavaScript toolbox.

Operator overloading is a feature of JavaScript that allows you to define new meanings for existing operators. This can be useful for creating more concise and readable code, or for extending the functionality of JavaScript in new ways.

For example, you could define a new operator called `+` that adds two numbers together, but also adds two strings together by concatenating them.

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

console.log(add(1, 2)); // 3

console.log(add(“Hello”, ” world”)); // “Hello world”

Operator overloading is a powerful feature that can be used to create more expressive and efficient code. However, it is important to use operator overloading carefully, as it can make your code more difficult to read and understand.

Operator overloading is a feature of many programming languages that allows you to define new meanings for existing operators. This means that you can use the same operator to perform different operations on different data types.

For example, the `+` operator is used to add two numbers together, but it can also be used to concatenate two strings. This is because the `+` operator is overloaded to work with both numbers and strings.

Operator overloading can be used to create more concise and readable code. For example, the following code uses operator overloading to add two numbers together and concatenate two strings:

javascript const a = 1; const b = 2;

console.log(a + b); // 3

const str1 = “Hello”; const str2 = ” world”;

console.log(str1 + str2); // “Hello world”

Without operator overloading, you would need to use separate functions to add two numbers together and concatenate two strings. This would make the code less readable and more difficult to maintain.

How to overload operators in JavaScript?

To overload an operator in JavaScript, you use the `operator` keyword. The `operator` keyword takes two arguments: the operator name and a function that defines the new operation.

For example, the following code overloads the `+` operator to add two numbers together:

const a = 1; const b = 2;

The `add` function takes two arguments, `a` and `b`, and returns the sum of those two numbers. This function is then used to overload the `+` operator.

You can also overload operators to work with objects, arrays, and other data types. For example, the following code overloads the `+` operator to concatenate two strings:

javascript function concat(a, b) { return a + b; }

The `concat` function takes two strings as arguments and returns the concatenation of those two strings. This function is then used to overload the `+` operator.

Operator overloading is a powerful feature that can be used to create more concise and readable code. However, it is important to use operator overloading carefully, as it can make your code more difficult to read and understand.

Operator overloading is a feature that is not supported by all programming languages. If you are planning to use operator overloading, it is important to make sure that the language you are using supports this feature.

Here are some additional resources that you may find helpful:

• [MDN: Operator Overloading](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_overloading)
• [Stack Overflow: Operator Overloading in JavaScript](https://stackoverflow.com/questions/2261736/operator-overloading-in-javascript)
• [TutorialsPoint: Operator Overloading in JavaScript](https://www.tutorialspoint.com/javascript/javascript_operator_overloading.htm)

3. Examples of operator overloading in JavaScript

Operator overloading is a powerful feature of JavaScript that allows you to define new meanings for existing operators. This can be used to create more concise and readable code, or to extend the functionality of JavaScript in new ways.

Here are a few examples of operator overloading in JavaScript:

• Overloading the `+` operator to add two numbers together:
• Overloading the `+` operator to concatenate two strings together:

console.log(“Hello ” + “world”); // “Hello world”

• Overloading the `[]` operator to access an element of an array by its index:

javascript function get(array, index) { return array[index]; }

const array = [“a”, “b”, “c”]; console.log(get(array, 0)); // “a”

• Overloading the `()` operator to call a function:

javascript function myFunction() { console.log(“Hello world”); }

console.log(myFunction()); // “Hello world”

• Overloading the `new` operator to create a new instance of a class:

javascript class MyClass { constructor() { console.log(“Creating a new instance of MyClass”); } }

const myInstance = new MyClass(); // “Creating a new instance of MyClass”

As you can see, operator overloading can be used to do a lot of different things in JavaScript. It’s a powerful feature that can be used to create more concise and readable code, or to extend the functionality of JavaScript in new ways.

4. Benefits of operator overloading in JavaScript

There are a number of benefits to using operator overloading in JavaScript.

• Conciseness: Operator overloading can help to make your code more concise and readable. For example, instead of writing the following code:

javascript const sum = a + b;

you can write the following code using operator overloading:

The second code is much more concise and easier to read.

• Extensibility: Operator overloading can also help to extend the functionality of JavaScript. For example, you could overload the `+` operator to add two objects together, or you could overload the `()` operator to call a function with different arguments.
• Reusability: Operator overloading can also help to make your code more reusable. For example, you could create a custom function that overloads the `+` operator to add two numbers together. This function could then be used by any other part of your code that needs to add two numbers together.

Overall, operator overloading is a powerful feature that can be used to improve the conciseness, extensibility, and reusability of your JavaScript code.

5. How to overload operators in JavaScript

To overload an operator in JavaScript, you need to create a function with the same name as the operator you want to overload. For example, to overload the `+` operator, you would create a function called `+`.

The function you create to overload an operator must have the following signature:

javascript function operator(a, b) { // Your code here }

where `a` and `b` are the operands of the operator.

For example, the following function overloads the `+` operator to add two numbers together:

javascript function +(a, b) { return a + b; }

Once you have created the function to overload an operator, you need to call the `Object.prototype.operator` method to register the function with the operator. For example, to overload the `+` operator, you would call the following code:

javascript Object.prototype.operator += function(a, b) { return a + b; };

Now, you can use the overloaded operator in your code. For example, the following code will add two numbers together:

javascript const sum = 1 + 2;

Operator overloading is a powerful feature of JavaScript that can be used to improve the conciseness, extensibility, and reusability of your code. By understanding how to overload operators,

What is operator overloading in JavaScript?

Operator overloading is a feature of JavaScript that allows you to define new meanings for existing operators. This can be useful for making your code more concise and readable, or for creating new functionality that wouldn’t be possible without operator overloading.

How do I overload an operator in JavaScript?

To overload an operator in JavaScript, you use the `operator` keyword. For example, the following code overloads the `+` operator to add two objects together:

javascript const obj1 = { a: 1, b: 2 }; const obj2 = { a: 3, b: 4 };

const sum = obj1 + obj2;

console.log(sum); // { a: 4, b: 6 }

What are the limitations of operator overloading in JavaScript?

There are a few limitations to operator overloading in JavaScript. First, you can only overload operators that have two operands. Second, you can’t overload operators that are used for assignment (such as the `=` operator). Third, you can’t overload operators that are used for comparison (such as the `>` operator).

Is operator overloading safe?

Operator overloading can be safe if you use it carefully. However, it’s important to be aware of the potential for errors when overloading operators. For example, if you overload an operator in a way that doesn’t make sense, your code could produce unexpected results.

What are some common uses for operator overloading in JavaScript?

Operator overloading is often used to make code more concise and readable. For example, you could overload the `+` operator to add two objects together, or you could overload the `*` operator to multiply two arrays together. Operator overloading can also be used to create new functionality that wouldn’t be possible without it. For example, you could overload the `>` operator to compare two objects by their age, or you could overload the `[]` operator to access a property of an object by its name.

operator overloading is a powerful tool that can be used to extend the functionality of JavaScript objects. By overloading operators, you can create objects that behave in a more intuitive way, and you can also make your code more concise and readable. However, it is important to use operator overloading carefully, as it can make your code more difficult to understand for other developers.

Here are some key takeaways to remember when using operator overloading:

• Operator overloading should be used only when it makes sense for the object.
• Overloaded operators should have the same arity as the original operator.
• Overloaded operators should have the same precedence as the original operator.
• Overloaded operators should have the same associativity as the original operator.
• Overloaded operators should be consistent with the behavior of other overloaded operators in the same class.

By following these guidelines, you can use operator overloading to create powerful and expressive JavaScript code.

Author Profile

Latest entries

• December 26, 2023 Error Fixing User: Anonymous is not authorized to perform: execute-api:invoke on resource: How to fix this error
• December 26, 2023 How To Guides Valid Intents Must Be Provided for the Client: Why It’s Important and How to Do It
• December 26, 2023 Error Fixing How to Fix the The Root Filesystem Requires a Manual fsck Error
• December 26, 2023 Troubleshooting How to Fix the `sed unterminated s` Command

Similar Posts

Py4j networkerror: answer from java side is empty.

Py4j.protocol.Py4JNetworkError: Answer from Java side is empty Have you ever encountered the Py4jNetworkError: Answer from Java side is empty? This error can be a real pain, especially when you’re trying to debug a Python program that’s interacting with a Java server. In this article, we’ll take a look at what causes this error and how…

Java lang.IllegalArgumentException: Unsupported class file major version 61

Java.lang.IllegalArgumentException: Unsupported Class File Major Version 61 If you’re a Java developer, you’ve probably come across the dreaded `java.lang.IllegalArgumentException: Unsupported Class File Major Version` error. This error occurs when you try to load a class file that has a major version number that is higher than the one supported by your JVM. In this article,…

Adjacent JSX Elements Must Be Wrapped in an Enclosing Tag

Adjacent JSX Elements Must Be Wrapped in an Enclosing Tag When you’re writing JSX, it’s important to remember that adjacent elements must be wrapped in an enclosing tag. This is a common mistake that can lead to errors in your code. In this article, we’ll take a closer look at the why adjacent JSX elements…

How to Adjust a List by Normalizing in Java

Adjusting a List by Normalizing in Java Lists are a fundamental data structure in Java, and they’re used to store ordered collections of data. However, lists can sometimes become out of order, which can make them difficult to use. Fortunately, Java provides a number of methods for normalizing lists, which means reordering them so that…

Java Util Zip ZipException: Zip End Header Not Found

Java.util.zip.ZipException: Zip End header not found When you’re working with ZIP files in Java, you may encounter the dreaded ZipException: Zip End header not found error. This error can occur for a number of reasons, but it typically means that the ZIP file is corrupt or incomplete. In this article, we’ll take a look at…

How to Fix the Java Lang IllegalStateException: Failed to Load ApplicationContext

Java.lang.IllegalStateException: Failed to load ApplicationContext Have you ever encountered the dreaded Java.lang.IllegalStateException: Failed to load ApplicationContext error? If so, you know how frustrating it can be. This error can occur for a variety of reasons, but it often stems from a problem with your Spring configuration. In this article, we’ll take a closer look at…

DEV Community

Posted on Aug 20, 2023

JavaScript Operators: A Comprehensive Guide

JavaScript, being a versatile and widely-used programming language, provides a plethora of operators that empower developers to manipulate data, perform calculations, and make decisions. In this article, we will delve into the world of JavaScript operators, exploring their diverse types, functionalities, and practical examples.

Table of Contents

• Introduction to JavaScript Operators
• Arithmetic Operators
• Assignment Operators
• Comparison Operators
• Logical Operators
• Unary Operators
• Conditional (Ternary) Operator
• Bitwise Operators
• String Operators
• Type Operators
• Operator Precedence
• Operator Overloading
• Common Operator Mistakes to Avoid
• Real-world Examples of Operator Usage
• Frequently Asked Questions (FAQs)
• Access Our JavaScript Resources

1. Introduction to JavaScript Operators

At the core of JavaScript lies a rich set of operators that facilitate tasks ranging from basic arithmetic calculations to advanced logical evaluations. Operators are symbols that allow you to perform operations on values and variables.

2. Arithmetic Operators

Arithmetic operators are essential for numeric computations. The plus (+) operator can not only add numbers but also concatenate strings. For instance:

3. Assignment Operators

Assignment operators help in assigning values to variables. The equal sign (=) is the most basic assignment operator. However, compound assignment operators combine operations with assignments. Here's an example:

4. Comparison Operators

Comparison operators are used to compare values. The equality (==) and strict equality (===) operators determine if values are equal. For instance:

5. Logical Operators

Logical operators are crucial for decision-making. The logical AND (&&) and logical OR (||) operators are used to combine conditions. Example:

6. Unary Operators

Unary operators work on a single value. The increment (++) and decrement (--) operators change the value by 1. Example:

7. Conditional (Ternary) Operator

The conditional operator is a concise way to write if-else statements. Example:

8. Bitwise Operators

Bitwise operators manipulate values at the bit level. The bitwise AND (&) and bitwise OR (|) operators perform binary operations. Example:

9. String Operators

String operators, like the concatenation operator (+), combine strings. Example:

10. Type Operators

Type operators provide insights into variable types. The typeof operator tells you the type of a value. Example:

11. Operator Precedence

Operator precedence determines the order in which operators are evaluated. Example:

12. Operator Overloading

JavaScript doesn't support true operator overloading, but operators might behave differently based on types.

13. Common Operator Mistakes

Avoid common mistakes, such as using the wrong operator or misunderstanding operator behavior, to ensure accurate code.

14. Real-world Examples

Explore practical examples of operators in action, from calculating discounts to validating user input.

15. Conclusion

JavaScript operators are indispensable tools that enable developers to manipulate data effectively and make informed decisions in their code. By mastering these operators, you unlock the potential to create dynamic and efficient applications.

Why are operators important in JavaScript? Operators enable developers to perform various tasks, from calculations to logical evaluations.

Can I use arithmetic operators with strings? Yes, JavaScript's loose typing allows using arithmetic operators with strings.

What's the difference between == and ===? The triple equals (===) checks both value and type, while double equals (==) checks value only.

How do logical operators work? Logical operators combine conditions and determine whether a given condition is true or false.

Is operator overloading possible in JavaScript? JavaScript doesn't support traditional operator overloading.

Top comments (0)

Templates let you quickly answer FAQs or store snippets for re-use.

Are you sure you want to hide this comment? It will become hidden in your post, but will still be visible via the comment's permalink .

Hide child comments as well

For further actions, you may consider blocking this person and/or reporting abuse

Jonas Scholz - May 12

35 Years of Web, Speedometer 3, Chrome 123-124, Firefox 124-125, Vivaldi mobile 6.6, and more | Front End News #108

Adrian Sandu - May 8

Exploring the Best Tools for Real-Time Code Collaboration

Suraj Vishwakarma - May 20

I coded for 100 days and documented it on YouTube...

Virag Kormoczy - May 8

We're a place where coders share, stay up-to-date and grow their careers.

• How to Overload Operator in JavaScript
• JavaScript Howtos

In the primitive stage, JavaScript did not have any explicit way of defining the operator overloading function. Later, there was an update where we would have to use the command npm install operator-overloading --save to enable the syntax.

We would initiate a variable noting var overload = require('operator-overloading') and then define the overload function for our case. But the most recent use case has a more flexible way of defining the function scope for operator overloading.

We will depend on Babel Dev dependencies as it is easier for testing. We will explain the guide for installing its necessities in the following segment and showcase an example.

Implement Operator Overloading in JavaScript

The basic start is creating a directory and setting the necessary package.json . So, we will first create a folder named operator overloading and open it in Visual Studio Code.

In the terminal of VSCode, we will run the following commands.

After running these commands, the package.json is not added to your folder; there will be one package-lock.json . Unpack the contents of this file from this portal , copy the contents, and paste them into a new file called package.json that you need to create in your base folder.

Next, follow the following commands in the terminal.

Now, create a .babelrc file in the root directory and set its content like this:

So, all your dependencies to enable the operator overloading are initiated. All you have to do is now create a JavaScript file and type codes to check the mechanism of operator overloading.

Code Snippet:

To test the output of the code above, try to open a Bash portal in VSCode and run the following. Technically, we will test our code via babel-node.cmd .

Here, ex.js is our JavaScript file name. The output that infers is according to what is expected. Let’s check it out.

The class Point is the initiated class with a constructor with two parameters. For the operator overloading case here, we have the syntax [Symbol.for(+)](other ).

For different operators, this syntax changes. However, the p1 and p2 objects have the corresponding x summed up throughout the process.

Generally, the leftmost or starting instance is defined by this.x(x of p1 = 5) , and the next x of the p2 = 2 is denoted by other.x . This is the basic concept of performing p1.add(p2) .

In the final result of summing up all the user-defined classes, we get x=11 and y=10 .

There is another way of explaining operator overloading. ExtendScript is one of the facets that portrays the operation via the UX domain; also, PaperScript has a good way of defining the working principle.

You could use proxy and Symbol to complete the task. Also, the toString() and valueOf() work effortlessly to present the concept of this function.

The operators that do not support overloading are typeof , === , !== , && , || , and instanceof .

Era is an observer who loves cracking the ambiguos barriers. An AI enthusiast to help others with the drive and develop a stronger community.

Related Article - JavaScript Operator

• How to Compare Numbers in JavaScript
• Short-Circuiting in JavaScript
• The Ternary Operator in JavaScript
• The Elvis Operator in JavaScript
• Bitwise XOR Operator in JavaScript

Get high quality AI code reviews

• 90+ point analyses every run
• AI that understands your code

Javascript Operator Overloading: Javascript Explained

Table of contents.

Javascript is a powerful language used by millions of developers in order to create interactive web applications. One of its key features is the ability to overload operators, or use an operator in a way that differs from its normally expected meaning. In this article, we’ll discuss what Javascript operator overloading is and how it works, as well what its benefits and best practices are.

What is Javascript Operator Overloading?

Javascript operator overloading is the ability for developers to use certain Javascript operators in a way that allows them to perform specific tasks without explicitly coding for them. These tasks include creating variables that act as objects, adding new methods and properties to existing objects, and creating shortcuts for longer operations. In some cases, it is even possible to use operators to redefine the meaning of an operator in the context of a certain data type.

Operator overloading is a form of abstraction, as it allows developers to use complex operations with a single line of code. It shortens the amount of code needed to complete tasks, while also making the code easier to read and understand.

Operator overloading is a powerful tool for developers, as it allows them to create more efficient and concise code. It also allows developers to create more complex operations without having to write out the entire operation. This can be especially useful when dealing with large datasets or complex operations.

Understanding How Javascript Operators Work

Javascript has six primary operators, which include addition (+), subtraction (-), multiplication (*), division (/), assignment (=), and comparison (==). Each operator works by performing a different set of tasks when applied to different types of variables or objects. For example, addition can be used to add two numbers together; subtraction can be used to subtract one number from another; multiplication can be used to multiply two numbers together, and so on.

Operator overloading allows developers to use these operators in a way that provides further functionality. This is done by assigning a specific type of operator to a task or action. For example, the “+” operator can be used to add two numbers together, but can also be used to concatenate two strings together.

In addition to the primary operators, there are also several other operators that can be used in Javascript. These include the modulus operator (%), the increment operator (++), the decrement operator (–), the logical operators (&&, ||, !), and the ternary operator (?:). Each of these operators has its own specific purpose and can be used to perform a variety of tasks.

Benefits of Operator Overloading in Javascript

Javascript operator overloading has numerous benefits for developers. It increases code legibility by making complex operations easier to read and understand. Additionally, it reduces the amount of code necessary to complete certain operations. This makes it easier for developers to write clean and maintainable code that is easy to debug and test.

Javascript operator overloading can also provide performance improvements by reducing the amount of memory and processing required to complete certain tasks. In some cases, it is also possible to reduce the amount of code sent over the network, which can lead to faster loading times for web applications.

Furthermore, operator overloading can help to reduce the complexity of code by allowing developers to use the same operator for multiple operations. This can help to reduce the amount of time spent debugging and testing code, as well as making it easier to read and understand.

Examples of Operator Overloading in Javascript

There are many examples of Javascript operator overloading. Here are some of the most common operations:

• Adding methods or properties to existing objects – e.g. adding a “getName()” method to an “Employee” object.
• Creating variables that act as objects – e.g. creating a number variable, which can contain properties like “min”, “max”, and “value”.
• Creating shortcuts for longer operations – e.g. using the “&&” operator to save time when writing conditions.
• Redefining the meaning of an operator in the context of a certain data type – e.g. using “+” to add two numbers together, or using “+” to concatenate two strings together.

Detailed Explanation & Code:

Let’s take the instance of overloading the “+” operator to concatenate two strings.

Normally, the “+” operator can be used to add two numbers:

But in JavaScript, the “+” operator is overloaded to also concatenate two strings:

Another instance is using the “+” operator to add a number and a string:

Here, JavaScript converts the number to a string and then concatenates the two strings.

Operator overloading can also be used to create custom functions that can be used to manipulate data in a more efficient way. For example, a custom function could be created to add two numbers together, or to concatenate two strings together. This can help to reduce the amount of code that needs to be written, and can make the code more readable.

Javascript Syntax Rules for Operator Overloading

When using operator overloading in Javascript, there are certain syntax rules that must be followed. For example, all operators must be placed at the beginning of an expression or within parentheses if they are written in between expressions. Additionally, when overloading an operator, the type of the variable or object must be clearly specified.

It is also important to note that when overloading an operator, the operator must be given a unique name. This is to ensure that the operator is not confused with any other existing operators. Furthermore, the operator must be declared as a function in order to be used in the code. Finally, the operator must be given a return value in order for it to be used in the code.

Best Practices for Implementing Operator Overloading

When implementing operator overloading in Javascript, it is important to consider its potential impacts on readability and performance. Because operator overloading can be counterintuitive and difficult to debug, it is important to make sure that any code that uses it is well-commented and thoroughly tested before being deployed into production.

Additionally, it is important to avoid using operator overloading whenever possible. While it can be useful for certain tasks, using it liberally may lead to poor performance or unmaintainable code. It is usually best to only use operator overloading when the gains in reduced complexity outweigh any potential performance or readability issues.

When using operator overloading, it is important to ensure that the code is as clear and concise as possible. This will help to ensure that the code is easy to read and understand, and that any potential issues can be quickly identified and resolved.

Troubleshooting Common Issues with Operator Overloading

Though it can be helpful for certain tasks, operator overloading in Javascript can also lead to unexpected behavior and difficult-to-debug errors. Some common issues include incorrect assignments, unexpected object properties, and unexpected behavior when chaining operators together.

When troubleshooting such issues, understanding the order of precedence of operators can be helpful. Additionally, understanding what is happening “under the hood” when an overloaded operator is used can help identify where potential issues may be occurring.

In summary, proper use of operator overloading in Javascript can help make code more concise and readable while also providing performance improvements. However, it is important to understand its syntax rules and best practices before attempting to use it. Additionally, proper testing and troubleshooting must be done to avoid any unexpected behaviors that can result from incorrect use.

When troubleshooting operator overloading issues, it is important to remember that the order of operations is important. Additionally, it is important to consider the context in which the operator is being used, as this can affect the behavior of the operator. Finally, it is important to consider the data types of the operands, as this can also affect the behavior of the operator.

Related Contents

• Java Method Overloading: Java-Method Explained
• In Java Method Overloading: Java-Method Explained
• Javascript Overload Function: Javascript Explained
• Java Class Overloading: Java-Class Explained
• Javascript Function Overload: Javascript Explained

Nisha Kumari

Nisha Kumari, a Founding Engineer at Bito, brings a comprehensive background in software engineering, specializing in Java/J2EE, PHP, HTML, CSS, JavaScript, and web development. Her career highlights include significant roles at Accenture, where she led end-to-end project deliveries and application maintenance, and at PubMatic, where she honed her skills in online advertising and optimization. Nisha's expertise spans across SAP HANA development, project management, and technical specification, making her a versatile and skilled contributor to the tech industry.

Written by developers for developers

Latest posts, mastering python’s writelines() function for efficient file writing | a comprehensive guide, understanding the difference between == and === in javascript – a comprehensive guide, compare two strings in javascript: a detailed guide for efficient string comparison, exploring the distinctions: == vs equals() in java programming, understanding matplotlib inline in python: a comprehensive guide for visualizations, related articles.

Cut review time by 50%

• Join us on Slack
• Twitter / X
• AI Code Review Agent
• AI Chat in your IDE
• AI Chat in your CLI
• AI Code Completions
• AI Prompt Templates
• AI Automations
• Documentation Agent
• Unit Test Agent
• Documentation
• 2023 State of AI in Software Report
• 2023 How Devs use AI Report
• Dev Resources
• Terms of Use
• Privacy Statement
• © 2023 Bito. All rights reserved.

Install on IDEs like IntelliJ, WebStorm etc.

Popular Articles

• Jsx: Markup Expressions In Javascript (May 04, 2024)
• The Tostring() Method (Apr 22, 2024)
• Understanding The Reflect Api In Javascript (Apr 22, 2024)
• Proxy Invariants And Usage Guidelines (Apr 22, 2024)
• Methods For Performing Meta-Level Operations On Objects (Apr 22, 2024)

Operator Overload: Making Sense of JavaScript Operators

Switch Language Switch to Hindi Switch to Spanish

Table of Contents

What Are JavaScript Operators?

How to use javascript operators, common operators in javascript, javascript arithmetic operators, javascript assignment operators, javascript comparison operators, javascript logical operators, javascript bitwise operators, javascript string operators, javascript special operators.

JavaScript is a powerful programming language that can do a lot of amazing things. But to really harness its full potential, you need to understand all of the different operators that are used in the language. In this blog post, I'm going to dive into the world of JavaScript operators and show you how to use them.

Simply put, operators are symbols that are used to perform an operation on one or more operands. In JavaScript, the most commonly used operators are the arithmetic operators, the assignment operators, the comparison operators, the logical operators, the bitwise operators, the string operators, the conditional operators, and the special operators. Let's take a look at each of these in turn.

Using operators in JavaScript is pretty straightforward. All you need to do is combine the operator with its operands to perform the operation. For example, if you want to add two numbers together, you would use the addition operator (+) with the two numbers:

var x = 4 + 5; // x is now equal to 9

Likewise, if you want to subtract two numbers, you would use the subtraction operator (-):

var x = 8 - 3; // x is now equal to 5

It's important to note that the order in which you use the operators matters. For example, if you were to write the following code:

var x = 8 - 3 + 5; // x is now equal to 10

The subtraction operator (–) would be performed first, followed by the addition operator (+). This is because the arithmetic operators in JavaScript follow the order of operations (also known as the PEMDAS rule).

Now that you know how to use JavaScript operators, let's take a look at some of the most common operators in JavaScript.

Arithmetic operators are used to performing basic mathematical operations such as addition, subtraction, multiplication, and division. The most commonly used -arithmetic operators in JavaScript are:

• Addition (+)
• Subtraction (-)
• Multiplication (*)
• Division (/)
• Modulus (%)

For example, if you want to add two numbers together, you would use the addition operator (+):

Similarly, if you want to subtract two numbers, you would use the subtraction operator (-):

You can also use the multiplication operator (*) to multiply two numbers:

var x = 4 * 5; // x is now equal to 20

And the division operator (/) to divide two numbers:

var x = 8 / 2; // x is now equal to 4

Finally, the modulus operator (%) can be used to find the remainder of a division operation:

var x = 8 % 3; // x is now equal to 2

Assignment operators are used to assign a value to a variable. The most commonly used assignment operators in JavaScript are:

• Assignment (=)
• Addition Assignment (+=)
• Subtraction Assignment (-=)
• Multiplication Assignment (*=)
• Division Assignment (/=)

For example, if you want to assign the number 5 to the variable x, you would use the assignment operator (=):

var x = 5; // x is now equal to 5

You can also use the addition assignment operator (+=) to add a number to a variable:

var x += 5; // x is now equal to 10

Similarly, the subtraction assignment operator (-=) can be used to subtract a number from a variable:

var x -= 5; // x is now equal to 5

The multiplication assignment operator (*=) can be used to multiply a number by a variable:

var x *= 5; // x is now equal to 25

And the division assignment operator (/=) can be used to divide a number by a variable:

var x /= 5; // x is now equal to 1

Comparison operators are used to comparing two values. The most commonly used comparison operators in JavaScript are:

• Equal To (==)
• Not Equal To (!=)
• Greater Than (>)
• Less Than ()
• Greater Than Or Equal To (>=)
• Less Than Or Equal To (=)

For example, if you want to check if two numbers are equal, you would use the equal to operator (==):

var x == 5; // x is now equal to true

You can also use the not equal to operator (!=) to check if two numbers are not equal:

var x != 5; // x is now equal to false

The greater than operator (>) can be used to check if one number is greater than another:

var x > 5; // x is now equal to false

And the less than operator () can be used to check if one number is less than another:

var x 5; // x is now equal to true

The greater than or equal to operator (>=) can be used to check if one number is greater than or equal to another:

var x >= 5; // x is now equal to true

Finally, the less than or equal to operator (=) can be used to check if one number is less than or equal to another:

var x = 5; // x is now equal to true

Logical operators are used to combining two or more conditions. The most commonly used logical operators in JavaScript are:

• AND (&&)

For example, if you want to check if two conditions are true, you would use the AND operator (&&):

var x && y; // x and y are both true

You can also use the OR operator (||) to check if one condition is true or the other:

var x || y; // either x or y is true

The NOT operator (!) can be used to check if a condition is false:

var x != y; // x is not equal to y

Bitwise operators are used to manipulating binary numbers. The most commonly used bitwise operators in JavaScript are:

• AND (&)
• Left Shift ()
• Right Shift (>>)
• Zero Fill Right Shift (>>>)

For example, if you want to check if two binary numbers are the same, you would use the AND operator (&):

var x & y; // x and y are both 1

You can also use the OR operator (|) to set a bit in a binary number:

var x | y; // either x or y is 1

The NOT operator (~) can be used to flip the bits in a binary number:

var x ~ y; // x is not equal to y

The XOR operator (^) can be used to check if two binary numbers are different:

var x ^ y; // x and y are different

The left shift operator () can be used to move all the bits in a number to the left:

var x 2; // x is now equal to 8

And the right shift operator (>>) can be used to move all the bits in a number to the right:

var x >> 2; // x is now equal to 2

Finally, the zero fill right shift operator (>>>) can be used to move all the bits in a number to the right and fill the empty bits with zeros:

var x >>> 2; // x is now equal to 0

String operators are used to manipulating strings. The most commonly used string operators in JavaScript are:

• Concatenation (+)
• Substring (substr())
• Substring with length (substr(start, length))

For example, if you want to concatenate two strings together, you would use the concatenation operator (+):

var x = 'Hello ' + 'World'; // x is now equal to 'Hello World'

You can also use the substring (substr()) method to get a substring of a string:

var x = 'Hello World'.substr(6); // x is now equal to 'World'

And the substring with length (substr(start, length)) method to get a substring of a string with a specific length:

var x = 'Hello World'.substr(6, 5); // x is now equal to 'World'

JavaScript Conditional Operators

Conditional operators are used to conditionally execute a statement. The most commonly used conditional operators in JavaScript are:

For example, if you want to conditionally execute a statement based on a condition, you would use the if operator:

if (x == 5) { // Do something }

You can also use the else operator to execute a statement if the condition is false:

if (x == 5) { // Do something } else { // Do something else }

And the switch operator to execute a statement based on a set of conditions:

switch (x) { case 5: // Do something break; default: // Do something else break; }

Special operators are used to performing special operations in JavaScript. The most commonly used special operators in JavaScript are:

• instance of

For example, if you want to check the type of a variable, you would use the type of operator:

var x = 5; typeof x; // x is now equal to 'number'

You can also use the delete operator to delete a property from an object:

var x = { a: 5 }; delete x.a; // x is now equal to { }

The in operator can be used to check if a property exists in an object:

var x = { a: 5 }; 'a' in x; // x is now equal to true

And the instanceof operator can be used to check if an object is an instance of a class:

var x = new Date(); x instanceof Date; // x is now equal to true

I hope this blog post has helped you make sense of JavaScript operators. As you can see, there are a lot of different operators that can be used in JavaScript, and it's important to understand how to use them properly in order to get the most out of the language. If you have any questions or comments, feel free to leave them in the comments section below. Thanks for reading!

• Skip to main content
• Select language
• Skip to search
• Assignment operators

An assignment operator assigns a value to its left operand based on the value of its right operand.

The basic assignment operator is equal ( = ), which assigns the value of its right operand to its left operand. That is, x = y assigns the value of y to x . The other assignment operators are usually shorthand for standard operations, as shown in the following definitions and examples.

Simple assignment operator which assigns a value to a variable. The assignment operation evaluates to the assigned value. Chaining the assignment operator is possible in order to assign a single value to multiple variables. See the example.

Addition assignment

The addition assignment operator adds the value of the right operand to a variable and assigns the result to the variable. The types of the two operands determine the behavior of the addition assignment operator. Addition or concatenation is possible. See the addition operator for more details.

Subtraction assignment

The subtraction assignment operator subtracts the value of the right operand from a variable and assigns the result to the variable. See the subtraction operator for more details.

Multiplication assignment

The multiplication assignment operator multiplies a variable by the value of the right operand and assigns the result to the variable. See the multiplication operator for more details.

Division assignment

The division assignment operator divides a variable by the value of the right operand and assigns the result to the variable. See the division operator for more details.

Remainder assignment

The remainder assignment operator divides a variable by the value of the right operand and assigns the remainder to the variable. See the remainder operator for more details.

Exponentiation assignment

This is an experimental technology, part of the ECMAScript 2016 (ES7) proposal. Because this technology's specification has not stabilized, check the compatibility table for usage in various browsers. Also note that the syntax and behavior of an experimental technology is subject to change in future version of browsers as the spec changes.

The exponentiation assignment operator evaluates to the result of raising first operand to the power second operand. See the exponentiation operator for more details.

Left shift assignment

The left shift assignment operator moves the specified amount of bits to the left and assigns the result to the variable. See the left shift operator for more details.

Right shift assignment

The right shift assignment operator moves the specified amount of bits to the right and assigns the result to the variable. See the right shift operator for more details.

Unsigned right shift assignment

The unsigned right shift assignment operator moves the specified amount of bits to the right and assigns the result to the variable. See the unsigned right shift operator for more details.

Bitwise AND assignment

The bitwise AND assignment operator uses the binary representation of both operands, does a bitwise AND operation on them and assigns the result to the variable. See the bitwise AND operator for more details.

Bitwise XOR assignment

The bitwise XOR assignment operator uses the binary representation of both operands, does a bitwise XOR operation on them and assigns the result to the variable. See the bitwise XOR operator for more details.

Bitwise OR assignment

The bitwise OR assignment operator uses the binary representation of both operands, does a bitwise OR operation on them and assigns the result to the variable. See the bitwise OR operator for more details.

Left operand with another assignment operator

In unusual situations, the assignment operator (e.g. x += y ) is not identical to the meaning expression (here x = x + y ). When the left operand of an assignment operator itself contains an assignment operator, the left operand is evaluated only once. For example:

Specifications

Browser compatibility.

• Arithmetic operators

Document Tags and Contributors

• JavaScript basics
• JavaScript first steps
• JavaScript building blocks
• Introducing JavaScript objects
• Introduction
• Grammar and types
• Control flow and error handling
• Loops and iteration
• Expressions and operators
• Numbers and dates
• Text formatting
• Regular expressions
• Indexed collections
• Keyed collections
• Working with objects
• Details of the object model
• Iterators and generators
• Meta programming
• A re-introduction to JavaScript
• JavaScript data structures
• Equality comparisons and sameness
• Inheritance and the prototype chain
• Strict mode
• JavaScript typed arrays
• Memory Management
• Concurrency model and Event Loop
• References:
• ArrayBuffer
• AsyncFunction
• Float32Array
• Float64Array
• GeneratorFunction
• InternalError
• Intl.Collator
• Intl.DateTimeFormat
• Intl.NumberFormat
• ParallelArray
• ReferenceError
• SIMD.Bool16x8
• SIMD.Bool32x4
• SIMD.Bool64x2
• SIMD.Bool8x16
• SIMD.Float32x4
• SIMD.Float64x2
• SIMD.Int16x8
• SIMD.Int32x4
• SIMD.Int8x16
• SIMD.Uint16x8
• SIMD.Uint32x4
• SIMD.Uint8x16
• SharedArrayBuffer
• StopIteration
• SyntaxError
• Uint16Array
• Uint32Array
• Uint8ClampedArray
• WebAssembly
• decodeURI()
• decodeURIComponent()
• encodeURI()
• encodeURIComponent()
• parseFloat()
• Array comprehensions
• Bitwise operators
• Comma operator
• Comparison operators
• Conditional (ternary) Operator
• Destructuring assignment
• Expression closures
• Generator comprehensions
• Grouping operator
• Legacy generator function expression
• Logical Operators
• Object initializer
• Operator precedence
• Property accessors
• Spread syntax
• async function expression
• class expression
• delete operator
• function expression
• function* expression
• in operator
• new operator
• void operator
• Legacy generator function
• async function
• for each...in
• function declaration
• try...catch
• Arguments object
• Arrow functions
• Default parameters
• Method definitions
• Rest parameters
• constructor
• element loaded from a different domain for which you violated the same-origin policy.">Error: Permission denied to access property "x"
• InternalError: too much recursion
• RangeError: argument is not a valid code point
• RangeError: invalid array length
• RangeError: invalid date
• RangeError: precision is out of range
• RangeError: radix must be an integer
• RangeError: repeat count must be less than infinity
• RangeError: repeat count must be non-negative
• ReferenceError: "x" is not defined
• ReferenceError: assignment to undeclared variable "x"
• ReferenceError: deprecated caller or arguments usage
• ReferenceError: invalid assignment left-hand side
• ReferenceError: reference to undefined property "x"
• SyntaxError: "0"-prefixed octal literals and octal escape seq. are deprecated
• SyntaxError: "use strict" not allowed in function with non-simple parameters
• SyntaxError: "x" is a reserved identifier
• SyntaxError: JSON.parse: bad parsing
• SyntaxError: Malformed formal parameter
• SyntaxError: Unexpected token
• SyntaxError: Using //@ to indicate sourceURL pragmas is deprecated. Use //# instead
• SyntaxError: a declaration in the head of a for-of loop can't have an initializer
• SyntaxError: applying the 'delete' operator to an unqualified name is deprecated
• SyntaxError: for-in loop head declarations may not have initializers
• SyntaxError: function statement requires a name
• SyntaxError: identifier starts immediately after numeric literal
• SyntaxError: illegal character
• SyntaxError: invalid regular expression flag "x"
• SyntaxError: missing ) after argument list
• SyntaxError: missing ) after condition
• SyntaxError: missing : after property id
• SyntaxError: missing ; before statement
• SyntaxError: missing = in const declaration
• SyntaxError: missing ] after element list
• SyntaxError: missing formal parameter
• SyntaxError: missing name after . operator
• SyntaxError: missing variable name
• SyntaxError: missing } after function body
• SyntaxError: missing } after property list
• SyntaxError: redeclaration of formal parameter "x"
• SyntaxError: return not in function
• SyntaxError: test for equality (==) mistyped as assignment (=)?
• SyntaxError: unterminated string literal
• TypeError: "x" has no properties
• TypeError: "x" is (not) "y"
• TypeError: "x" is not a constructor
• TypeError: "x" is not a function
• TypeError: "x" is not a non-null object
• TypeError: "x" is read-only
• TypeError: More arguments needed
• TypeError: can't access dead object
• TypeError: can't define property "x": "obj" is not extensible
• TypeError: can't redefine non-configurable property "x"
• TypeError: cyclic object value
• TypeError: invalid 'in' operand "x"
• TypeError: invalid Array.prototype.sort argument
• TypeError: invalid arguments
• TypeError: invalid assignment to const "x"
• TypeError: property "x" is non-configurable and can't be deleted
• TypeError: setting getter-only property "x"
• TypeError: variable "x" redeclares argument
• URIError: malformed URI sequence
• Warning: -file- is being assigned a //# sourceMappingURL, but already has one
• Warning: 08/09 is not a legal ECMA-262 octal constant
• Warning: Date.prototype.toLocaleFormat is deprecated
• Warning: JavaScript 1.6's for-each-in loops are deprecated
• Warning: String.x is deprecated; use String.prototype.x instead
• Warning: expression closures are deprecated
• Warning: unreachable code after return statement
• JavaScript technologies overview
• Lexical grammar
• Enumerability and ownership of properties
• Iteration protocols
• Transitioning to strict mode
• Template literals
• Deprecated features
• ECMAScript 2015 support in Mozilla
• ECMAScript 5 support in Mozilla
• ECMAScript Next support in Mozilla
• Firefox JavaScript changelog
• New in JavaScript 1.1
• New in JavaScript 1.2
• New in JavaScript 1.3
• New in JavaScript 1.4
• New in JavaScript 1.5
• New in JavaScript 1.6
• New in JavaScript 1.7
• New in JavaScript 1.8
• New in JavaScript 1.8.1
• New in JavaScript 1.8.5
• Documentation:
• All pages index
• Methods index
• Properties index
• Pages tagged "JavaScript"
• JavaScript doc status
• The MDN project

JS Tutorial

Js versions, js functions, js html dom, js browser bom, js web apis, js vs jquery, js graphics, js examples, js references, javascript operators.

Javascript operators are used to perform different types of mathematical and logical computations.

The Assignment Operator = assigns values

The Addition Operator + adds values

The Multiplication Operator * multiplies values

The Comparison Operator > compares values

JavaScript Assignment

The Assignment Operator ( = ) assigns a value to a variable:

Assignment Examples

Javascript addition.

The Addition Operator ( + ) adds numbers:

JavaScript Multiplication

The Multiplication Operator ( * ) multiplies numbers:

Multiplying

Types of javascript operators.

There are different types of JavaScript operators:

• Arithmetic Operators
• Assignment Operators
• Comparison Operators
• String Operators
• Logical Operators
• Bitwise Operators
• Ternary Operators
• Type Operators

JavaScript Arithmetic Operators

Arithmetic Operators are used to perform arithmetic on numbers:

Arithmetic Operators Example

Arithmetic operators are fully described in the JS Arithmetic chapter.

Advertisement

JavaScript Assignment Operators

Assignment operators assign values to JavaScript variables.

The Addition Assignment Operator ( += ) adds a value to a variable.

Assignment operators are fully described in the JS Assignment chapter.

JavaScript Comparison Operators

Comparison operators are fully described in the JS Comparisons chapter.

JavaScript String Comparison

All the comparison operators above can also be used on strings:

Note that strings are compared alphabetically:

JavaScript String Addition

The + can also be used to add (concatenate) strings:

The += assignment operator can also be used to add (concatenate) strings:

The result of text1 will be:

When used on strings, the + operator is called the concatenation operator.

Adding Strings and Numbers

Adding two numbers, will return the sum, but adding a number and a string will return a string:

The result of x , y , and z will be:

If you add a number and a string, the result will be a string!

JavaScript Logical Operators

Logical operators are fully described in the JS Comparisons chapter.

JavaScript Type Operators

Type operators are fully described in the JS Type Conversion chapter.

JavaScript Bitwise Operators

Bit operators work on 32 bits numbers.

The examples above uses 4 bits unsigned examples. But JavaScript uses 32-bit signed numbers. Because of this, in JavaScript, ~ 5 will not return 10. It will return -6. ~00000000000000000000000000000101 will return 11111111111111111111111111111010

Bitwise operators are fully described in the JS Bitwise chapter.

Test Yourself With Exercises

Multiply 10 with 5 , and alert the result.

Start the Exercise

Test Yourself with Exercises!

Exercise 1 »   Exercise 2 »   Exercise 3 »   Exercise 4 »   Exercise 5 »

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

• Trending Now
• Foundational Courses
• Data Science
• Practice Problem
• Machine Learning
• System Design
• DevOps Tutorial

Assignment Operators in Programming

• Binary Operators in Programming
• Operator Associativity in Programming
• C++ Assignment Operator Overloading
• What are Operators in Programming?
• Assignment Operators In C++
• Bitwise AND operator in Programming
• Increment and Decrement Operators in Programming
• Types of Operators in Programming
• Logical AND operator in Programming
• Modulus Operator in Programming
• Solidity - Assignment Operators
• Augmented Assignment Operators in Python
• Pre Increment and Post Increment Operator in Programming
• Right Shift Operator (>>) in Programming
• JavaScript Assignment Operators
• Move Assignment Operator in C++ 11
• Assignment Operators in Python
• Assignment Operators in C
• Subtraction Assignment( -=) Operator in Javascript

Assignment operators in programming are symbols used to assign values to variables. They offer shorthand notations for performing arithmetic operations and updating variable values in a single step. These operators are fundamental in most programming languages and help streamline code while improving readability.

Table of Content

What are Assignment Operators?

• Types of Assignment Operators
• Assignment Operators in C++
• Assignment Operators in Java
• Assignment Operators in C#
• Assignment Operators in Javascript
• Application of Assignment Operators

Assignment operators are used in programming to  assign values  to variables. We use an assignment operator to store and update data within a program. They enable programmers to store data in variables and manipulate that data. The most common assignment operator is the equals sign ( = ), which assigns the value on the right side of the operator to the variable on the left side.

Types of Assignment Operators:

• Simple Assignment Operator ( = )
• Addition Assignment Operator ( += )
• Subtraction Assignment Operator ( -= )
• Multiplication Assignment Operator ( *= )
• Division Assignment Operator ( /= )
• Modulus Assignment Operator ( %= )

Below is a table summarizing common assignment operators along with their symbols, description, and examples:

Assignment Operators in C:

Here are the implementation of Assignment Operator in C language:

Assignment Operators in C++:

Here are the implementation of Assignment Operator in C++ language:

Assignment Operators in Java:

Here are the implementation of Assignment Operator in java language:

Assignment Operators in Python:

Here are the implementation of Assignment Operator in python language:

Assignment Operators in C#:

Here are the implementation of Assignment Operator in C# language:

Assignment Operators in Javascript:

Here are the implementation of Assignment Operator in javascript language:

Application of Assignment Operators:

• Variable Initialization : Setting initial values to variables during declaration.
• Mathematical Operations : Combining arithmetic operations with assignment to update variable values.
• Loop Control : Updating loop variables to control loop iterations.
• Conditional Statements : Assigning different values based on conditions in conditional statements.
• Function Return Values : Storing the return values of functions in variables.
• Data Manipulation : Assigning values received from user input or retrieved from databases to variables.

Conclusion:

In conclusion, assignment operators in programming are essential tools for assigning values to variables and performing operations in a concise and efficient manner. They allow programmers to manipulate data and control the flow of their programs effectively. Understanding and using assignment operators correctly is fundamental to writing clear, efficient, and maintainable code in various programming languages.

Please Login to comment...

Similar reads.

• Programming

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Operator Overloading

GraalVM JavaScript provides an early implementation of the ECMAScript operator overloading proposal . This lets you overload the behavior of JavaScript’s operators on your JavaScript classes.

If you want to experiment with this feature, you will first need to enable it. Since both the proposal and our implementation of it are in early stages, you will need to set the following experimental option.

After setting the option, you will see a new builtin in the global namespace, the Operators function. You can call this function, passing it a JavaScript object as an argument. The object should have a property for every operator you wish to overload, with the key being the name of the operator and the value being a function which implements it. The return value of the Operators function is a constructor that you can then subclass when defining your type. By subclassing this constructor, you get a class whose objects will all inherit the overloaded operator behavior that you defined in your argument to the Operators function.

Basic Example

Let’s look at an example from the original proposal featuring vectors:

Here we define overloads for two operators, + and == . Calling the Operators function with the table of overloaded operators yields the VectorOps class. We then define our Vector class as a subclass of VectorOps .

If we create instances of Vector , we can observe that they follow our overloaded operator definitions:

Example with Mixed Types

It is also possible to overload operators between values of different types, allowing, for example, multiplication of vectors by numbers.

To define mixed-type operators, we need to pass additional objects to the Operators function. These extra tables should each have either a left property or a right property, depending on whether we are overloading the behavior of operators with some other type on the left or on the right side of the operator. In our case, we are overloading the * operator for cases when there is a Number on the left and our type, Vector , on the right. Each extra table can have either a left property or a right property and then any number of operator overloads which will apply to that particular case.

Let’s see this in action:

The function Operators(table, extraTables...) returns a class with overloaded operators. Users should define their own class which extends that class.

The table argument must be an object with one property for every overloaded operator. The property key must be the name of the operator. These are the names of operators which can be overloaded:

• binary operators: "+" , "-" , "*" , "/" , "%" , "**" , "&" , "^" , "|" , "<<" , ">>" , ">>>" , "==" , "<"
• unary operators: "pos" , "neg" , "++" , "--" , "~"

The "pos" and "neg" operator names correspond to unary + and unary - , respectively. Overloading "++" works both for pre-increments ++x and post-increments x++ , the same goes for "--" . The overload for "==" is used both for equality x == y and inequality x != y tests. Similarly, the overload for "<" is used for all comparison operators ( x < y , x <= y , x > y , x >= y ) by swapping the arguments and/or negating the result.

The value assigned to an operator name must be a function of two arguments in the case of binary operators or a function of one argument in the case of unary operators.

The table argument can also have an open property. If so, the value of that property must be an array of operator names. These are the operators which future classes will be able to overload on this type (e.g. a Vector type might declare "*" to be open so that later a Matrix type might overload the operations Vector * Matrix and Matrix * Vector ). If the open property is missing, all operators are considered to be open for future overloading with other types.

Following the first argument table are optional arguments extraTables . Each of these must also be an object. Each extra table must have either a left property or a right property, not both. The value of that property must be one of the following JavaScript constructors:

• any class with overloaded operators (i.e. extended from a constructor returned by Operators )

The other properties of the extra table should be operator overloads as in the first table argument (operator name as key, function implementing the operator as value).

These extra tables define the behavior of operators when one of the operand types is of a type other than the one being defined. If the extra table has a left property, its operator definitions will apply to cases when the left operand is of the type named by the left property and the right operand is of the type whose operators are being defined. Similarly for the right property, if the extra table has a right property, the table’s operator definitions will apply when the right operand has the named type and the left operand has the type whose operators are being defined.

Note that you are free to overload any of the binary operators between your custom type and the JavaScript numeric types Number and BigInt . However, the only operators you are allowed to overload between your custom type and the String type are "==" and "<" .

The Operators function will return a constructor that you will usually want to extend in your own class. Instances of that class will respect your overloaded operator definitions. Whenever you use an operator on an object with overloaded operators, the following happens:

1) Every operand that does not have overloaded operators is coerced to a primitive. 2) If there is an applicable overload for this pairing of operands, it is called. Otherwise, a TypeError is thrown.

Notably, your objects with overloaded operators will not be coerced to primitives when applying operators and you can get TypeError s when applying undefined operators to them. There are two exceptions to this:

1) If you are using the + operator and one of the arguments is a string (or an object without overloaded operators that coerces to a string via ToPrimitive ), then the result will be a concatenation of the ToString values of the two operands. 2) If you are using the == operator and there is no applicable overload found, the two operands are assumed to be different ( x == y will return false and x != y will return true ).

Differences from the Proposal

There a few differences between the proposal (as defined by its specification and prototype implementation) and our implementation in GraalVM JavaScript:

• You do not have to use the with operators from construction to enable the use of overloaded operators. When you overload operators for a class, those operators can then be used anywhere without using with operators from . Furthermore, our parser will not accept the with operators from clause as valid JavaScript.
• You cannot use decorators to define overloaded operators. At the time of implementing this proposal, GraalVM JavaScript does not support decorators (these are still an in-progress proposal).
• You cannot overload the "[]" and "[]=" operators for reading and writing integer-indexed elements. These two operators require more complex treatment and are not currently supported.