Skip to content
Home » JavaScript Assignment Operator

JavaScript Assignment Operator

    The JavaScript assignment operator assigns a value to a JavaScript variable.The value of a variable or an expression is assigned to another variable, the variable that receives the value is always on left hand side and expression whose value is assigned is on right hand side of the assignment operator.

    Syntax

    //Syntax
    var <variable> = < variable or expression>;
    //Example
    var myNumber = 334.55;
    var myExp = a + 3;

    The JavaScript assignment operation is evaluated from right-to-left.

    There are many types of assignment in JavaScript which are:

    • Simple assignment
    • Chained assignment
    • Complex or Self-assignment
    • Destructuring assignment

    We shall discuss each one of them one-by-one with suitable examples.

    Simple Variable Assignment

    You have already seen an example of simple assignment in the earlier section. In this method, you simply assign a value of constant, or a variable or an expression to the variable on the left-hand side of the assignment operator.

    Consider the following example,

    //variable declaration simple assignment
    var A = 33;    //assigned a constant
    var B = C;     //assigned a variable value
    var F = 3 * 4; //assigned an expression

    Chained Assignment

    The JavaScript programming allows multiple assignments at the same time that looks like a chained assignment. Each part of the chain is executed first from right and then followed by other assignment to the leftmost variable.

    //variable declaration chained assignment
    var A = B = C = 220;
    //The above is same as 
    var A = 220;
    var B = 220;
    var C = 220;
    var D = 220;

    The chained assignment starts with rightmost expression first and then move to the leftmost variable in the expression. The expression A = B = C is same as A = (B = C). The expression in the parenthesis is executed first and then the next pair (A = B).

    Self-Assignment

    The self-assignment is compound assignment where the left-hand variable is part of right-hand expression. Consider the following example.

    //variable declaration self-assignemnt
    var x += 10;
    //It is same as 
    var x = x + 10;

    The expression involving left-hand side( x + 10) on the right side is of assignment operator is evaluated first, and then assigned back to the variable x. This is self-assignment.

    Note that the expression x += 10 can also be written as x = x + 10;

    Here is a list of all self-assignment types in JavaScript.

    Assignment ExpressionExpressionStandard Form
    additionx += 1x = x + 1
    subtractionx -= 1x = x – 1
    multiplicationx *= 1x = x * 1
    divisionx /= 1x = x / 1
    remainderx %= 1x = x % 1
    exponentialx **=1x = x ** 1
    right shiftx >>= 1x = x >> 1
    left shiftx <<= 1x = x << 1
    unsigned right shiftx >>>= 1x = x >>> 1
    logical ANDx &&=1x = x && 1
    logical OR x ||= 1x = x || 1
    bitwise ANDx &= 1x = x &= 1
    bitwise ORx |= 1x = x | 1
    bitwise XORx ^= 1x = x ^ 1
    types of self-assignments

    Destructuring Assignment

    The destructuring allows to quickly assign the values of an array to variables. Consider the following example, where we accessed each element of the by its index and assigned it to another variables.

    //array declaration
    var fruits = ["oranges","apples","banana", "mangoes"];
    //assigning values of array to variables
    var item1 = fruits[0];
    var item2 = fruits[1];
    var item3 = fruits[2];
    var item4 = fruits[3];

    The same can be does in few steps using destructuring. See the same example with destructuring below.

    //array declaration
    var fruits = ["oranges","apples","banana", "mangoes"];
    //destructuring array 
    var [item1, item2, item3, item4] = fruits;
    //output to console
    console.log(item1);
    console.log(item2);
    console.log(item3);
    console.log(item4);

    The output of the above program is given below.

    You can clearly see how easily we were able to assign values of array to variables using destructuing assignment.

    In the next post, we will discuss about arithmetic operators.

    Exit mobile version