Rust - Borrowing ?
Tags: rust, borrowing, tutorial, developer
Published: 2021-10-02 14:55:19

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/sbbj37pg3p1y45z0499s.jpeg)

O *borrowing* permitir ter múltiplas referências a um recurso ao mesmo tempo, aderindo um conteúdo proprietário único em um local de responsabilidade, podemos pegar com base os ponteiros em C.

O *borrowing* trabalha com as suas referências, vale lembrar que é um objeto então eles podem ser mutáveis assim são movidos e imutáveis que são apenas copiados.

Exemplo abaixo.

```rust

fn main() {
    let texto = String::from("google");

    let tamanho = calcula_tamanho(&texto);

    println!("O texto é: '{}' de tamanho {}.", texto, tamanho);
}

fn calcular(texto: &String) -> usize {
    texto.len()
}

/*
  O texto é: 'google' de tamanho 6.
*/

```

No exemplo acima a finalidade do código e saber quantas letras tem o texto *"google"*, temos uma função chamada *calcular* que retorna o tamanho da string passada por parâmetro veja que na função passamos uma string.

O *&* são a referências. é uma forma de passar o dado sem que tome posse dele.

O *&texto* nos permitir criar uma referência, mas sem posse após a contagem o *valor* não é destruído por sair do escopo.

E se no caso tentarmos modificar o valor emprestado ?

```rust

fn main() {
    let texto = String::from("google");

    calcula_tamanho(&texto);
}

fn calcula_tamanho(texto: &String)  {
    texto.push_str(" vou pesquisar");
}


/*
  error[E0596]: cannot borrow immutable borrowed content `*texto` as mutable
 --> main.rs:8:5
  |
7 | fn calcula_tamanho(texto: &String)  {
  |                           ------- use `&mut String` here to make mutable
8 |     texto.push_str(" vou pesquisar");
  |     ^^^^^ cannot borrow as mutable
*/

```

Como já imaginava, aquele error onde a variável não é mutável. No console o informa "`&mut String` here to make mutable" como fazer uma variável mutável.

Vamos para um exemplo mutável.

```rust

fn main() {
  let mut pesquisar = String::from("google");

  modifica(&mut pesquisar);

  print!("Pesquisa: {}", pesquisar);
}

fn modifica(texto: &mut String) {
  texto.push_str(" pokemon");
}

/*
  Pesquisa: google pokemon
*/
```

Estamos alterando a variável pesquisar que declaramos como *mut* após isso, na função um parâmetro string com referência a variável mutável assim conseguimos alterar com base na chamada.

As referências mutáveis tem restrições.

```rust

fn main() {
  let mut texto = String::from("texto");
  let texto_2 = &mut texto;
  let texto_3 = &mut texto;
}

/*
error[E0499]: cannot borrow `texto` as mutable more than once at a time
 --> main.rs:4:22
  |
3 |   let texto_2 = &mut texto;
  |                      ----- first mutable borrow occurs here
4 |   let texto_3 = &mut texto;
  |                      ^^^^^ second mutable borrow occurs here
5 | }
  | - first borrow ends here
*/
```

A maioria das linguagens de programação permiti modificar um valor quando você quiser, só que no Rust não irá, pois é uma forma da linguagem evitar erros do tipo *data races*.

*Um data race é parecido com uma condição de corrida, e acontece quando esses três fatores ocorrem:*
   *Dois ou mais ponteiros acessam o mesmo dado ao mesmo tempo.
Ao menos um dos ponteiros é usado para escrever sobre o dado.
Não há nenhum mecanismo sendo usado para sincronizar o acesso ao dado.*

Então para referências existe regras que um dado só pode ter um ou o outro, mas não os dois.

Então galera é isso, espero que tenham gostado até a próxima.