---
title: "O que é Yul?"
description: "Aprenda a Usar Yul para Escrever Smart Contracts e Como Ele é Diferente do Solidity"
---

# O que é Yul?

Yul é uma linguagem de programação intermediária [programming language](https://www.alchemy.com/overviews/web3-programming-languages) que pode ser usada para escrever uma forma de linguagem assembly dentro de [smart contracts](https://www.alchemy.com/overviews/solidity-smart-contract). Embora costumemos ver Yul usado dentro de smart contracts, é possível escrever um smart contract inteiramente em Yul.

Entender Yul pode elevar o nível dos seus smart contracts e permitir que você entenda o que está acontecendo por baixo dos panos em [solidity](https://www.alchemy.com/overviews/solidity), o que, por sua vez, pode ajudar a reduzir os custos de gas para o usuário.

Podemos identificar Yul em um smart contract com a seguinte sintaxe.

No restante deste artigo, discutiremos os fundamentos do uso de Yul por meio de exemplos, e recomendamos que você acompanhe no Remix.

## **Atribuições de variáveis, operações e avaliações em yul**

O primeiro tópico que precisamos cobrir são operações simples. Yul tem \+, -, , /, %, , <, > e =.

Observe que >= e <= não estão incluídos na lista de operadores disponíveis em Yul porque Yul não possui esses operadores. Além disso, em vez de avaliações resultarem em true ou false, elas resultam em 1 ou 0, respectivamente. Dito isso, vamos começar a aprender um pouco de Yul!

<EmbeddedTable
  table={{
    columns: [
      { key: "1", width: 200, title: "Instruction", dataType: "object" },
      { key: "2", width: 200, title: "Explanation", dataType: "object" },
    ],
    data: [
      {
        "1": { title: "<p>let</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Isso é necessário antes de definir uma variável. Como todos os valores são bytes, não há necessidade de atribuir um tipo de valor.</p>", tooltip: "", icon: "" },
        id: 0,
      },
      {
        "1": { title: "<p>:=</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x = y</p>", tooltip: "", icon: "" },
        id: 1,
      },
      {
        "1": { title: "<p>add(x,y)</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x + y</p>", tooltip: "", icon: "" },
        id: 2,
      },
      {
        "1": { title: "<p>sub(x,y)</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x - y</p>", tooltip: "", icon: "" },
        id: 3,
      },
      {
        "1": { title: "<p>mul(x,y)</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x * y</p>", tooltip: "", icon: "" },
        id: 4,
      },
      {
        "1": { title: "<p>div(x,y)</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x / y (ou 0 se y for igual a 0)</p>", tooltip: "", icon: "" },
        id: 5,
      },
      {
        "1": { title: "<p>mod(x,y)</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x % y (ou 0 se y for igual a 0)</p>", tooltip: "", icon: "" },
        id: 6,
      },
      {
        "1": { title: "<p>lt(x,y)</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x < y</p>", tooltip: "", icon: "" },
        id: 7,
      },
      {
        "1": { title: "<p>gt(x,y)</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x > y</p>", tooltip: "", icon: "" },
        id: 8,
      },
      {
        "1": { title: "<p>eq(x,y)</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x == y</p>", tooltip: "", icon: "" },
        id: 9,
      },
      {
        "1": { title: "<p>iszero(x)</p>", tooltip: "", icon: "" },
        "2": { title: "<p>Equivalente em Solidity: x == 0</p>", tooltip: "", icon: "" },
        id: 10,
      },
    ],
  }}
/>

Vamos dar uma olhada rápida em um exemplo antes de continuar.

## **For loops e if statements em yul**

Para aprender sobre for loops e if statements, vamos escrever uma função que conta quantos números são pares em uma série.

A sintaxe dos if statements é semelhante à do Solidity, mas não é necessário colocar a condição entre parênteses.

Para o for loop, observe que usamos chaves ao declarar _i_ e ao incrementar _i_, mas não ao avaliar a condição. Além disso, usamos um _continue_ para pular uma iteração do loop. Também podemos usar break statements em Yul.

## **Como funciona o storage em yul**

Existem 2²⁵⁶ slots para um smart contract. Ao declarar variáveis, começamos pelo slot 0 e incrementamos a partir daí. Cada slot tem 256 bits de comprimento \(32 bytes\); é daí que vêm os nomes uint256 e bytes32. Todas as variáveis são convertidas para hexadecimal. Se uma variável, como um uint128, for usada, não ocupamos um slot inteiro para armazená-la. Em vez disso, ela é preenchida com 0's do lado esquerdo.

Para saber mais sobre [como funciona o storage em Yul](http://www.alchemy.com/overviews/yul-storage), leia nosso outro artigo, que aborda:

1. Arrays
1. Arrays dinâmicos
1. Mappings
1. Mappings aninhados

## **Como ler e escrever variáveis empacotadas em yul**

Empacotar variáveis significa ordená-las de forma que a soma de seu armazenamento fique abaixo de 32 bytes, para que caibam juntas em um slot! Empacotar variáveis pode economizar gas e é uma técnica essencial para otimizadores de smart contracts.

Por exemplo, `0x000000000000000000000000000002` e `0x000000000000000000000000000001` cabem perfeitamente juntos no mesmo slot porque ambos ocupam 16 bytes \(metade de um slot\).

Para saber mais sobre [como ler e escrever variáveis de storage empacotadas em Yul](http://www.alchemy.com/overviews/yul-packed-storage-variables), leia nosso artigo aprofundado!

## **Como funciona a memory em yul?**

A memory se comporta de forma diferente do storage, pois não é persistente \(ou seja, assim que a função termina de ser executada, todas as variáveis são apagadas\). Alguns usos da memory em Yul são:

1. Retornar valores para chamadas externas
1. Definir valores de função para chamadas externas
1. Obter valores de chamadas externas
1. Reverter com uma mensagem de erro
1. Registrar mensagens (logging)

Para saber mais sobre [como funciona a memory em Yul](http://www.alchemy.com/overviews/yul-memory), leia nosso outro artigo, que se aprofunda no assunto!

## **Como funcionam as chamadas de contrato em yul?**

Depois de entender a sintaxe, o storage e o funcionamento da memory em Yul, é hora de chamar contratos. Nosso último artigo da série sobre Yul explica [como as chamadas de contrato funcionam em Yul](http://www.alchemy.com/overviews/yul-contract-calls), especificamente por meio de:

1. `call()` - chama o contrato no endereço a, retornando 0 em caso de erro e 1 em caso de sucesso
1. `staticcall()` - idêntico a call\(g, a, 0, in, insize, out, outsize\), mas não permite modificações de estado
1. `delegatecall()` - idêntico a callcode, mas também mantém caller e callvalue‍

Mais informações sobre as definições de chamadas de contrato podem ser encontradas na [documentação da linguagem Yul](https://docs.soliditylang.org/en/v0.8.19/yul.html#yul-call-return-area).