Regex pour obtenir une chaîne entre accolades

Malheureusement, malgré avoir essayé d'apprendre les regex au moins une fois par an pendant autant d'années que je me souvienne, j'oublie toujours car je les utilise si rarement. Cette année, ma résolution du nouvel an est de ne pas essayer d'apprendre à nouveau l'expression régulière - Donc cette année, pour me sauver des larmes, je la donnerai à Stack Overflow . (Dernier remix de Noël).

Je veux passer une chaîne dans ce format {getThis}et recevoir la chaîne getThis. Quelqu'un pourrait-il m'aider à m'en tenir à ma résolution du nouvel an?

Questions connexes sur Stack Overflow:

• Comment transformer des guillemets réguliers (ie ', ") en guillemets LaTeX / TeX (ie`', `` '')
• Regex: pour extraire une sous-chaîne entre deux balises dans une chaîne
• Regex pour tout remplacer \ n dans une chaîne, mais pas dans la balise [code] [/ code]

Si votre chaîne sera toujours de ce format, une expression régulière est excessive:

>>> var g='{getThis}';
>>> g.substring(1,g.length-1)
"getThis"

substring(1signifie commencer un caractère dans (juste après le premier {) et ,g.length-1)signifie prendre des caractères jusqu'à (mais non compris) le caractère à la longueur de la chaîne moins un. Cela fonctionne car la position est basée sur zéro, c'est-à-dire g.length-1la dernière position.

Pour les lecteurs autres que l'affiche originale: s'il doit s'agir d'une expression régulière, utilisez cette option /{([^}]*)}/si vous souhaitez autoriser les chaînes vides, ou /{([^}]+)}/si vous souhaitez effectuer une correspondance uniquement lorsqu'il y a au moins un caractère entre les accolades. Panne:

• /: démarrer le modèle regex
  • {: une accolade littérale
    • (: commencer à capturer
      • [: commencez à définir une classe de caractères à capturer
        • ^}: "autre chose que }"
      • ]: OK, c'est toute notre définition de classe
      • *: n'importe quel nombre de caractères correspondant à cette classe que nous venons de définir
    • ): capture terminée
  • }: une accolade littérale doit immédiatement suivre ce que nous avons capturé
• /: terminer le modèle regex

Essayer

/{(.*?)}/

Cela signifie, correspond à n'importe quel caractère entre {et}, mais ne soyez pas gourmand - correspond à la chaîne la plus courte qui se termine par} (le? Arrête * d'être gourmand). Les parenthèses vous permettent d'extraire la partie correspondante.

Une autre façon serait

/{([^}]*)}/

Cela correspond à n'importe quel caractère sauf un} char (une autre façon de ne pas être gourmand)

/\{([^}]+)\}/

/        - delimiter
\{       - opening literal brace escaped because it is a special character used for quantifiers eg {2,3}
(        - start capturing
[^}]     - character class consisting of
    ^    - not
    }    - a closing brace (no escaping necessary because special characters in a character class are different)
+        - one or more of the character class
)        - end capturing
\}       - the closing literal brace
/        - delimiter

Essaye ça:

/[^{\}]+(?=})/g

Par exemple

Welcome to RegExr v2.1 by #{gskinner.com},  #{ssd.sd} hosted by Media Temple!

sera de retour gskinner.com, ssd.sd.

Voici une solution simple utilisant javascript replace

var st = '{getThis}';

st = st.replace(/\{|\}/gi,''); // "getThis"

Comme le souligne la réponse acceptée ci-dessus, le problème d'origine est facilement résolu avec une sous-chaîne, mais l'utilisation de replace peut résoudre les cas d'utilisation les plus compliqués.

Si vous avez une chaîne comme "randomstring999 [fieldname]", vous utilisez un modèle légèrement différent pour obtenir fieldname

var nameAttr = "randomstring999[fieldname]";

var justName = nameAttr.replace(/.*\[|\]/gi,''); // "fieldname"

Celui-ci fonctionne dans Textmate et correspond à tout ce qui se trouve dans un fichier CSS entre les accolades.

\{(\s*?.*?)*?\}

selector {. . matches here including white space. . .}

Si vous souhaitez pouvoir renvoyer davantage le contenu, placez-le dans un autre jeu de parenthèses comme ceci:

\{((\s*?.*?)*?)\}

et vous pouvez accéder au contenu via $ 1.

Cela fonctionne également pour les fonctions, mais je ne l'ai pas testé avec des accolades imbriquées.

Vous voulez utiliser lookahead et lookbehind regex. Cela ne vous donnera que ce qui se trouve à l'intérieur des accolades:

(?<=\{)(.*?)(?=\})

Essaye ça

let path = "/{id}/{name}/{age}";
const paramsPattern = /[^{\}]+(?=})/g;
let extractParams = path.match(paramsPattern);
console.log("extractParams", extractParams) // prints all the names between {} = ["id", "name", "age"]

L'expression régulière pour obtenir des tableaux de chaînes avec des accolades entourées se produit dans une chaîne, plutôt que de simplement rechercher la première occurrence.

 /\{([^}]+)\}/gm 

J'ai examiné les autres réponses et une logique vitale semble leur manquer. c'est-à-dire, sélectionnez tout entre deux crochets CONSÉCUTIFS, mais PAS les crochets

alors, voici ma réponse

\{([^{}]+)\}

var re = /{(.*)}/;
var m = "{helloworld}".match(re);
if (m != null)
    console.log(m[0].replace(re, '$1'));

Le plus simple .replace(/.*{(.*)}.*/, '$1')renvoie malheureusement la chaîne entière si l'expression régulière ne correspond pas. L'extrait de code ci-dessus peut détecter plus facilement une correspondance.

Essayez celui-ci, selon http://www.regextester.com cela fonctionne normalement pour js .

([^{]*?)(?=\})

Vous pouvez utiliser cette récursivité regex pour faire correspondre tout entre les deux, même un autre {}(comme un texte JSON):

\{([^()]|())*\}

Même cela m'aide en essayant de résoudre le problème de quelqu'un,

Diviser le contenu à l' intérieur des accolades ( {}) ayant un motif analogue, {'day': 1, 'count': 100}.

Par exemple:

#include <iostream> 
#include <regex> 
#include<string> 
using namespace std; 

int main() 
{ 
    //string to be searched
    string s = "{'day': 1, 'count': 100}, {'day': 2, 'count': 100}";

    // regex expression for pattern to be searched 
    regex e ("\\{[a-z':, 0-9]+\\}");
    regex_token_iterator<string::iterator> rend;

    regex_token_iterator<string::iterator> a ( s.begin(), s.end(), e );
    while (a!=rend) cout << " [" << *a++ << "]";
    cout << endl;

    return 0; 
}

Production:

[{'day': 1, 'count': 100}] [{'day': 2, 'count': 100}]