Come analizzare un file yaml in ruggine
Come ottenere il pacchetto Yaml nel linguaggio ruggine in Ubuntu 20.04
Rust ci fornisce un pacchetto chiamato Yaml_Rust, che dobbiamo implementare all'interno del nostro programma mentre analizziamo qualsiasi file YAML. Una caratteristica di sicurezza della memoria e altri vantaggi del linguaggio ruggine sono presenti in Yaml_Rust, una pura implementazione della ruggine di YAML 1.2. Usiamo il comando cargo per creare un nuovo progetto all'interno. Abbiamo dato un comando "$ cargo nuovo esempio1_cargo". Questo comando crea una nuova directory denominata Esempio1_Cargo. Per nominare il progetto, abbiamo usato il comando "$ CD Esempio1_Cargo".
I file creati dal carico sono archiviati in una directory con lo stesso nome del nostro progetto, Esempio1_Cargo, dal secondo comando. Elenca i file inserendo la directory Esempio1_Cargo. Noterai che il carico ha prodotto un carico.File Toml e directory SRC con il principale.File RS. Per aggiungere la rottura di yaml all'interno della ruggine, aprire il carico.File Toml e inserire il “Yaml-rust = 0.4 "nella sezione Dipendenza. Poiché la dipendenza da igname viene aggiunta nel nostro carico.File Toml, salvalo e spostamoci per scrivere un codice nel principale SRC.File RS per analizzare Yaml.
Esempio 1
Con questa soluzione, vogliamo offrire parser YAML conformi al 100% con YAML 1.2. Ci sono solo alcuni problemi noti che impediscono al parser di analizzare correttamente quasi tutti gli esempi nelle specifiche. In alcune circostanze, uno scalare semplice vuoto è un'eccezione. Potrebbe non essere un grosso problema per la maggior parte degli utenti, tuttavia, poiché la popolare biblioteca Libyaml ha anche problemi ad analizzare questi campioni.
Qui, dobbiamo importare la dipendenza da yaml-rust con la cassa esterna. Una dipendenza da Yaml-Rust scritta con la cassa esterna è specificata da una dichiarazione di cassa esterna. L'identificatore fornito dalla Dichiarazione della cassa esterna viene quindi utilizzato per legare la cassa esterna nell'ambito di dichiarazione. Successivamente, i documenti YAML vengono caricati usando Yaml :: Yamlloader e accessibili come VEC/Hashmap. Quindi, all'interno della FN main () del programma Rust, abbiamo un'istruzione Let utilizzata per creare i dati della struttura YAML. C'è un'altra istruzione Let che viene chiamata con i documenti variabili. All'interno di quella variabile docs, abbiamo scartato i dati YAML, che vengono caricati all'interno della variabile "S".
La funzione di downrap viene utilizzata per fornire i risultati del calcolo e restituire il panico se si verifica qualcosa di inaspettato. La variabile DOC seleziona il primo documento, definito dall'espressione di let. Con il comando println, viene gestito il debug del documento. Con il "Assert_eq!"Espressione, abbiamo accesso all'indice per la mappa e l'array. L'array o il tasto non validi è anche verificato con il metodo Assert, che lancia il messaggio BadValue se non esistono. Quindi, l'oggetto YAML viene scaricato nella stringa.
Il codice precedente si compila con il comando cargo run, che genera le mappe e l'array del documento YAML in formato Rust. Inoltre, il documento YAML è stampato all'interno della seguente figura:
Esempio n. 2
L'esempio precedente dimostra l'analisi di un documento YAML all'interno del programma Rust. Qui, abbiamo creato un file YAML separato che Rust elaborerà. Nota che mantieni il file YAML all'interno della directory in cui la cartella SRC e il carico.Il file toml si trova altrimenti il compilatore non può analizzare il file. Abbiamo uno Students_Result.File Yaml per l'analisi in ruggine. Il documento all'interno di questo file YAML è il seguente:
Qui, abbiamo il programma Rust per analizzare il file Yaml. Prima di allora, dobbiamo aggiungere la dipendenza Yaml_Rust nel carico.file toml.
Qui, abbiamo incluso il pacchetto Yaml_Rust con la dichiarazione di Crea esterno e ha anche dichiarato YAML_RUST, che ha gli oggetti YAML Loader e Yaml Emetter. Lo Yamlloader carica il documento Yaml e l'emettitore Yaml funge da flusso di output. Quindi, abbiamo inserito la nostra principale implementazione della funzione, in cui l'errore IO è assegnato per il fallimento delle operazioni del file system. All'interno della FN main (), abbiamo lasciato dichiarazioni di dichiarare le variabili. La variabile Docs ha il comando std :: fs per la copia del file "Student_Results.yaml ".
Esistono altri dati variabili che caricano il file YAML. Con il metodo di downrap, abbiamo visualizzato i risultati del calcolo. Attraverso il DOC variabile, abbiamo avuto accesso al documento YAML. Quindi, abbiamo iterato i valori della chiave della mappa e abbiamo ottenuto la somma dei valori. I segni all'interno del documento YAML saranno la somma dell'operazione di iterazione della mappa. Quindi, il modello di abbinamento Rust per il caso: Yaml :: Hash Operation. Inoltre, per Yaml :: Array, Yaml :: String e The Yaml :: Integer.
Conclusione
L'articolo parla di sanello del file yaml in ruggine. Il linguaggio Rust supporta file e documenti YAML. Con la dipendenza da Yaml-Rust, possiamo facilmente manipolare i file o i documenti YAML in Rust. Dobbiamo configurare la dipendenza da yaml-rust all'interno del carico.File Toml, che può permetterci di accedere al modulo Yaml di Rust. Abbiamo dato due esempi con la sintassi di YAML e li abbiamo analizzati con il linguaggio della ruggine.