Solidity - Assignment Operators
Last Updated :
24 Apr, 2025
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:
- Simple Assignment Operator.
- Arithmetic Assignment Operator.
- 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:
