Vous pouvez utiliser cette

const regex = /\*(.*?[^\\])\*/gm;
const str = `some text *some number \\* other number* blah blah *some number \\* other number* more text`;
const subst = `<strong>$1</strong>`;

// The substituted value will be contained in the result variable
const result = str.replace(regex, subst);
const finalResult = result.replace(/\\(.)/g,'$1')   //replacing escaped character here

console.log(finalResult);

Ceci utilise l'expression régulière ci-dessus pour trouver * jusqu'au dernier * . Et qu'avec \\ (.) , je trouve le caractère échappé et je le remplace par le groupe capturé.

const regex = /\*(.*)\*/gm;
const str = `some text *some number \\* other number* more text`;
const subst = `<strong>$1</strong>`;

// The substituted value will be contained in the result variable
const result = str.replace(regex, subst);
const finalResult = result.replace(/\\(.)/,'$1')   //replacing escaped character here

console.log(finalResult);

MISE À JOUR: Pour faire correspondre plus d'une sous-chaîne

\*(.*)\*

Vous pouvez utiliser

var str = "some text *some number \\* other number* more text";
console.log(
 str.replace(/((?:^|[^\\])(?:\\{2})*)\*([^\\*]*(?:\\[\s\S][^*\\]*)*)\*/g, 
   function($0, $1, $2) { return $1 + '<strong>' + $2.replace(/\\([\s\S])/g, '$1') + '</strong>'; }
 )
)

Le premier / ((?: ^ | [^ \\]) (?: \\ {2}) *) \ * ([^ \\ *] * (?: \ \ [\ s \ S] [^ * \\] *) *) \ * / g regex correspond à toutes les chaînes de * sans échappement :

• ((?: ^ | [^ \\]) (?: \\ {2}) *) - Groupe 1:
  • (?: ^ | [^ \\]) - début de chaîne ou non-barre oblique inverse
  • (?: \\ {2}) * - 0+ occurrences de double barre oblique inverse (cela évite de faire correspondre * échappé)
• \ * - un * caractère
• ([^ \\ *] * (?: \\ [\ s \ S] [^ * \\] *) *) - Groupe 2:
  • [^ \\ *] * - 0+ caractères autres que \ et *
  • (?: \\ [\ s \ S] [^ * \\] *) * - 0+ séquences de
    • \\ [\ s \ S] - un \ et n'importe quel caractère
    • [^ * \\] * - 0+ caractères autres que \ et *
• \ * - un caractère * .

La correspondance est passée à la méthode anonyme comme deuxième argument de la méthode replace et le contenu du groupe 2 est traité pour "unescape" toute séquence d'échappement avec . replace (/ \\ ([\ s \ S]) / g, '$ 1') : \\ correspond à une barre oblique inverse et ([\ s \ S]) correspond et capture n'importe quel caractère du groupe 1, et c'est ce qui reste après le remplacement par l'espace réservé du groupe $1.

Il pourrait y avoir un moyen plus simple d'accomplir la même tâche en utilisant l'expression régulière suivante:

var str = `some text *some number \\* other number* more text`

console.log(str.replace(/\\.|\*((\\.|[^*])+)\*/g, function(match, $1) {
	return $1 ? '<strong>' + $1 + '</strong>' : match;
}));

L'idée correspond à une chaîne désirée devrait se produire après que tous les caractères échappés sont consommés. Nous essayons de faire correspondre tous les caractères échappés en utilisant le premier côté de l'alternance, puis à la deuxième tentative, nous voulons faire correspondre notre modèle souhaité s'il existe.

Code JS:

\\.|\*((\\.|[^*])+)\*

Breakdown:

• \\. Faire correspondre un caractère échappé
• | Ou
• \ * Correspond à un littéral *
• ( Début du premier groupe de capture
  • ( Début du deuxième groupe de capture
    • \\. Faire correspondre un caractère échappé
    • | Ou
    • [^ *] + Correspond à tout sauf *
  • ) + Fin du deuxième groupe de capture, répéter une ou plusieurs fois
  • ) Fin du premier groupe de capture
• \ * Correspond à un littéral *