Solidity – Assignment Operators

Solidity is a high-level, statically-typed programming language for Ethereum smart contracts. Python, JavaScript, and C++ impact it. Solidity has several variable and value assignment operators. Solidity supports the following types of operators:

1. Simple Assignment Operator.
2. Arithmetic Assignment Operator.
3. Bitwise Assignment Operator.

Simple Assignment Operator

The simple assignment operator(=) assigns the value of the right-hand operand to the left-hand operand.

Example:

uint a;

a = 10; // Assigns the value 10 to the variable a.

Below is the Solidity program to implement a simple assignment operator.

Solidity

// Solidity program to implement
// simple assignment operator
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract AssignmentOperators {

  function basicAssignment() public pure returns (uint)
  {
    uint a;
    a = 10;

    // a is now equal to 10
    return a;
  }
}

Output:

Arithmetic Assignment Operators

These operators perform arithmetic operations and then assign the result to the left-hand operand. Solidity supports the following arithmetic assignment operators:

Operator	Denotation	Description
Addition Assignment	+=	Adds the right-hand operand to the left-hand operand and assigns the result to the left-hand operand.
Subtraction Assignment	-=	Subtracts the right-hand operand from the left-hand operand and assigns the result to the left-hand operand.
Multiplication Assignment	*=	Multiplies the right-hand operand by the left-hand operand and assigns the result to the left-hand operand.
Division Assignment	/=	Divides the left-hand operand by the right-hand operand and assigns the result to the left-hand operand.
Modulus Assignment	%=	Calculates the modulus (remainder) after dividing the left-hand operand by the right-hand operand and assigns the result to the left-hand operand.

Example:

uint a = 10;

a += 5; // a = a + 5 => a = 15

a -= 3; // a = a – 3 => a = 12

a *= 2; // a = a * 2 => a = 24

a /= 4; // a = a / 4 => a = 6

a %= 5; // a = a % 5 => a = 1

Note: Solidity does not support increment (++) and decrement (–) operators, which are common in other programming languages.

Below is the Solidity program to implement Arithmetic Assignment Operators:

Solidity

// Solidity program to implement
// Arithmetic Assignment Operators
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract AssignmentOperators {

  function arithmeticAssignment() public pure returns (uint, uint,
                                                       uint, uint, uint)
  {
    // Addition assignment (+=)
    uint a = 5;

    // a is now equal to 8 (5 + 3)
    a += 3;

    // Subtraction assignment (-=)
    uint b = 10;

    // b is now equal to 6 (10 - 4)
    b -= 4;

    // Multiplication assignment (*=)
    uint c = 6;

    // c is now equal to 12 (6 * 2)
    c *= 2;

    // Division assignment (/=)
    uint d = 25;

    // d is now equal to 5 (25 / 5)
    d /= 5;

    // Modulus assignment (%=)
    uint e = 27;

    // e is now equal to 7 (27 % 10)
    e %= 10;

    return (a, b, c, d, e);
  }
}

Output:

Bitwise Assignment Operators

These operators perform bitwise operations and then assign the result to the left-hand operand. Solidity supports the following bitwise assignment operators:

Operator	Denotation	Description
Bitwise AND Assignment	&=	Performs a bitwise AND operation on the left-hand operand and the right-hand operand and assigns the result to the left-hand operand.
Bitwise OR Assignment	|=	Performs a bitwise OR operation on the left-hand operand and the right-hand operand and assigns the result to the left-hand operand.
Bitwise XOR Assignment	^=	Performs a bitwise XOR operation on the left-hand operand and the right-hand operand and assigns the result to the left-hand operand.
Left shift Assignment	<<=	Shifts the left-hand operand’s bits to the left by the number of positions specified by the right-hand operand and assigns the result to the left-hand operand.
Right shift Assignment	>>=	Shifts the left-hand operand’s bits to the right by the number of positions specified by the right-hand operand and assigns the result to the left-hand operand.

Example:

uint a = 0x0F; // 15 in hexadecimal

a &= 0x3C; // a = a & 0x3C => a = 0x0C (12 in decimal)

a |= 0x30; // a = a | 0x30 => a = 0x3C (60 in decimal)

a ^= 0x12; // a = a ^ 0x12 => a = 0x2E (46 in decimal)

a <<= 2; // a = a << 2 => a = 0xB8 (184 in decimal)

a >>= 1; // a = a >> 1 => a = 0x5C (92 in decimal)

Below is the Solidity program to implement bitwise assignment operators:

Solidity

// Solidity program to implement
// bitwise assignment operators
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract AssignmentOperators {
  function bitwiseAssignment() public pure returns (uint, uint,
                                                    uint, uint, uint)
  {
    // Bitwise AND assignment (&=)
    // 0011 1100 in binary
    uint a = 0x3C;

    // 0010 1010 in binary
    // a is now equal to 0x28 (0010 1000 in binary)
    a &= 0x2A;

    // Bitwise OR assignment (|=)
    // 0011 1100 in binary
    uint b = 0x3C;

    // 0010 1010 in binary
    // b is now equal to 0x3E (0011 1110 in binary)
    b |= 0x2A;

    // Bitwise XOR assignment (^=)
    // 0011 1100 in binary
    uint c = 0x3C;

    // 0010 1010 in binary
    // c is now equal to 0x16 (0001 0110 in binary)
    c ^= 0x2A;

    // Left shift assignment (<<=)
    // 0011 1100 in binary
    uint d = 0x3C;

    // Shift left by 2 positions
    // d is now equal to 0xF0 (1111 0000 in binary)
    d <<= 2;

    // Right shift assignment (>>=)
    // 0011 1100 in binary
    uint e = 0x3C;

    // Shift right by 2 positions
    // e is now equal to 0x0F (0000 1111 in binary)
    e >>= 2;

    return (a, b, c, d, e);
  }
}

Output: