> 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)
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.
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)
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!.
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,
}
/* --snip-- */
}
```
#### Mapeamento[](https://use.ink/basics/storing-values#mapping)
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)
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)
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)
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,
}
#[ink(storage)]
pub struct MyContract {
// Store Auctions in a vec
auctions: Vec,
}
}
```
Os valores de uma enumeração devem ser referenciados como `Status::OpeningPeriod`.
### Inicializando o Storage nos Constructors
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-- */
}
}
```
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://lunes-labs.gitbook.io/dao-lunes-labs-pt/developers/para-desenvolvedores/smart-contract-ink-4.x/fundamentos/armazenando-valores.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.