# #\[ink(selector = S:u32)]

A selector must be a `u32` decodable integer. For example

Aplicável a mensagens ink! e construtores ink!.&#x20;

Por padrão, o ink! cria um seletor para cada mensagem e construtor. Isso é necessário, pois o contrato é compilado para um blob Wasm e as funções são invocadas por meio do seletor, que identifica um método - os nomes dos métodos não estão mais disponíveis nessas camadas subjacentes.&#x20;

Usando esse atributo, é possível especificar um seletor de despacho concreto para a entidade marcada. Isso permite que o autor do contrato controle precisamente os seletores de suas APIs, possibilitando a renomeação da API sem quebrá-la.&#x20;

Um seletor deve ser um inteiro decodificável `u32`. Por exemplo:

* `selector = 0xCAFEBABE`
* `selector = 42`

Uma exceção é o seletor de fallback `_`, que permite que chamadas de contrato que não correspondem a nenhum dos outros seletores de mensagem sejam despachadas para uma mensagem de fallback. Mensagens de fallback podem ser pagáveis `payable`.

### Exemplos[​](https://use.ink/macros-attributes/selector#examples) <a href="#examples" id="examples"></a>

```rust
#[ink(message, selector = 0xC0DECAFE)]
fn my_message_1(&self) {}

#[ink(message, selector = 42)]
fn my_message_2(&self) {}

#[ink(message, payable, selector = _)]
fn my_fallback(&self) {}
```

...então o seletor de `my_message_1` é `[0xC0, 0xDE, 0xCA, 0xFE]` e o seletor de `my_message_2` é `[0, 0, 0, 42]`, já que definir o seletor manualmente substitui o seletor gerado automaticamente.\


### Controlando o seletor das mensagens. <a href="#controlling-the-messages-selector" id="controlling-the-messages-selector"></a>

Cada mensagem ink! e construtor ink! possui um seletor com o qual a mensagem ou construtor pode ser identificado de forma única dentro do contrato inteligente ink!. Um seletor não único de mensagem ou construtor resulta em um erro de compilação. Esses seletores são principalmente usados para direcionar o despacho do contrato ao ser chamado.&#x20;

Um autor de contrato inteligente ink! pode controlar o seletor de uma mensagem ink! ou construtor ink! usando o seletor. Um exemplo é mostrado abaixo:

```rust
#[ink::contract]
mod flipper {
    #[ink(storage)]
    pub struct Flipper {
        value: bool,
    }

    impl Flipper {
        #[ink(constructor)]
        #[ink(selector = 0xDEADBEEF)] // Works on constructors as well.
        pub fn new(initial_value: bool) -> Self {
            Flipper { value: initial_value }
        }

        #[ink(message)]
        #[ink(selector = 0xCAFEBABE)] // You can either specify selector out-of-line.
        pub fn flip(&mut self) {
            self.value = !self.value;
        }

        #[ink(message, selector = 0xC0DECAFE)] // ...or specify the selector inline.
        pub fn get(&self) -> bool {
            self.value
        }
    }
}
```
