Khaitan

Khaitan

1663554507

How to Call Rest API with Rust and Yew

Learn how to call Rest API with Rust and Yew. Learn how to call a rest API using a web app frontend using 100% Rust. 

WebAssembly opens the door for frontend developers to use languages that don't compile to JavaScript, like Rust.

This technology will change web development!!

We use js-sys, web-sys, and friends to power this web application.

Let me know if you would like me to OpenSource this project.

00:00 Introduction
00:10 What We'll Build (yew weather api client)
00:20 Weather API Research
01:41 Project Setup
01:19 Creating basic yew app structure
03:20 Calling HTTP Rest endpoint from Rust
05:05 Printing API Result to the console
06:34 Creating Rust structs to store Forecast
08:52 Things go sideways! troubleshooting json serde parser
11:08 Printing parsed Rust structure to the console
11:18 Rendering weather data to the page
13:25 Testing rendering weather data to the page
13:47 Creating YEW components to render each weather update
18:17 Happy path works: Rendering weather API data with yew
19:54 Making yew app robust to errors
25:18 Testing YEW app with no internet connection

#rust #rustlang #api 

How to Call Rest API with Rust and Yew
Jade Bird

Jade Bird

1662452162

Learn Rust Programming - Full Course for Beginners

Learn the Rust programming language in this course for beginners. Learn the Rust programming language from scratch! Learn how to code and build your own real-world applications using Rust so that you can get hired this year. No previous programming or Rust experience needed.

  1. Rust Course for Beginners - Lesson 1 - Installing Rust and Hello World
  2. Rust Course for Beginners - Lesson 2 - Variables and Constants
  3. Rust Course for Beginners - Lesson 3 - Basic Data Types
  4. Rust Course for Beginners - Lesson 4 - Functions
  5. Rust Course for Beginners - Lesson 5 - If Expressions
  6. Rust Course for Beginners - Lesson 6 - Loops
  7. Rust Course for Beginners - Lesson 7 - Ownership
  8. Rust Course for Beginners - Lesson 8 - Ownership and Functions
  9. Rust Course for Beginners - Lesson 9 - References and Borrowing
  10. Rust Course for Beginners - Lesson 10 - String vs &str

Rust Course for Beginners - Lesson 1 - Installing Rust and Hello World

Rust Course for Beginners - Lesson 2 - Variables and Constants

Rust Course for Beginners - Lesson 3 - Basic Data Types

Rust Course for Beginners - Lesson 4 - Functions

Rust Course for Beginners - Lesson 5 - If Expressions

Rust Course for Beginners - Lesson 6 - Loops

Rust Course for Beginners - Lesson 7 - Ownership

Rust Course for Beginners - Lesson 8 - Ownership and Functions

Rust Course for Beginners - Lesson 9 - References and Borrowing

Understanding Strings in Rust - String vs &str

In this video, we are going to explore the difference between String and &str in Rust, as well as different tips to use them.

#rust #rustlang

Learn Rust Programming - Full Course for Beginners
Romolo  Morelli

Romolo Morelli

1662432480

Comprensione dei tipi di dati primitivi in ​​Rust

Tipi di dati primitivi - Il linguaggio di programmazione Rust

Rust ha un elenco di tipi di dati che si dice siano primitivi. I tipi primitivi Rust possono essere raggruppati in tipi di dati scalari e composti. Esaminiamo cosa sono, come vengono utilizzati e i loro limiti.

Copriremo:

  • Cosa sono i tipi di dati primitivi?
  • Tipi di dati primitivi in ​​Rust
    • Tipi primitivi scalari in Rust
    • Tipi primitivi composti in Rust
  • Limitazioni dei tipi primitivi Rust

Questo articolo è destinato a coloro che hanno appena iniziato a utilizzare Rust e desiderano comprendere rapidamente ed essere in grado di utilizzare i tipi di dati primitivi in ​​Rust.

Cosa sono i tipi di dati primitivi?

I tipi di dati primitivi, come suggerisce il nome, sono fondamentalmente solo tipi di dati forniti con un linguaggio di programmazione. Sono integrati e, se combinati insieme, possono formare tipi di dati più complessi, chiamati tipi di dati non primitivi.

Come accennato, il linguaggio di programmazione Rust viene fornito con un elenco di tipi di dati primitivi incorporati che gli sviluppatori possono utilizzare come elementi costitutivi per altri tipi di dati.

Tipi di dati primitivi in ​​Rust

Diamo un'occhiata ai tipi di dati primitivi forniti da Rust.

Vogliamo prima raggrupparli in tipi di dati scalari e composti. La differenza tra questi due è che i tipi composti contengono più valori in un tipo mentre i tipi scalari contengono un solo valore.

Tipi primitivi scalari in Rust

Ci sono cinque tipi primitivi scalari che dovresti conoscere in Rust:

  • booleano
  • Carattere
  • Numero intero
  • Galleggiante
  • Unità

Diamo un'occhiata a definizioni ed esempi per ogni tipo.

booltipo di dati

Si dice che il tipo di dati booleano sia vero o falso, in questo modo:

let active = true;
let inactive = false;

I tipi di dati booleani vengono utilizzati principalmente per confrontare valori o logica, ad esempio per verificare se il punteggio di un test è A, B o C.

chartipo di dati

Il tipo di carattere è un tipo di dati a 4 byte. Viene utilizzato per memorizzare singoli caratteri, come ad esempio:

let first = 'a';
let second = 'b';
let symbol = '∞';

I tipi di dati dei caratteri vengono utilizzati per memorizzare singoli caratteri, consentendo all'allocazione di memoria in Rust di rimanere piccola.

integertipo di dati

Esistono vari tipi di dati interi, che rientrano in due categorie: con segno (i) e senza segno (u). Includono quanto segue: i8, i16, i32, i64, isize, u8, u16, u32, u64, usize. Ecco alcuni esempi:

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floatingtipo di dati

I tipi di dati mobili sono sempre o f32o f64, che possono variare ampiamente da numeri negativi a positivi:

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

I float sono ciò che chiamiamo decimali. Vedi alcuni esempi qui sotto:

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unittipo di dati

In Rust, il tipo di dati dell'unità utilizza il simbolo ()e viene utilizzato principalmente come meccanismo per evitare l'uso di null.

Qualsiasi espressione che non restituisce nulla viene effettivamente restituita ()in Rust. È più come voidnelle lingue C-like.

Un altro caso d'uso è come Response<(), String>il che significa che la risposta può fallire o avere successo.

Tipi primitivi composti in Rust

Di seguito sono riportati quattro tipi di dati primitivi composti in Rust che tratteremo di seguito:

  • Vettore
  • Corda
  • Fetta
  • Tuple

Come abbiamo fatto nella sezione precedente, diamo un'occhiata alle definizioni e agli esempi per ogni tipo.

arraytipo di dati

Un array è un tipo di dati che contiene un gruppo di elementi. La sua dimensione è sempre fissa e dello stesso tipo di dati, in questo modo:

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

Negli esempi precedenti, l' countsarray contiene 7elementi di tipo di dati i32(interi), mentre l' gradearray contiene 4elementi di tipo di dati i32.

stringtipo di dati

Esistono due stringtipi di dati in Rust : String(String Object) e &str(String literal).

L' Stringoggetto non è nel linguaggio principale, ma è fornito nella libreria standard. È anche il tipo di stringa più comune perché è mutevole. Per creare un String:

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

Il &strtipo di dati in Rust è considerato una fetta di stringa e si dice che sia immutabile, il che significa che non possono essere modificati durante la vita del programma. Dai un'occhiata all'esempio qui sotto:

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

Nell'esempio sopra, durante la vita di quel programma, namesarà sempre associato alla stringa Victor Jonah, mentre companysarà sempre associato alla stringa LogRocket.

slicetipo di dati

Le fette sono simili agli array, ma ci sono alcune differenze.

Mentre le dimensioni dell'array sono fisse, le fette hanno dimensioni dinamiche; la lunghezza non è nota in fase di compilazione e i dati vengono suddivisi in una nuova raccolta. Vedi un esempio qui sotto:

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

Le fette sono anche un puntatore all'oggetto stringa sopra in cui possiamo recuperare un determinato carattere nel valore della stringa. Possiamo anche prendere in prestito elementi in una fetta da usare da qualche altra parte.

tupletipo di dati

In altri linguaggi come JavaScript, le tuple sono indicate come oggetti. Sono tipi di dati fissi che contengono diversi tipi di elementi, a differenza degli array, che possono contenere solo lo stesso tipo di elementi.

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

Nell'esempio sopra, la tupla employeecontiene tre elementi: una stringa ( Victor Jonah), un intero ( 25) e un'altra stringa ( Technical Writer).

Limitazioni di Rust e dei suoi tipi primitivi

Come nota a margine, sarà essenziale discutere i limiti del linguaggio di programmazione Rust in generale. La maggior parte delle persone ha detto o affermato che Rust è molto adorabile, il che è vero, ma ci sono alcuni punti da considerare.

La prima cosa da notare è che la sua curva di apprendimento è ripida; Rust richiede più tempo per imparare come linguaggio perché è un linguaggio di programmazione di sistema e ha concetti di programmazione di alto livello.

C'è molto da imparare quando si tratta di tipi di dati primitivi Rust e di combinarli insieme, come la corrispondenza di modelli, i puntatori, le stringhe letterali, tre tipi di array e altro ancora. Tuttavia, vale il tuo tempo.

Dalla mia osservazione, la ripida curva di apprendimento deriva principalmente dalla mancanza di chiarezza nella documentazione di Rust nei primi giorni di lavoro con Rust.

Questo mi porta a una seconda nota: la comunità di Rust può essere meno evidente all'inizio, ma quando ci si avvicina, la comunità è accogliente, attiva e disponibile.

Un'altra cosa da notare è che Rust è un linguaggio di programmazione statico, ed è molto severo al punto che tutto deve essere dichiarato prima che venga compilato. Questo è uno dei principi fondamentali di Rust, che impone di controllare tutto in fase di compilazione.

Questo può rallentare lo sviluppo, ma è anche per una buona causa perché quando la maggior parte delle cose viene controllata in fase di compilazione, è meno probabile che il programma fallisca in fase di esecuzione.

Conclusione

I tipi di dati primitivi Rust sono integrati e i loro casi d'uso sono esattamente ciò di cui ha bisogno un tipico linguaggio di programmazione. Questi tipi di dati sono disponibili in due forme: scalare e composto.

Conoscere e comprendere tutti i diversi tipi di dati primitivi in ​​Rust è molto utile nel tuo viaggio in Rust. Ho fatto questo articolo sul lato breve per quello scopo. Grazie per aver letto.

Fonte dell'articolo originale su https://blog.logrocket.com

#rust #rustlang

Comprensione dei tipi di dati primitivi in ​​Rust
许 志强

许 志强

1662425220

理解 Rust 中的原始數據類型

原始數據類型 - Rust 編程語言

Rust 有一個被稱為原始數據類型的列表。Rust 原始類型可以分為標量和復合數據類型。讓我們回顧一下它們是什麼,如何使用它們以及它們的局限性。

我們將涵蓋:

  • 什麼是原始數據類型?
  • Rust 中的原始數據類型
    • Rust 中的標量原始類型
    • Rust 中的複合原始類型
  • Rust 原始類型的限制

本文旨在幫助那些剛開始使用 Rust 並希望快速理解並能夠使用 Rust 中的原始數據類型的人。

什麼是原始數據類型?

顧名思義,原始數據類型基本上只是編程語言附帶的數據類型。它們是內置的,當組合在一起時,可以形成更複雜的數據類型,稱為非原始數據類型。

正如我們所提到的,Rust 編程語言帶有一個內置的原始數據類型列表,開發人員可以將其用作其他數據類型的構建塊。

Rust 中的原始數據類型

讓我們看看 Rust 提供的原始數據類型。

我們想首先將它們分組為標量和復合數據類型。這兩者的區別在於復合類型在一個類型中包含多個值,而標量類型只包含一個值。

Rust 中的標量原始類型

在 Rust 中有五種你應該熟悉的標量原始類型:

  • 布爾值
  • 特點
  • 整數
  • 漂浮的
  • 單元

讓我們看一下每種類型的定義和示例。

bool數據類型

布爾數據類型被稱為真或假,如下所示:

let active = true;
let inactive = false;

布爾數據類型主要用於比較值或邏輯——例如,檢查測試分數是 A、B 還是 C。

char數據類型

字符類型是 4 字節數據類型。它用於存儲單個字符,例如:

let first = 'a';
let second = 'b';
let symbol = '∞';

字符數據類型用於存儲單個字符,允許Rust中的內存分配保持較小。

integer數據類型

有多種整數數據類型,分為兩類:有符號 (i) 和無符號 (u)。它們包括:i8, i16, i32, i64, isize, u8, u16, u32, u64, usize. 這裡有些例子:

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floating數據類型

浮動數據類型始終是f32or f64,其範圍可以從負數到正數:

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

浮點數就是我們所說的小數。請參閱下面的一些示例:

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unit數據類型

在 Rust 中,unit 數據類型使用符號(),它主要用作避免使用null.

任何不返回任何內容的表達式實際上都會()在 Rust 中返回。它更像是void在類 C 語言中。

另一個用例就像Response<(), String>這意味著響應可能失敗或成功。

Rust 中的複合原始類型

下面是 Rust 中的四種複合原始數據類型,我們將在下面介紹:

  • 大批
  • 細繩
  • 元組

正如我們在上一節中所做的那樣,讓我們看一下每種類型的定義和示例。

array數據類型

數組是包含一組元素的數據類型。它的大小始終是固定的並且具有相同的數據類型,如下所示:

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

在上面的示例中,counts數組包含7數據類型i32(整數)的元素,而grade數組包含4數據類型的元素i32

string數據類型

Rust中有兩種string數據類型:String(String Object)和&str(String literal)。

該對String像不在核心語言中,而是在標準庫中提供。它也是最常見的字符串類型,因為它是可變的。創建一個String

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

Rust 中的&str數據類型被視為字符串切片,據說是不可變的,這意味著它們在程序的生命週期內無法更改。看看下面的例子:

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

在上面的示例中,在該程序的生命週期內,name將始終與 string 關聯Victor Jonah,而company將始終與 string 關聯LogRocket

slice數據類型

切片與數組類似,但有一些區別。

雖然數組大小是固定的,但切片的大小是動態的;長度在編譯時是未知的,數據被分割成一個新的集合。請參見下面的示例:

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

切片也是一個指向上面字符串對象的指針,我們可以在其中檢索字符串值中的某個字符。我們還可以藉用切片中的元素以在其他地方使用。

tuple數據類型

在 JavaScript 等其他語言中,元組被稱為對象。它們是包含不同類型元素的固定數據類型——與數組不同,數組只能包含相同類型的元素。

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

在上面的示例中,元組employee包含三個元素:一個字符串 ( Victor Jonah)、一個整數 ( 25) 和另一個字符串 ( Technical Writer)。

Rust 及其原始類型的局限性

作為一個旁注,討論Rust 編程語言的一般限制將是必不可少的。大多數人都說過或聲稱 Rust 非常可愛——這是真的——但有幾點需要考慮。

首先要注意的是它的學習曲線很陡。Rust 需要更多時間來學習作為一種語言,因為它是一種系統編程語言並且具有高級編程概念。

當談到 Rust 原始數據類型並將它們組合在一起時,有很多東西需要學習——比如模式匹配、指針、字符串文字、三種類型的數組等等。不過,值得您花時間。

根據我的觀察,陡峭的學習曲線主要是由於早期使用 Rust 的 Rust 文檔缺乏清晰度。

這讓我想到了第二點:Rust 社區一開始可能不太引人注目,但當你伸出手時,社區就會變得熱情、活躍和樂於助人。

另外需要注意的是,Rust 是一種靜態編程語言,它非常嚴格,以至於在編譯之前必須說明所有內容。這是 Rust 的主要原則之一,它強制要求在編譯時檢查所有內容。

這可能會減慢開發速度,但也是一個很好的原因,因為當大多數事情在編譯時檢查時,程序在運行時失敗的可能性較小。

結論

Rust 原始數據類型是內置的,它們的用例正是典型編程語言所需要的。這些數據類型有兩種形式:標量和復合。

了解和理解 Rust 中所有不同的原始數據類型對您的 Rust 之旅非常有幫助。為了這個目的,我在簡短的一面寫了這篇文章。感謝您的閱讀。

文章原文來源https://blog.logrocket.com

#rust #rustlang

理解 Rust 中的原始數據類型

Comprender los tipos de datos primitivos en Rust

Tipos de datos primitivos: el lenguaje de programación Rust

Rust tiene una lista de tipos de datos que se dice que son primitivos. Los tipos primitivos de Rust se pueden agrupar en tipos de datos escalares y compuestos. Repasemos qué son, cómo se usan y sus limitaciones.

Cubriremos:

  • ¿Qué son los tipos de datos primitivos?
  • Tipos de datos primitivos en Rust
    • Tipos primitivos escalares en Rust
    • Tipos primitivos compuestos en Rust
  • Limitaciones de los tipos primitivos de Rust

Este artículo está destinado a beneficiar a aquellos que recién comienzan en Rust y desean comprender rápidamente y poder usar los tipos de datos primitivos en Rust.

¿Qué son los tipos de datos primitivos?

Los tipos de datos primitivos, como su nombre lo indica, son básicamente tipos de datos que vienen con un lenguaje de programación. Están incorporados y, cuando se combinan entre sí, pueden formar tipos de datos más complejos, que se denominan tipos de datos no primitivos.

Como mencionamos, el lenguaje de programación Rust viene con una lista de tipos de datos primitivos incorporados que los desarrolladores pueden usar como bloques de construcción para otros tipos de datos.

Tipos de datos primitivos en Rust

Veamos los tipos de datos primitivos que proporciona Rust.

Primero queremos agruparlos en tipos de datos escalares y compuestos. La diferencia entre estos dos es que los tipos compuestos contienen múltiples valores en un tipo, mientras que los tipos escalares contienen solo un valor.

Tipos primitivos escalares en Rust

Hay cinco tipos primitivos escalares con los que debería estar familiarizado en Rust:

  • booleano
  • Personaje
  • Entero
  • Flotante
  • Unidad

Veamos definiciones y ejemplos para cada tipo.

booltipo de datos

Se dice que el tipo de datos booleano es verdadero o falso, así:

let active = true;
let inactive = false;

Los tipos de datos booleanos se utilizan principalmente para comparar valores o lógica; por ejemplo, para comprobar si la puntuación de una prueba es A, B o C.

chartipo de datos

El tipo de carácter es un tipo de datos de 4 bytes. Se utiliza para almacenar caracteres individuales, como:

let first = 'a';
let second = 'b';
let symbol = '∞';

Los tipos de datos de caracteres se utilizan para almacenar caracteres individuales, lo que permite que la asignación de memoria en Rust permanezca pequeña.

integertipo de datos

Hay varios tipos de datos enteros, que se dividen en dos categorías: con signo (i) y sin signo (u). Incluyen lo siguiente: i8, i16, i32, i64, isize, u8, u16, u32, u64, usize. Aquí hay unos ejemplos:

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floatingtipo de datos

Los tipos de datos flotantes son siempre f32o f64, que pueden variar ampliamente de números negativos a positivos:

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

Los flotantes son a lo que nos referimos como decimales. Vea algunos ejemplos a continuación:

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unittipo de datos

En Rust, el tipo de datos de la unidad usa el símbolo ()y se usa principalmente como un mecanismo para evitar el uso de null.

Cualquier expresión que no devuelve nada en realidad devuelve ()en Rust. Es más como voiden lenguajes tipo C.

Otro caso de uso es Response<(), String>que significa que la respuesta puede fallar o tener éxito.

Tipos primitivos compuestos en Rust

A continuación se muestran cuatro tipos de datos primitivos compuestos en Rust que cubriremos a continuación:

  • Formación
  • Cuerda
  • Rodaja
  • tuplas

Como hicimos en la sección anterior, veamos definiciones y ejemplos para cada tipo.

arraytipo de datos

Una matriz es un tipo de datos que contiene un grupo de elementos. Su tamaño siempre es fijo y del mismo tipo de datos, así:

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

En los ejemplos anteriores, la countsmatriz contiene 7elementos de tipo de datos i32(enteros), mientras que la gradematriz contiene 4elementos de tipo de datos i32.

stringtipo de datos

Hay dos stringtipos de datos en Rust : String(Objeto de cadena) y &str(Literal de cadena).

El Stringobjeto no está en el idioma principal, pero se proporciona en la biblioteca estándar. También es el tipo de cadena más común porque es mutable. Para crear un String:

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

El &strtipo de datos en Rust se considera un segmento de cadena y se dice que es inmutable, lo que significa que no se pueden cambiar durante la vida útil del programa. Echa un vistazo al siguiente ejemplo:

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

En el ejemplo anterior, durante la vigencia de ese programa, namesiempre estará asociado con la cadena Victor Jonah, mientras companyque siempre estará asociado con la cadena LogRocket.

slicetipo de datos

Las rebanadas son similares a las matrices, pero hay algunas diferencias.

Si bien los tamaños de las matrices son fijos, los sectores tienen un tamaño dinámico; la longitud no se conoce en tiempo de compilación y los datos se dividen en una nueva colección. Vea un ejemplo a continuación:

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

Las rebanadas también son un puntero al objeto de cadena de arriba donde podemos recuperar un cierto carácter en el valor de la cadena. También podemos tomar prestados elementos en un segmento para usarlos en otro lugar.

tupletipo de datos

En otros lenguajes como JavaScript, las tuplas se conocen como objetos. Son tipos de datos fijos que contienen diferentes tipos de elementos, a diferencia de las matrices, que solo pueden contener el mismo tipo de elementos.

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

En el ejemplo anterior, la tupla employeecontiene tres elementos: una cadena ( Victor Jonah), un entero ( 25) y otra cadena ( Technical Writer).

Limitaciones de Rust y sus tipos primitivos

Como nota al margen, será esencial discutir las limitaciones del lenguaje de programación Rust en general. La mayoría de la gente ha dicho o afirmado que Rust es muy adorable, lo cual es cierto, pero hay algunos puntos a considerar.

Lo primero a tener en cuenta es que su curva de aprendizaje es empinada; Rust toma más tiempo para aprender como lenguaje porque es un lenguaje de programación de sistemas y tiene conceptos de programación de alto nivel.

Hay mucho que aprender cuando se trata de tipos de datos primitivos de Rust y combinarlos, como coincidencia de patrones, punteros, literales de cadena, tres tipos de matrices y más. Sin embargo, vale la pena su tiempo.

Según mi observación, la pronunciada curva de aprendizaje se debe principalmente a la falta de claridad en la documentación de Rust en los primeros días de trabajo con Rust.

Esto me lleva a una segunda nota: la comunidad de Rust puede ser menos notoria al principio, pero cuando te acercas, la comunidad es acogedora, activa y servicial.

Otra cosa a tener en cuenta es que Rust es un lenguaje de programación estático, y es muy estricto hasta el punto de que todo debe indicarse antes de compilarlo. Este es uno de los principios fundamentales de Rust, que impone que todo debe verificarse en el momento de la compilación.

Esto puede ralentizar el desarrollo, pero también es por una buena causa porque cuando la mayoría de las cosas se verifican en tiempo de compilación, es menos probable que el programa falle en tiempo de ejecución.

Conclusión

Los tipos de datos primitivos de Rust están incorporados y sus casos de uso son exactamente lo que necesita un lenguaje de programación típico. Estos tipos de datos vienen en dos formas: escalar y compuesto.

Conocer y comprender todos los diferentes tipos de datos primitivos en Rust es muy útil en su recorrido por Rust. He hecho este artículo en el lado breve para ese propósito. Gracias por leer.

Fuente del artículo original en https://blog.logrocket.com

#rust #rustlang

Comprender los tipos de datos primitivos en Rust
Poppy Cooke

Poppy Cooke

1662410700

Comprendre les types de données primitifs dans Rust

Types de données primitifs - Le langage de programmation Rust

Rust a une liste de types de données dits primitifs. Les types primitifs Rust peuvent être regroupés en types de données scalaires et composés. Passons en revue ce qu'ils sont, comment ils sont utilisés et leurs limites.

Nous couvrirons :

  • Que sont les types de données primitifs ?
  • Types de données primitifs dans Rust
    • Types primitifs scalaires dans Rust
    • Types primitifs composés dans Rust
  • Limitations des types primitifs Rust

Cet article est destiné à ceux qui débutent dans Rust et qui souhaitent comprendre rapidement et pouvoir utiliser les types de données primitifs dans Rust.

Que sont les types de données primitifs ?

Les types de données primitifs, comme leur nom l'indique, ne sont essentiellement que des types de données fournis avec un langage de programmation. Ils sont intégrés et, lorsqu'ils sont combinés, peuvent former des types de données plus complexes, appelés types de données non primitifs.

Comme nous l'avons mentionné, le langage de programmation Rust est livré avec une liste de types de données primitifs intégrés que les développeurs peuvent utiliser comme blocs de construction pour d'autres types de données.

Types de données primitifs dans Rust

Examinons les types de données primitifs fournis par Rust.

Nous voulons d'abord les regrouper en types de données scalaires et composés. La différence entre ces deux est que les types composés contiennent plusieurs valeurs dans un type tandis que les types scalaires ne contiennent qu'une seule valeur.

Types primitifs scalaires dans Rust

Il existe cinq types primitifs scalaires avec lesquels vous devriez être familiarisé dans Rust :

  • booléen
  • Personnage
  • Entier
  • Flottant
  • Unité

Examinons les définitions et les exemples pour chaque type.

boolType de données

Le type de données booléen est dit vrai ou faux, comme ceci :

let active = true;
let inactive = false;

Les types de données booléens sont principalement utilisés pour comparer des valeurs ou une logique, par exemple, pour vérifier si un score de test est A, B ou C.

charType de données

Le type de caractère est un type de données à 4 octets. Il est utilisé pour stocker des caractères uniques, tels que :

let first = 'a';
let second = 'b';
let symbol = '∞';

Les types de données de caractères sont utilisés pour stocker des caractères uniques, permettant à l' allocation de mémoire dans Rust de rester petite.

integerType de données

Il existe différents types de données entières, qui relèvent de deux catégories : signé (i) et non signé (u). Ils comprennent les éléments suivants : i8, i16, i32, i64, isize, u8, u16, u32, u64, usize. Voici quelques exemples:

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floatingType de données

Les types de données flottantes sont toujours soit f32ou f64, qui peuvent varier largement de nombres négatifs à positifs :

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

Les flottants sont ce que nous appelons des décimales. Voir quelques exemples ci-dessous :

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unitType de données

Dans Rust, le type de données d'unité utilise le symbole ()et il est principalement utilisé comme mécanisme pour éviter d'utiliser null.

Toute expression qui ne renvoie rien revient en fait ()dans Rust. C'est plus comme voiddans les langages de type C.

Un autre cas d'utilisation est comme Response<(), String>ce qui signifie que la réponse peut échouer ou réussir.

Types primitifs composés dans Rust

Vous trouverez ci-dessous quatre types de données primitives composées dans Rust que nous aborderons ci-dessous :

  • Déployer
  • Chaîne de caractères
  • Tranche
  • Tuples

Comme nous l'avons fait dans la section précédente, examinons les définitions et les exemples pour chaque type.

arrayType de données

Un tableau est un type de données qui contient un groupe d'éléments. Sa taille est toujours fixe et du même type de données, comme ceci :

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

Dans les exemples ci-dessus, le countstableau contient 7des éléments de type de données i32(entiers), tandis que le gradetableau contient 4des éléments de type de données i32.

stringType de données

Il existe deux stringtypes de données dans Rust : String(String Object) et &str(String literal).

L' Stringobjet n'est pas dans le langage de base, mais est fourni dans la bibliothèque standard. C'est aussi le type de chaîne le plus courant car il est modifiable. Pour créer un String:

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

Le &strtype de données dans Rust est considéré comme une tranche de chaîne et on dit qu'il est immuable, ce qui signifie qu'il ne peut pas être modifié pendant la durée de vie du programme. Jetez un oeil à l'exemple ci-dessous:

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

Dans l'exemple ci-dessus, pendant la durée de vie de ce programme, namesera toujours associé à la chaîne Victor Jonah, tandis que companysera toujours associé à la chaîne LogRocket.

sliceType de données

Les tranches sont similaires aux tableaux, mais il existe quelques différences.

Alors que les tailles de tableau sont fixes, les tranches sont de taille dynamique ; la longueur n'est pas connue au moment de la compilation et les données sont découpées en une nouvelle collection. Voir un exemple ci-dessous :

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

Les tranches sont également un pointeur vers l'objet chaîne ci-dessus où nous pouvons récupérer un certain caractère dans la valeur de chaîne. Nous pouvons également emprunter des éléments dans une tranche pour les utiliser ailleurs.

tupleType de données

Dans d'autres langages comme JavaScript, les tuples sont appelés objets. Ce sont des types de données fixes qui contiennent différents types d'éléments, contrairement aux tableaux, qui ne peuvent contenir que le même type d'éléments.

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

Dans l'exemple ci-dessus, le tuple employeecontient trois éléments : une chaîne ( Victor Jonah), un entier ( 25) et une autre chaîne ( Technical Writer).

Limitations de Rust et de ses types primitifs

En remarque, il sera essentiel de discuter des limites du langage de programmation Rust en général. La plupart des gens ont dit ou affirmé que Rust était très aimable - ce qui est vrai - mais il y a quelques points à considérer.

La première chose à noter est que sa courbe d'apprentissage est abrupte ; Rust prend plus de temps à apprendre en tant que langage car il s'agit d'un langage de programmation système et possède des concepts de programmation de haut niveau.

Il y a beaucoup à apprendre en ce qui concerne les types de données primitifs Rust et leur combinaison - comme la correspondance de modèles, les pointeurs, les littéraux de chaîne, trois types de tableaux, etc. Néanmoins, cela vaut votre temps.

D'après mes observations, la courbe d'apprentissage abrupte résulte principalement du manque de clarté de la documentation Rust dans les premiers jours de travail avec Rust.

Cela m'amène à une deuxième remarque : la communauté Rust est peut-être moins visible au tout début, mais lorsque vous la contactez, la communauté est accueillante, active et serviable.

Une autre chose à noter est que Rust est un langage de programmation statique, et il est très strict au point que tout doit être déclaré avant d'être compilé. C'est l'un des grands principes de Rust, qui impose que tout soit vérifié au moment de la compilation.

Cela peut ralentir le développement, mais c'est aussi pour une bonne cause car lorsque la plupart des choses sont vérifiées au moment de la compilation, il est moins probable que le programme échoue à l'exécution.

Conclusion

Les types de données primitifs Rust sont intégrés et leurs cas d'utilisation sont exactement ce dont un langage de programmation typique a besoin. Ces types de données se présentent sous deux formes : scalaire et composée.

Connaître et comprendre tous les différents types de données primitifs dans Rust est très utile dans votre voyage Rust. J'ai fait cet article sur le côté bref à cet effet. Merci pour la lecture.

Source de l'article original sur https://blog.logrocket.com

#rust #rustlang

Comprendre les types de données primitifs dans Rust
田辺  明美

田辺 明美

1662403440

Rustのプリミティブデータ型を理解する

プリミティブ データ型 - The Rust Programming Language

Rust には、プリミティブと呼ばれるデータ型のリストがあります。Rust プリミティブ型は、スカラー データ型と複合データ型にグループ化できます。それらが何であるか、それらがどのように使用されるか、およびそれらの制限を確認しましょう。

以下について説明します。

  • プリミティブ データ型とは
  • Rust のプリミティブ データ型
    • Rust のスカラー プリミティブ型
    • Rust の複合プリミティブ型
  • Rust プリミティブ型の制限

この記事は、Rust を使い始めたばかりで、Rust のプリミティブ データ型をすぐに理解し、使用できるようになりたい人に役立つことを目的としています。

プリミティブ データ型とは

プリミティブ データ型は、その名前が示すように、基本的にプログラミング言語に付属する単なるデータ型です。これらは組み込みであり、組み合わせると、非プリミティブ データ型と呼ばれるより複雑なデータ型を形成できます。

前述したように、Rust プログラミング言語には、開発者が他のデータ型のビルディング ブロックとして使用できる組み込みのプリミティブ データ型のリストが付属しています。

Rust のプリミティブ データ型

Rust が提供する基本的なデータ型を見てみましょう。

まず、それらをスカラー データ型と複合データ型にグループ化します。これら 2 つの違いは、複合型には 1 つの型に複数の値が含まれるのに対し、スカラー型には値が 1 つしか含まれないことです。

Rust のスカラー プリミティブ型

Rust では、5 つのスカラー プリミティブ型を理解しておく必要があります。

  • ブール値
  • キャラクター
  • 整数
  • フローティング
  • 単位

各タイプの定義と例を見てみましょう。

boolデータ・タイプ

Boolean データ型は、次のように true または false のいずれかと言われます。

let active = true;
let inactive = false;

ブール型のデータ型は、主に値またはロジックを比較するために使用されます。たとえば、テストのスコアが A、B、または C であるかどうかを確認する場合などです。

charデータ・タイプ

文字型は 4 バイトのデータ型です。次のような単一の文字を格納するために使用されます。

let first = 'a';
let second = 'b';
let symbol = '∞';

文字データ型は単一の文字を格納するために使用され、Rust でのメモリ割り当てを小さく保つことができます。

integerデータ・タイプ

さまざまな整数データ型があり、符号付き (i) と符号なし (u) の 2 つのカテゴリに分類されます。次のものが含まれます: i8i16i32i64isizeu8u16u32。ここではいくつかの例を示します。u64usize

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floatingデータ・タイプ

浮動小数点データ型は常に または のいずれf32f64であり、負の数から正の数まで広範囲に及ぶ可能性があります。

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

浮動小数点数は、小数と呼ばれるものです。以下の例を参照してください。

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unitデータ・タイプ

Rust では unit データ型はシンボル()を使用し、使用を回避するためのメカニズムとして使用されることがほとんどnullです。

何も返さない式は()、Rust では実際に返されます。これはvoid、C ライクな言語に似ています。

別の使用例はResponse<(), String>、応答が失敗または成功する可能性があることを意味します。

Rust の複合プリミティブ型

以下は、Rust の 4 つの複合プリミティブ データ型であり、以下で説明します。

  • 配列
  • スライス
  • タプル

前のセクションで行ったように、各タイプの定義と例を見てみましょう。

arrayデータ・タイプ

配列は、要素のグループを含むデータ型です。そのサイズは常に固定されており、次のように同じデータ型です。

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

上記の例では、counts配列に7はデータ型i32(整数) の要素が含まれていますが、grade配列に4はデータ型の要素が含まれていますi32

stringデータ・タイプ

Rust には (文字列オブジェクト) と (文字列リテラル) の 2 つのデータ型がありますstringString&str

Stringオブジェクトはコア言語にはありませんが、標準ライブラリで提供されています。また、可変であるため、最も一般的な文字列型でもあります。を作成するにはString:

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

Rustの&strデータ型は文字列スライスと見なされ、不変であると言われています。つまり、プログラムの存続期間中に変更することはできません。以下の例を見てください。

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

上記の例では、そのプログラムの存続期間中、nameは常に stringVictor Jonahに関連付けられますが、は常に stringcompanyに関連付けられますLogRocket

sliceデータ・タイプ

スライスは配列に似ていますが、いくつかの違いがあります。

配列のサイズは固定されていますが、スライスのサイズは動的です。長さはコンパイル時には不明であり、データは新しいコレクションにスライスされます。以下の例を参照してください。

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

スライスは、文字列値内の特定の文字を取得できる上記の文字列オブジェクトへのポインターでもあります。スライス内の要素を借りて、別の場所で使用することもできます。

tupleデータ・タイプ

JavaScript などの他の言語では、タプルはオブジェクトと呼ばれます。それらは、異なるタイプの要素を含む固定データ型です — 同じタイプの要素のみを含むことができる配列とは異なります。

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

上記の例では、タプルには文字列 ( )、整数 ( )、および別の文字列 ( )employeeの 3 つの要素が含まれています。Victor Jonah25Technical Writer

Rust とそのプリミティブ型の制限

補足として、Rust プログラミング言語全般の制限について説明することが不可欠です。ほとんどの人は、Rust はとても愛らしいと言ったり主張したりしていますが、これは本当です。しかし、考慮すべき点がいくつかあります。

最初に注意すべきことは、学習曲線が急勾配であることです。Rust はシステム プログラミング言語であり、高度なプログラミング概念を備えているため、言語としての学習にはより多くの時間がかかります。

Rust のプリミティブ データ型とそれらの組み合わせに関しては、学ぶべきことがたくさんあります — パターン マッチング、ポインター、文字列リテラル、3 種類の配列など。それにもかかわらず、それはあなたの時間の価値があります。

私の観察によると、急激な学習曲線は、ほとんどの場合、Rust を使用した初期の頃の Rust のドキュメントに明確さが欠けていたことが原因です。

これは 2 つ目の注意点です。最初は Rust コミュニティはあまり目立たないかもしれませんが、手を差し伸べると、コミュニティは歓迎され、活発で、助けになります。

もう 1 つ注意すべき点は、Rust は静的プログラミング言語であり、コンパイルする前にすべてを記述しなければならないという点で非常に厳密です。これは Rust の主な原則の 1 つであり、コンパイル時にすべてをチェックする必要があります。

これは開発を遅くする可能性がありますが、コンパイル時にほとんどのことをチェックすると、実行時にプログラムが失敗する可能性が低くなるため、正当な理由でもあります。

結論

Rust プリミティブ データ型は組み込みであり、それらのユース ケースはまさに典型的なプログラミング言語が必要とするものです。これらのデータ型には、スカラーと複合の 2 つの形式があります。

Rust のさまざまなプリミティブ データ型をすべて知って理解することは、Rust の旅において非常に役立ちます。その目的のために、この記事を簡潔に作成しました。読んでくれてありがとう。

https://blog.logrocket.comの元の記事ソース

#rust #rustlang

Rustのプリミティブデータ型を理解する

Понимание примитивных типов данных в Rust

Примитивные типы данных — язык программирования Rust

В Rust есть список типов данных, которые считаются примитивными. Примитивные типы Rust можно сгруппировать в скалярные и составные типы данных. Давайте рассмотрим, что они из себя представляют, как они используются и каковы их ограничения.

Мы рассмотрим:

  • Что такое примитивные типы данных?
  • Примитивные типы данных в Rust
    • Скалярные примитивные типы в Rust
    • Составные примитивные типы в Rust
  • Ограничения примитивных типов Rust

Эта статья предназначена для тех, кто только начинает работать с Rust и хочет быстро понять и научиться использовать примитивные типы данных в Rust.

Что такое примитивные типы данных?

Примитивные типы данных, как следует из названия, — это просто типы данных, поставляемые с языком программирования. Они являются встроенными и при объединении друг с другом могут образовывать более сложные типы данных, которые называются непримитивными типами данных.

Как мы уже упоминали, язык программирования Rust поставляется со списком встроенных примитивных типов данных, которые разработчики могут использовать в качестве строительных блоков для других типов данных.

Примитивные типы данных в Rust

Давайте посмотрим на примитивные типы данных, которые предоставляет Rust.

Мы хотим сначала сгруппировать их по скалярным и составным типам данных. Разница между ними заключается в том, что составные типы содержат несколько значений в типе, а скалярные типы содержат только одно значение.

Скалярные примитивные типы в Rust

В Rust есть пять типов скалярных примитивов, с которыми вы должны быть знакомы:

  • логический
  • Персонаж
  • Целое число
  • Плавающий
  • Ед. изм

Давайте посмотрим на определения и примеры для каждого типа.

boolтип данных

Тип данных Boolean считается либо истинным, либо ложным, например:

let active = true;
let inactive = false;

Логические типы данных в основном используются для сравнения значений или логики — например, чтобы проверить, соответствует ли результат теста A, B или C.

charтип данных

Символьный тип представляет собой 4-байтовый тип данных. Он используется для хранения отдельных символов, таких как:

let first = 'a';
let second = 'b';
let symbol = '∞';

Символьные типы данных используются для хранения отдельных символов, благодаря чему выделение памяти в Rust остается небольшим.

integerтип данных

Существуют различные целочисленные типы данных, которые делятся на две категории: со знаком (i) и без знака (u). К ним относятся следующие: i8, i16, i32, i64, isize, u8, u16, u32, u64, usize. Вот некоторые примеры:

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floatingтип данных

Типы данных с плавающей запятой всегда либо f32или f64, которые могут широко варьироваться от отрицательных до положительных чисел:

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

Поплавки — это то, что мы называем десятичными числами. См. несколько примеров ниже:

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unitтип данных

В Rust тип данных unit использует символ (), и он в основном используется как механизм, позволяющий избежать использования null.

Любое выражение, которое ничего не возвращает, на самом деле возвращается ()в Rust. Это больше похоже voidна C-подобные языки.

Другой вариант использования подобен Response<(), String>тому, что означает, что ответ может быть либо неудачным, либо успешным.

Составные примитивные типы в Rust

Ниже приведены четыре составных примитивных типа данных в Rust, которые мы рассмотрим ниже:

  • Множество
  • Нить
  • Ломтик
  • Кортежи

Как и в предыдущем разделе, давайте рассмотрим определения и примеры для каждого типа.

arrayтип данных

Массив — это тип данных, который содержит группу элементов. Его размер всегда фиксирован и имеет один и тот же тип данных, например:

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

В приведенных выше примерах countsмассив содержит 7элементы типа данных i32(целые числа), а gradeмассив содержит 4элементы типа данных i32.

stringтип данных

В Rust есть дваstring типа данных : String(String Object) и &str(String literal).

Объект Stringне находится в основном языке, но предоставляется в стандартной библиотеке. Это также наиболее распространенный строковый тип, поскольку он является изменяемым. Чтобы создать String:

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

Тип &strданных в Rust рассматривается как срез строки и считается неизменяемым, что означает, что они не могут быть изменены в течение жизни программы. Взгляните на пример ниже:

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

В приведенном выше примере во время жизни этой программы nameвсегда будет ассоциироваться со строкой Victor Jonah, а companyвсегда будет ассоциироваться со строкой LogRocket.

sliceтип данных

Срезы похожи на массивы, но есть несколько отличий.

В то время как размеры массива фиксированы, срезы имеют динамический размер; длина неизвестна во время компиляции, и данные нарезаются в новую коллекцию. См. пример ниже:

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

Срезы также являются указателем на строковый объект выше, где мы можем получить определенный символ в строковом значении. Мы также можем заимствовать элементы из слайса, чтобы использовать их где-то еще.

tupleтип данных

В других языках, таких как JavaScript, кортежи называются объектами. Это фиксированные типы данных, которые содержат элементы разных типов, в отличие от массивов, которые могут содержать элементы только одного типа.

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

В приведенном выше примере кортеж employeeсодержит три элемента: строку ( Victor Jonah), целое число ( 25) и еще одну строку ( Technical Writer).

Ограничения Rust и его примитивных типов

В качестве примечания важно обсудить ограничения языка программирования Rust в целом. Большинство людей говорили или утверждали, что Rust очень привлекателен — и это правда — но есть несколько моментов, которые следует учитывать.

Первое, что нужно отметить, это то, что его кривая обучения крутая; Rust требует больше времени для изучения как языка, потому что это язык системного программирования и имеет концепции программирования высокого уровня.

Есть чему поучиться, когда дело доходит до примитивных типов данных Rust и их объединения — например, сопоставление с образцом, указатели, строковые литералы, три типа массивов и многое другое. Тем не менее, это стоит вашего времени.

По моим наблюдениям, крутая кривая обучения в основном связана с отсутствием ясности в документации Rust в первые дни работы с Rust.

Это подводит меня ко второму замечанию: сообщество Rust может быть менее заметным в самом начале, но когда вы обращаетесь к нему, оно становится приветливым, активным и готовым помочь.

Еще одна вещь, которую следует отметить, это то, что Rust — это статический язык программирования, и он очень строг до такой степени, что все должно быть указано до его компиляции. Это один из основных принципов Rust, согласно которому все должно проверяться во время компиляции.

Это может замедлить разработку, но также и по уважительной причине, потому что, когда большинство вещей проверяется во время компиляции, меньше вероятность того, что программа выйдет из строя во время выполнения.

Вывод

Примитивные типы данных Rust встроены, и их варианты использования точно соответствуют требованиям типичного языка программирования. Эти типы данных бывают двух видов: скалярные и составные.

Знание и понимание всех различных примитивных типов данных в Rust очень полезно в вашем путешествии по Rust. Я сделал эту статью на краткой стороне для этой цели. Спасибо за чтение.

Оригинальный источник статьи на https://blog.logrocket.com

#rust #rustlang

Понимание примитивных типов данных в Rust
최  호민

최 호민

1662388941

Rust의 기본 데이터 유형 이해하기

원시 데이터 유형 - The Rust 프로그래밍 언어

Rust에는 원시적이라고 하는 데이터 유형 목록이 있습니다. Rust 기본 유형은 스칼라 및 복합 데이터 유형으로 그룹화할 수 있습니다. 그것들이 무엇인지, 어떻게 사용되는지, 그리고 그 한계를 검토해 봅시다.

우리는 다음을 다룰 것입니다:

  • 원시 데이터 유형이란 무엇입니까?
  • Rust의 기본 데이터 유형
    • Rust의 스칼라 기본 유형
    • Rust의 복합 기본 유형
  • Rust 기본 유형의 제한 사항

이 기사는 Rust를 이제 막 시작하고 Rust의 기본 데이터 유형을 빠르게 이해하고 사용할 수 있기를 원하는 사람들을 위한 것입니다.

원시 데이터 유형이란 무엇입니까?

기본 데이터 유형은 이름에서 알 수 있듯이 기본적으로 프로그래밍 언어와 함께 제공되는 데이터 유형입니다. 그것들은 기본 제공되며 함께 결합될 때 비기본 데이터 유형이라고 하는 더 복잡한 데이터 유형을 형성할 수 있습니다.

우리가 언급했듯이, Rust 프로그래밍 언어는 개발자가 다른 데이터 유형의 빌딩 블록으로 사용할 수 있는 기본 제공 기본 데이터 유형 목록과 함께 제공됩니다.

Rust의 기본 데이터 유형

Rust가 제공하는 기본 데이터 유형을 살펴보겠습니다.

먼저 스칼라 및 복합 데이터 유형으로 그룹화하려고 합니다. 이 두 가지의 차이점은 복합 유형은 유형에 여러 값을 포함하는 반면 스칼라 유형은 하나의 값만 포함한다는 것입니다.

Rust의 스칼라 기본 유형

Rust에는 다음과 같은 다섯 가지 기본 스칼라 유형이 있습니다.

  • 부울
  • 성격
  • 정수
  • 떠 있는
  • 단위

각 유형에 대한 정의와 예를 살펴보겠습니다.

bool데이터 형식

부울 데이터 유형은 다음과 같이 true 또는 false라고 합니다.

let active = true;
let inactive = false;

부울 데이터 유형은 주로 값이나 논리를 비교하는 데 사용됩니다(예: 테스트 점수가 A, B 또는 C인지 확인하는 경우).

char데이터 형식

문자 유형은 4바이트 데이터 유형입니다. 다음과 같은 단일 문자를 저장하는 데 사용됩니다.

let first = 'a';
let second = 'b';
let symbol = '∞';

문자 데이터 유형은 단일 문자를 저장하는 데 사용되므로 Rust의 메모리 할당 은 작게 유지됩니다.

integer데이터 형식

부호 있는(i) 및 부호 없는(u)의 두 가지 범주에 속하는 다양한 정수 데이터 유형이 있습니다. 여기에는 다음이 포함됩니다. i8, i16, i32, i64, isize, u8, u16, u32, u64, usize. 여기 몇 가지 예가 있어요.

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floating데이터 형식

부동 데이터 유형은 항상 f32또는 f64이며 음수에서 양수까지 광범위할 수 있습니다.

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

부동 소수점은 우리가 십진수라고 부르는 것입니다. 아래의 몇 가지 예를 참조하십시오.

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unit데이터 형식

Rust에서 단위 데이터 유형은 기호 ()를 사용하며 주로 사용을 피하기 위한 메커니즘으로 사용 null됩니다.

아무것도 반환하지 않는 표현식은 실제로 ()Rust에서 반환됩니다. voidC 계열 언어와 비슷합니다 .

또 다른 사용 사례는 Response<(), String>응답이 실패하거나 성공할 수 있음을 의미합니다.

Rust의 복합 기본 유형

다음은 아래에서 다룰 Rust의 4가지 복합 기본 데이터 유형입니다.

  • 정렬
  • 일부분
  • 튜플

이전 섹션에서 했던 것처럼 각 유형에 대한 정의와 예를 살펴보겠습니다.

array데이터 형식

배열은 요소 그룹을 포함하는 데이터 유형입니다. 크기는 항상 고정되어 있으며 다음과 같은 데이터 유형입니다.

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

위의 예에서 counts배열에는 7데이터 유형 i32(정수)의 요소가 포함되고 grade배열에는 4데이터 유형의 요소가 포함 i32됩니다.

string데이터 형식

Rust 에는 (String Object) 및 (String literal) 의 두 가지string 데이터 유형 이 있습니다 .String&str

객체 는 String핵심 언어가 아니지만 표준 라이브러리에서 제공됩니다. 또한 변경 가능하기 때문에 가장 일반적인 문자열 유형입니다. 생성하려면 String:

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

Rust 의 &str데이터 유형은 문자열 슬라이스로 간주되며 변경할 수 없다고 합니다. 즉, 프로그램 수명 동안 변경할 수 없습니다. 아래의 예를 살펴보십시오.

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

위의 예에서 해당 프로그램의 수명 동안 은 항상 namestring 과 연결되고 는 항상 string 과 연결됩니다 .Victor JonahcompanyLogRocket

slice데이터 형식

슬라이스는 배열과 유사하지만 몇 가지 차이점이 있습니다.

배열 크기는 고정되어 있지만 슬라이스 크기는 동적입니다. 길이는 컴파일 시간에 알 수 없으며 데이터는 새 컬렉션으로 분할됩니다. 아래 예를 참조하십시오.

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

슬라이스는 문자열 값에서 특정 문자를 검색할 수 있는 위의 문자열 개체에 대한 포인터이기도 합니다. 다른 곳에서 사용하기 위해 슬라이스의 요소를 빌릴 수도 있습니다.

tuple데이터 형식

JavaScript와 같은 다른 언어에서는 튜플을 객체라고 합니다. 동일한 유형의 요소만 포함할 수 있는 배열과 달리 다른 유형의 요소를 포함하는 고정 데이터 유형입니다.

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

위의 예에서 튜플 은 문자열( ), 정수( ) 및 다른 문자열( ) employee의 세 가지 요소를 포함합니다 .Victor Jonah25Technical Writer

Rust와 기본 유형의 한계

참고로, 일반적으로 Rust 프로그래밍 언어의 한계 를 논의하는 것이 필수적 입니다. 대부분의 사람들은 Rust가 매우 사랑스럽다고 말하거나 주장했습니다. 사실입니다. 하지만 고려해야 할 몇 가지 사항이 있습니다.

주목해야 할 첫 번째 사항은 학습 곡선이 가파르다는 것입니다. Rust는 시스템 프로그래밍 언어이고 높은 수준의 프로그래밍 개념을 가지고 있기 때문에 언어로 배우는 데 더 많은 시간이 걸립니다.

패턴 일치, 포인터, 문자열 리터럴, 세 가지 유형의 배열 등과 같은 Rust 기본 데이터 유형과 이들을 함께 결합할 때 배울 것이 많습니다. 그럼에도 불구하고 시간을 할애할 가치가 있습니다.

내 관찰에 따르면, 가파른 학습 곡선은 대부분 Rust로 작업하던 초기에 Rust 문서의 명확성이 부족했기 때문입니다.

이것은 저를 두 번째로 알려줍니다. Rust 커뮤니티는 처음에는 눈에 잘 띄지 않을 수 있지만, 다가가면 커뮤니티는 환영하고 활동적이며 도움이 됩니다.

또 하나 주목해야 할 점은 Rust는 정적 프로그래밍 언어이며 컴파일되기 전에 모든 것이 명시되어야 한다는 점에서 매우 엄격하다는 것입니다. 이것은 모든 것이 컴파일 시간에 확인되어야 한다는 것을 강제하는 Rust의 주요 원칙 중 하나입니다.

이것은 개발 속도를 늦출 수 있지만 컴파일 시간에 대부분의 항목을 검사할 때 프로그램이 런타임에 실패할 가능성이 적기 때문에 좋은 원인이기도 합니다.

결론

Rust 기본 데이터 유형은 내장되어 있으며 그 사용 사례는 전형적인 프로그래밍 언어가 필요로 하는 것과 정확히 같습니다. 이러한 데이터 유형은 스칼라 및 복합의 두 가지 형식으로 제공됩니다.

Rust의 모든 다양한 기본 데이터 유형을 알고 이해하는 것은 Rust 여정에 큰 도움이 됩니다. 나는 그 목적을 위해 이 기사를 간략하게 작성했습니다. 읽어 주셔서 감사합니다.

https://blog.logrocket.com 의 원본 기사 출처

#rust #rustlang

Rust의 기본 데이터 유형 이해하기
Zenon  Pruschke

Zenon Pruschke

1662381720

Primitive Datentypen in Rust verstehen

Primitive Datentypen - Die Programmiersprache Rust

Rust hat eine Liste von Datentypen, die als primitiv bezeichnet werden. Rust-Primitive-Typen können in skalare und zusammengesetzte Datentypen gruppiert werden. Sehen wir uns an, was sie sind, wie sie verwendet werden und welche Einschränkungen sie haben.

Wir werden abdecken:

  • Was sind primitive Datentypen?
  • Primitive Datentypen in Rust
    • Skalare primitive Typen in Rust
    • Zusammengesetzte primitive Typen in Rust
  • Einschränkungen der primitiven Typen von Rust

Dieser Artikel soll denjenigen zugutekommen, die gerade mit Rust beginnen und die primitiven Datentypen in Rust schnell verstehen und verwenden möchten.

Was sind primitive Datentypen?

Primitive Datentypen sind, wie der Name schon sagt, im Grunde nur Datentypen, die mit einer Programmiersprache geliefert werden. Sie sind integriert und können, wenn sie miteinander kombiniert werden, komplexere Datentypen bilden, die als nicht primitive Datentypen bezeichnet werden.

Wie bereits erwähnt, enthält die Programmiersprache Rust eine Liste von eingebauten primitiven Datentypen, die Entwickler als Bausteine ​​für andere Datentypen verwenden können.

Primitive Datentypen in Rust

Schauen wir uns die primitiven Datentypen an, die Rust bereitstellt.

Wir wollen sie zunächst in skalare und zusammengesetzte Datentypen gruppieren. Der Unterschied zwischen diesen beiden besteht darin, dass zusammengesetzte Typen mehrere Werte in einem Typ enthalten, während skalare Typen nur einen Wert enthalten.

Skalare primitive Typen in Rust

Es gibt fünf skalare primitive Typen, mit denen Sie in Rust vertraut sein sollten:

  • Boolesch
  • Charakter
  • Ganze Zahl
  • Schwimmend
  • Einheit

Sehen wir uns Definitionen und Beispiele für jeden Typ an.

boolDatentyp

Der boolesche Datentyp soll entweder wahr oder falsch sein, etwa so:

let active = true;
let inactive = false;

Boolesche Datentypen werden hauptsächlich zum Vergleichen von Werten oder Logik verwendet – beispielsweise um zu überprüfen, ob ein Testergebnis A, B oder C ist.

charDatentyp

Der Zeichentyp ist ein 4-Byte-Datentyp. Es wird verwendet, um einzelne Zeichen zu speichern, wie zum Beispiel:

let first = 'a';
let second = 'b';
let symbol = '∞';

Zeichendatentypen werden verwendet, um einzelne Zeichen zu speichern, wodurch die Speicherallokation in Rust klein bleibt.

integerDatentyp

Es gibt verschiedene ganzzahlige Datentypen, die in zwei Kategorien fallen: mit Vorzeichen (i) und ohne Vorzeichen (u). Dazu gehören die folgenden: i8, i16, i32, i64, isize, u8, u16, u32, u64, usize. Hier sind einige Beispiele:

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floatingDatentyp

Floating-Datentypen sind immer entweder f32oder f64, was von negativen bis zu positiven Zahlen reichen kann:

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

Floats sind das, was wir als Dezimalzahlen bezeichnen. Siehe einige Beispiele unten:

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unitDatentyp

In Rust verwendet der Einheitendatentyp das Symbol ()und wird hauptsächlich als Mechanismus verwendet, um die Verwendung von zu vermeiden null.

Jeder Ausdruck, der nichts zurückgibt, wird tatsächlich ()in Rust zurückgegeben. Es ist eher wie voidin C-ähnlichen Sprachen.

Ein weiterer Anwendungsfall ist wie folgt Response<(), String>: Die Antwort kann entweder fehlschlagen oder erfolgreich sein.

Zusammengesetzte primitive Typen in Rust

Unten sind vier zusammengesetzte primitive Datentypen in Rust, die wir unten behandeln werden:

  • Array
  • Schnur
  • Scheibe
  • Tupel

Schauen wir uns, wie im vorigen Abschnitt, Definitionen und Beispiele für jeden Typ an.

arrayDatentyp

Ein Array ist ein Datentyp, der eine Gruppe von Elementen enthält. Seine Größe ist immer fest und vom gleichen Datentyp, etwa so:

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

In den obigen Beispielen enthält das countsArray 7Elemente vom Datentyp i32(Ganzzahlen), während das gradeArray 4Elemente vom Datentyp enthält i32.

stringDatentyp

Es gibt zwei stringDatentypen in Rust : String(String Object) und &str(String Literal).

Das StringObjekt ist nicht in der Kernsprache, sondern wird in der Standardbibliothek bereitgestellt. Es ist auch der häufigste Zeichenfolgentyp, da es veränderlich ist. So erstellen Sie String:

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

Der &strDatentyp in Rust wird als String-Slice betrachtet und gilt als unveränderlich, was bedeutet, dass er während der Lebensdauer des Programms nicht geändert werden kann. Schauen Sie sich das folgende Beispiel an:

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

Im obigen Beispiel wird während der Lebensdauer dieses Programms nameimmer der Zeichenfolge zugeordnet Victor Jonah, während companyimmer der Zeichenfolge zugeordnet wird LogRocket.

sliceDatentyp

Slices ähneln Arrays, es gibt jedoch einige Unterschiede.

Während Array-Größen festgelegt sind, haben Slices eine dynamische Größe; Die Länge ist zur Kompilierzeit nicht bekannt und die Daten werden in eine neue Sammlung geschnitten. Siehe ein Beispiel unten:

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

Slices sind auch ein Zeiger auf das obige String-Objekt, wo wir ein bestimmtes Zeichen im String-Wert abrufen können. Wir können auch Elemente in einem Slice ausleihen, um sie woanders zu verwenden.

tupleDatentyp

In anderen Sprachen wie JavaScript werden Tupel als Objekte bezeichnet. Sie sind feste Datentypen, die verschiedene Arten von Elementen enthalten – im Gegensatz zu Arrays, die nur denselben Elementtyp enthalten können.

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

Im obigen Beispiel employeeenthält das Tupel drei Elemente: eine Zeichenfolge ( Victor Jonah), eine Ganzzahl ( 25) und eine weitere Zeichenfolge ( Technical Writer).

Einschränkungen von Rust und seinen primitiven Typen

Als Randnotiz wird es wichtig sein, die Einschränkungen der Programmiersprache Rust im Allgemeinen zu diskutieren. Die meisten Leute haben gesagt oder behauptet, dass Rust sehr liebenswert ist – was wahr ist – aber es gibt ein paar Punkte zu beachten.

Das erste, was zu beachten ist, ist, dass seine Lernkurve steil ist; Rust braucht mehr Zeit, um als Sprache zu lernen, weil es eine Systemprogrammiersprache ist und über Programmierkonzepte auf hoher Ebene verfügt.

Es gibt viel zu lernen, wenn es um primitive Datentypen von Rust und deren Kombination geht – wie Mustervergleich, Zeiger, Zeichenfolgenliterale, drei Arten von Arrays und mehr. Trotzdem ist es Ihre Zeit wert.

Aus meiner Beobachtung resultiert die steile Lernkurve meist aus der Unübersichtlichkeit der Rust-Dokumentation in den früheren Tagen der Arbeit mit Rust.

Das bringt mich zu einer zweiten Anmerkung: Die Rust-Community mag am Anfang weniger auffällig sein, aber wenn Sie sich melden, ist die Community einladend, aktiv und hilfsbereit.

Eine andere Sache, die zu beachten ist, ist, dass Rust eine statische Programmiersprache ist, und es ist sehr streng bis zu dem Punkt, dass alles angegeben werden muss, bevor es kompiliert wird. Dies ist eines der Hauptprinzipien von Rust, das erzwingt, dass alles zur Kompilierzeit überprüft werden sollte.

Das kann die Entwicklung verlangsamen, hat aber auch einen guten Zweck, denn wenn die meisten Dinge zur Kompilierzeit überprüft werden, ist es weniger wahrscheinlich, dass das Programm zur Laufzeit fehlschlägt.

Fazit

Rust primitive Datentypen sind eingebaut und ihre Anwendungsfälle sind genau das, was eine typische Programmiersprache braucht. Diese Datentypen gibt es in zwei Formen: skalar und zusammengesetzt.

All die verschiedenen primitiven Datentypen in Rust zu kennen und zu verstehen, ist auf Ihrer Reise mit Rust sehr hilfreich. Zu diesem Zweck habe ich diesen Artikel auf der kurzen Seite erstellt. Vielen Dank fürs Lesen.

Quelle des Originalartikels unter https://blog.logrocket.com

#rust #rustlang

Primitive Datentypen in Rust verstehen

Entendendo os tipos de dados primitivos em Rust

Tipos de dados primitivos - A linguagem de programação Rust

Rust tem uma lista de tipos de dados que são considerados primitivos. Os tipos primitivos Rust podem ser agrupados em tipos de dados escalares e compostos. Vamos rever o que são, como são usados ​​e suas limitações.

Cobriremos:

  • O que são tipos de dados primitivos?
  • Tipos de dados primitivos em Rust
    • Tipos primitivos escalares em Rust
    • Tipos primitivos compostos em Rust
  • Limitações dos tipos primitivos Rust

Este artigo destina-se a beneficiar aqueles que estão apenas começando em Rust e desejam entender rapidamente e poder usar os tipos de dados primitivos em Rust.

O que são tipos de dados primitivos?

Tipos de dados primitivos, como o nome indica, são basicamente apenas tipos de dados que vêm com uma linguagem de programação. Eles são integrados e, quando combinados, podem formar tipos de dados mais complexos, chamados de tipos de dados não primitivos.

Como mencionamos, a linguagem de programação Rust vem com uma lista de tipos de dados primitivos integrados que os desenvolvedores podem usar como blocos de construção para outros tipos de dados.

Tipos de dados primitivos em Rust

Vejamos os tipos de dados primitivos que o Rust fornece.

Queremos primeiro agrupá-los em tipos de dados escalares e compostos. A diferença entre esses dois é que os tipos compostos contêm vários valores em um tipo, enquanto os tipos escalares contêm apenas um valor.

Tipos primitivos escalares em Rust

Existem cinco tipos primitivos escalares com os quais você deve estar familiarizado no Rust:

  • boleano
  • Personagem
  • inteiro
  • Flutuando
  • Unidade

Vejamos as definições e exemplos para cada tipo.

booltipo de dados

Diz-se que o tipo de dados Boolean é verdadeiro ou falso, assim:

let active = true;
let inactive = false;

Os tipos de dados booleanos são usados ​​principalmente para comparar valores ou lógica — por exemplo, para verificar se uma pontuação de teste é A, B ou C.

chartipo de dados

O tipo de caractere é um tipo de dados de 4 bytes. Ele é usado para armazenar caracteres únicos, como:

let first = 'a';
let second = 'b';
let symbol = '∞';

Os tipos de dados de caractere são usados ​​para armazenar caracteres únicos, permitindo que a alocação de memória no Rust permaneça pequena.

integertipo de dados

Existem vários tipos de dados inteiros, que se enquadram em duas categorias: assinados (i) e não assinados (u). Eles incluem o seguinte: i8, i16, i32, i64, isize, u8, u16, u32, u64, usize. aqui estão alguns exemplos:

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floatingtipo de dados

Os tipos de dados flutuantes são sempre f32ou f64, que podem variar amplamente de números negativos a positivos:

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

Floats são o que chamamos de decimais. Veja alguns exemplos abaixo:

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unittipo de dados

Em Rust, o tipo de dados unitário usa o símbolo ()e é usado principalmente como um mecanismo para evitar o uso de null.

Qualquer expressão que não retorne nada na verdade retorna ()em Rust. É mais como voidem linguagens semelhantes a C.

Outro caso de uso é como Response<(), String>, o que significa que a resposta pode falhar ou ser bem-sucedida.

Tipos primitivos compostos em Rust

Abaixo estão quatro tipos de dados primitivos compostos em Rust que abordaremos abaixo:

  • Variedade
  • Corda
  • Fatiar
  • Tuplas

Como fizemos na seção anterior, vamos ver as definições e exemplos para cada tipo.

arraytipo de dados

Uma matriz é um tipo de dados que contém um grupo de elementos. Seu tamanho é sempre fixo e do mesmo tipo de dados, assim:

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

Nos exemplos acima, o countsarray contém 7elementos do tipo de dados i32(inteiros), enquanto o gradearray contém 4elementos do tipo de dados i32.

stringtipo de dados

Existem dois stringtipos de dados em Rust : String(String Object) e &str(String literal).

O Stringobjeto não está no idioma principal, mas é fornecido na biblioteca padrão. É também o tipo de string mais comum porque é mutável. Para criar um String:

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

O &strtipo de dados em Rust é considerado como fatia de string e é dito ser imutável, o que significa que eles não podem ser alterados durante a vida útil do programa. Dê uma olhada no exemplo abaixo:

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

No exemplo acima, durante a vida útil desse programa, namesempre estará associado à string Victor Jonah, enquanto companysempre estará associado à string LogRocket.

slicetipo de dados

As fatias são semelhantes às matrizes, mas existem algumas diferenças.

Enquanto os tamanhos dos arrays são fixos, os slices são dinâmicos em tamanho; o comprimento não é conhecido em tempo de compilação e os dados são divididos em uma nova coleção. Veja um exemplo abaixo:

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

As fatias também são um ponteiro para o objeto string acima, onde podemos recuperar um determinado caractere no valor da string. Também podemos emprestar elementos em uma fatia para usar em outro lugar.

tupletipo de dados

Em outras linguagens como JavaScript, as tuplas são chamadas de objetos. Eles são tipos de dados fixos que contêm diferentes tipos de elementos — ao contrário dos arrays, que só podem conter o mesmo tipo de elementos.

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

No exemplo acima, a tupla employeecontém três elementos: uma string ( Victor Jonah), um inteiro ( 25) e outra string ( Technical Writer).

Limitações do Rust e seus tipos primitivos

Como nota lateral, será essencial discutir as limitações da linguagem de programação Rust em geral. A maioria das pessoas disse ou afirmou que Rust é muito adorável – o que é verdade – mas há alguns pontos a serem considerados.

A primeira coisa a notar é que sua curva de aprendizado é íngreme; Rust leva mais tempo para aprender como uma linguagem porque é uma linguagem de programação de sistema e possui conceitos de programação de alto nível.

Há muito o que aprender quando se trata de tipos de dados primitivos Rust e combiná-los - como correspondência de padrões, ponteiros, literais de string, três tipos de matrizes e muito mais. No entanto, vale a pena o seu tempo.

Da minha observação, a curva de aprendizado íngreme resulta principalmente da falta de clareza na documentação do Rust nos primeiros dias de trabalho com o Rust.

Isso me leva a uma segunda observação: a comunidade Rust pode ser menos perceptível no início, mas quando você entra em contato, a comunidade é acolhedora, ativa e prestativa.

Outra coisa a notar é que Rust é uma linguagem de programação estática, e é muito rigorosa ao ponto de que tudo tem que ser declarado antes de ser compilado. Este é um dos principais princípios do Rust, que impõe que tudo seja verificado em tempo de compilação.

Isso pode retardar o desenvolvimento, mas também é por uma boa causa, porque quando a maioria das coisas é verificada em tempo de compilação, é menos provável que o programa falhe em tempo de execução.

Conclusão

Os tipos de dados primitivos Rust são integrados e seus casos de uso são exatamente o que uma linguagem de programação típica precisa. Esses tipos de dados vêm em duas formas: escalar e composto.

Conhecer e entender todos os diferentes tipos de dados primitivos no Rust é muito útil em sua jornada no Rust. Eu fiz este artigo no lado breve para esse fim. Obrigado por ler.

Fonte do artigo original em https://blog.logrocket.com

#rust #rustlang

Entendendo os tipos de dados primitivos em Rust
Louis Jones

Louis Jones

1662366841

Primitive Data Types - The Rust Programming Language

Rust has a list of data types that are said to be primitive. Rust primitive types can be grouped into scalar and compound data types. Let's review what they are, how they're used, and their limitations.

This article is intended to benefit those who are just getting started in Rust and want to quickly understand and be able to use the primitive data types in Rust.

We will cover:

  • What are primitive data types?
  • Primitive data types in Rust
    • Scalar primitive types in Rust
    • Compound primitive types in Rust
  • Limitations of Rust primitive types

Read more at https://blog.logrocket.com

#rust #rustlang 

Primitive Data Types - The Rust Programming Language
Duong Tran

Duong Tran

1662363274

Tìm hiểu về kiểu dữ liệu nguyên thuỷ trong Rust

Rust có một danh sách các kiểu dữ liệu được cho là nguyên thủy. Các kiểu nguyên thủy của Rust có thể được nhóm lại thành các kiểu dữ liệu vô hướng và phức hợp. Hãy xem lại chúng là gì, cách chúng được sử dụng và những hạn chế của chúng.

Chúng tôi sẽ bao gồm:

  • Các kiểu dữ liệu nguyên thủy là gì?
  • Các kiểu dữ liệu ban đầu trong Rust
    • Các kiểu nguyên thủy vô hướng trong Rust
    • Hợp chất các kiểu nguyên thủy trong Rust
  • Hạn chế của các kiểu nguyên thủy Rust

Bài viết này nhằm mang lại lợi ích cho những ai mới bắt đầu sử dụng Rust và muốn nhanh chóng hiểu và có thể sử dụng các kiểu dữ liệu nguyên thủy trong Rust.

Các kiểu dữ liệu nguyên thủy là gì?

Các kiểu dữ liệu nguyên thủy, như tên của nó, về cơ bản chỉ là các kiểu dữ liệu đi kèm với một ngôn ngữ lập trình. Chúng được tích hợp sẵn và khi kết hợp với nhau, có thể tạo thành các kiểu dữ liệu phức tạp hơn, được gọi là kiểu dữ liệu không nguyên thủy.

Như chúng tôi đã đề cập, ngôn ngữ lập trình Rust đi kèm với một danh sách các kiểu dữ liệu nguyên thủy được tích hợp sẵn mà các nhà phát triển có thể sử dụng làm khối xây dựng cho các kiểu dữ liệu khác.

Các kiểu dữ liệu ban đầu trong Rust

Hãy xem xét các kiểu dữ liệu nguyên thủy mà Rust cung cấp.

Trước tiên, chúng tôi muốn nhóm chúng thành các kiểu dữ liệu vô hướng và phức hợp. Sự khác biệt giữa hai kiểu này là kiểu phức hợp chứa nhiều giá trị trong một kiểu trong khi kiểu vô hướng chỉ chứa một giá trị.

Các kiểu nguyên thủy vô hướng trong Rust

Có năm kiểu nguyên thủy vô hướng mà bạn nên quen thuộc trong Rust:

  • Boolean
  • Tính cách
  • Số nguyên
  • Nổi
  • Đơn vị

Hãy xem định nghĩa và ví dụ cho từng loại.

boolloại dữ liệu

Kiểu dữ liệu Boolean được cho là đúng hoặc sai, như sau:

let active = true;
let inactive = false;

Kiểu dữ liệu Boolean chủ yếu được sử dụng để so sánh các giá trị hoặc logic - ví dụ: để kiểm tra xem điểm kiểm tra là A, B hay C.

charloại dữ liệu

Kiểu ký tự là kiểu dữ liệu 4 byte. Nó được sử dụng để lưu trữ các ký tự đơn lẻ, chẳng hạn như:

let first = 'a';
let second = 'b';
let symbol = '∞';

Các kiểu dữ liệu ký tự được sử dụng để lưu trữ các ký tự đơn lẻ, cho phép phân bổ bộ nhớ trong Rust vẫn nhỏ.

integerloại dữ liệu

Có nhiều kiểu dữ liệu số nguyên khác nhau, thuộc hai loại: có dấu (i) và không dấu (u). Chúng bao gồm những điều sau : i8,,,,,,, . i16_ i32_ Dưới đây là một số ví dụ:i64isizeu8u16u32u64usize

let height = 172; //u8
let weight = 68; // u8 
let size = 23; // u8
let data = -128 // i8

floatingloại dữ liệu

Các kiểu dữ liệu nổi luôn là một trong hai kiểu dữ liệu f32này f64có thể có phạm vi rộng từ số âm đến số dương:

f32 ---> -3.8x10^8 to +3.8x10^8
f64 ---> -1.8x10^308 to +1.8x10^308 

Phao là những gì chúng tôi gọi là số thập phân. Xem một số ví dụ dưới đây:

let interest = 1.20;
let returns = 2.80;
let agency = 10.0;

unitloại dữ liệu

Trong Rust, kiểu dữ liệu đơn vị sử dụng ký hiệu ()và nó chủ yếu được sử dụng như một cơ chế để tránh sử dụng null.

Bất kỳ biểu thức nào trả về không có gì thực sự trả về ()trong Rust. Nó giống voidvới ngôn ngữ C-like hơn.

Một trường hợp sử dụng khác giống như vậy Response<(), String>có nghĩa là phản hồi có thể thất bại hoặc thành công.

Hợp chất các kiểu nguyên thủy trong Rust

Dưới đây là bốn kiểu dữ liệu nguyên thủy phức hợp trong Rust mà chúng tôi sẽ trình bày dưới đây:

  • Mảng
  • Sợi dây
  • Lát cắt
  • Tuples

Như chúng ta đã làm trong phần trước, chúng ta hãy xem xét các định nghĩa và ví dụ cho từng loại.

arrayloại dữ liệu

Mảng là một kiểu dữ liệu có chứa một nhóm các phần tử. Kích thước của nó luôn cố định và có cùng kiểu dữ liệu, như sau:

let counts: [i32; 7] = [4, 2, 4, 8, 3, 2, 4, 8];
let grade: [i32; 4] = [20, 40, 34, 70];

Trong các ví dụ trên, countsmảng chứa 7các phần tử của kiểu dữ liệu i32(số nguyên), trong khi grademảng chứa 4các phần tử của kiểu dữ liệu i32.

stringloại dữ liệu

hai stringkiểu dữ liệu trong Rust : String(Đối tượng chuỗi) và &str(Chuỗi ký tự).

Đối Stringtượng không phải bằng ngôn ngữ cốt lõi, nhưng được cung cấp trong thư viện chuẩn. Nó cũng là kiểu chuỗi phổ biến nhất vì nó có thể thay đổi được. Để tạo String:

String::new();


let name = String::new();
name.push_str = 'Victor Jonah';
println("{}", name);

Kiểu &strdữ liệu trong Rust được coi là string slice và nó được cho là bất biến, có nghĩa là chúng không thể thay đổi trong suốt thời gian tồn tại của chương trình. Hãy xem ví dụ dưới đây:

let name:&str = 'Victor Jonah';
let company:&str = 'LogRocket';

Trong ví dụ trên, trong suốt thời gian tồn tại của chương trình đó, namesẽ luôn được liên kết với chuỗi Victor Jonah, trong khi companysẽ luôn được liên kết với chuỗi LogRocket.

sliceloại dữ liệu

Slices tương tự như mảng, nhưng có một vài điểm khác biệt.

Trong khi kích thước mảng là cố định, các lát cắt có kích thước động; độ dài không được xác định trong thời gian biên dịch và dữ liệu được chia thành một bộ sưu tập mới. Xem ví dụ bên dưới:

let grades: [132:6] = [20, 10, 30, 40, 50, 10, 20];
let slice = &[20...4]; // 20, 10, 30, 40

Slices cũng là một con trỏ đến đối tượng chuỗi ở trên nơi chúng ta có thể truy xuất một ký tự nào đó trong giá trị chuỗi. Chúng ta cũng có thể mượn các phần tử trong một lát cắt để sử dụng ở một nơi khác.

tupleloại dữ liệu

Trong các ngôn ngữ khác như JavaScript, các bộ giá trị được gọi là các đối tượng. Chúng là các kiểu dữ liệu cố định chứa các loại phần tử khác nhau - không giống như mảng, chỉ có thể chứa cùng một loại phần tử.

let employee: (&str, i32, &str) = ('Victor Jonah', 25, 'Technical Writer');

Trong ví dụ trên, bộ giá trị employeechứa ba phần tử: một chuỗi ( Victor Jonah), một số nguyên ( 25) và một chuỗi khác ( Technical Writer).

Hạn chế của Rust và các loại nguyên thủy của nó

Cũng cần lưu ý thêm, sẽ rất cần thiết để thảo luận về những hạn chế của ngôn ngữ lập trình Rust nói chung. Hầu hết mọi người đã nói hoặc khẳng định rằng Rust rất đáng yêu - đó là sự thật - nhưng có một vài điểm cần xem xét.

Điều đầu tiên cần lưu ý là đường cong học tập của nó rất dốc; Rust mất nhiều thời gian hơn để học như một ngôn ngữ vì nó là một ngôn ngữ lập trình hệ thống và có các khái niệm lập trình cấp cao.

Có rất nhiều điều phải học khi nói đến các kiểu dữ liệu nguyên thủy của Rust và kết hợp chúng với nhau - như khớp mẫu, con trỏ, chuỗi ký tự, ba loại mảng, v.v. Tuy nhiên, nó là giá trị thời gian của bạn.

Theo quan sát của tôi, đường cong học tập dốc hầu hết là do tài liệu Rust thiếu rõ ràng trong những ngày đầu làm việc với Rust.

Điều này đưa tôi đến một lưu ý thứ hai: cộng đồng Rust có thể ít được chú ý ngay từ đầu, nhưng khi bạn tiếp cận, cộng đồng luôn chào đón, tích cực và hữu ích.

Một điều cần lưu ý nữa là Rust là một ngôn ngữ lập trình tĩnh, và nó rất nghiêm ngặt đến mức mọi thứ phải được nêu rõ trước khi nó được biên dịch. Đây là một trong những nguyên tắc chính của Rust, nguyên tắc này bắt buộc mọi thứ phải được kiểm tra tại thời điểm biên dịch.

Điều này có thể làm chậm quá trình phát triển, nhưng cũng có lý do chính đáng vì khi hầu hết mọi thứ được kiểm tra tại thời điểm biên dịch, ít có khả năng chương trình bị lỗi trong thời gian chạy.

Sự kết luận

Các kiểu dữ liệu nguyên thủy của Rust được tích hợp sẵn và các trường hợp sử dụng của chúng chính xác là những gì một ngôn ngữ lập trình điển hình cần. Các kiểu dữ liệu này có hai dạng: vô hướng và phức hợp.

Biết và hiểu tất cả các kiểu dữ liệu nguyên thủy khác nhau trong Rust sẽ rất hữu ích trong hành trình Rust của bạn. Tôi đã thực hiện bài viết này trên khía cạnh ngắn gọn cho mục đích đó. Cảm ơn bạn đã đọc.

Nguồn bài viết gốc tại https://blog.logrocket.com

#rust #rustlang

Tìm hiểu về kiểu dữ liệu nguyên thuỷ trong Rust
Awesome  Rust

Awesome Rust

1662012660

IC Naming: A Decentralized Name Service on IC Built on Rust

IC Naming

This repository contains the canister and canister-related components of IC Naming. You can own your web3 name with IC Naming.

Development

Open src folder with Visual Studio Code with Remote Dev Tools extension, and load the source code in the container.

./sh_setup_dev.sh
./sh_go.sh

Build on Windows

If you want to build this project on Windows, please install something below:

OpenSSL

install vcpkg https://vcpkg.io/en/getting-started.html

  • ./vcpkg.exe install openssl-windows:x64-windows
  • ./vcpkg.exe install openssl:x64-windows-static

set env:

OPENSSL_DIR="\installed\x64-windows-static"

Browser Extensions

You can find source code of the browser extension in the icnaming-browser-extensions repository.

Screenshots

search_name

set_values

browser-extensions

Download details:

Author: IC-Naming
Source code: https://github.com/IC-Naming/icnaming 
License: AGPL-3.0 license

#rust #rustlang #web3 #blockchain

IC Naming: A Decentralized Name Service on IC Built on Rust
Awesome  Rust

Awesome Rust

1662005280

Neatar: The Web3 Avatar Like As Gravatar Built on Rust

neatar

The Web3 avatar like as Gravatar

Getting avatar

POST https://rest.nearapi.org/view
Content-Type: application/json

{
  "contract": "alpha.neatar.testnet",
  "method": "avatar_of",
  "params": {
    "account_id": "ilyar.testnet"
  },
  "rpc_node": "https://rpc.testnet.near.org"
}

Via curl

curl https://rest.nearapi.org/view -H 'content-type: application/json' \
--data-raw '{
  "contract": "alpha.neatar.testnet",
  "method": "avatar_of",
  "params": {
    "account_id": "ilyar.testnet"
  },
  "rpc_node": "https://rpc.testnet.near.org"
}'

Example response:

data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMSAxIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjxyZWN0IHg9IjAiIHk9IjAiIHdpZHRoPSIxIiBoZWlnaHQ9IjEiIGZpbGw9IiMwMDAiIHN0cm9rZT0iIzAwMCIvPjwvc3ZnPg0=

Download details:

Author: neatar
Source code: https://github.com/neatar/dapp 
License: Unlicense license

#rust #rustlang #web3 #blockchain #dapp

Neatar: The Web3 Avatar Like As Gravatar Built on Rust