{"id":7815,"date":"2019-06-13T00:00:00","date_gmt":"2019-06-12T22:00:00","guid":{"rendered":"https:\/\/blog.ouidou.fr\/?p=7815"},"modified":"2025-12-01T16:46:12","modified_gmt":"2025-12-01T15:46:12","slug":"du-dosage-a-la-rouille","status":"publish","type":"post","link":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille","title":{"rendered":"Du dosage \u00e0 la rouille"},"content":{"rendered":"<p><em>Article \u00e9crit par Cedric Brancourt<\/em><\/p>\n<p>Parlons de la rouille, cette d\u00e9licieuse sauce qui accompagne nos soupes de poisson. Le bon dosage des ingr\u00e9dients ravira le palais vos convives\u00a0!<\/p>\n<p>Pour faire une portion de rouille les ingr\u00e9dients sont\u00a0:<\/p>\n<pre><code>1\/2 gousse d'ail d\u00e9germ\u00e9e 1\/8 petit piment rouge 1\/8 jaune d'\u0153uf 1\/8 tranche de pain 1\/32 L d'huile d'olive <\/code><\/pre>\n<p>Plus on est nombreux autour de la table et plus on rit.<\/p>\n<p>Il va donc falloir multiplier la proportion des ingr\u00e9dients pour atteindre un dosage \u00e9quilibr\u00e9. Miam\u00a0!<\/p>\n<p>Je profite de cet article d\u00e9di\u00e9 \u00e0 la recette de la rouille pour \u00e9voquer Rust au passage.<\/p>\n<p>Non, pas le jeu vid\u00e9o pour survivaliste virtuel frustr\u00e9 (je plaisante, bisous\u00a0!). <a href=\"https:\/\/www.rust-lang.org\/\">Rust(2018)<\/a>\u00a0: Le langage de programmation qui fait peur.<\/p>\n<p>Je ne sais plus par quelle association d\u2019id\u00e9e j\u2019en suis arriv\u00e9 l\u00e0. Mais je vais vous expliquer comment je calcule le dosage des ingr\u00e9dients de ma rouille avec Rust.<\/p>\n<p>En esp\u00e9rant qu\u2019a l\u2019issu de cet article Rust ne vous intimidera plus et titillera votre palais.<\/p>\n<h2 id=\"pourquoi-autant-dintrt-pour-la-rouille\">Pourquoi autant d\u2019int\u00e9r\u00eat pour la rouille\u00a0?<\/h2>\n<p>Le premier aspect s\u00e9duisant de Rust est l\u2019absence de <em>garbage collector<\/em>, \u00e9vitant beaucoup de probl\u00e8mes de latence.<\/p>\n<p>Son syst\u00e8me de gestion de m\u00e9moire, qui martyrise les nouveaux venus, apporte un gros avantage en termes de s\u00e9curit\u00e9. (Mais ce n\u2019est <a href=\"https:\/\/medium.com\/@shnatsel\/how-rusts-standard-library-was-vulnerable-for-years-and-nobody-noticed-aebf0503c3d6\">pas le pays des Bisounours<\/a> non plus)<\/p>\n<p>Rust est id\u00e9al pour l\u2019embarqu\u00e9, les outils syst\u00e8me, mais pas que. WebAssembly, protocoles r\u00e9seau, concurrence, portabilit\u00e9\u2026<\/p>\n<p>C\u2019est \u00e0 chacun de choisir ses arguments.<\/p>\n<h2 id=\"la-recette\">La recette<\/h2>\n<p>Pour g\u00e9n\u00e9rer un nouveau <code>crate<\/code> (un package Rust), il est possible d\u2019utiliser <code>cargo<\/code> (l\u2019outil de build).<\/p>\n<div class=\"language-bash highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code>cargo new doser <span class=\"nt\">--bin<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>L\u2019option <code>--bin<\/code> pr\u00e9cise qu\u2019il s\u2019agit d\u2019un ex\u00e9cutable et non d\u2019une biblioth\u00e8que.<\/p>\n<p>Le point d\u2019entr\u00e9e d\u2019un <code>crate<\/code>, sans surprise, est le fichier <code>main.rs<\/code>.<\/p>\n<p>Le doseur de rouille a besoin de la recette unitaire. Profitons-en pour introduire quelques notions.<\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ main.rs<\/span>  <span class=\"k\">const<\/span> <span class=\"n\">RECIPE<\/span><span class=\"p\">:<\/span> <span class=\"o\">&amp;<\/span><span class=\"nb\">str<\/span> <span class=\"o\">=<\/span> <span class=\"s\">\" 1\/2 gousse d'ail d\u00e9germ\u00e9e 1\/8 piment rouge 1\/8 jaune d'\u0153uf 1\/8 tranche de pain 1\/32 L d'huile d'olive \"<\/span><span class=\"p\">;<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>C\u2019est une constante <code>const<\/code>, nomm\u00e9e <code>RECIPE<\/code> dont on d\u00e9finit le type <a href=\"https:\/\/doc.rust-lang.org\/std\/str\/\"><code>&amp;str<\/code><\/a>. <code>&amp;str<\/code> est une <a href=\"https:\/\/stackoverflow.com\/questions\/24158114\/what-are-the-differences-between-rusts-string-and-str\/24159933#24159933\">r\u00e9f\u00e9rence vers une cha\u00eene de caract\u00e8res UTF-8 immuable<\/a>.<\/p>\n<p>La ligne se terminant par un <code>;<\/code> il s\u2019agit d\u2019une <a href=\"https:\/\/doc.rust-lang.org\/reference\/statements.html\">d\u00e9claration<\/a>.<\/p>\n<h2 id=\"les-ingrdients\">Les Ingr\u00e9dients<\/h2>\n<p>Pour mod\u00e9liser les ingr\u00e9dients de la recette et leurs proportions utilisons une structure dans son propre module.<\/p>\n<p>Un module Rust peut \u00eatre d\u00e9clar\u00e9 gr\u00e2ce \u00e0 <code>mod<\/code> suivi d\u2019accolades <code>{}<\/code>, le contenu des accolades sera alors la d\u00e9finition du module.<\/p>\n<p>Le contenu du module peut aussi \u00eatre d\u00e9port\u00e9 dans un autre fichier qui porte le nom du module en question. Dans ce cas on omet les parenth\u00e8ses.<\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ main.rs<\/span>  <span class=\"k\">use<\/span> <span class=\"n\">ingredient<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ ingredient.rs<\/span> <span class=\"k\">use<\/span> <span class=\"nn\">num_rational<\/span><span class=\"p\">::<\/span><span class=\"n\">Ratio<\/span><span class=\"p\">;<\/span>  <span class=\"k\">pub<\/span> <span class=\"k\">struct<\/span> <span class=\"n\">Ingredient<\/span> <span class=\"p\">{<\/span>   <span class=\"k\">pub<\/span> <span class=\"n\">label<\/span><span class=\"p\">:<\/span> <span class=\"nb\">String<\/span><span class=\"p\">,<\/span>   <span class=\"k\">pub<\/span> <span class=\"n\">quantity<\/span><span class=\"p\">:<\/span> <span class=\"n\">Ratio<\/span><span class=\"o\">&lt;<\/span><span class=\"nb\">u32<\/span><span class=\"o\">&gt;<\/span> <span class=\"p\">}<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Dans notre fichier <code>ingredient.rs<\/code> est d\u00e9fini une structure (<code>struct<\/code>) que le module expose publiquement. Par d\u00e9faut la visibilit\u00e9 est priv\u00e9e le mot cl\u00e9 <code>pub<\/code> rend publique la structure et ses champs.<\/p>\n<p>Nos ingr\u00e9dients sont compos\u00e9s\u00a0:<\/p>\n<ul>\n<li>d\u2019un <code>label<\/code> qui contient la d\u00e9signation, qui est une donn\u00e9e de type <code>String<\/code>.<\/li>\n<li>d\u2019une <code>quantity<\/code> qui contient une fraction <code>Ratio<\/code>.<\/li>\n<\/ul>\n<p><code>use num_rational::Ratio<\/code> est la syntaxe d\u2019import de Rust. Par ce biais nous indiquons que nous utilisons la structure <code>Ratio<\/code> de la biblioth\u00e8que <code>num_rational<\/code>.<\/p>\n<p>La philosophie de Rust est d\u2019embarquer le strict minimum dans le noyau du langage et d\u2019utiliser des <code>crates<\/code> pour ajouter des fonctions ou structures.<\/p>\n<p><code>num_rational<\/code> ne fait pas partie du langage, c\u2019est une d\u00e9pendance externe.<\/p>\n<p>Pour g\u00e9rer les d\u00e9pendances il faut utiliser le fichier <code>Cargo.toml<\/code> qui est cr\u00e9e \u00e0 la racine du projet.<\/p>\n<div class=\"language-toml highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"nn\">[package]<\/span> <span class=\"py\">name<\/span> <span class=\"p\">=<\/span> <span class=\"s\">\"doser\"<\/span> <span class=\"py\">version<\/span> <span class=\"p\">=<\/span> <span class=\"s\">\"0.1.0\"<\/span> <span class=\"py\">authors<\/span> <span class=\"p\">=<\/span> <span class=\"p\">[<\/span><span class=\"s\">\"Cedric &lt;cedric.brancourt@gmail.com&gt;\"<\/span><span class=\"p\">]<\/span> <span class=\"py\">edition<\/span> <span class=\"p\">=<\/span> <span class=\"s\">\"2018\"<\/span>  <span class=\"nn\">[dependencies]<\/span> <span class=\"py\">num-rational<\/span> <span class=\"p\">=<\/span> <span class=\"s\">\"0.2\"<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>La section <code>dependencies<\/code> permet de r\u00e9f\u00e9rencer les d\u00e9pendances \u00e0 r\u00e9cup\u00e9rer lors du <code>cargo build<\/code> ou <code>cargo run<\/code>.<\/p>\n<p>Le type <code>Ratio<\/code> prend un param\u00e8tre si l\u2019on regarde la d\u00e9finition de ce type.<\/p>\n<p>La d\u00e9finition du constructeur est <code>pub fn new(numer: T, denom: T) -&gt; Ratio&lt;T&gt;<\/code>.<\/p>\n<p>Puisqu\u2019il existe plusieurs types de num\u00e9riques suivant leur taille, sign\u00e9s ou pas, la biblioth\u00e8que utilise un <a href=\"https:\/\/doc.rust-lang.org\/1.30.0\/book\/second-edition\/ch10-01-syntax.html\">type g\u00e9n\u00e9rique<\/a> <code>T<\/code>. Qui donnera un <code>Ratio<\/code> d\u00e9riv\u00e9 de ce type.<\/p>\n<p>Dans le cadre de notre recette, les quantit\u00e9s n\u00e9gatives n\u2019\u00e9tant pas possible, il ne s\u2019agira que d\u2019entiers non sign\u00e9s de 32 bits\u00a0: <code>u32<\/code>.<\/p>\n<p>\u00c0 pr\u00e9sent d\u00e9finissons une m\u00e9thode <code>scale<\/code> qui sera en charge de retourner un nouvel ingr\u00e9dient multipli\u00e9 par la quantit\u00e9.<\/p>\n<p>Un nouvel ingr\u00e9dient, car il n\u2019est pas question ici de changer la valeur de l\u2019ingr\u00e9dient d\u2019origine, mais d\u2019en obtenir un nouveau \u00e0 l\u2019\u00e9chelle de la recette.<\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ ingredient.rs<\/span> <span class=\"c\">\/\/ ...<\/span>  <span class=\"k\">impl<\/span> <span class=\"n\">Ingredient<\/span> <span class=\"p\">{<\/span>     <span class=\"k\">pub<\/span> <span class=\"k\">fn<\/span> <span class=\"nf\">scale<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"k\">self<\/span><span class=\"p\">,<\/span> <span class=\"n\">mult<\/span><span class=\"p\">:<\/span> <span class=\"nb\">u32<\/span><span class=\"p\">)<\/span> <span class=\"k\">-&gt;<\/span> <span class=\"n\">Self<\/span> <span class=\"p\">{<\/span>         <span class=\"n\">Self<\/span> <span class=\"p\">{<\/span>             <span class=\"n\">label<\/span><span class=\"p\">:<\/span> <span class=\"k\">self<\/span><span class=\"py\">.label<\/span><span class=\"nf\">.clone<\/span><span class=\"p\">(),<\/span>             <span class=\"n\">quantity<\/span><span class=\"p\">:<\/span> <span class=\"k\">self<\/span><span class=\"py\">.quantity<\/span> <span class=\"o\">*<\/span> <span class=\"n\">mult<\/span><span class=\"p\">,<\/span>         <span class=\"p\">}<\/span>     <span class=\"p\">}<\/span> <span class=\"p\">}<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p><code>impl<\/code> nous permet de d\u00e9finir des m\u00e9thodes pour la structure <code>Ingredient<\/code>. Nous d\u00e9finissons une m\u00e9thode publique (<code>pub<\/code>) nomm\u00e9e <code>scale<\/code>.<\/p>\n<p>Elle prend en argument\u00a0:<\/p>\n<ul>\n<li><code>&amp;self<\/code> qui est une <a href=\"https:\/\/doc.rust-lang.org\/book\/ch04-02-references-and-borrowing.html#references-and-borrowing\">r\u00e9f\u00e9rence<\/a> \u00e0 l\u2019objet courant.<\/li>\n<li><code>mult: u32<\/code> qui est notre multiplicateur de type <code>u32<\/code><\/li>\n<\/ul>\n<p>Elle retourne <code>Self<\/code> qui est un alias vers le type courant, donc vers <code>Ingredient<\/code><\/p>\n<p>Le corps de la fonction se contente de retourner une nouvelle instance d\u2019ingr\u00e9dient dont\u00a0:<\/p>\n<ul>\n<li>la <code>quantity<\/code> est multipli\u00e9e par <code>mult<\/code>. Ce qui retourne un nouveau <code>Ratio<\/code><\/li>\n<li>le label est lui explicitement clon\u00e9.<\/li>\n<\/ul>\n<p>Sinon nous aurions transf\u00e9r\u00e9 la propri\u00e9t\u00e9 du label au nouvel ingr\u00e9dient. Ce qui produirait une erreur de compilation car leur cycle de vie est diff\u00e9rent.<\/p>\n<h3 id=\"tests-unitaires\">Tests unitaires<\/h3>\n<p>Rust permet d\u2019\u00e9crire des tests unitaires \u00e0 proximit\u00e9 du code source sans les embarquer dans le build de production.<\/p>\n<p>Beaucoup de tests qui auraient \u00e9t\u00e9 \u00e9crits dans un langage interpr\u00e9t\u00e9 et non typ\u00e9 sont \u00e9vit\u00e9s car le compilateur sert de garde-fou.<\/p>\n<p>L\u2019unique test \u00e0 \u00e9crire dans notre cas est de v\u00e9rifier que la logique impl\u00e9ment\u00e9e est la bonne.<\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ ingredient.rs<\/span> <span class=\"c\">\/\/ ...<\/span>  <span class=\"nd\">#[cfg(test)]<\/span> <span class=\"k\">mod<\/span> <span class=\"n\">tests<\/span> <span class=\"p\">{<\/span>     <span class=\"k\">use<\/span> <span class=\"nn\">crate<\/span><span class=\"p\">::<\/span><span class=\"n\">Ingredient<\/span><span class=\"p\">;<\/span>     <span class=\"k\">use<\/span> <span class=\"nn\">num_rational<\/span><span class=\"p\">::<\/span><span class=\"n\">Ratio<\/span><span class=\"p\">;<\/span>      <span class=\"nd\">#[test]<\/span>     <span class=\"k\">fn<\/span> <span class=\"nf\">it_scale_quantity<\/span><span class=\"p\">()<\/span> <span class=\"p\">{<\/span>         <span class=\"k\">let<\/span> <span class=\"n\">quantity<\/span> <span class=\"o\">=<\/span> <span class=\"nn\">Ratio<\/span><span class=\"p\">::<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"mi\">1<\/span><span class=\"p\">,<\/span> <span class=\"mi\">2<\/span><span class=\"p\">);<\/span>         <span class=\"k\">let<\/span> <span class=\"n\">ingredient<\/span> <span class=\"o\">=<\/span> <span class=\"n\">Ingredient<\/span> <span class=\"p\">{<\/span>             <span class=\"n\">label<\/span><span class=\"p\">:<\/span> <span class=\"s\">\"\"<\/span><span class=\"nf\">.to_string<\/span><span class=\"p\">(),<\/span>             <span class=\"n\">quantity<\/span><span class=\"p\">,<\/span>         <span class=\"p\">};<\/span>          <span class=\"nd\">assert_eq!<\/span><span class=\"p\">(<\/span><span class=\"n\">ingredient<\/span><span class=\"nf\">.scale<\/span><span class=\"p\">(<\/span><span class=\"mi\">2<\/span><span class=\"p\">)<\/span><span class=\"py\">.quantity<\/span><span class=\"p\">,<\/span> <span class=\"nn\">Ratio<\/span><span class=\"p\">::<\/span><span class=\"nf\">from_integer<\/span><span class=\"p\">(<\/span><span class=\"mi\">1<\/span><span class=\"p\">))<\/span>     <span class=\"p\">}<\/span> <span class=\"p\">}<\/span>  <\/code><\/pre>\n<\/div>\n<\/div>\n<p><code>#[cfg(test)]<\/code> est une annotation destin\u00e9e au compilateur. Elle indique que la section qui suit est destin\u00e9e \u00e0 l\u2019environnement de test et donc ne sera pas embarqu\u00e9e dans le binaire de production.<\/p>\n<p>Ensuite est d\u00e9fini un module de tests avec <code>mod tests {}<\/code>. Ce module importe ses d\u00e9pendances \u00e0 <code>Ratio<\/code> et <code>Ingredient<\/code> avec <code>use<\/code>.<\/p>\n<p>Viens ensuite notre test qui n\u2019est autre qu\u2019une fonction pr\u00e9c\u00e9d\u00e9e de l\u2019annotation <code>#[test]<\/code>.<\/p>\n<p>Dans ce test on cr\u00e9e un ingr\u00e9dient avec une <code>quantity<\/code> de 1\/2.<\/p>\n<p>Puis on v\u00e9rifie que la <code>quantity<\/code> du r\u00e9sultat d\u2019une multiplication par 2 nous donne un <code>Ratio<\/code> \u00e9quivalent \u00e0 1.<\/p>\n<p>\u00c0 ce stade vous pouvez jouer avec le fichier <a href=\"https:\/\/play.rust-lang.org\/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=e67b5aa7da325847e612275ff584639a\">ingredient.rs dans le Playground<\/a><\/p>\n<h2 id=\"le-parser\">Le parser<\/h2>\n<p>Notre recette est une cha\u00eene de caract\u00e8res multi-lignes. Nous allons l\u2019analyser pour retourner une collection d\u2019ingr\u00e9dients.<\/p>\n<p>Notre analyseur est lui aussi un module nomm\u00e9 <code>parser<\/code>. Il expose une fonction publique\u00a0:<\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"k\">pub<\/span> <span class=\"k\">fn<\/span> <span class=\"nf\">parse<\/span><span class=\"p\">(<\/span><span class=\"n\">input<\/span><span class=\"p\">:<\/span> <span class=\"o\">&amp;<\/span><span class=\"nb\">str<\/span><span class=\"p\">)<\/span> <span class=\"k\">-&gt;<\/span> <span class=\"nb\">Vec<\/span><span class=\"o\">&lt;<\/span><span class=\"n\">Ingredient<\/span><span class=\"o\">&gt;<\/span> <span class=\"p\">{<\/span>     <span class=\"n\">input<\/span><span class=\"nf\">.lines<\/span><span class=\"p\">()<\/span><span class=\"nf\">.filter_map<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"n\">parse_line<\/span><span class=\"p\">)<\/span><span class=\"nf\">.collect<\/span><span class=\"p\">()<\/span> <span class=\"p\">}<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Cette fonction prend en param\u00e8tre un <code>&amp;str<\/code> que nous avons d\u00e9j\u00e0 rencontr\u00e9 plus haut.<\/p>\n<p>Elle renvoi une collection de type <a href=\"https:\/\/doc.rust-lang.org\/1.30.0\/book\/second-edition\/ch08-01-vectors.html\">vecteur<\/a> <code>Vec<\/code>.<\/p>\n<p>Le type <code>Vec<\/code> attend lui aussi un param\u00e8tre, qui est le type de ses \u00e9l\u00e9ments (<code>Ingredient<\/code>).<\/p>\n<p><code>lines()<\/code> appel\u00e9 sur <code>input<\/code> renvoi un <a href=\"https:\/\/doc.rust-lang.org\/std\/iter\/trait.Iterator.html\">it\u00e9rateur<\/a> sur les lignes du <code>&amp;str<\/code>.<\/p>\n<p>Ensuite est appel\u00e9 <a href=\"https:\/\/doc.rust-lang.org\/std\/iter\/trait.Iterator.html#method.filter_map\"><code>filter_map<\/code><\/a> qui fonctionne comme un <code>map<\/code> classique \u00e0 quelques d\u00e9tails pr\u00e8s, nous y reviendrons plus loin.<\/p>\n<p>L\u2019argument <code>&amp;parse_line<\/code> est une r\u00e9f\u00e9rence \u00e0 la fonction <code>parse_line<\/code> qui sera appliqu\u00e9e sur chaque ligne.<\/p>\n<p>Le tout renvoi un <code>iterator<\/code> de nouveau.<\/p>\n<p>Pour terminer nous appelons <a href=\"https:\/\/doc.rust-lang.org\/std\/iter\/trait.Iterator.html#method.collect\"><code>collect<\/code><\/a> qui s\u2019applique aux it\u00e9rateurs pour renvoyer une collection (<code>Vec<\/code>).<\/p>\n<p>Revenons \u00e0 notre fonction <code>parse_line<\/code>.<\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ parser.rs<\/span> <span class=\"c\">\/\/ ...<\/span>  <span class=\"k\">fn<\/span> <span class=\"nf\">parse_line<\/span><span class=\"p\">(<\/span><span class=\"n\">line<\/span><span class=\"p\">:<\/span> <span class=\"o\">&amp;<\/span><span class=\"nb\">str<\/span><span class=\"p\">)<\/span> <span class=\"k\">-&gt;<\/span> <span class=\"nb\">Option<\/span><span class=\"o\">&lt;<\/span><span class=\"n\">Ingredient<\/span><span class=\"o\">&gt;<\/span> <span class=\"p\">{<\/span>     <span class=\"k\">let<\/span> <span class=\"n\">splits<\/span><span class=\"p\">:<\/span> <span class=\"nb\">Vec<\/span><span class=\"o\">&lt;&amp;<\/span><span class=\"nb\">str<\/span><span class=\"o\">&gt;<\/span> <span class=\"o\">=<\/span> <span class=\"n\">line<\/span><span class=\"nf\">.splitn<\/span><span class=\"p\">(<\/span><span class=\"mi\">2<\/span><span class=\"p\">,<\/span> <span class=\"sc\">' '<\/span><span class=\"p\">)<\/span><span class=\"nf\">.collect<\/span><span class=\"p\">();<\/span>      <span class=\"k\">match<\/span> <span class=\"n\">splits<\/span><span class=\"p\">[<\/span><span class=\"o\">..<\/span><span class=\"p\">]<\/span> <span class=\"p\">{<\/span>         <span class=\"p\">[<\/span><span class=\"n\">quantity<\/span><span class=\"p\">,<\/span> <span class=\"n\">label<\/span><span class=\"p\">]<\/span> <span class=\"k\">=&gt;<\/span> <span class=\"nf\">Some<\/span><span class=\"p\">(<\/span><span class=\"n\">Ingredient<\/span> <span class=\"p\">{<\/span>             <span class=\"n\">quantity<\/span><span class=\"p\">:<\/span> <span class=\"nf\">str_to_ratio<\/span><span class=\"p\">(<\/span><span class=\"n\">quantity<\/span><span class=\"p\">),<\/span>             <span class=\"n\">label<\/span><span class=\"p\">:<\/span> <span class=\"n\">label<\/span><span class=\"nf\">.to_string<\/span><span class=\"p\">(),<\/span>         <span class=\"p\">}),<\/span>         <span class=\"mi\">_<\/span> <span class=\"k\">=&gt;<\/span> <span class=\"nb\">None<\/span><span class=\"p\">,<\/span>     <span class=\"p\">}<\/span> <span class=\"p\">}<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Cette fonction prend en argument un <code>&amp;str<\/code> qui repr\u00e9sente une ligne de texte et l\u2019analyse pour en ressortir un <code>Ingredient<\/code>.<\/p>\n<p>Cependant il est possible que la ligne ne soit pas format\u00e9e correctement.<\/p>\n<p>Dans ce cas quel est le retour de la fonction\u00a0?<\/p>\n<p>Rust n\u2019a pas de <code>nil<\/code> ou <code>null<\/code>, comme d\u2019autres langages il dispose de valeurs mises en boites, <a href=\"https:\/\/doc.rust-lang.org\/std\/option\/index.html\">ici <code>Option<\/code><\/a> qui d\u00e9note l\u2019\u00e9ventualit\u00e9 qu\u2019il y ait une valeur.<\/p>\n<p><code>Option<\/code> est une \u00e9num\u00e9ration de valeurs possibles\u00a0:<\/p>\n<ul>\n<li><code>Some(Ingredient)<\/code><\/li>\n<li><code>None<\/code><\/li>\n<\/ul>\n<p><code>line.splitn(2, ' ').collect()<\/code> divise la ligne en 2 parties \u00e0 partir du premier espace, et retourne une collection.<\/p>\n<p><code>let splits: Vec&lt;&amp;str&gt;<\/code> permet de pr\u00e9ciser le type de la collection attendue qui ne peut pas \u00eatre toujours d\u00e9duit par le compilateur.<\/p>\n<p><code>splits<\/code> est ensuite d\u00e9structur\u00e9 avec <code>match<\/code> qui permet de faire des branches en fonction des motifs (<em>pattern matching<\/em>).<\/p>\n<p>Soit nous obtenons 2 \u00e9l\u00e9ments pour construire <code>Some(Ingredient)<\/code> soit la ligne est mal format\u00e9e et donc <code>None<\/code>.<\/p>\n<p>Lors de la construction de <code>Ingredient<\/code>, <code>to_string<\/code> est appel\u00e9 sur <code>label<\/code>.<\/p>\n<p><code>label<\/code> localement est de type <code>&amp;str<\/code>(r\u00e9f\u00e9rence emprunt\u00e9e) alors que la structure <code>Ingredient<\/code> attend un <code>String<\/code> (valeur poss\u00e9d\u00e9e), <code>to_string<\/code> op\u00e8re la copie comme vu pr\u00e9c\u00e9demment avec <code>clone<\/code>.<\/p>\n<p>Puisque nous obtenons un r\u00e9sultat de type <code>Option<\/code>, dans la fonction <code>parse<\/code> nous obtenons un <code>Iterator&lt;Option&gt;<\/code>.<\/p>\n<p>Pour obtenir un <code>Iterator&lt;Ingredient&gt;<\/code> il suffit d\u2019utiliser <a href=\"https:\/\/doc.rust-lang.org\/std\/iter\/struct.FilterMap.html\"><code>filter_map<\/code><\/a> qui va ignorer les r\u00e9sultats de type <code>None<\/code> et d\u00e9baller l\u2019ingr\u00e9dient du <code>Some(Ingredient)<\/code>.<\/p>\n<p>Pour convertir <code>quantity<\/code> qui est aussi de type <code>&amp;str<\/code> en <code>Ratio<\/code>, nous utilisons la fonction <code>str_to_ratio<\/code><\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ parser.rs<\/span> <span class=\"c\">\/\/...<\/span>  <span class=\"k\">fn<\/span> <span class=\"nf\">str_to_ratio<\/span><span class=\"p\">(<\/span><span class=\"n\">s<\/span><span class=\"p\">:<\/span> <span class=\"o\">&amp;<\/span><span class=\"nb\">str<\/span><span class=\"p\">)<\/span> <span class=\"k\">-&gt;<\/span> <span class=\"n\">Ratio<\/span><span class=\"o\">&lt;<\/span><span class=\"nb\">u32<\/span><span class=\"o\">&gt;<\/span> <span class=\"p\">{<\/span>     <span class=\"k\">let<\/span> <span class=\"n\">numerics<\/span><span class=\"p\">:<\/span> <span class=\"nb\">Vec<\/span><span class=\"o\">&lt;<\/span><span class=\"nb\">u32<\/span><span class=\"o\">&gt;<\/span> <span class=\"o\">=<\/span> <span class=\"n\">s<\/span>         <span class=\"nf\">.splitn<\/span><span class=\"p\">(<\/span><span class=\"mi\">2<\/span><span class=\"p\">,<\/span> <span class=\"sc\">'\/'<\/span><span class=\"p\">)<\/span>         <span class=\"nf\">.map<\/span><span class=\"p\">(<\/span><span class=\"nn\">str<\/span><span class=\"p\">::<\/span><span class=\"nn\">parse<\/span><span class=\"p\">::<\/span><span class=\"o\">&lt;<\/span><span class=\"nb\">u32<\/span><span class=\"o\">&gt;<\/span><span class=\"p\">)<\/span>         <span class=\"nf\">.filter_map<\/span><span class=\"p\">(<\/span><span class=\"nn\">Result<\/span><span class=\"p\">::<\/span><span class=\"n\">ok<\/span><span class=\"p\">)<\/span>         <span class=\"nf\">.collect<\/span><span class=\"p\">();<\/span>      <span class=\"k\">match<\/span> <span class=\"n\">numerics<\/span><span class=\"p\">[<\/span><span class=\"o\">..<\/span><span class=\"p\">]<\/span> <span class=\"p\">{<\/span>         <span class=\"p\">[<\/span><span class=\"n\">numer<\/span><span class=\"p\">]<\/span> <span class=\"k\">=&gt;<\/span> <span class=\"nn\">Ratio<\/span><span class=\"p\">::<\/span><span class=\"nf\">from_integer<\/span><span class=\"p\">(<\/span><span class=\"n\">numer<\/span><span class=\"p\">),<\/span>         <span class=\"p\">[<\/span><span class=\"n\">numer<\/span><span class=\"p\">,<\/span> <span class=\"n\">denom<\/span><span class=\"p\">]<\/span> <span class=\"k\">=&gt;<\/span> <span class=\"nn\">Ratio<\/span><span class=\"p\">::<\/span><span class=\"nf\">new<\/span><span class=\"p\">(<\/span><span class=\"n\">numer<\/span><span class=\"p\">,<\/span> <span class=\"n\">denom<\/span><span class=\"p\">),<\/span>         <span class=\"mi\">_<\/span> <span class=\"k\">=&gt;<\/span> <span class=\"nd\">panic!<\/span><span class=\"p\">(<\/span><span class=\"s\">\"Malformed recipe quantity: {:?}\"<\/span><span class=\"p\">,<\/span> <span class=\"n\">numerics<\/span><span class=\"p\">),<\/span>     <span class=\"p\">}<\/span> <span class=\"p\">}<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Cette fonction s\u00e9pare le <code>&amp;str<\/code> en 2 parties \u00e0 partir du <code>\/<\/code> puis transforme les r\u00e9sultats en <code>u32<\/code>.<\/p>\n<p><code>filter_map<\/code> est de nouveau utilis\u00e9, cette fois pour n\u2019obtenir que le contenu des boites <a href=\"https:\/\/doc.rust-lang.org\/std\/result\/index.html\"><code>Result::ok<\/code><\/a>.<\/p>\n<p>Ensuite le r\u00e9sultat est d\u00e9compos\u00e9 avec <code>match<\/code>\u00a0:<\/p>\n<ul>\n<li>une seule valeur c\u2019est un <code>Ratio<\/code> depuis un entier.<\/li>\n<li>deux valeurs c\u2019est un <code>Ratio<\/code> \u00e0 partir d\u2019un num\u00e9rateur et d\u2019un d\u00e9nominateur.<\/li>\n<li>aucun des deux c\u2019est une erreur.<\/li>\n<\/ul>\n<p><a href=\"https:\/\/doc.rust-lang.org\/std\/macro.panic.html\"><code>panic!<\/code><\/a> est une macro comme tout ce qui se termine par un <code>!<\/code>. Elle termine le programme comme une exception non intercept\u00e9e.<\/p>\n<p>En lecteur attentif, vous noterez qu\u2019il aurait \u00e9t\u00e9 pr\u00e9f\u00e9rable de renvoyer un <code>Option&lt;Ratio&gt;<\/code> pour s\u00e9curiser les erreurs d\u2019analyse de la cha\u00eene de caract\u00e8res. Ce qui n\u2019est pas fait par besoin de d\u00e9montrer <code>panic!<\/code> dans l\u2019article.<\/p>\n<h2 id=\"la-chanson-de-la-main\">La chanson de la main<\/h2>\n<p><a href=\"https:\/\/www.youtube.com\/watch?v=tvanSC9FlkE\">Elle vient de loin\u2026<\/a><\/p>\n<p>De retour dans notre fichier <code>main.rs<\/code> voyons comment combiner tout \u00e7a.<\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ main.rs<\/span>  <span class=\"k\">mod<\/span> <span class=\"n\">ingredient<\/span><span class=\"p\">;<\/span> <span class=\"k\">mod<\/span> <span class=\"n\">parser<\/span><span class=\"p\">;<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Cette forme de d\u00e9claration de module pr\u00e9cise que les modules <code>ingredient<\/code> et <code>parser<\/code> se trouvent dans les fichiers du m\u00eame nom.<\/p>\n<p>La fonction <code>main<\/code> du fichier <code>main.rs<\/code> est, sans surprise, celle qui est ex\u00e9cut\u00e9e lors du lancement du programme.<\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ main.rs<\/span>  <span class=\"k\">fn<\/span> <span class=\"nf\">scale_ingredients<\/span><span class=\"p\">(<\/span><span class=\"n\">ins<\/span><span class=\"p\">:<\/span> <span class=\"nb\">Vec<\/span><span class=\"o\">&lt;<\/span><span class=\"n\">Ingredient<\/span><span class=\"o\">&gt;<\/span><span class=\"p\">,<\/span> <span class=\"n\">mult<\/span><span class=\"p\">:<\/span> <span class=\"nb\">u32<\/span><span class=\"p\">)<\/span> <span class=\"k\">-&gt;<\/span> <span class=\"nb\">Vec<\/span><span class=\"o\">&lt;<\/span><span class=\"n\">Ingredient<\/span><span class=\"o\">&gt;<\/span> <span class=\"p\">{<\/span>     <span class=\"n\">ins<\/span><span class=\"nf\">.iter<\/span><span class=\"p\">()<\/span><span class=\"nf\">.map<\/span><span class=\"p\">(|<\/span><span class=\"n\">e<\/span><span class=\"p\">|<\/span> <span class=\"n\">e<\/span><span class=\"nf\">.scale<\/span><span class=\"p\">(<\/span><span class=\"n\">mult<\/span><span class=\"p\">))<\/span><span class=\"nf\">.collect<\/span><span class=\"p\">()<\/span> <span class=\"p\">}<\/span>  <span class=\"k\">fn<\/span> <span class=\"nf\">main<\/span><span class=\"p\">()<\/span> <span class=\"p\">{<\/span>     <span class=\"k\">let<\/span> <span class=\"n\">scale<\/span><span class=\"p\">:<\/span> <span class=\"nb\">u32<\/span> <span class=\"o\">=<\/span> <span class=\"mi\">2<\/span><span class=\"p\">;<\/span>     <span class=\"k\">let<\/span> <span class=\"n\">base_ingredients<\/span> <span class=\"o\">=<\/span> <span class=\"nn\">parser<\/span><span class=\"p\">::<\/span><span class=\"nf\">parse<\/span><span class=\"p\">(<\/span><span class=\"n\">RECIPE<\/span><span class=\"p\">);<\/span>     <span class=\"k\">for<\/span> <span class=\"n\">i<\/span> <span class=\"n\">in<\/span> <span class=\"n\">base_ingredients<\/span><span class=\"nf\">.iter<\/span><span class=\"p\">()<\/span> <span class=\"p\">{<\/span>         <span class=\"nd\">println!<\/span><span class=\"p\">(<\/span><span class=\"s\">\"{}\"<\/span><span class=\"p\">,<\/span> <span class=\"n\">i<\/span><span class=\"nf\">.scale<\/span><span class=\"p\">(<\/span><span class=\"n\">scale<\/span><span class=\"p\">))<\/span>     <span class=\"p\">}<\/span> <span class=\"p\">}<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Cette fonction d\u00e9clare une variable locale <code>scale<\/code> qui est le multiplicateur de la recette. Puis utilise la fonction <code>parse<\/code> du module <code>parser<\/code> pour obtenir les ingr\u00e9dients depuis <code>RECIPE<\/code>.<\/p>\n<p>Ensuite nous it\u00e9rons sur les ingr\u00e9dients pour afficher l\u2019ingr\u00e9dient multipli\u00e9 par l\u2019\u00e9chelle.<\/p>\n<p><a href=\"https:\/\/doc.rust-lang.org\/std\/primitive.slice.html#method.iter\"><code>iter()<\/code><\/a> Nous permet d\u2019obtenir un <code>Iterator<\/code> depuis un <code>Vec<\/code>.<\/p>\n<p><a href=\"https:\/\/doc.rust-lang.org\/std\/macro.println.html\"><code>println!<\/code><\/a> est la macro qui permet d\u2019afficher sur la sortie standard.<\/p>\n<p>Pour qu\u2019une valeur puisse \u00eatre format\u00e9e pour la sortie texte, elle doit impl\u00e9menter le <code>Trait<\/code> <a href=\"https:\/\/doc.rust-lang.org\/std\/fmt\/trait.Display.html\"><code>Display<\/code><\/a>.<\/p>\n<p>Un <a href=\"https:\/\/doc.rust-lang.org\/book\/ch10-02-traits.html\"><code>Trait<\/code><\/a> s\u2019apparente \u00e0 une interface pour un comportement impl\u00e9ment\u00e9 sur plusieurs types.<\/p>\n<p>L\u2019impl\u00e9mentation de <code>Display<\/code> pour notre ingr\u00e9dient se d\u00e9clare ainsi\u00a0:<\/p>\n<div class=\"language-rust highlighter-rouge\">\n<div class=\"highlight\">\n<pre class=\"highlight\"><code><span class=\"c\">\/\/ ingredient.rs<\/span>  <span class=\"k\">impl<\/span> <span class=\"nn\">std<\/span><span class=\"p\">::<\/span><span class=\"nn\">fmt<\/span><span class=\"p\">::<\/span><span class=\"n\">Display<\/span> <span class=\"k\">for<\/span> <span class=\"n\">Ingredient<\/span> <span class=\"p\">{<\/span>     <span class=\"k\">fn<\/span> <span class=\"nf\">fmt<\/span><span class=\"p\">(<\/span><span class=\"o\">&amp;<\/span><span class=\"k\">self<\/span><span class=\"p\">,<\/span> <span class=\"n\">f<\/span><span class=\"p\">:<\/span> <span class=\"o\">&amp;<\/span><span class=\"k\">mut<\/span> <span class=\"nn\">std<\/span><span class=\"p\">::<\/span><span class=\"nn\">fmt<\/span><span class=\"p\">::<\/span><span class=\"n\">Formatter<\/span><span class=\"p\">)<\/span> <span class=\"k\">-&gt;<\/span> <span class=\"nn\">std<\/span><span class=\"p\">::<\/span><span class=\"nn\">fmt<\/span><span class=\"p\">::<\/span><span class=\"n\">Result<\/span> <span class=\"p\">{<\/span>         <span class=\"nd\">write!<\/span><span class=\"p\">(<\/span><span class=\"n\">f<\/span><span class=\"p\">,<\/span> <span class=\"s\">\"{} {}\"<\/span><span class=\"p\">,<\/span> <span class=\"k\">self<\/span><span class=\"py\">.quantity<\/span><span class=\"p\">,<\/span> <span class=\"k\">self<\/span><span class=\"py\">.label<\/span><span class=\"p\">)<\/span>     <span class=\"p\">}<\/span> <span class=\"p\">}<\/span> <\/code><\/pre>\n<\/div>\n<\/div>\n<p>Elle prend en argument la structure courante et une <a href=\"https:\/\/doc.rust-lang.org\/std\/fmt\/struct.Formatter.html\">fonction de formatage<\/a><\/p>\n<p>La macro <code>write!<\/code> pousse les donn\u00e9es format\u00e9es dans un tampon. Le format choisi est tout simplement d\u2019afficher la quantit\u00e9 suivie du libell\u00e9.<\/p>\n<h2 id=\"pour-aller-plus-loin\">Pour aller plus loin<\/h2>\n<p>L\u2019ensemble du programme est disponible est <a href=\"https:\/\/play.rust-lang.org\/?version=stable&amp;mode=debug&amp;edition=2018&amp;gist=d714874cb965fc559a8cf993283a3733\">disponible dans le Playground Rust<\/a>, qui permet de jouer avec le code sans avoir \u00e0 installer Rust.<\/p>\n<p>Le code est \u00e9galement disponible sur <a href=\"https:\/\/github.com\/Electron-libre\/doser\">GitHub<\/a>.<\/p>\n<p><code>cargo test<\/code> permettra de lancer les tests. <code>cargo run<\/code> lancera l\u2019application (en environnement de d\u00e9veloppement).<\/p>\n<p>Pour continuer d\u2019exp\u00e9rimenter avec Rust je recommande de tenter ces exercices\u00a0:<\/p>\n<ul>\n<li>s\u00e9curiser la fonction <code>parser::str_to_ratio<\/code> pour supprimer le <code>panic!<\/code><\/li>\n<li>faire en sorte de pouvoir <a href=\"https:\/\/doc.rust-lang.org\/book\/ch12-01-accepting-command-line-arguments.html\">passer le multiplicateur<\/a> \u00e0 l\u2019invocation du programme<\/li>\n<li>parall\u00e9liser l\u2019ex\u00e9cution des <code>parse_line<\/code> avec <a href=\"https:\/\/doc.rust-lang.org\/book\/ch16-00-concurrency.html\">l\u2019outillage du langage<\/a><\/li>\n<\/ul>\n<p>Un dernier conseil pour la faim et le dosage de la rouille\u00a0:<\/p>\n<p>Rust permet beaucoup d\u2019optimisations de gestion de la m\u00e9moire. Cependant, la ma\u00eetrise de la recette est dans le dosage\u00a0!<\/p>\n<p>Utiliser des r\u00e9f\u00e9rences \u00e0 tout bout de chandelles vous obligera \u00e0 affronter le <a href=\"https:\/\/doc.rust-lang.org\/1.30.0\/book\/second-edition\/ch10-03-lifetime-syntax.html?highlight=borrow,checker#the-borrow-checker\">bourreau shaker<\/a>.<\/p>\n<p>Dans un premier temps abusez de <code>clone<\/code>, puis optimisez progressivement.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>D\u00e9mystifier Rust autour du calembour \u00e0 la sauce rouille<\/p>\n","protected":false},"author":10,"featured_media":12565,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"fifu_image_url":"","fifu_image_alt":"","footnotes":""},"categories":[34],"tags":[],"class_list":["post-7815","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-articles-techniques"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.9 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Du dosage \u00e0 la rouille - Ouidou<\/title>\n<meta name=\"description\" content=\"Nos experts abordent l&#039;importance du dosage des ingr\u00e9dients pour pr\u00e9venir la rouille et optimiser les m\u00e9langes de b\u00e9ton.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Du dosage \u00e0 la rouille - Ouidou\" \/>\n<meta property=\"og:description\" content=\"Nos experts abordent l&#039;importance du dosage des ingr\u00e9dients pour pr\u00e9venir la rouille et optimiser les m\u00e9langes de b\u00e9ton.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille\" \/>\n<meta property=\"og:site_name\" content=\"Ouidou\" \/>\n<meta property=\"article:published_time\" content=\"2019-06-12T22:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2025-12-01T15:46:12+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/06\/Du-dosage-a\u0300-la-rouille.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1105\" \/>\n\t<meta property=\"og:image:height\" content=\"564\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Sara Lourties\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u00c9crit par\" \/>\n\t<meta name=\"twitter:data1\" content=\"Sara Lourties\" \/>\n\t<meta name=\"twitter:label2\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data2\" content=\"9 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille\"},\"author\":{\"name\":\"Sara Lourties\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\"},\"headline\":\"Du dosage \u00e0 la rouille\",\"datePublished\":\"2019-06-12T22:00:00+00:00\",\"dateModified\":\"2025-12-01T15:46:12+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille\"},\"wordCount\":1850,\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/06\\\/Du-dosage-a\u0300-la-rouille.png\",\"articleSection\":[\"Articles Techniques\"],\"inLanguage\":\"fr-FR\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille\",\"name\":\"Du dosage \u00e0 la rouille - Ouidou\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/06\\\/Du-dosage-a\u0300-la-rouille.png\",\"datePublished\":\"2019-06-12T22:00:00+00:00\",\"dateModified\":\"2025-12-01T15:46:12+00:00\",\"description\":\"Nos experts abordent l'importance du dosage des ingr\u00e9dients pour pr\u00e9venir la rouille et optimiser les m\u00e9langes de b\u00e9ton.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille#primaryimage\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/06\\\/Du-dosage-a\u0300-la-rouille.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2019\\\/06\\\/Du-dosage-a\u0300-la-rouille.png\",\"width\":1105,\"height\":564,\"caption\":\"Du dosage a la rouille - Visuel article technique\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/articles-techniques\\\/du-dosage-a-la-rouille#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Accueil\",\"item\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Du dosage \u00e0 la rouille\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"name\":\"Blog Ouidou\",\"description\":\"Conseil et expertise en technologies\",\"publisher\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#organization\",\"name\":\"Ouidou\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"contentUrl\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/04\\\/image_2022-04-13_150237378.png\",\"width\":180,\"height\":180,\"caption\":\"Ouidou\"},\"image\":{\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/ouidou.fr\\\/blog\\\/#\\\/schema\\\/person\\\/e1d66085fb7c22ede319ce56adc373a4\",\"name\":\"Sara Lourties\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g\",\"caption\":\"Sara Lourties\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Du dosage \u00e0 la rouille - Ouidou","description":"Nos experts abordent l'importance du dosage des ingr\u00e9dients pour pr\u00e9venir la rouille et optimiser les m\u00e9langes de b\u00e9ton.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille","og_locale":"fr_FR","og_type":"article","og_title":"Du dosage \u00e0 la rouille - Ouidou","og_description":"Nos experts abordent l'importance du dosage des ingr\u00e9dients pour pr\u00e9venir la rouille et optimiser les m\u00e9langes de b\u00e9ton.","og_url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille","og_site_name":"Ouidou","article_published_time":"2019-06-12T22:00:00+00:00","article_modified_time":"2025-12-01T15:46:12+00:00","og_image":[{"width":1105,"height":564,"url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/06\/Du-dosage-a\u0300-la-rouille.png","type":"image\/png"}],"author":"Sara Lourties","twitter_card":"summary_large_image","twitter_misc":{"\u00c9crit par":"Sara Lourties","Dur\u00e9e de lecture estim\u00e9e":"9 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille#article","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille"},"author":{"name":"Sara Lourties","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4"},"headline":"Du dosage \u00e0 la rouille","datePublished":"2019-06-12T22:00:00+00:00","dateModified":"2025-12-01T15:46:12+00:00","mainEntityOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille"},"wordCount":1850,"publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/06\/Du-dosage-a\u0300-la-rouille.png","articleSection":["Articles Techniques"],"inLanguage":"fr-FR"},{"@type":"WebPage","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille","url":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille","name":"Du dosage \u00e0 la rouille - Ouidou","isPartOf":{"@id":"https:\/\/ouidou.fr\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille#primaryimage"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille#primaryimage"},"thumbnailUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/06\/Du-dosage-a\u0300-la-rouille.png","datePublished":"2019-06-12T22:00:00+00:00","dateModified":"2025-12-01T15:46:12+00:00","description":"Nos experts abordent l'importance du dosage des ingr\u00e9dients pour pr\u00e9venir la rouille et optimiser les m\u00e9langes de b\u00e9ton.","breadcrumb":{"@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille#primaryimage","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/06\/Du-dosage-a\u0300-la-rouille.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2019\/06\/Du-dosage-a\u0300-la-rouille.png","width":1105,"height":564,"caption":"Du dosage a la rouille - Visuel article technique"},{"@type":"BreadcrumbList","@id":"https:\/\/ouidou.fr\/blog\/articles-techniques\/du-dosage-a-la-rouille#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Accueil","item":"https:\/\/ouidou.fr\/blog\/"},{"@type":"ListItem","position":2,"name":"Du dosage \u00e0 la rouille"}]},{"@type":"WebSite","@id":"https:\/\/ouidou.fr\/blog\/#website","url":"https:\/\/ouidou.fr\/blog\/","name":"Blog Ouidou","description":"Conseil et expertise en technologies","publisher":{"@id":"https:\/\/ouidou.fr\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/ouidou.fr\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/ouidou.fr\/blog\/#organization","name":"Ouidou","url":"https:\/\/ouidou.fr\/blog\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","contentUrl":"https:\/\/ouidou.fr\/blog\/wp-content\/uploads\/2022\/04\/image_2022-04-13_150237378.png","width":180,"height":180,"caption":"Ouidou"},"image":{"@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/ouidou.fr\/blog\/#\/schema\/person\/e1d66085fb7c22ede319ce56adc373a4","name":"Sara Lourties","image":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/b2ef32f9fc1e16168b39587a2ec1dafedc70a9d41fa1b4a930ec7744b3e35ec7?s=96&d=mm&r=g","caption":"Sara Lourties"}}]}},"_links":{"self":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7815","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/users\/10"}],"replies":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/comments?post=7815"}],"version-history":[{"count":5,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7815\/revisions"}],"predecessor-version":[{"id":17970,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/posts\/7815\/revisions\/17970"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media\/12565"}],"wp:attachment":[{"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/media?parent=7815"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/categories?post=7815"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ouidou.fr\/blog\/wp-json\/wp\/v2\/tags?post=7815"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}