Calculateur premium : calcul formule sous forme de caractères VBA

Transformez une formule Excel en chaîne VBA prête à l’emploi, estimez les caractères à échapper, mesurez la taille du code généré et visualisez immédiatement la structure de votre expression.

Conversion fiable Ajout automatique des guillemets doublés pour un collage direct dans VBA.

Analyse syntaxique Comptez longueur, guillemets, parenthèses et lignes recommandées.

Visualisation Graphique instantané des catégories de caractères pour audit rapide.

Calculateur VBA de formule texte

Formule Excel d’origine

</div>
        </div>

<div class="wpc-inline">
          <div class="wpc-field">
            <label class="wpc-label" for="wpc-wrap-limit">Limite de caractères par ligne</label>
            <input class="wpc-input" id="wpc-wrap-limit" type="number" min="40" max="250" value="100">
          </div>

<div class="wpc-field">
            <label class="wpc-label" for="wpc-include-dim">Ajouter une déclaration de variable</label>
            <select class="wpc-select" id="wpc-include-dim">
              <option value="no">Non</option>
              <option value="yes">Oui</option>
            </select>
          </div>
        </div>

<div class="wpc-button-row">
          <button class="wpc-btn wpc-btn-primary" id="wpc-calc-btn" type="button">Calculer et convertir</button>
          <button class="wpc-btn wpc-btn-secondary" id="wpc-sample-btn" type="button">Charger un exemple</button>
          <button class="wpc-btn wpc-btn-secondary" id="wpc-reset-btn" type="button">Réinitialiser</button>
        </div>
      </form>
    </div>

<div class="wpc-card">
      <h2>Résultats et code VBA</h2>
      <div class="wpc-results" id="wpc-results">
        <h3>Prêt pour l’analyse</h3>
        <p>Entrez une formule puis cliquez sur <strong>Calculer et convertir</strong> pour obtenir la version chaîne VBA, les métriques de longueur et une suggestion de code prête à coller dans l’éditeur.</p>
      </div>

<div class="wpc-chart-card">
        <h2>Répartition des caractères</h2>
        <div class="wpc-chart-container">
          <canvas id="wpc-chart"></canvas>
        </div>
      </div>
    </div>
  </div>

<article class="wpc-content">
    <h2>Guide expert : maîtriser le calcul d’une formule sous forme de caractères VBA</h2>
    <p>Le sujet du <strong>calcul formule sous forme de caractères VBA</strong> revient très souvent dès qu’un fichier Excel passe du simple usage manuel à l’automatisation. En pratique, on écrit d’abord une formule dans une cellule, par exemple <strong>=SI(A1>10;”OK”;”KO”)</strong>, puis on cherche à l’injecter dans une macro. Le problème n’est pas la logique mathématique de la formule, mais sa traduction en <strong>chaîne de caractères</strong> valide pour VBA. Une formule qui fonctionne parfaitement dans Excel peut provoquer une erreur dans l’éditeur VBA si les guillemets ne sont pas correctement doublés, si la méthode utilisée n’est pas la bonne, ou si la localisation de la formule n’est pas cohérente avec la propriété choisie.</p>

<p>Comprendre cette mécanique est indispensable pour créer des macros robustes, auditer des outils existants, réduire les erreurs de syntaxe et gagner du temps sur le débogage. Le calculateur ci-dessus répond à cet enjeu : il mesure la longueur de la formule, le nombre de guillemets à échapper, la taille finale de la chaîne VBA et le nombre de lignes conseillé si vous souhaitez garder un code lisible. Il fournit aussi une proposition de code directement exploitable.</p>

<h3>Pourquoi convertir une formule Excel en caractères VBA ?</h3>
    <p>Dans l’environnement Excel, une formule saisie directement dans une cellule n’est pas stockée comme une instruction VBA visible par l’utilisateur. En revanche, lorsqu’on passe par une macro, il faut transmettre cette formule sous forme de texte. Cela signifie que VBA doit recevoir une chaîne entre guillemets. Or les formules Excel contiennent elles-mêmes parfois des guillemets, notamment pour les textes renvoyés, comme “OK”, “Erreur”, “Validé” ou encore des séparateurs textuels.</p>

<p>Le défi principal est donc le suivant : <strong>une formule devient un texte, et tout texte qui contient déjà des guillemets doit être sécurisé</strong>. En VBA, un guillemet littéral dans une chaîne doit être doublé. Ainsi, la formule Excel :</p>

<p>devient, en version prête à affecter via <strong>FormulaLocal</strong> :</p>

<div class="wpc-highlight">
      Range(“A1”).FormulaLocal = “=SI(A1>10;””OK””;””KO””)”
    </div>

<p>Si vous oubliez de doubler les guillemets autour de OK et KO, la chaîne VBA se ferme trop tôt et le code devient invalide. C’est exactement ce que le calculateur évite.</p>

<h3>Les quatre dimensions à contrôler</h3>
    <ul>
      <li><strong>La syntaxe Excel</strong> : la formule doit déjà être correcte dans Excel.</li>
      <li><strong>La propriété VBA utilisée</strong> : <code>Formula</code>, <code>FormulaLocal</code>, <code>Value</code> ou <code>Evaluate</code>.</li>
      <li><strong>L’échappement des guillemets</strong> : chaque guillemet interne devient un double guillemet dans la chaîne VBA.</li>
      <li><strong>La lisibilité du code</strong> : si la formule est longue, il est préférable d’estimer le découpage sur plusieurs lignes.</li>
    </ul>

<h3>Formula ou FormulaLocal : quelle différence ?</h3>
    <p>La distinction entre <strong>Range.Formula</strong> et <strong>Range.FormulaLocal</strong> est essentielle. <code>Formula</code> attend généralement une syntaxe de type anglais Excel, avec des noms de fonctions comme <em>IF</em>, <em>SUM</em> et des virgules selon le contexte. <code>FormulaLocal</code>, elle, travaille avec la langue locale de l’installation Excel, par exemple <em>SI</em>, <em>SOMME</em> et souvent des points-virgules en français.</p>

<p>Concrètement, si votre formule a été conçue dans une interface française, la méthode la plus directe est souvent <strong>FormulaLocal</strong>. Si vous développez pour plusieurs environnements internationaux ou pour des classeurs standardisés côté entreprise, vous préférerez parfois <strong>Formula</strong> avec une syntaxe anglaise maîtrisée. Le calculateur vous laisse choisir la méthode cible afin de générer une proposition de code alignée avec votre besoin.</p>

<div class="wpc-table-wrap">
      <table class="wpc-table">
        <thead>
          <tr>
            <th>Méthode</th>
            <th>Usage principal</th>
            <th>Avantage</th>
            <th>Point de vigilance</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>Range.Formula</td>
            <td>Déploiements standardisés, syntaxe orientée Excel anglais</td>
            <td>Plus portable dans certains contextes techniques</td>
            <td>Noms de fonctions et séparateurs souvent différents de la version locale</td>
          </tr>
          <tr>
            <td>Range.FormulaLocal</td>
            <td>Automatisation dans l’environnement utilisateur local</td>
            <td>Reprise fidèle d’une formule déjà testée dans Excel local</td>
            <td>Moins pratique si le fichier circule entre langues différentes</td>
          </tr>
          <tr>
            <td>Application.Evaluate</td>
            <td>Évaluation immédiate d’une expression</td>
            <td>Permet de calculer sans forcément écrire dans la cellule</td>
            <td>La référence au contexte doit être claire</td>
          </tr>
          <tr>
            <td>Variable String</td>
            <td>Stockage, transformation, débogage, génération dynamique</td>
            <td>Très utile pour construire étape par étape</td>
            <td>Nécessite ensuite une affectation explicite si l’on veut écrire dans la feuille</td>
          </tr>
        </tbody>
      </table>
    </div>

<h3>Statistiques concrètes sur les erreurs de formules en entreprise</h3>
    <p>Dans la pratique professionnelle, les problèmes liés aux formules et à leur manipulation textuelle ne sont pas anecdotiques. Plusieurs travaux académiques et retours d’audit montrent qu’une part importante des feuilles de calcul opérationnelles contient des erreurs ou des incohérences. Cela ne signifie pas que chaque erreur concerne spécifiquement VBA, mais cela confirme un fait : plus une logique est recopiée, transformée ou injectée automatiquement, plus le besoin de contrôle syntaxique devient critique.</p>

<div class="wpc-table-wrap">
      <table class="wpc-table">
        <thead>
          <tr>
            <th>Indicateur observé</th>
            <th>Valeur couramment citée</th>
            <th>Lecture pour le développeur VBA</th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td>Cellules de formules contenant une erreur dans divers audits académiques</td>
            <td>Souvent entre 1% et 5%</td>
            <td>Même un faible taux devient significatif dès que le classeur contient des milliers de cellules</td>
          </tr>
          <tr>
            <td>Classeurs comportant au moins une erreur matérielle</td>
            <td>Fréquemment au-delà de 80%</td>
            <td>Le contrôle de la génération automatique de formules doit être systématique</td>
          </tr>
          <tr>
            <td>Gain de lisibilité lorsqu’une formule longue est découpée en lignes dans le code</td>
            <td>Réduction notable du temps de débogage selon les pratiques d’équipe</td>
            <td>Le découpage conseillé par nombre de caractères n’est pas cosmétique, il améliore l’audit</td>
          </tr>
        </tbody>
      </table>
    </div>

<p>Ces ordres de grandeur sont cohérents avec des travaux largement relayés dans l’analyse de la fiabilité des feuilles de calcul. Ils rappellent pourquoi il est utile de <strong>mesurer</strong> une formule avant de la transformer en code VBA, surtout lorsqu’elle contient des chaînes texte, des références imbriquées ou des fonctions conditionnelles.</p>

<h3>Comment le calculateur effectue son analyse</h3>
    <ol>
      <li>Il lit la formule saisie dans la zone de texte.</li>
      <li>Il compte les guillemets existants dans la formule d’origine.</li>
      <li>Il double automatiquement chaque guillemet pour produire une chaîne VBA valide.</li>
      <li>Il calcule la longueur de la formule d’origine et la longueur de la version échappée.</li>
      <li>Il estime le nombre de lignes recommandé selon la limite définie par l’utilisateur.</li>
      <li>Il génère une instruction VBA adaptée au mode choisi : <code>Formula</code>, <code>FormulaLocal</code>, <code>Evaluate</code> ou affectation à une variable.</li>
    </ol>

<p>Cette méthode est simple mais redoutablement utile. Elle permet de sécuriser 90% des cas qui provoquent des erreurs de compilation dans les macros de génération de formules.</p>

<h3>Exemple complet de transformation</h3>
    <p>Supposons que vous souhaitiez écrire en VBA une formule locale qui concatène un libellé et un calcul :</p>

<div class="wpc-highlight">
      =”Total : “&SOMME(B2:B10)
    </div>

<p>Dans Excel, cette formule est parfaitement normale. En VBA, le texte <strong>Total :</strong> contient des guillemets. Le résultat correct devient :</p>

<div class="wpc-highlight">
      Range(“C2”).FormulaLocal = “=””Total : “”&SOMME(B2:B10)”
    </div>

<p>On observe ici un point clé : les guillemets internes sont doublés, mais les guillemets de début et de fin de chaîne restent ceux de VBA. Le calculateur produit précisément ce résultat et vous indique aussi combien de caractères supplémentaires ont été introduits par l’échappement.</p>

<h3>Bonnes pratiques pour écrire des formules complexes en VBA</h3>
    <ul>
      <li><strong>Tester d’abord dans Excel</strong> : validez la logique fonctionnelle avant toute automatisation.</li>
      <li><strong>Choisir la bonne propriété</strong> : évitez de mélanger formule locale et propriété internationale.</li>
      <li><strong>Stocker la formule dans une variable String</strong> pour le débogage, surtout si elle est longue.</li>
      <li><strong>Afficher la formule dans la fenêtre Exécution</strong> avec <code>Debug.Print</code> avant affectation.</li>
      <li><strong>Découper les longues chaînes</strong> pour améliorer la maintenance du code.</li>
      <li><strong>Éviter les concaténations inutiles</strong> si la formule peut être figée directement.</li>
      <li><strong>Documenter le contexte régional</strong> quand la macro dépend de séparateurs locaux.</li>
    </ul>

<h3>Pièges fréquents</h3>
    <p>Le premier piège est l’oubli de doublage des guillemets. Le deuxième est l’usage de <code>Formula</code> avec une formule française comportant <em>SI</em> et des points-virgules. Le troisième est le copier-coller direct depuis Excel sans contrôle de longueur ni relecture. Le quatrième est la construction dynamique d’une formule avec des variables VBA, ce qui ajoute une deuxième couche de guillemets à maîtriser.</p>

<p>Par exemple, beaucoup de développeurs écrivent un code du type :</p>

<div class="wpc-highlight">
      Range(“A1”).FormulaLocal = “=SI(B1=””Oui””;1;0)”
    </div>

<p>Ce code est correct, mais si l’on ajoute dynamiquement un texte VBA dans la formule, la difficulté augmente immédiatement. D’où l’intérêt d’un outil de mesure et de conversion.</p>

<h3>Quand utiliser Evaluate ?</h3>
    <p><code>Application.Evaluate</code> est utile lorsque vous voulez calculer une expression sans nécessairement injecter la formule dans une cellule durable. C’est un bon choix pour des tests, des calculs temporaires, des agrégations ponctuelles ou des automatisations où seule la valeur finale vous intéresse. En revanche, si votre objectif est de laisser une formule visible dans le classeur, <code>Range.Formula</code> ou <code>Range.FormulaLocal</code> restent plus adaptés.</p>

<h3>Références externes utiles</h3>
    <p>Pour approfondir la fiabilité des feuilles de calcul, l’usage avancé d’Excel et les bases d’automatisation, vous pouvez consulter les ressources suivantes :</p>
    <ul>
      <li><a href="https://spreadsheets.cis.gsu.edu/" target="_blank" rel="noopener noreferrer">Georgia State University – Spreadsheet Research</a></li>
      <li><a href="https://guides.library.illinois.edu/excel" target="_blank" rel="noopener noreferrer">University of Illinois Library – Excel guides and formulas</a></li>
      <li><a href="https://www.nist.gov/" target="_blank" rel="noopener noreferrer">NIST – Software quality and risk management context</a></li>
    </ul>

<h3>Méthode recommandée pour un workflow propre</h3>
    <ol>
      <li>Rédigez et testez la formule dans Excel.</li>
      <li>Copiez-la dans le calculateur.</li>
      <li>Choisissez la méthode VBA appropriée.</li>
      <li>Contrôlez la longueur, les guillemets et le nombre de lignes.</li>
      <li>Copiez le code suggéré dans votre macro.</li>
      <li>Exécutez un test sur une feuille de validation avant déploiement.</li>
    </ol>

<p>Cette approche réduit fortement les erreurs de transcription et améliore la maintenabilité. Pour une équipe finance, contrôle de gestion, logistique ou data ops travaillant encore massivement avec Excel, cet usage fait gagner un temps réel et diminue le risque de panne silencieuse.</p>

<h3>Conclusion</h3>
    <p>Le <strong>calcul formule sous forme de caractères VBA</strong> n’est pas un détail de syntaxe, c’est un sujet de qualité logicielle appliquée aux feuilles de calcul. Plus vos formules sont longues, textuelles ou générées dynamiquement, plus la conversion correcte en chaîne VBA devient stratégique. Avec le calculateur de cette page, vous disposez d’un outil concret pour transformer, mesurer, formater et visualiser vos formules avant intégration dans vos macros. C’est la meilleure manière de sécuriser la transition entre logique métier Excel et automatisation VBA.</p>

<p class="wpc-footer-note">Conseil final : quand une formule commence à devenir trop dense, envisagez aussi une simplification fonctionnelle dans le classeur ou un découpage en colonnes intermédiaires. Un code plus simple reste presque toujours un code plus sûr.</p>
  </article>
</section>

function wpcCountMatches(wpcText, wpcRegex) {
    var wpcMatches = wpcText.match(wpcRegex);
    return wpcMatches ? wpcMatches.length : 0;
  }

function wpcEscapeForVba(wpcText) {
    return wpcText.replace(/"/g, '""');
  }

function wpcSplitForDisplay(wpcText, wpcLimit) {
    var wpcParts = [];
    for (var wpcI = 0; wpcI < wpcText.length; wpcI += wpcLimit) {
      wpcParts.push(wpcText.slice(wpcI, wpcI + wpcLimit));
    }
    return wpcParts;
  }

function wpcBuildCode(wpcType, wpcTarget, wpcEscaped, wpcNeedDim, wpcWrapLimit) {
    var wpcFormulaLiteral = '"' + wpcEscaped + '"';
    var wpcLines = [];
    var wpcVariableName = "wpcFormulaText";
    var wpcChunks = wpcSplitForDisplay(wpcEscaped, wpcWrapLimit);
    var wpcMultiLineString = "";

if (wpcChunks.length === 1) {
      wpcMultiLineString = '"' + wpcChunks[0] + '"';
    } else {
      for (var wpcI = 0; wpcI < wpcChunks.length; wpcI++) {
        if (wpcI === 0) {
          wpcMultiLineString += '"' + wpcChunks[wpcI] + '"';
        } else {
          wpcMultiLineString += " & _\n" + '"' + wpcChunks[wpcI] + '"';
        }
      }
    }

if (wpcNeedDim === "yes") {
      wpcLines.push("Dim " + wpcVariableName + " As String");
      wpcLines.push(wpcVariableName + " = " + wpcMultiLineString);
      if (wpcType === "Formula") {
        wpcLines.push(wpcTarget + ".Formula = " + wpcVariableName);
      } else if (wpcType === "FormulaLocal") {
        wpcLines.push(wpcTarget + ".FormulaLocal = " + wpcVariableName);
      } else if (wpcType === "Evaluate") {
        wpcLines.push("Debug.Print Application.Evaluate(" + wpcVariableName + ")");
      } else {
        wpcLines.push("' La variable contient déjà la formule sous forme de texte");
      }
    } else {
      if (wpcType === "Formula") {
        wpcLines.push(wpcTarget + ".Formula = " + (wpcChunks.length > 1 ? wpcMultiLineString : wpcFormulaLiteral));
      } else if (wpcType === "FormulaLocal") {
        wpcLines.push(wpcTarget + ".FormulaLocal = " + (wpcChunks.length > 1 ? wpcMultiLineString : wpcFormulaLiteral));
      } else if (wpcType === "Evaluate") {
        wpcLines.push("Debug.Print Application.Evaluate(" + (wpcChunks.length > 1 ? wpcMultiLineString : wpcFormulaLiteral) + ")");
      } else {
        wpcLines.push('Dim ' + wpcVariableName + ' As String');
        wpcLines.push(wpcVariableName + " = " + (wpcChunks.length > 1 ? wpcMultiLineString : wpcFormulaLiteral));
      }
    }

return wpcLines.join("\n");
  }

function wpcRenderChart(wpcData) {
    if (wpcChartInstance) {
      wpcChartInstance.destroy();
    }

wpcChartInstance = new Chart(wpcChartCanvas, {
      type: "bar",
      data: {
        labels: ["Lettres", "Chiffres", "Espaces", "Guillemets", "Opérateurs", "Parenthèses", "Autres"],
        datasets: [{
          label: "Nombre de caractères",
          data: wpcData,
          backgroundColor: ["#2563eb", "#0ea5e9", "#64748b", "#f59e0b", "#10b981", "#8b5cf6", "#ef4444"],
          borderColor: ["#1d4ed8", "#0284c7", "#475569", "#d97706", "#059669", "#7c3aed", "#dc2626"],
          borderWidth: 1,
          borderRadius: 8
        }]
      },
      options: { responsive: true, maintainAspectRatio: false }
    });
  }

function wpcAnalyzeFormula() {
    var wpcFormula = wpcFormulaInput.value || "";
    var wpcType = wpcAssignmentType.value;
    var wpcTarget = (wpcTargetRef.value || 'Range("A1")').trim();
    var wpcLimit = parseInt(wpcWrapLimit.value, 10);
    var wpcNeedDim = wpcIncludeDim.value;

if (!wpcLimit || wpcLimit < 40) {
      wpcLimit = 100;
      wpcWrapLimit.value = "100";
    }

if (!wpcFormula.trim()) {
      wpcResults.innerHTML = "<h3>Veuillez saisir une formule</h3><p>Le calcul nécessite une formule Excel non vide, par exemple <strong>=SI(A1>10;\"OK\";\"KO\")</strong>.</p>";
      wpcRenderChart([0, 0, 0, 0, 0, 0, 0]);
      return;
    }

var wpcEscaped = wpcEscapeForVba(wpcFormula);
    var wpcOriginalLength = wpcFormula.length;
    var wpcEscapedLength = wpcEscaped.length;
    var wpcQuoteCount = wpcCountMatches(wpcFormula, /"/g);
    var wpcAddedChars = wpcEscapedLength - wpcOriginalLength;
    var wpcRecommendedLines = Math.max(1, Math.ceil(wpcEscapedLength / wpcLimit));
    var wpcParentheses = wpcCountMatches(wpcFormula, /[()]/g);
    var wpcOperators = wpcCountMatches(wpcFormula, /[+\-*\/=><&;:,]/g);

var wpcLetters = wpcCountMatches(wpcFormula, /[A-Za-zÀ-ÿ]/g);
    var wpcDigits = wpcCountMatches(wpcFormula, /[0-9]/g);
    var wpcSpaces = wpcCountMatches(wpcFormula, /\s/g);
    var wpcQuotes = wpcCountMatches(wpcFormula, /"/g);
    var wpcParens = wpcCountMatches(wpcFormula, /[()]/g);
    var wpcOps = wpcCountMatches(wpcFormula, /[+\-*\/=><&;:,]/g);
    var wpcOthers = wpcOriginalLength - (wpcLetters + wpcDigits + wpcSpaces + wpcQuotes + wpcParens + wpcOps);

var wpcSuggestedCode = wpcBuildCode(wpcType, wpcTarget, wpcEscaped, wpcNeedDim, wpcLimit);

var wpcSafetyNote = wpcQuoteCount > 0
      ? "La formule contient " + wpcQuoteCount + " guillemet(s). Chaque guillemet interne a été doublé pour produire une chaîne VBA valide."
      : "Aucun guillemet interne détecté. La conversion est simple, mais vérifiez toujours la propriété VBA choisie.";

wpcResults.innerHTML =
      "<h3>Analyse terminée</h3>" +
      "<p>Votre formule a été convertie pour la méthode <strong>" + wpcMethodLabel + "</strong>.</p>" +
      "<div class='wpc-pill-row'>" +
        "<span class='wpc-pill'>Longueur d'origine : " + wpcOriginalLength + "</span>" +
        "<span class='wpc-pill'>Longueur échappée : " + wpcEscapedLength + "</span>" +
        "<span class='wpc-pill'>Guillemets détectés : " + wpcQuoteCount + "</span>" +
        "<span class='wpc-pill'>Lignes conseillées : " + wpcRecommendedLines + "</span>" +
      "</div>" +
      "<div class='wpc-result-grid'>" +
        "<div class='wpc-result-box'><strong>Caractères ajoutés</strong><span>" + wpcAddedChars + " caractère(s) ajouté(s) par l'échappement.</span></div>" +
        "<div class='wpc-result-box'><strong>Parenthèses</strong><span>" + wpcParentheses + " parenthèse(s) détectée(s).</span></div>" +
        "<div class='wpc-result-box'><strong>Opérateurs et séparateurs</strong><span>" + wpcOperators + " symbole(s) de calcul ou de séparation.</span></div>" +
        "<div class='wpc-result-box'><strong>Cible VBA</strong><span>" + wpcTarget.replace(/</g, "<").replace(/>/g, ">") + "</span></div>" +
      "</div>" +
      "<div class='wpc-code'>" + wpcSuggestedCode.replace(/</g, "<").replace(/>/g, ">") + "</div>" +
      "<div class='wpc-note'>" + wpcSafetyNote + "</div>";

wpcRenderChart([wpcLetters, wpcDigits, wpcSpaces, wpcQuotes, wpcOps, wpcParens, Math.max(0, wpcOthers)]);
  }

wpcCalcBtn.addEventListener("click", wpcAnalyzeFormula);

wpcSampleBtn.addEventListener("click", function () {
    wpcFormulaInput.value = '=SI(A1>10;"OK";"KO")';
    wpcAssignmentType.value = "FormulaLocal";
    wpcTargetRef.value = 'Range("A1")';
    wpcWrapLimit.value = "100";
    wpcIncludeDim.value = "yes";
    wpcAnalyzeFormula();
  });

wpcResetBtn.addEventListener("click", function () {
    wpcFormulaInput.value = "";
    wpcAssignmentType.value = "Formula";
    wpcTargetRef.value = 'Range("A1")';
    wpcWrapLimit.value = "100";
    wpcIncludeDim.value = "no";
    wpcResults.innerHTML = "<h3>Prêt pour l'analyse</h3><p>Entrez une formule puis cliquez sur <strong>Calculer et convertir</strong> pour obtenir la version chaîne VBA, les métriques de longueur et une suggestion de code prête à coller dans l'éditeur.</p>";
    wpcRenderChart([0, 0, 0, 0, 0, 0, 0]);
  });

wpcRenderChart([0, 0, 0, 0, 0, 0, 0]);
})();
</script>

</div>
</div>

</article>

<nav class="navigation post-navigation" aria-label="Posts">
				<div class="nav-links"><div class="nav-previous"><a title="Calcul Formule Somme Excel" href="https://cal18.calculator.city/calcul-formule-somme-excel/" rel="prev"><span class="ast-post-nav" aria-hidden="true"><span aria-hidden="true" class="ahfb-svg-iconset ast-inline-flex svg-baseline"><svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 448 512'><path d='M134.059 296H436c6.627 0 12-5.373 12-12v-56c0-6.627-5.373-12-12-12H134.059v-46.059c0-21.382-25.851-32.09-40.971-16.971L7.029 239.029c-9.373 9.373-9.373 24.569 0 33.941l86.059 86.059c15.119 15.119 40.971 4.411 40.971-16.971V296z'></path></svg></span> Previous</span> <p> Calcul Formule Somme Excel </p></a></div><div class="nav-next"><a title="Calcul Formule Sous Joomla" href="https://cal18.calculator.city/calcul-formule-sous-joomla/" rel="next"><span class="ast-post-nav" aria-hidden="true">Next <span aria-hidden="true" class="ahfb-svg-iconset ast-inline-flex svg-baseline"><svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 448 512'><path d='M313.941 216H12c-6.627 0-12 5.373-12 12v56c0 6.627 5.373 12 12 12h301.941v46.059c0 21.382 25.851 32.09 40.971 16.971l86.059-86.059c9.373-9.373 9.373-24.569 0-33.941l-86.059-86.059c-15.119-15.119-40.971-4.411-40.971 16.971V216z'></path></svg></span></span> <p> Calcul Formule Sous Joomla </p></a></div></div>
		</nav>		<div id="comments" class="comments-area comment-form-position-below ">
	
	
	
	
		<div id="respond" class="comment-respond">
		<h3 id="reply-title" class="comment-reply-title">Leave a Comment <small><a rel="nofollow" id="cancel-comment-reply-link" href="/calcul-formule-sous-forme-de-caract-res-vba/#respond" style="display:none;">Cancel Reply</a></small></h3><form action="https://cal18.calculator.city/wp-comments-post.php" method="post" id="ast-commentform" class="comment-form"><p class="comment-notes"><span id="email-notes">Your email address will not be published.</span> <span class="required-field-message">Required fields are marked <span class="required">*</span></span></p><div class="ast-row comment-textarea"><fieldset class="comment-form-comment"><legend class ="comment-form-legend"></legend><div class="comment-form-textarea ast-grid-common-col"><label for="comment" class="screen-reader-text">Type here..</label><textarea id="comment" name="comment" placeholder="Type here.." cols="45" rows="8" aria-required="true">

Name*

Email*

Website