[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"article-deep-evm-7-boucles-conditionnels-efficaces-gas-yul":3},{"article":4,"author":58},{"id":5,"category_id":6,"title":7,"slug":8,"excerpt":9,"content_md":10,"content_html":11,"locale":12,"author_id":13,"published":14,"published_at":15,"meta_title":7,"meta_description":16,"focus_keyword":17,"og_image":18,"canonical_url":18,"robots_meta":19,"created_at":15,"updated_at":15,"tags":20,"category_name":38,"related_articles":39},"d6000000-0000-0000-0000-000000000107","a0000000-0000-0000-0000-000000000062","Deep EVM #7 : Boucles et conditionnels efficaces en gas dans Yul","deep-evm-7-boucles-conditionnels-efficaces-gas-yul","Écrivez des boucles for et des instructions switch optimisées en gas dans Yul. Comparez avec les patterns Solidity, analysez le bytecode produit et mesurez les économies réelles.","## Les boucles en Yul\n\nYul offre un seul type de boucle : `for`. Mais cette boucle est suffisamment flexible pour exprimer des patterns while, do-while et de parcours de tableaux.\n\n### Syntaxe de base\n\n```yul\nfor { let i := 0 } lt(i, 10) { i := add(i, 1) } {\n    \u002F\u002F Corps de la boucle\n}\n```\n\nLa structure est `for { init } condition { post } { body }`. Chaque partie compile directement en opcodes JUMP\u002FJUMPI — il n'y a pas d'abstraction intermédiaire.\n\n### Boucle while\n\n```yul\nfor { } condition { } {\n    \u002F\u002F Corps — exécuté tant que condition est vraie\n}\n```\n\n### Incrémentation en pré vs post\n\nEn Yul, l'incrément est toujours explicite avec `add`. Il n'y a pas de `i++` — vous écrivez `i := add(i, 1)`. Cela coûte exactement PUSH1 + ADD + SWAP + POP = 12 gas par itération.\n\nComparaison avec Solidity (mode unchecked) :\n\n```solidity\n\u002F\u002F Solidity unchecked — compile en un code similaire\nunchecked {\n    for (uint256 i; i \u003C 10; ++i) { ... }\n}\n```\n\nLe Yul produit un bytecode presque identique au `unchecked` Solidity. L'avantage de Yul est le contrôle total : vous pouvez structurer la boucle pour minimiser les opérations de pile.\n\n## Les conditionnels en Yul\n\n### if\n\nYul n'a pas de `else`. Si vous avez besoin de branches multiples, utilisez `switch` ou enchaînez des `if` :\n\n```yul\nif iszero(value) {\n    revert(0, 0)\n}\n```\n\n### switch\n\n```yul\nswitch selector\ncase 0x70a08231 {\n    \u002F\u002F balanceOf\n}\ncase 0xa9059cbb {\n    \u002F\u002F transfer\n}\ndefault {\n    revert(0, 0)\n}\n```\n\nLe `switch` en Yul compile en une chaîne d'EQ + JUMPI — similaire au dispatcher if-else de Solidity. Ce n'est pas une table de saut O(1) ; c'est du O(N) dans le pire cas.\n\n## Optimisations pratiques\n\n### Déroulage de boucle\n\nPour les boucles courtes avec un nombre fixe d'itérations, déroulez manuellement :\n\n```yul\n\u002F\u002F Au lieu de boucler 4 fois :\nmstore(add(ptr, 0x00), val0)\nmstore(add(ptr, 0x20), val1)\nmstore(add(ptr, 0x40), val2)\nmstore(add(ptr, 0x60), val3)\n```\n\nÉconomise le coût de la condition et de l'incrément à chaque itération (environ 18 gas par itération).\n\n### Compteur décroissant\n\n```yul\n\u002F\u002F Plus efficace : compter vers le bas\nfor { let i := n } gt(i, 0) { i := sub(i, 1) } {\n    \u002F\u002F Le test `gt(i, 0)` est 1 gas moins cher que `lt(i, n)` car\n    \u002F\u002F il n'a pas besoin de charger n depuis la pile\n}\n```\n\n### Arrêt anticipé\n\nSortez de la boucle dès que possible avec `break` :\n\n```yul\nfor { let i := 0 } lt(i, length) { i := add(i, 1) } {\n    let element := mload(add(ptr, mul(i, 0x20)))\n    if eq(element, target) {\n        result := i\n        break\n    }\n}\n```\n\n## Benchmarks de gas\n\n| Pattern | Gas par itération (Solidity) | Gas par itération (Yul) | Économie |\n|---------|------------------------------|------------------------|-----------|\n| Boucle standard | ~95 | ~78 | 18 % |\n| Avec unchecked | ~80 | ~78 | 3 % |\n| Accès tableau | ~110 | ~85 | 23 % |\n| Copie mémoire | ~120 | ~90 | 25 % |\n\nLes économies sont les plus significatives pour les boucles qui accèdent à la mémoire ou au stockage, où l'overhead de Solidity (vérifications de limites, ABI encoding) est le plus élevé.\n\n## Conclusion\n\nLes boucles et conditionnels en Yul offrent un contrôle fin sur le gas. Les gains les plus importants viennent de l'élimination des vérifications de limites de Solidity, du déroulage des boucles courtes et de l'utilisation de compteurs décroissants.\n\nDans le prochain article, nous mettrons en pratique toutes ces techniques en construisant un échange de tokens en Yul pur.","\u003Ch2 id=\"les-boucles-en-yul\">Les boucles en Yul\u003C\u002Fh2>\n\u003Cp>Yul offre un seul type de boucle : \u003Ccode>for\u003C\u002Fcode>. Mais cette boucle est suffisamment flexible pour exprimer des patterns while, do-while et de parcours de tableaux.\u003C\u002Fp>\n\u003Ch3>Syntaxe de base\u003C\u002Fh3>\n\u003Cpre>\u003Ccode class=\"language-yul\">for { let i := 0 } lt(i, 10) { i := add(i, 1) } {\n    \u002F\u002F Corps de la boucle\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Cp>La structure est \u003Ccode>for { init } condition { post } { body }\u003C\u002Fcode>. Chaque partie compile directement en opcodes JUMP\u002FJUMPI — il n’y a pas d’abstraction intermédiaire.\u003C\u002Fp>\n\u003Ch3>Boucle while\u003C\u002Fh3>\n\u003Cpre>\u003Ccode class=\"language-yul\">for { } condition { } {\n    \u002F\u002F Corps — exécuté tant que condition est vraie\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch3>Incrémentation en pré vs post\u003C\u002Fh3>\n\u003Cp>En Yul, l’incrément est toujours explicite avec \u003Ccode>add\u003C\u002Fcode>. Il n’y a pas de \u003Ccode>i++\u003C\u002Fcode> — vous écrivez \u003Ccode>i := add(i, 1)\u003C\u002Fcode>. Cela coûte exactement PUSH1 + ADD + SWAP + POP = 12 gas par itération.\u003C\u002Fp>\n\u003Cp>Comparaison avec Solidity (mode unchecked) :\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-solidity\">\u002F\u002F Solidity unchecked — compile en un code similaire\nunchecked {\n    for (uint256 i; i < 10; ++i) { ... }\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Cp>Le Yul produit un bytecode presque identique au \u003Ccode>unchecked\u003C\u002Fcode> Solidity. L’avantage de Yul est le contrôle total : vous pouvez structurer la boucle pour minimiser les opérations de pile.\u003C\u002Fp>\n\u003Ch2 id=\"les-conditionnels-en-yul\">Les conditionnels en Yul\u003C\u002Fh2>\n\u003Ch3>if\u003C\u002Fh3>\n\u003Cp>Yul n’a pas de \u003Ccode>else\u003C\u002Fcode>. Si vous avez besoin de branches multiples, utilisez \u003Ccode>switch\u003C\u002Fcode> ou enchaînez des \u003Ccode>if\u003C\u002Fcode> :\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-yul\">if iszero(value) {\n    revert(0, 0)\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch3>switch\u003C\u002Fh3>\n\u003Cpre>\u003Ccode class=\"language-yul\">switch selector\ncase 0x70a08231 {\n    \u002F\u002F balanceOf\n}\ncase 0xa9059cbb {\n    \u002F\u002F transfer\n}\ndefault {\n    revert(0, 0)\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Cp>Le \u003Ccode>switch\u003C\u002Fcode> en Yul compile en une chaîne d’EQ + JUMPI — similaire au dispatcher if-else de Solidity. Ce n’est pas une table de saut O(1) ; c’est du O(N) dans le pire cas.\u003C\u002Fp>\n\u003Ch2 id=\"optimisations-pratiques\">Optimisations pratiques\u003C\u002Fh2>\n\u003Ch3>Déroulage de boucle\u003C\u002Fh3>\n\u003Cp>Pour les boucles courtes avec un nombre fixe d’itérations, déroulez manuellement :\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-yul\">\u002F\u002F Au lieu de boucler 4 fois :\nmstore(add(ptr, 0x00), val0)\nmstore(add(ptr, 0x20), val1)\nmstore(add(ptr, 0x40), val2)\nmstore(add(ptr, 0x60), val3)\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Cp>Économise le coût de la condition et de l’incrément à chaque itération (environ 18 gas par itération).\u003C\u002Fp>\n\u003Ch3>Compteur décroissant\u003C\u002Fh3>\n\u003Cpre>\u003Ccode class=\"language-yul\">\u002F\u002F Plus efficace : compter vers le bas\nfor { let i := n } gt(i, 0) { i := sub(i, 1) } {\n    \u002F\u002F Le test `gt(i, 0)` est 1 gas moins cher que `lt(i, n)` car\n    \u002F\u002F il n'a pas besoin de charger n depuis la pile\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch3>Arrêt anticipé\u003C\u002Fh3>\n\u003Cp>Sortez de la boucle dès que possible avec \u003Ccode>break\u003C\u002Fcode> :\u003C\u002Fp>\n\u003Cpre>\u003Ccode class=\"language-yul\">for { let i := 0 } lt(i, length) { i := add(i, 1) } {\n    let element := mload(add(ptr, mul(i, 0x20)))\n    if eq(element, target) {\n        result := i\n        break\n    }\n}\n\u003C\u002Fcode>\u003C\u002Fpre>\n\u003Ch2 id=\"benchmarks-de-gas\">Benchmarks de gas\u003C\u002Fh2>\n\u003Ctable>\u003Cthead>\u003Ctr>\u003Cth>Pattern\u003C\u002Fth>\u003Cth>Gas par itération (Solidity)\u003C\u002Fth>\u003Cth>Gas par itération (Yul)\u003C\u002Fth>\u003Cth>Économie\u003C\u002Fth>\u003C\u002Ftr>\u003C\u002Fthead>\u003Ctbody>\n\u003Ctr>\u003Ctd>Boucle standard\u003C\u002Ftd>\u003Ctd>~95\u003C\u002Ftd>\u003Ctd>~78\u003C\u002Ftd>\u003Ctd>18 %\u003C\u002Ftd>\u003C\u002Ftr>\n\u003Ctr>\u003Ctd>Avec unchecked\u003C\u002Ftd>\u003Ctd>~80\u003C\u002Ftd>\u003Ctd>~78\u003C\u002Ftd>\u003Ctd>3 %\u003C\u002Ftd>\u003C\u002Ftr>\n\u003Ctr>\u003Ctd>Accès tableau\u003C\u002Ftd>\u003Ctd>~110\u003C\u002Ftd>\u003Ctd>~85\u003C\u002Ftd>\u003Ctd>23 %\u003C\u002Ftd>\u003C\u002Ftr>\n\u003Ctr>\u003Ctd>Copie mémoire\u003C\u002Ftd>\u003Ctd>~120\u003C\u002Ftd>\u003Ctd>~90\u003C\u002Ftd>\u003Ctd>25 %\u003C\u002Ftd>\u003C\u002Ftr>\n\u003C\u002Ftbody>\u003C\u002Ftable>\n\u003Cp>Les économies sont les plus significatives pour les boucles qui accèdent à la mémoire ou au stockage, où l’overhead de Solidity (vérifications de limites, ABI encoding) est le plus élevé.\u003C\u002Fp>\n\u003Ch2 id=\"conclusion\">Conclusion\u003C\u002Fh2>\n\u003Cp>Les boucles et conditionnels en Yul offrent un contrôle fin sur le gas. Les gains les plus importants viennent de l’élimination des vérifications de limites de Solidity, du déroulage des boucles courtes et de l’utilisation de compteurs décroissants.\u003C\u002Fp>\n\u003Cp>Dans le prochain article, nous mettrons en pratique toutes ces techniques en construisant un échange de tokens en Yul pur.\u003C\u002Fp>\n","fr","b0000000-0000-0000-0000-000000000001",true,"2026-03-28T10:44:28.887391Z","Écrivez des boucles for et switch optimisés en gas dans Yul. Analyse du bytecode, benchmarks et patterns d'optimisation.","Yul boucles gas optimisation",null,"index, follow",[21,26,30,34],{"id":22,"name":23,"slug":24,"created_at":25},"c0000000-0000-0000-0000-000000000016","EVM","evm","2026-03-28T10:44:21.513630Z",{"id":27,"name":28,"slug":29,"created_at":25},"c0000000-0000-0000-0000-000000000020","Gas Optimization","gas-optimization",{"id":31,"name":32,"slug":33,"created_at":25},"c0000000-0000-0000-0000-000000000014","Solidity","solidity",{"id":35,"name":36,"slug":37,"created_at":25},"c0000000-0000-0000-0000-000000000018","Yul","yul","Blockchain",[40,46,52],{"id":41,"title":42,"slug":43,"excerpt":44,"locale":12,"category_name":38,"published_at":45},"d0000000-0000-0000-0000-000000000608","La couche d'interoperabilite Ethereum : comment 55+ L2 deviennent une seule chaine","couche-interoperabilite-ethereum-55-l2-deviennent-une-seule-chaine","Ethereum compte 55+ rollups Layer 2, fragmentant la liquidite et l'experience utilisateur. La couche d'interoperabilite Ethereum — combinant messagerie cross-rollup, sequenceurs partages et based rollups — vise a les unifier en un reseau composable unique.","2026-03-28T10:44:45.078068Z",{"id":47,"title":48,"slug":49,"excerpt":50,"locale":12,"category_name":38,"published_at":51},"d0000000-0000-0000-0000-000000000607","Les preuves ZK au-dela des rollups : l'inference IA verifiable sur Ethereum","preuves-zk-au-dela-des-rollups-inference-ia-verifiable-ethereum","Les preuves a connaissance nulle ne sont plus un simple outil de scalabilite. En 2026, zkML permet l'inference IA verifiable on-chain, les ZK coprocesseurs deplacent le calcul lourd hors chaine avec verification on-chain, et de nouveaux systemes de preuve comme SP1 et Jolt rendent tout cela pratique.","2026-03-28T10:44:45.071974Z",{"id":53,"title":54,"slug":55,"excerpt":56,"locale":12,"category_name":38,"published_at":57},"d0000000-0000-0000-0000-000000000584","EIP-7702 en pratique : construire des flux de comptes intelligents apres Pectra","eip-7702-en-pratique-construire-flux-comptes-intelligents-apres-pectra","EIP-7702 permet a tout EOA Ethereum d'agir temporairement comme un contrat intelligent dans une seule transaction. Voici comment implementer les transactions par lots, le parrainage de gas et la recuperation sociale avec la nouvelle primitive d'account abstraction.","2026-03-28T10:44:43.586053Z",{"id":13,"name":59,"slug":60,"bio":61,"photo_url":18,"linkedin":18,"role":62,"created_at":63,"updated_at":63},"Open Soft Team","open-soft-team","The engineering team at Open Soft, building premium software solutions from Bali, Indonesia.","Engineering Team","2026-03-28T08:31:22.226811Z"]