Galeria de mapas mentais Dominando RUST 2ª Edição
Este é um mapa mental sobre como dominar o RUST. Por meio das etapas e sugestões acima, você pode melhorar gradualmente suas habilidades de programação em Rust e aproveitar a segurança da memória e o desempenho eficiente trazidos pelo Rust.
Editado em 2024-04-04 15:14:48A segunda unidade do Curso Obrigatório de Biologia resumiu e organizou os pontos de conhecimento, abrangendo todos os conteúdos básicos, o que é muito conveniente para todos aprenderem. Adequado para revisão e visualização de exames para melhorar a eficiência do aprendizado. Apresse-se e colete-o para aprender juntos!
Este é um mapa mental sobre Extração e corrosão de mim. O conteúdo principal inclui: Corrosão de metais, Extração de metais e a série de reatividade.
Este é um mapa mental sobre Reatividade de metais. O conteúdo principal inclui: Reações de deslocamento de metais, A série de reatividade de metais.
A segunda unidade do Curso Obrigatório de Biologia resumiu e organizou os pontos de conhecimento, abrangendo todos os conteúdos básicos, o que é muito conveniente para todos aprenderem. Adequado para revisão e visualização de exames para melhorar a eficiência do aprendizado. Apresse-se e colete-o para aprender juntos!
Este é um mapa mental sobre Extração e corrosão de mim. O conteúdo principal inclui: Corrosão de metais, Extração de metais e a série de reatividade.
Este é um mapa mental sobre Reatividade de metais. O conteúdo principal inclui: Reações de deslocamento de metais, A série de reatividade de metais.
Proficiente em ferrugem
Capítulo 1 Introdução ao Rust
1.1 O que é Rust e por que você precisa dele
Rust é uma linguagem de programação rápida, altamente simultânea, segura e poderosa, originalmente criada e lançada em 2006 por Graydon Hoare. Agora é uma linguagem de código aberto, mantida e desenvolvida principalmente pela equipe Mozilla e por muitos membros da comunidade de código aberto.
Rust tem um site de desenvolvimento de código aberto no GitHub e seu impulso de desenvolvimento é muito rápido. Novos recursos são adicionados à linguagem por meio de um processo de solicitação de comentário (RFC) conduzido pela comunidade, onde qualquer pessoa pode enviar novos recursos e descrevê-los detalhadamente em um documento RFC. O consenso é então buscado na RFC e, se o consenso for alcançado, o recurso entra na fase de implementação.
Rust existe como uma linguagem estática e fortemente tipada. Atributos estáticos significam que o compilador possui informações sobre todas as variáveis e tipos relevantes em tempo de compilação e faz muitas verificações em tempo de compilação, deixando apenas uma pequena quantidade de verificação de tipo em tempo de execução.
1.2 Instale a cadeia de ferramentas Rust
ferrugem.rs
1.3 Introdução à Ferrugem
1.3.1 Tipos primitivos
bool
Esses são valores booleanos comuns que podem ser verdadeiros ou falsos.
Caracteres
personagem
inteiro
Este tipo é caracterizado pela largura de bits. O comprimento máximo suportado pelo Rust é 128 bits.
tamanho
Um inteiro assinado de tamanho variável (o tamanho depende do tamanho do ponteiro subjacente).
usar
Inteiro não assinado de tamanho variável (o tamanho depende do tamanho do ponteiro subjacente).
f32
tipo de ponto flutuante f32 bits
f64
tipo de ponto flutuante f64 bits
[T;
Uma matriz de tamanho fixo, T representa o tipo de elemento, N representa o número de elementos e é uma constante não negativa em tempo de compilação.
[T]
Uma visualização dimensionada dinamicamente de uma sequência contígua, T representando qualquer tipo.
str
Fatiamento de strings, usado principalmente como referência, ou seja, &str
(T, você, ..)
Sequências finitas, T e U podem ser de tipos diferentes.
fn(i32)->i32
Uma função que recebe um parâmetro de tipo i32 e retorna um parâmetro de tipo i32. As funções também possuem um tipo.
1.3.2 Declaração de variáveis e imutabilidade
No Rust, usamos a palavra-chave let para declarar variáveis. Depois que uma variável é inicializada, ela não pode receber outro valor. Se posteriormente você precisar apontar a variável para outra variável (do mesmo tipo), será necessário precedê-la com a palavra-chave mut.
1.3.3 Função
As funções abstraem um monte de instruções em entidades nomeadas que podem ser chamadas posteriormente a partir de outro código e ajudam os usuários a gerenciar a complexidade.
fn adicionar (a: u64, b: u64) -> u64 { um b } fn principal() { seja a: u64 = 17; seja b = 3; deixe resultado = adicionar (a, b); println!("Resultado {}", resultado); }
Funções são basicamente expressões que retornam um valor, que por padrão é um valor do tipo () (unidade), que é semelhante ao tipo de retorno void em C/C++.
1.3.4 Encerramento
Rust suporta fechamentos. Os encerramentos são semelhantes às funções, mas possuem mais informações sobre o ambiente ou escopo em que são declarados. Embora as funções tenham um nome associado a elas, as definições dos encerramentos não têm, mas podem ser atribuídas a variáveis. Outra vantagem da inferência de tipo Rust é que na maioria dos casos você pode especificar parâmetros para fechamentos sem tipos. Este é o encerramento mais simples "let my_closure = ||();". Definimos um fechamento sem parâmetros que não faz nada. Podemos então chamá-lo via my_closure(), que é semelhante a uma função. As duas barras verticais "||" são usadas para armazenar parâmetros de fechamento, como |a, b|. Às vezes é necessário especificar o tipo de parâmetro (|a:u32|) quando Rust não consegue descobrir o tipo correto.
fn principal() { deixe duplicador = |x| deixe valor = 5; deixe duas vezes = doubler(valor); println!("{} dobrado é {}", valor, duas vezes); deixe big_closure = |b, c| seja z = b c; z * duas vezes }; deixe algum_número = big_closure(1, 2); println!("Resultado do fechamento: {}", some_number); }
1.3.5 Sequência
String é um dos tipos de dados mais comumente usados em qualquer linguagem de programação. No Rust, eles geralmente aparecem em duas formas: tipo &str e tipo String. As strings Rust são garantidamente sequências de bytes codificadas em UTF-8 válidas. Eles não são terminados em NULL como strings C e podem conter bytes nulos entre strings.
fn principal() { deixe pergunta = "Como você está?"; deixe pessoa: String = "Bob".to_string(); deixe namaste = String::from("zd"); println!("{}! {} {}", nome, pergunta, pessoa); }
No código acima, o tipo de pessoa e namaste é String, e o tipo de pergunta é &str. Existem muitas maneiras de criar dados do tipo String. Os dados do tipo string são alocados no heap. Os dados do tipo &str geralmente são um ponteiro para uma string existente. Essas strings estão na pilha e no heap ou podem ser strings no segmento de dados do código do objeto compilado.
1.3.6 Condições e julgamentos
Os julgamentos condicionais em Rust são semelhantes aos de outras linguagens. Eles também seguem uma estrutura if else semelhante a C.
fn principal() { deixe ferrugem_is_awesome = verdadeiro; se ferrugem_é_incrível { println!("De fato"); } outro { println!("Bem, você deveria tentar Rust!"); } }
Em Rust, a construção if não é uma declaração, mas uma expressão. Na linguagem geral de programação, as instruções não retornam nenhum valor, mas as expressões, sim. Essa distinção significa que as condições if else em Rust sempre retornam um valor. O valor pode ser do tipo vazio () ou um valor real. Qualquer que seja a última linha entre chaves, ela se torna o valor de retorno da expressão if else. É importante observar que as ramificações if e else devem ter o mesmo tipo de retorno.
fn principal() { deixe resultado = se 1 == 2 { "Espere o que?" } outro { "A ferrugem faz sentido" }; println!("Quer saber? {}.", resultado); }
Quando o valor a ser atribuído é retornado da expressão if else, precisamos usar um ponto e vírgula como marca final. Por exemplo, if é uma expressão, então let é uma instrução que espera que tenhamos um ponto e vírgula no final.
1.3.7 expressão de correspondência
As expressões de correspondência do Rust são muito simples e fáceis de usar. É basicamente semelhante a uma versão simplificada da instrução switch em linguagem C, permitindo aos usuários fazer julgamentos com base no valor da variável e se há funcionalidade de filtragem avançada.
fn req_status() -> u32 { 200 } fn principal() { deixe status = req_status(); status da correspondência { 200 => println!("Sucesso"), 404 => println!("Não encontrado"), outro => { println!("Solicitação falhou com código: {}", outro); } } }
Cada correspondência deve retornar o mesmo tipo. Além disso, devemos realizar uma correspondência exata em todos os valores correspondentes possíveis. Rust nos permite ignorar as possibilidades restantes usando catch all variáveis (aqui outro) ou _ (sublinhado).
1.3.8 Ciclo
Fazer algo repetidamente no Rust pode ser feito usando 3 construções, nomeadamente loop, while e for. Em todas essas construções, as palavras-chave continue e break geralmente são incluídas, permitindo pular e sair do loop, respectivamente.
fn principal() { seja mut x = 1024; laço { se x < 0 { quebrar; } println!("{} mais corridas pela frente", x); x-= 1; } }
Um recurso adicional de execução de loops em Rust é a capacidade de rotular blocos de código de loop com nomes. Isso pode ser usado em situações em que você tem dois ou mais loops aninhados e deseja interromper qualquer um deles, não apenas para loops que contêm instruções break diretamente.
fn bobo_sub(a: i32, b: i32) -> i32 { deixe mut resultado = 0; 'incremento: loop { se resultado == a { deixe mut dec = b; 'decremento: loop { ifdec==0{ quebrar 'incremento; } outro { resultado -= 1; dezembro -= 1; } } } outro { resultado = 1; } } resultado } fn principal() { seja a = 10; seja b = 4; deixe resultado = bobo_sub(a, b); println!("{} menos {} é {}", a, b, resultado); }
Rust também possui a palavra-chave for, que é semelhante ao loop for usado em outras linguagens, mas sua implementação é completamente diferente. O loop for do Rust é basicamente um açúcar sintático para uma construção de iteração mais poderosa (iterador). Simplificando, os loops for em Rust funcionam apenas com tipos que podem ser convertidos em iteradores. Um desses tipos é o tipo Range. O tipo Range pode se referir a uma série de números.
fn principal() { print!("Intervalo normal: "); para eu em 0..10 { imprimir!("{},", eu); } imprimir!(); print!("Intervalo inclusivo: "); para eu em 0..=10 { imprimir!("(),", eu); } }
1.3.9 Tipos de dados personalizados
Tipos personalizados são tipos definidos pelos usuários. Os tipos personalizados podem ser compostos de vários tipos. Eles podem ser wrappers em torno de tipos primitivos ou uma combinação de vários tipos personalizados. Eles vêm em três formas: estrutura, enumeração e união, também conhecidas como struct, enum e união. Eles permitem que você represente seus dados com mais facilidade. As regras de nomenclatura para tipos personalizados seguem CamelCase.
Estrutura
No Rust, existem três formas de declaração de estrutura. A mais simples delas é a unit struct, que é declarada usando a palavra-chave struct, seguida de seu nome e terminando com ponto e vírgula.
estrutura Dummy; fn principal() { deixe valor = Dummy; }
A segunda forma de estrutura é a estrutura de tupla, que possui dados associados. Cada um desses campos não é nomeado, mas é referenciado com base na sua posição na definição.
estrutura Cor(u8, u8, u8); fn principal() { deixe branco = Cor (255, 255, 255); deixe vermelho = branco.0; deixe verde = branco.1; deixe azul = branco.2; println!("Valor vermelho: {}", vermelho); deixe laranja = Cor (255, 165, 0); deixe Color(r, g, b) = laranja; println!("R: {}, G: {}, B: {} (laranja)", r, g, b); deixe Color(r, _, b) = laranja; }
As estruturas de tupla são ideais para modelar dados com menos de 5 atributos. Qualquer escolha diferente dessa prejudicará a legibilidade e o raciocínio do código. Para tipos de dados com mais de 3 campos, construa estruturas usando linguagem semelhante a C. Esta é a terceira forma e a mais comumente usada.
estruturar Jogador { nome: Corda, QI: u8, amigos: u8, pontuação: sub-16 } fn bump_player_score(mut player: Jogador, pontuação: u16) { jogador.score = pontuação; println!("Estatísticas atualizadas do jogador:"); } fn principal() { deixe nome = "Alice".to_string(); deixe jogador = Jogador {nome, QI: 171, amigos: 134, pontuação: 1129 }; bump_player_score(jogador, 120); }
enumerar
As enumerações são uma boa maneira de fazer isso quando você precisa modelar diferentes tipos de coisas. Ele é criado usando a palavra-chave enum, seguida pelo nome da enumeração e um par de chaves. Dentro das chaves podemos escrever todos os tipos possíveis, ou seja, variantes. Essas variantes podem ser definidas com ou sem dados, e os dados contidos podem ser de qualquer tipo, estrutura, estrutura de tupla ou até mesmo um tipo de enumeração.
enum Direção { N, E, S, C } enum PlayerAction { Mover { direção: direção, Velocidade: u8 }, Espere, Ataque (Direção) } fn principal() { deixe simulado_player_action = PlayerAction::Move { direção: Direção::N, velocidade: 2, }; correspondência simulada_player_action { PlayerAction::Wait => println!("O jogador quer esperar"), PlayerAction::Move { direção, velocidade } => { println!("O jogador quer se mover na direção {:?} com velocidade {}", direção, velocidade) } PlayerAction::Attack(direção) => { println!("O jogador deseja acessar a direção {:?}", direção) } }; }
1.3.10 Funções e métodos em tipos
bloco impl na estrutura
Podemos adicionar comportamento a uma estrutura definida usando dois mecanismos: funções semelhantes a construtores e métodos getter e setter.
estruturar Jogador { nome: Corda, QI: u8, amigos: u8 } impl Jogador { fn with_name(nome: &str) -> Jogador { Jogador { nome: nome.to_string(), QI: 100, amigos: 100 } } fn get_friends(&self) -> u8 { eu.amigos } fn set amigos(&mut self, contagem: u8) { self.amigos = contar; } } fn principal() { deixe mut player = Player::with_name("Dave"); jogador.set_friends(23); println!("Contagem de amigos de{}: {}", player.name, player.get_friends()); deixe _ = Jogador::get_friends(&player); }
Método associado: Este método não possui tipo próprio como primeiro parâmetro. É semelhante aos métodos estáticos em linguagens de programação orientadas a objetos. Esses métodos podem ser chamados no próprio tipo e não requerem que uma instância do tipo seja chamada. Um método associado é chamado precedendo o nome do método com o nome da estrutura e dois pontos duplos.
Método de instância: uma função que toma self como o primeiro parâmetro externo. O self aqui é semelhante ao self em Python e aponta para a instância que implementa o método.
impl blocos e enumerações
As enumerações são amplamente utilizadas em máquinas de estado e, quando usadas com expressões de correspondência, podem tornar o código de transição de estado muito conciso. Eles também podem ser usados para modelagem de tipos de erros personalizados.
enumModoPagamento { Débito, Crédito, PayPal } fn pay_by_credit(amt: u64) { println!("Processando pagamento de crédito de {}", amt); } fn pagamento_por_débito(amt: u64) { println!("Processando pagamento de débito de {}", amt); } fn paypal_redirect (amt: u64) { println!("Redirecionando para paypal pelo valor: {}", amt); } impl ModoPagamento { fn pagar(&self, valor: u64) { corresponder a si mesmo { PaymentMode::Débito => pay_by_debit(valor), PaymentMode::Crédito => pay_by_credit(valor), PaymentMode::Paypal => paypal_redirect(valor) } } } fn get_saved_payment_mode() -> PaymentMode { Modo de Pagamento::Débito } fn principal() { deixe pagamento_mode = get_saved_payment_mode(); pagamento_modo.pay(512); }
Módulo 1.3.11, instruções de importação e uso
As linguagens de programação geralmente fornecem uma maneira de dividir grandes blocos de código em vários arquivos para gerenciar a complexidade. Java segue a convenção de que cada arquivo .java é uma classe pública e C nos fornece arquivos de cabeçalho e instruções de inclusão. Rust fornece um mecanismo de módulo. Módulos são uma forma de nomear e organizar código em programas Rust.
Todo programa Rust requer um módulo raiz. Para arquivos executáveis, geralmente é o arquivo main.rs, e para bibliotecas, geralmente é o arquivo lib.rs.
Os módulos podem ser declarados dentro de outros módulos ou organizados em arquivos e diretórios.
Para que o compilador reconheça nosso módulo, precisamos usar a palavra-chave mod declaração. Em nosso módulo raiz, precisamos usar a palavra-chave use antes do nome do módulo, o que significa trazer o elemento para o escopo.
Os elementos definidos em um módulo são privados por padrão e precisam ser expostos aos chamadores usando a palavra-chave pub.
1.3.12 Coleta
variedade
Os arrays têm comprimento fixo e podem armazenar elementos do mesmo tipo. Eles são representados por [T, N], onde T representa qualquer tipo e N representa o número de elementos do array. O tamanho do array não pode ser representado por uma variável e deve ser um valor literal de usize.
tupla
Lista de projetos
par chave/valor
fatiar
1.3.13 Iterador
sub tópico
sub tópico
sub tópico
1.4 Melhorar o contador de personagens
1.5 Resumo
Capítulo 2 Usando Cargo para gerenciar projetos
2.1 Gerenciador de pacotes de software
2.2 Módulos
2.2.1 Módulos aninhados
2.2.2 Usando arquivos como módulos
2.2.3 Usando diretórios como módulos
2.3 Carga e bibliotecas
2.3.1 Criar um novo projeto Cargo
2.3.2 Cargas e dependências
2.3.3 Usando Cargo para executar testes
2.3.4 Usando Cargo para executar o exemplo
2.3.5 Espaço de trabalho de carga
2.4 Extensão da ferramenta de carga
2.4.1 Instalação de Subcomandos e Carga
2.4.2 Use clippy para formatar código
2.4.3 Introdução ao arquivo de manifesto Cargo.toml
2.5 Configure um ambiente de desenvolvimento Rust
2.6 Use Cargo para construir o programa imgtool
2.7 Resumo
Capítulo 3 Teste, documentação e benchmarking
3.1 Objetivo do teste
3.2 Organizando testes
3.3 Testes unitários
3.3.1 O primeiro teste unitário
3.3.2 Executando testes
3.3.3 Isolar código de teste
3.3.4 Teste de falha
3..3.5 Ignorar testes
3.4 Teste de integração
3.4.1 Primeiro teste de integração
3.4.2 Compartilhando código comum
3.5 Documentação
3.5.1 Escrevendo documentação
3.5.2 Gerar e visualizar documentos
3.5.3 Documentos hospedados
3.5.4 Propriedades do documento
3.5.5 Testes documentados
3.6 Referência
3.6.1 Ferramentas integradas de micro-benchmark
3.6.2 Benchmarking na versão estável do Rust
3.7 Escrevendo e testando pacotes de software - simulador de porta lógica
3.8 Teste de integração de CI e Travis CI
3.9 Resumo
Capítulo 4 Tipos, genéricos e características
4.1 Sistemas de tipos e sua importância
4.2 Genéricos
4.2.1 Criando genéricos#
4.2.2 Implementação genérica
4.2.3 Aplicações genéricas
4.3 Usando recursos para abstrair comportamento
4.3.1 Características
4.3.2 Várias formas de recursos
4.4 Usando recursos genéricos de pacote – intervalos de recursos
4.4.1 Intervalos característicos em tipos
4.4.2 Intervalos característicos em funções genéricas e blocos de código impl
4.4.3 Use a combinação de recursos " " para formar um intervalo
4.4.4 Intervalo de recurso e sintaxe de recurso impl
4.5 Introdução aos recursos padrão da biblioteca
4.6 Usando objetos de características para alcançar o verdadeiro polimorfismo
4.6.1 Distribuição
4.6.2 Objetos característicos
4.7 Resumo
Capítulo 5 Gerenciamento e segurança de memória
5.1 Programas e Memória
5.2 Como os programas usam a memória
5.3 Gerenciamento e classificação de memória
5.4 Introdução à alocação de memória
5.4.1 Pilha
5.4.2 Pilha
5.5 Defeitos no Gerenciamento de Memória
5.6 Segurança da memória
5.7 Três princípios de segurança de memória
5.7.1 Propriedade
5.7.2 Reutilizando tipos através de traits
5.7.3 Empréstimo
5.7.4 Tipos de métodos baseados em regras de empréstimo
5.7.5 Ciclo de vida
5.8 Tipos de ponteiro em Rust
5.8.1 Referências – indicadores seguros
5.8.2 Ponteiros brutos
5.8.3 Ponteiros inteligentes
5.8.4 Ponteiros inteligentes contados por referência
5.8.5 Aplicação da variabilidade interna
5.9 Resumo
Capítulo 6 Tratamento de Exceções
6.1 Introdução ao tratamento de exceções
6.2 Exceções recuperáveis
6.2.1 Opção
6.2.2 Resultado
6.3 Combinação Opção/Resultado
6.3.1 Combinadores comuns
6.3.2 Aplicação do combinador
6.3.3 Conversão entre tipos de Opção e Resultado
6.4 Retorno antecipado e operador "?"
6.5 Exceções irrecuperáveis
6.6 Erros personalizados e características de erro
6.7 Resumo
Capítulo 7 Conceitos Avançados
7.1 Introdução aos sistemas de tipos
7.1.1 Blocos de código e expressões
7.1.2 instrução let
7.1.3 Loops como expressões
7.1.4 Clareza de tipo e distinção de símbolos em tipos numéricos
7.1.5 Inferência de tipo
7.1.6 Aliases de tipo
7.2 Corda
7.2.1 String contendo propriedade - String
7.2.2 Empréstimo de string——&str
7.2.3 Fatiamento e fragmentação de strings
7.2.4 Usando strings em funções
7.2.5 Concatenação de strings
7.2.6 Cenários de aplicação de &str e String
7.3 Valores globais
7.3.1 Constantes
7.3.2 Valores estáticos
7.3.3 Função em tempo de compilação —— const fn
7.3.4 Valores estáticos dinâmicos por meio da macro lazy_static
7.4 Iteradores
7.5 Tipos avançados
7.5.1 Tipos de comprimento indefinido
7.5.2 Tipos de funções
7.5.3 nunca digite “!” e despacho de função
7.5.4 União
7.5.5 Vaca
7.6 Recursos avançados
7.6.1 Dimensionado e Dimensionado
7.6.2 Empréstimo e AsRef
7.6.3 ToBoned
7.6.4 De e para dentro
7.6.5 Objetos característicos e segurança de objetos
7.6.6 Sintaxe geral de chamada de função
7.6.7 Regras de recursos
7.7 Fechamentos avançados
7.7.1 Fechamento Fn
7.7.2 Fechamento FnMut
7.7.3 Fechamento FnOnce
7.8 Constantes em estruturas, enumerações e características
7.9 Módulos, caminhos e importações
7.9.1 Importação
7.9.2 Importar novamente
7.9.3 Privacidade
7.10 Padrões e Guardas de Correspondência Avançada
7.10.1 Guarda de Partida
7.10.2 Construção avançada de let
7.11 Fundição
7.12 Tipos e Memória
7.12.1 Alinhamento de memória
7.12.2 módulo std::mem
7.13 Serialização e desserialização usando serde
7.14 Resumo
Capítulo 8 Simultaneidade
8.1 Modelo de execução do programa
8.2 Simultaneidade
8.2.1 Métodos concorrentes
8.2.2 Defeitos
8.3 Simultaneidade em Rust
8.3.1 Noções básicas de thread
8.3.2 Tópicos personalizados
8.3.3 Acessando dados em threads
8.4 Modelo de simultaneidade de thread
8.4.1 Modelo de compartilhamento de estado
8.4.2 Exclusão mútua
8.4.3 Mutabilidade compartilhada através de Arc e Mutex
8.4.4 Comunicação via mensagens
8.5 Segurança de thread em Rust
8.5.1 O que é segurança de thread?
8.5.2 Características de segurança de rosca
8.5.3 Enviar
8.5.4 Sincronização
8.6 Implementando concorrência usando o modelo de ator
8.7 Outras bibliotecas
8.8 Resumo
Capítulo 9 Macros e Metaprogramação
9.1 O que é metaprogramação?
9.2 Cenários de aplicação de macros Rust
9.3 Macros e seus tipos em Rust
9.4 Crie macros usando macro_rules!
9.5 Macros integradas na biblioteca padrão
9.6 macro_rules! Tipo de tag macro!
9.7 Repetição em macros
9.8 Aplicação avançada de macros - escrevendo DSL para inicialização do HashMap
9.9 Casos de uso de macros - escrevendo testes
9.10 Exercício
9.11 Macros de processo
9.12 Macros derivadas
9.13 Macros de alto nível
9.14 Pacotes de software de macro de processo comumente usados
9.15 Resumo
Capítulo 10 Ferrugem insegura e interfaces de funções externas
10.1 Segurança e Insegurança
10.1.1 Funções inseguras e blocos de código
10.1.2 Características e implementações inseguras
10.2 Chamando código C em Rust
10.3 Chamando código Rust por meio da linguagem C
10.4 Usando bibliotecas C/C externas em Rust
10.5 Construindo extensões nativas do Python usando PyO3
10.6 Criando extensões nativas para Node.js em Rust
10.7 Resumo
Capítulo 11 Registro
11.1 A exploração madeireira e sua importância
11.2 Requisitos para uma estrutura de registro
11.3 Estrutura de log e seus recursos
11.4 Método de registro
11.4.1 Log não estruturado
11.4.2 Log estruturado
11.5 Registro em Rust
11.5.1 log – Registro para Rust
11.5.2 env_logger
11.5.3 log4rs
11.5.4 Usando slog para registro estruturado
11.6 Resumo
Capítulo 12 Rust e programação de rede
12.1 Introdução à Programação de Rede
12.2 E/S de rede síncrona
12.3 E/S de rede assíncrona
12.3.1 Abstrações assíncronas em Rust
12.3.2 Construindo um servidor Redis assíncrono
12.4 Resumo
Capítulo 13 Construindo Aplicações Web com Rust
13.1 Aplicações Web em Rust
13.2 Usando hyper para comunicação HTTP
13.2.1 API do lado do servidor Hyper cria um serviço de URL curto
13.2.2 Hyper como cliente - construindo um cliente curto de URL
13.2.3 Estrutura web
13.3 Conhecimento básico do Actix-web
13.4 Construindo uma API de favoritos usando actix-web
13.5 Resumo
Capítulo 14 Rust e WebAssembly
14.1 A importância da durabilidade dos dados
14.2SQLite
14.3 PostgreSQL
Conjunto de conexões 14.4 r2d2
14.5 Postgres e diesel ORM
14.6 Resumo
Capítulo 15 Rust e WebAssembly
15.1 O que é WebAssmbly
15.2 Objetivos de design do WebAssembly
15.3 Introdução ao WebAssembly
15.3.1 Experimente on-line
15.3.2 Métodos para gerar WebAssembly
15.4 Ferrugem e WebAssembly
15.4.1 wasm-bindgen
15.4.2 Outros projetos WebAssembly
15.5 Resumo
Capítulo 16 Rust e aplicativos de desktop
16.1 Introdução ao desenvolvimento de GUI
16.2 Estrutura GTK
16.3 Construir um aplicativo de desktop de notícias por meio de gtk-rs
16.4 Exercícios
16.5 Outras estruturas de UI emergentes
16.6 Resumo
Capítulo 17 Depuração
17.1 Introdução à depuração
17.1.1 Noções básicas do depurador
17.1.2 Pré-requisitos para comissionamento
17.1.3 Configurando o GDB
17.1.4 Um programa de exemplo – buggie
17.1.5 Noções básicas do GDB
17.1.6 Integrando GDB no Visual Studio Code
17.2 Introdução ao depurador rr
17.3 Resumo