Regex para obter string entre chaves

Infelizmente, apesar de ter tentado aprender regex pelo menos uma vez por ano durante tantos anos quanto consigo me lembrar, sempre me esqueço de usá-los com pouca frequência. Este ano, minha resolução de ano novo é não tentar aprender regex novamente - então, este ano, para me salvar das lágrimas, vou entregá-lo ao Stack Overflow . (Último remix de Natal).

Quero passar uma string neste formato {getThis}e retornar a string getThis. Alguém poderia me ajudar a cumprir minha resolução de ano novo?

Perguntas relacionadas no Stack Overflow:

• Como alguém pode transformar aspas regulares (ou seja, ', ") em aspas LaTeX / TeX (ou seja,`', `` '')
• Regex: para puxar uma sub-string entre duas tags em uma string
• Regex para substituir todos \ n em uma String, mas não aqueles dentro da tag [code] [/ code]

Se sua string será sempre nesse formato, uma regex é um exagero:

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

substring(1significa iniciar um caractere (logo após o primeiro {) e ,g.length-1)significa levar caracteres até (mas não incluindo) o caractere no comprimento da string menos um. Isso funciona porque a posição é baseada em zero, ou seja, g.length-1é a última posição.

Para leitores que não sejam o autor da postagem original: Se tiver que ser uma regex, use /{([^}]*)}/se quiser permitir strings vazias ou /{([^}]+)}/se quiser corresponder apenas quando houver pelo menos um caractere entre as chaves. Demolir:

• /: inicia o padrão regex
  • {: uma chave literal
    • (: começar a capturar
      • [: comece a definir uma classe de personagens para capturar
        • ^}: "qualquer coisa diferente de }"
      • ]: OK, essa é toda a nossa definição de classe
      • *: qualquer número de caracteres correspondentes à classe que acabamos de definir
    • ): captura concluída
  • }: uma chave literal deve seguir imediatamente o que capturamos
• /: termina o padrão regex

Experimentar

/{(.*?)}/

Isso significa que combine qualquer caractere entre {e}, mas não seja ganancioso - combine a string mais curta que termina com} (o? Para * de ser ganancioso). Os parênteses permitem que você extraia a parte correspondente.

Outra forma seria

/{([^}]*)}/

Corresponde a qualquer caractere, exceto a} char (outra maneira de não ser ganancioso)

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

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

Experimente isto:

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

Por exemplo

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

vai voltar gskinner.com, ssd.sd.

Aqui está uma solução simples usando substituição de javascript

var st = '{getThis}';

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

Como a resposta aceita acima aponta, o problema original é facilmente resolvido com substring, mas usar substituir pode resolver os casos de uso mais complicados

Se você tem uma string como "randomstring999 [fieldname]", você usa um padrão ligeiramente diferente para obter fieldname

var nameAttr = "randomstring999[fieldname]";

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

Este funciona no Textmate e corresponde a tudo em um arquivo CSS entre as chaves.

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

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

Se você quiser mais poder retornar o conteúdo, envolva-o em mais um conjunto de parênteses da seguinte forma:

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

e você pode acessar o conteúdo por meio de $ 1.

Isso também funciona para funções, mas não testei com chaves aninhadas.

Você deseja usar regex lookahead e lookbehind. Isso fornecerá apenas o que está dentro das chaves:

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

Tente isto

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 para obter matrizes de string com chaves entre chaves ocorre na string, em vez de apenas encontrar a primeira ocorrência.

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

Procurei outras respostas e parece que falta uma lógica vital nelas. ou seja, selecione tudo entre dois colchetes CONSECUTIVOS, mas NÃO os colchetes

então, aqui está minha resposta

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

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

O mais simples, .replace(/.*{(.*)}.*/, '$1')infelizmente, retorna a string inteira se a regex não corresponder. O trecho de código acima pode detectar uma correspondência mais facilmente.

Tente este, de acordo com http://www.regextester.com ele funciona para js normalmente.

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

Você pode usar essa recursão regex para corresponder a tudo, até mesmo outro {}(como um texto JSON):

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

Até mesmo isso me ajuda a tentar resolver o problema de alguém,

Divida o conteúdo entre colchetes ( {}) com um padrão como {'day': 1, 'count': 100},.

Por exemplo:

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

Resultado:

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