A Information to Utilizing Solidity Information Varieties

Solidity Blockchain programming tutorial

Solidity affords extra knowledge varieties than most programming languages. We will divide these varieties into worth varieties and reference varieties. Worth varieties are these which tackle a selected worth, whereas reference varieties retailer the reference to an object.

This programming tutorial will discover the in-built sorts of the Solidity language whereas additionally contrasting them with the opposite common languages so to simply see the variations.

Learn: The way to Handle Variable and Operate Visibility in Solidity

Integer Varieties in Solidity

There are two sorts of obtainable integer values in Solidity: signed and unsigned. The signed values lie on both facet of the quantity line (i.e. they will both be constructive or destructive). The unsigned values start from zero to the utmost accepted constructive worth.

Signed values may be of the next subtypes: int8, int16, int24, and int256. Equally, unsigned values may be of the subtypes uint8, uint16, uint24, and uinit256. The shorthand for uint256 and unit are for int256 and int.

Astute builders might have observed that integer varieties change by ranges of 8.

The utmost worth that every integer kind can settle for is what differentiates the varied varieties. For instance, uint8 accepts a max worth of 2**8 -1, uint16 a max of 2**16 – 1, and so forth, to a most worth of 2**256 – 1.

Tackle Varieties in Solidity

Ethereum has 20 byte (160 bit) hexadecimal values referred to as addresses that it makes use of to determine accounts or good contracts. Addresses are particular numbers that should be declared utilizing one of many following key phrases: tackle or tackle payable.

The distinction between the 2 key phrases is that tackle payable can obtain tokens whereas tackle can not. Sensible contracts usually use tackle, whereas consumer accounts use tackle payable.

It’s doable for builders to transform a variable declared tackle to at least one which is payable utilizing the payable() perform, as proven within the following code instance:

tackle a = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
tackle payable b = payable (a);

Given the particular nature of tackle varieties, Solidity offers a number of helpful strategies and variables to get varied details about their state. These embrace:

  • Variables: tackle.steadiness is how a lot a given tackle has within the foreign money smallest items of the token. For Ethereum, that is Wei.
  • Strategies: tackle.ship() sends tokens to an tackle and returns a boolean worth. tackle.switch() transfers tokens to an tackle and returns an error if false.

Learn: Information to Inheritance in Solidity

Solidity Features

In Solidity, features are varieties, in contrast to in lots of different programming languages. To create a perform in Solidity, builders use the key phrase perform, adopted by the perform identify and parentheses. The parentheses can optionally have arguments. These arguments are declared in the identical method as variables. Here’s a code instance displaying easy methods to create a fundamental perform in Solidity:

perform chooseWinner( tackle x) {
// some code

As you could have observed within the code instance above, our perform additionally has curly brackets { }. That is the place you place the tactic physique. These { } can be utilized when you find yourself defining an interface or an summary technique.

Solidity Reference Varieties

There are three reference varieties in Solidity: arrays, structs, and mappings. Each time a programmer defines a reference kind, they should point out its knowledge location as effectively. The doable knowledge places embrace:

  • storage: This consists of information that’s completely saved on the blockchain and because of this it carries a excessive fuel price. All of the state variables of a sensible contract are saved right here by default.
  • reminiscence: This can be a momentary knowledge location that lasts solely till an exterior perform name is made. That is the place perform parameters are usually saved. reminiscence carries a low fuel price.
  • calldata: This can be a read-only reminiscence location that shops perform arguments. Builders can not modify the info saved right here within the perform physique.


In Solidity, builders can declare an array in the same method to many different programming languages, corresponding to Java. Right here is the way you declare an array in Solidity:

int48[12]  width;

The above array, named width, can retailer 12 values of kind int48. If you wish to create a dynamic array, then don’t place any worth within the sq. brackets.

Not like many different languages, the place uninitialized values are handled as undefined, Solidity defines default values for every uninitialized array factor. Builders can entry an array factor utilizing its index place or place within the array. Index positions run from 0 to n-1, identical to in different programming languages. Here’s a checklist of Solidity array varieties and their default values:

  • bool: false
  • Integer: 0
  • tackle: 0x0000000000000000000000000000000000000000

As well as, Solidity has some helpful strategies that may assist programmers manipulate arrays, together with:

  • push(factor): Used so as to add an array factor to finish of an array
  • pop(): This removes the final factor of the array and reduces the array size by 1

If you wish to decide the size of an array, you need to use the array.size area.


In Solidity, a struct is a knowledge construction that may retailer parts of various knowledge varieties. Right here is an instance of easy methods to outline a struct in Solidity:

struct EthereumTestnet{

int32 chainID = 5;
tackle ensAddress = “0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e” 


To entry a struct worth, merely use the struct identify adopted by .factor. As an illustration, to entry the chain ID of the above struct you’d use the next code:

int32 var = EthereumTestnet.chainID;


A mapping shops knowledge of key-value pairs. Any of the primitive knowledge varieties in Solidity generally is a key-value, besides an object. In the meantime, a price may be of any acceptable kind.

To outline a mapping in Solidity, builders use the key phrase mapping, adopted by the (key => worth) and its identify, as present on this code instance:<//p>

mapping(tackle => uint256) public funds; // you may also add a visibility modifier as proven 

The above mapping associates an tackle to nonetheless many tokens it paid. Programmers can entry the worth of a mapping by utilizing the key of the specified worth. You too can assign a price to it in the same manner. This idea is demonstrated within the code under, the place we create a perform to map an tackle after which returns the cost tackle. The feedback break every part down in better element:

perform subscribe() exterior payable {
       // units worth of mapping
       tackle sender = msg.sender;
       uint quantity = msg.worth;
       funds[sender] = quantity;

   perform getPaidAmount(tackle addr) public view returns (uint){
       // will get worth for given tackle
       return funds[addr];

Closing Ideas on Solidity Information Varieties

On this programming tutorial, we realized easy methods to work with varied primitive knowledge varieties within the Solidity programming language. Bear in mind, every time you’re utilizing a reference kind, you all the time want to point its knowledge location. For state variables, the info location is implicitly outlined as storage, so that you would not have to point it.

Learn: Greatest Kanban Instruments for Builders

Related Articles


Please enter your comment!
Please enter your name here

Latest Articles