> For the complete documentation index, see [llms.txt](https://lunes-labs.gitbook.io/dao-lunes-labs-pt/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://lunes-labs.gitbook.io/dao-lunes-labs-pt/developers/para-desenvolvedores/smart-contract-ink-4.x/fundamentos/armazenando-valores.md).

# Armazenando Valores

Aqui está como você armazena valores simples no armazenamento:

```rust
#[ink(storage)]
pub struct MyContract {
    // Store a bool
    my_bool: bool,
    // Store some number
    my_number: u32,
}
/* --snip-- */
```

### Tipos Suportados[​](https://use.ink/basics/storing-values#supported-types) <a href="#supported-types" id="supported-types"></a>

Os contratos Lunes podem armazenar tipos que são codificáveis e decodificáveis com o [Parity Codec](https://github.com/paritytech/parity-codec), o que inclui a maioria dos tipos de dados comuns do Rust, como `bool`, `u{8,16,32,64,128}`, `i{8,16,32,64,128}`, `String`, tuples e arrays.&#x20;

Além disso, o ink! fornece tipos específicos do [Lunes](https://substrate.io/), como AccountId, Balance e Hash, para contratos inteligentes como se fossem tipos primitivos.

#### String, Vetor e Mais[​](https://use.ink/basics/storing-values#string-vector-and-more) <a href="#string-vector-and-more" id="string-vector-and-more"></a>

Como o ink! opera em um ambiente `no_std`, precisamos fornecer nossas próprias definições para os tipos de dados incluídos em `std`, como `String` e `Vec`. A crate [`ink_prelude`](https://docs.rs/ink_prelude/latest/ink_prelude/index.html) oferece essas definições para a maioria dos tipos de dados `std` comuns e pode ser usada com segurança em um contrato ink!.&#x20;

Você pode usar as definições do prelude da seguinte forma:

```rust
#[ink::contract]
mod MyContractWithStringsAndArrays {
    use ink::prelude::string::String;
    use ink::prelude::vec::Vec;

    #[ink(storage)]
    pub struct MyContract {
        // Store some String
        my_string: String,
        // Store some u32 in a vec
        my_vector: Vec<u32>,
    }
    /* --snip-- */
}
```

#### Mapeamento[​](https://use.ink/basics/storing-values#mapping) <a href="#mapping" id="mapping"></a>

O ink! também fornece um tipo de armazenamento chamado Mapping. Você pode ler mais sobre ele [aqui](https://use.ink/datastructures/mapping).

#### Lunes Tipos[​](https://use.ink/basics/storing-values#substrate-types) <a href="#substrate-types" id="substrate-types"></a>

Aqui está um exemplo de como você armazenaria tipos do Lunes `AccountId`, `Balance` and `Hash`:

Aqui está um exemplo de como você armazenaria os tipos da Lunes `AccountId`, `Balance` e `Hash`:

```rust
#[ink::contract]
mod MyContract {

    // Our struct will use those default ink! types
    #[ink(storage)]
    pub struct MyContract {
        // Store some AccountId
        my_account: AccountId,
        // Store some Balance
        my_balance: Balance,
        // Store some Hash
        my_hash: Hash,
    }
    /* --snip-- */
}
```

#### Enum[​](https://use.ink/basics/storing-values#enum) <a href="#enum" id="enum"></a>

Enum também pode ser usado como um tipo de dado. Sua utilização está presente no exemplo na seção "[Struct](https://use.ink/basics/storing-values#struct)".

```rust
pub enum Status {
    /// An auction has not started yet.
    NotStarted,
    /// We are in the starting period of the auction, collecting initial bids.
    OpeningPeriod,
    /// We are in the ending period of the auction, where we are taking snapshots
    /// of the winning bids.
}
```

#### Struct[​](https://use.ink/basics/storing-values#struct) <a href="#struct" id="struct"></a>

Você pode combinar todos os tipos mencionados acima, inclusive em uma `struct` personalizada, que pode ser armazenada no armazenamento do contrato.

```rust
mod MyContract {
    use ink::prelude::string::String;
    use ink::prelude::vec::Vec;


    pub struct Auction {
        /// Branded name of the auction event.
        name: String,
        /// Some hash identifying the auction subject.
        subject: Hash,
        /// Auction status.
        status: Status, // Enum: Usage shown in next section
        /// Candle auction can have no winner.
        /// If auction is finalized, that means that the winner is determined.
        finalized: bool,
        /// vector
        vector: Vec<u8>,
    }

    #[ink(storage)]
    pub struct MyContract {
        // Store Auctions in a vec
        auctions: Vec<Auction>,
    }
}
```

Os valores de uma enumeração devem ser referenciados como `Status::OpeningPeriod`.

### Inicializando o Storage nos Constructors <a href="#initializing-storage-in-constructors" id="initializing-storage-in-constructors"></a>

Os construtores são responsáveis por inicializar os valores. Todo contrato inteligente ink! deve ter um construtor que é executado uma vez quando um contrato é criado. Os contratos inteligentes ink! podem ter vários construtores:

Observe que se você tiver um contrato cujo armazenamento contém Mappings, você precisará usar `ink_lang::utils::initialize_contract` em seu construtor. Consulte a [documentação](https://use.ink/datastructures/mapping) do [`Mapping` ](https://use.ink/datastructures/mapping) para obter mais detalhes.

```rust
#[ink::contract]
mod mycontract {

    #[ink(storage)]
    pub struct MyContract {
        number: u32,
    }

    impl MyContract {
        /// Constructor that initializes the `u32` value to the given `init_value`.
        #[ink(constructor)]
        pub fn new(init_value: u32) -> Self {
            Self {
                number: init_value,
            }
        }

        /// Constructor that initializes the `u32` value to the `u32` default.
        #[ink(constructor)]
        pub fn default() -> Self {
            Self {
                number: Default::default(),
            }
        }
    /* --snip-- */
    }
}
```