Regex per ottenere una stringa tra parentesi graffe

Sfortunatamente, nonostante abbia provato a imparare le espressioni regolari almeno una volta all'anno per tutti gli anni che riesco a ricordare, me ne dimentico sempre perché le uso così di rado. Quest'anno il mio proposito per il nuovo anno è di non provare a imparare di nuovo le espressioni regolari - Quindi quest'anno per salvarmi dalle lacrime lo darò a Stack Overflow . (Last Christmas remix).

Voglio passare una stringa in questo formato {getThis}e ricevere la stringa getThis. Qualcuno potrebbe essere di aiuto per aiutarmi a rispettare i miei propositi per il nuovo anno?

Domande correlate su Stack Overflow:

• Come si possono trasformare virgolette regolari (es. ', ") In virgolette LaTeX / TeX (es.' ',` `' ')
• Regex: per estrarre una sottostringa tra due tag in una stringa
• Regex per sostituire tutto \ n in una stringa, ma non quelli all'interno del tag [code] [/ code]

Se la tua stringa sarà sempre di quel formato, una regex è eccessiva:

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

substring(1significa iniziare un carattere in (appena dopo il primo {) e ,g.length-1)significa prendere caratteri fino a quando (ma non includendo) il carattere alla lunghezza della stringa meno uno. Questo funziona perché la posizione è a base zero, cioè g.length-1è l'ultima posizione.

Per lettori diversi dal poster originale: se deve essere una regex, usa /{([^}]*)}/se vuoi consentire stringhe vuote, o /{([^}]+)}/se vuoi trovare una corrispondenza solo quando c'è almeno un carattere tra le parentesi graffe. Abbattersi:

• /: avvia il pattern regex
  • {: una parentesi graffa letterale
    • (: inizia a catturare
      • [: inizia a definire una classe di caratteri da catturare
        • ^}: "qualsiasi cosa diversa da }"
      • ]: OK, questa è la nostra intera definizione di classe
      • *: qualsiasi numero di caratteri corrispondente alla classe appena definita
    • ): cattura completata
  • }: una parentesi graffa letterale deve seguire immediatamente ciò che abbiamo catturato
• /: termina il pattern regex

Provare

/{(.*?)}/

Ciò significa che trova qualsiasi carattere tra {e}, ma non essere avido: trova la stringa più breve che termina con} (il? Smette * di essere avido). Le parentesi ti consentono di estrarre la parte corrispondente.

Un altro modo sarebbe

/{([^}]*)}/

Corrisponde a qualsiasi carattere eccetto un carattere} (un altro modo per non essere avido)

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

/        - 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

Prova questo:

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

Per esempio

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

tornerà gskinner.com, ssd.sd.

Ecco una semplice soluzione utilizzando la sostituzione di javascript

var st = '{getThis}';

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

Come la risposta accettata sopra sottolinea il problema originale è facilmente risolvibile con la sottostringa, ma l'uso di sostituzione può risolvere i casi d'uso più complicati

Se hai una stringa come "randomstring999 [fieldname]", utilizzi un pattern leggermente diverso per ottenere fieldname

var nameAttr = "randomstring999[fieldname]";

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

Questo funziona in Textmate e corrisponde a tutto in un file CSS tra le parentesi graffe.

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

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

Se vuoi essere ulteriormente in grado di restituire il contenuto, racchiudi tutto in un altro set di parentesi in questo modo:

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

e puoi accedere ai contenuti tramite $ 1.

Funziona anche per le funzioni, ma non l'ho testato con parentesi graffe annidate.

Vuoi usare le espressioni regolari lookahead e lookbehind. Questo ti darà solo ciò che c'è dentro le parentesi graffe:

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

Prova questo

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"]

Regex per ottenere matrici di stringhe con parentesi graffe racchiuse si verifica in stringa, invece di trovare solo la prima occorrenza.

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

Ho esaminato le altre risposte e sembra che manchi una logica vitale. cioè, seleziona tutto tra due parentesi CONSECUTIVE, ma NON le parentesi

quindi, ecco la mia risposta

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

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

Il più semplice .replace(/.*{(.*)}.*/, '$1')purtroppo restituisce l'intera stringa se la regex non corrisponde. Lo snippet di codice sopra può rilevare più facilmente una corrispondenza.

Prova questo, secondo http://www.regextester.com funziona normalmente per js .

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

Puoi usare questa ricorsione regex per abbinare tutto, anche un altro {}(come un testo JSON):

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

Anche questo mi aiuta mentre cerco di risolvere il problema di qualcuno,

Dividere il contenuto all'interno parentesi graffe ( {}) aventi un disegno tipo, {'day': 1, 'count': 100}.

Per esempio:

#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; 
}

Produzione:

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