Regex para obtener una cadena entre llaves

Desafortunadamente, a pesar de haber tratado de aprender expresiones regulares al menos una vez al año durante tantos años como puedo recordar, siempre lo olvido, ya que las uso con poca frecuencia. Este año, mi resolución de año nuevo es no intentar aprender a regex nuevamente, así que este año, para salvarme de las lágrimas, se lo daré a Stack Overflow . (Remix de la última Navidad).

Quiero pasar una cadena en este formato {getThis}y que se me devuelva la cadena getThis. ¿Alguien podría ayudarme a cumplir con mi resolución de año nuevo?

Preguntas relacionadas sobre Stack Overflow:

• ¿Cómo se pueden convertir las comillas regulares (es decir, ', ") en comillas LaTeX / TeX (es decir,`', `` '')
• Regex: para extraer una subcadena entre dos etiquetas en una cadena
• Regex para reemplazar todos \ n en una cadena, pero no los que están dentro de la etiqueta [código] [/ código]

Si su cadena siempre tendrá ese formato, una expresión regular es excesiva:

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

substring(1significa comenzar un carácter en (justo después del primero {) y ,g.length-1)significa tomar caracteres hasta (pero sin incluir) el carácter en la longitud de la cadena menos uno. Esto funciona porque la posición está basada en cero, g.length-1es decir, es la última posición.

Para lectores que no sean el póster original: si tiene que ser una expresión regular, utilícela /{([^}]*)}/si desea permitir cadenas vacías o /{([^}]+)}/si solo desea hacer coincidir cuando haya al menos un carácter entre las llaves. Descompostura:

• /: inicia el patrón de expresiones regulares
  • {: una llave literalmente rizada
    • (: empezar a capturar
      • [: comienza a definir una clase de personajes para capturar
        • ^}: "cualquier cosa que no sea }"
      • ]: OK, esa es nuestra definición de clase completa
      • *: cualquier número de caracteres que coincida con esa clase que acabamos de definir
    • ): terminado de capturar
  • }: una llave literal debe seguir inmediatamente a lo que capturamos
• /: finalizar el patrón de expresiones regulares

Tratar

/{(.*?)}/

Eso significa que debe coincidir con cualquier carácter entre {y}, pero no sea codicioso: busque la cadena más corta que termine en} (el? Deja de ser codicioso). Los paréntesis le permiten extraer la parte correspondiente.

Otra forma seria

/{([^}]*)}/

Esto coincide con cualquier carácter excepto un} char (otra forma de no ser codicioso)

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

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

Prueba esto:

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

Por ejemplo

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

volverá gskinner.com, ssd.sd.

Aquí hay una solución simple usando javascript replace

var st = '{getThis}';

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

Como señala la respuesta aceptada anterior, el problema original se resuelve fácilmente con la subcadena, pero el uso de reemplazar puede resolver los casos de uso más complicados

Si tiene una cadena como "randomstring999 [fieldname]", utiliza un patrón ligeramente diferente para obtener fieldname

var nameAttr = "randomstring999[fieldname]";

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

Este funciona en Textmate y coincide con todo en un archivo CSS entre las llaves.

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

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

Si desea poder devolver más el contenido, envuélvalo todo en un paréntesis más de la siguiente manera:

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

y puede acceder a los contenidos a través de $ 1.

Esto también funciona para funciones, pero no lo he probado con llaves anidadas.

Desea utilizar la búsqueda anticipada y la retrospectiva de expresiones regulares. Esto le dará solo lo que está dentro de las llaves:

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

Prueba esto

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 obtener matrices de cadenas con llaves encerradas ocurre en cadena, en lugar de simplemente encontrar la primera aparición.

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

He examinado las otras respuestas y parece que les falta una lógica vital. es decir, seleccione todo entre dos corchetes CONSECUTIVOS, pero NO los corchetes

así que aquí está mi respuesta

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

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

.replace(/.*{(.*)}.*/, '$1')Desafortunadamente, el más simple devuelve la cadena completa si la expresión regular no coincide. El fragmento de código anterior puede detectar más fácilmente una coincidencia.

Pruebe este, de acuerdo con http://www.regextester.com , normalmente funciona para js .

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

Puede usar esta recursividad de expresiones regulares para hacer coincidir todo, incluso otro {}(como un texto JSON):

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

Incluso esto me ayuda mientras trato de resolver el problema de alguien,

Dividir el contenido dentro de llaves ( {}) que tiene un patrón como, {'day': 1, 'count': 100}.

Por ejemplo:

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

Salida:

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