Contenidos
Introducción
Solidity es un lenguaje de programación de alto nivel utilizado para implementar contratos inteligentes en la blockchain de Ethereum. Fue influenciado por C++, Python y JavaScript y está diseñado para ser fácil de leer y entender. Los contratos inteligentes son programas que se ejecutan de manera autónoma en la blockchain y pueden controlar la transferencia de activos digitales.
Este documento proporciona una visión general de los conceptos clave y las características del lenguaje Solidity, incluyendo variables, constantes, ámbito, tipos, operaciones aritméticas, operaciones lógicas, operadores bit a bit, operaciones de comparación, sentencias condicionales, sentencias de repetición y funciones.
Variables
En Solidity, las variables son contenedores para almacenar datos. Se pueden declarar dentro de contratos, funciones o en cualquier ámbito de bloque.
Tipos de Variables
- State Variables: Declaradas fuera de cualquier función, son almacenadas en la blockchain.
- Local Variables: Declaradas dentro de funciones y solo existen mientras la función está siendo ejecutada.
- Global Variables: Variables especiales proporcionadas por la blockchain.
Constantes
Las constantes son variables cuyos valores no pueden ser cambiados después de su inicialización.
1 |
uint constant myConstant = 10; |
Ámbito
El ámbito de una variable define la región del código en la que la variable es accesible. En Solidity, el ámbito puede ser:
- Público: Accesible dentro y fuera del contrato.
- Privado: Accesible solo dentro del contrato en el que está declarado.
- Interno: Accesible dentro del contrato y los contratos derivados.
- Externo: Accesible solo desde fuera del contrato.
Tipos
Tipos Simples
- Boolean: Representa valores
true
ofalse
. - Integer: Enteros con y sin signo (
int
,uint
). - Address: Representa direcciones de Ethereum.
Tipos Complejos
- Arrays: Colecciones de elementos del mismo tipo.
- Structs: Colecciones de elementos de diferentes tipos.
- Mappings: Asociaciones de clave-valor.
Variables de Entorno
Solidity proporciona variables globales que contienen información sobre la blockchain y las transacciones, como msg.sender
, msg.value
, block.number
, etc.
Operaciones Aritméticas
Sumar
1 2 3 |
uint a = 2; uint b = 3; uint sum = a + b; |
Restar
1 |
uint diff = a - b; |
Multiplicar
1 |
uint product = a * b; |
Dividir
1 |
uint quotient = a / b; |
Resto
1 |
uint remainder = a % b; |
Conversiones entre Sistemas Numéricos
Solidity permite conversiones entre diferentes tipos de datos numéricos:
1 2 |
int8 smallInt = int8(bigInt); uint8 smallUint = uint8(bigUint); |
Operaciones Lógicas
And
1 2 3 |
bool a = true; bool b = false; bool result = a && b; |
Or
1 |
bool result = a || b; |
Not
1 |
bool result = !a; |
Operadores Bit a Bit
- AND:
&
- OR:
|
- XOR:
^
- NOT:
~
- Shift Left:
<<
- Shift Right:
>>
1 2 3 4 5 6 7 8 |
uint a = 4; // 0100 in binary uint b = 2; // 0010 in binary uint andResult = a & b; // 0000 uint orResult = a | b; // 0110 uint xorResult = a ^ b; // 0110 uint notResult = ~a; // 1011 uint shiftLeft = a << 1; // 1000 uint shiftRight = a >> 1; // 0010 |
Operaciones de Comparación
eq (Equal to – Igual a)
1 |
bool result = (a == b); |
lt (Less than – Menos que)
1 |
bool result = (a < b); |
gt (Greater than – Más que)
1 |
bool result = (a > b); |
ge (Greater than or Equal to – Mayor o igual a)
1 |
bool result = (a >= b); |
le (Less than or Equal to – Menor o igual a)
1 |
bool result = (a <= b); |
ne (Not equal to – No es igual a)
1 |
bool result = (a != b); |
Sentencias Condicionales
If
1 2 3 |
if (a > b) { // Código } |
Else
1 2 3 4 5 |
if (a > b) { // Código } else { // Código } |
ElseIf
1 2 3 4 5 6 7 |
if (a > b) { // Código } else if (a == b) { // Código } else { // Código } |
Switch (No disponible en Solidity)
Solidity no soporta sentencias switch
. En su lugar, se deben usar sentencias if-else
.
Sentencias de Repetición
Bucle While
1 2 3 4 |
uint i = 0; while (i < 10) { i++; } |
Bucle Do-While
1 2 3 4 |
uint i = 0; do { i++; } while (i < 10); |
Bucle For
1 2 3 |
for (uint i = 0; i < 10; i++) { // Código } |
Bucle Foreach (No disponible en Solidity)
Solidity no soporta bucles foreach
. Se deben usar bucles for
o while
.
Funciones
Las funciones en Solidity son bloques de código reutilizables que pueden ser llamados desde otras partes del contrato.
1 2 3 |
function add(uint a, uint b) public pure returns (uint) { return a + b; } |
Funciones Modificadoras
- Pure: Indica que la función no accede ni modifica el estado del contrato.
- View: Indica que la función no modifica el estado del contrato pero puede leerlo.
- Payable: Indica que la función puede recibir Ether.
Ejemplo integrador
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 |
// SPDX-License-Identifier: MIT pragma solidity >=0.6.12 <0.9.0; contract Example { uint public myNumber; uint constant MY_CONSTANT = 42; struct Person { string name; uint age; } mapping(address => uint) public balances; constructor() { myNumber = 10; } function add(uint a, uint b) public pure returns (uint) { return a + b; } function subtract(uint a, uint b) public pure returns (uint) { return a - b; } function multiply(uint a, uint b) public pure returns (uint) { return a * b; } function divide(uint a, uint b) public pure returns (uint) { require(b != 0, "Cannot divide by zero"); return a / b; } function modulus(uint a, uint b) public pure returns (uint) { require(b != 0, "Cannot divide by zero"); return a % b; } function bitwiseAnd(uint a, uint b) public pure returns (uint) { return a & b; } function bitwiseOr(uint a, uint b) public pure returns (uint) { return a | b; } function bitwiseXor(uint a, uint b) public pure returns (uint) { return a ^ b; } function bitwiseNot(uint a) public pure returns (uint) { return ~a; } function shiftLeft(uint a, uint b) public pure returns (uint) { return a << b; } function shiftRight(uint a, uint b) public pure returns (uint) { return a >> b; } function isEqual(uint a, uint b) public pure returns (bool) { return a == b; } function isLess(uint a, uint b) public pure returns (bool) { return a < b; } function isGreater(uint a, uint b) public pure returns (bool) { return a > b; } function isLessOrEqual(uint a, uint b) public pure returns (bool) { return a <= b; } function isGreaterOrEqual(uint a, uint b) public pure returns (bool) { return a >= b; } function isNotEqual(uint a, uint b) public pure returns (bool) { return a != b; } function whileLoop() public pure returns (uint) { uint i = 0; while (i < 10) { i++; } return i; } function doWhileLoop() public pure returns (uint) { uint i = 0; do { i++; } while (i < 10); return i; } function forLoop() public pure returns (uint) { uint sum = 0; for (uint i = 0; i < 10; i++) { sum += i; } return sum; } function ifStatement(uint a, uint b) public pure returns (string memory) { if (a > b) { return "a is greater than b"; } else if (a == b) { return "a is equal to b"; } else { return "a is less than b"; } } function addPerson(string memory _name, uint _age) public pure returns (string memory) { Person memory newPerson = Person(_name, _age); return newPerson.name; } } |
