Solidity Tutorial: Learn Solidity for beginners

Ethereum Solidity is a high-level language for smart contracts with a JavaScript like syntax. Solidity is a tool for generating machine-level code to execute on EVM. The Solidity compiler takes the high-level code and breaks it down into simpler instructions. The Solidity code is wrapped in Contracts.

Source files can contain any number of contract definitions, including directives and pragma directives.

Ethereum Solidity supports import statements that are very similar to those available in JavaScript, even though Solidity is unaware of the concept of default export.

At the global level, import statements of the following form can be used:

import "filename";
Copy the code

The above statement imports all global symbols from filename into the current global scope.

import * as symbolName from "filename";
Copy the code

The following types are also called value types because their variables are always passed by value.

Key words: int/uint (uint8 to uint256, step size is 8 (unsigned, maximum 256 bits), int8 is int256)

Signed and unsigned integers of various sizes.

Ex. :

contract MySample{
uint UnsignedInt =50;
}
Copy the code

In the above statement, we create a uint named InsignedInt and set it to 50.

You can use the balance attribute to query the balance of an address and use the Transfer function to send Ethernet to the address.

address x = 0x123;
address myAddress = this;
if  (x.balance < 10 && myAddress.balance > = 10)
x.transfer(10);
Copy the code

Solidity has the same operators as JavaScript. Solidity has four types of operators:

Stability of increment operators: A ++, a-, ++a, -a, a+=1, a=a+1

Similar rules apply to other programming languages.

Logical operators in Solidity:! (negative), && (logic), | | (logical or) = = (equal),! = (unequal)

Ex. :

contract operators { // Arithmetic Operators // +,-,*,/, %, ** // Incremental Operators // a++, a--, a+=1, a=a+1,++a,--a; a=10; a= a++; //here, output will be 10, because the value is first returned and then then increment is done a=++a; //Logical Operators ! , &&, | | = =,! = isOwner = true && false; var orValue= 0x02 | 0x01; // output would be 0x03 //Bitwise Operators~,>>, <<; function Operators() { // Initialize state variables here}}Copy the code

More complex data types are sometimes required now. For this, Solidity provides the structure.

Solidity provides a way to define new types in Structs form. Structs are custom types that can group multiple variables.

Pragma solidity ^ 0.4.0; contract Ballot { struct Voter { // Struct uint weight1, weight2, weight3; bool voted; address delegate1, delegate2, delegate3, delegate4; string name; uint vote1, vote2, vote3, vote4, vote5; uint height1, height2, height3 } }Copy the code

Note: A structure can have only 16 members, more than that may cause the following errors: Stack too Deep.

Structure allows you to create more complex data types with multiple attributes.

Now, what if you need some collection, like an address? Well, like most languages, Solidity has arrays.

Maps can be thought of as hash tables that are virtually initialized such that every possible key exists and is mapped to a value whose byte representation is all zero: the default value of the type.

The mapping is declared as:

Mapping(_Keytype => _ValueType )
Copy the code

Note: _Keytype can be almost any type except dynamically sized arrays, contracts, enumerations, and structures.

Ex. :

contract MappingExample {
mapping(address => uint) public balances;
function update(uint newBalance) {
balances[msg.sender] = newBalance;  }}
contract MappingUser {
function f() returns (uint) {
MappingExample m = new MappingExample();
m.update(100);
return m.balances(this);
}}
Copy the code

Here is how to declare functions in Solidity.

function sampleFunc(string name, uint amount) {
}
Copy the code

The above declaration is an empty function that takes two arguments: a string and a uint.

This function can be called like this:

sampleFunc("Shashank", 10000);
Copy the code

Speaking of functions, Solidity also provides function modifiers.

Solidity supports multiple inheritance by copying code that contains polymorphism.

contract Owned {
address Owner ;
function owned() {
owner = msg.sender;
}}
contract Mortal is Owned {  // 'is' keyword is used for inheritance
function kill(){
self-destruct(owner);   }}
contract User is Owned, Mortal //Multiple inheritance
{
string public UserName;
function User(string _name){
UserName = _name;
}}
Copy the code

Well, I think the concepts discussed above are enough to get you started programming with Solidity.

Go write code!!

With this I have finished this Solidity Tutorial blog. I hope you enjoy reading this blog and find it informative. By now, an understanding of Solidity Programming Language is essential. Now go practice.

If you’re looking for a quick start on Ethereum development, check out this tutorial: Getting Started with Ethereum, which focuses on smart contracts and DApp development.

Other blockchain tutorials are as follows:

• Ethereum development advanced tutorial, mainly introduces the use of Node.js, mongodb, blockchain, IPFS to achieve decentralized e-commerce DApp combat, suitable for advanced.
• Java Ethereum development tutorial, mainly for Java and Android programmers for blockchain Ethereum development web3J details.
• Python Ethereum is a detailed explanation of blockchain ethereum development by Python engineers using Web3.py.
• PHP Ethereum mainly introduces the use of PHP for smart contract development interaction, account creation, transactions, transfers, token development, filters and events and other content.
• C# ethereum, mainly explains how to use C# based development. Net ethereum applications, including account management, status and transactions, smart contract development and interaction, filters and events, etc.
• PHP currency development tutorial, this course for beginners, content covers the core concepts of COINS, such as block mechanism, key chain store, decentralized consensus and script, trading and UTXO etc, also explained how to integrated the currency support functions in PHP code, such as creating address wallet, tectonic naked trading, management, This is a rare bitcoin development course for Php engineers.
• This course will help you quickly get started on the development of EOS blockchain decentralized applications, covering core knowledge points such as EOS tool chain, account and wallet, issuing tokens, development and deployment of smart contracts, using codes to interact with smart contracts, and finally completing the development of a notepad DApp using all knowledge points comprehensively.

Huizhi net original translation, reprint please indicate the source. Here is the original text