Valuetypes in Solidity
Tags: web3, solidity, beginners, ethereum
Published: 2022-08-28 15:24:22

Solidity is a smart contract programming language. It is most commonly used to write smart contracts for the Ethereum blockchain but can be used to implement smart contracts on any blockchain that uses the Ethereum Virtual Machine (EVM).
Like all other programming languages, datatypes in Solidity can be classified into 2 types, Values and References.

- 
**Values**: values simply mean that the datatype stores a value e.g boolean stores either `true` or `false`.
- 
**References**: datatypes of type reference do not store a value instead they store a reference to where the actual data is stored e.g an Array is a datatype of type reference.

In this article, we'll be looking at Value Datatypes and how to use them in a solidity contract.

### Boolean

```javascript
contract ValueType {
	bool public boo= true;
}
```
Here we have a contract named `ValueType`, we will declare all the value datatypes inside this contract. 
In the contract, we declare a boolean datatype using the keyword `bool`, this boolean is declared as `public` so it can be called outside the contract. 
The variable is given the name `boo` and its value set to `true`, the value of a boolean can either be `true` or `false`. 

### Unsigned Integer

Next up, we'll be looking at the unsigned integer datatype.
An unsigned integer means the datatype has to be greater than or equal to zero, we can not use negative numbers with unsigned integers only zero or positive numbers.
```javascript
contract ValueType {
	uint public numU= 123;
}
```
Here `uint` keyword is used to declare an unsigned integer, the variable is declared as `public`, the variable is given the name `numU`, and its value is set to `123`.
The keyword `uint` is an alias for `0` to `2^256 - 1`
There are different variants of `uint` with different ranges starting from `uint8`, `uint16`, etc which goes all the way to `uint256`.
Among these variations of `uint`, the most common one we will come across often is `uint256`. 
Unsigned integers only support numbers that are greater than zero, but what of cases where we need to use a negative number, in this case, we use integers.

### Integers

Next up, let's take a look at integers.
Integers allow us to use positive and negative numbers in our contract.
```javascript
contract ValueType {
	int public numI= -123;
}
```
An integer is declared using the `int` keyword, the variable here is declared to be `public`, the variable is given the name `numI` and the value set to `-123`.
Similar to unsigned integers, the keyword `int` is also an alias for `int256`.
There are also different variations of `int`, starting from `int8`, `int16` to `int256`.

### Address
Another value datatype that we will come across a lot in Solidity is type `address`.

```javascript
contract ValueType {
	address public addr= 0xFAed2F163D65141FbD48fD5FE1a4C08c2e50a4bF;
}
```
An address datatype is declared using the keyword `address`, this variable is made `public`, and the address is given the name `addr` and we set the value to a random Ethereum wallet address.

### byte32
The last value datatype we will be looking at in this article is `byte32`, we will encounter this datatype when working with the cryptographic cache function available in solidity called `kachek256`.
```javascript
contract ValueType {
	bytes32 public b32= 0x0000000000000000000000000000000;
}
```
We declare a `bytes32` by using the keyword `bytes32`, the variable is made public, and given the name `b32`, the value here is set to some random 32bytes.



## Conclusion
We haven't covered all the Valuetypes available in Solidity, in this article, but these are the most common ones we will come across when writing a Smart contract, you can find a full list of Solidity Valuetypes in the [documentation](https://docs.soliditylang.org/en/v0.8.16/types.html#value-types).

Thanks for reading, If you enjoyed reading this as much as I enjoyed writing it, then Like and Share this with your friends and feel free to connect with me on [Twitter](https://mobile.twitter.com/kolsCodes) 👨‍💻.