javascript - test - Regex para obtener una cuerda entre llaves "{Quiero lo que hay entre las llaves}"

javascript regex test

Question

Desafortunadamente, a pesar de haber tratado de aprender a extraer la expresión regular al menos una vez al año durante tantos años como puedo recordar, siempre me olvido ya que los uso con poca frecuencia. Este año la resolución de mi nuevo año es no intentar aprender geometría nuevamente - Así que este año para salvarme de las lágrimas, se lo daré a Stack Overflow . (Última remezcla de Navidad).

Quiero pasar una cadena en este formato {getThis} y devolver la cadena getThis . ¿Podría alguien ayudarme a mantener la resolución de mi nuevo año?

Preguntas relacionadas sobre desbordamiento de pila:

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

Answer 1

Éste funciona en Textmate y combina todo en un archivo CSS entre llaves.

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

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

Si desea poder devolver el contenido, envuelva todo en un conjunto más de paréntesis como sigue:

/{((/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.

Answer 2

Aquí hay una solución simple que usa javascript replace

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

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

Si tiene una cadena como "randomstring999 [nombre de campo]", utiliza un patrón ligeramente diferente para obtener el nombre de campo

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

Answer 3

Desea usar regex lookahead y lookbehind. Esto le dará solo lo que está dentro de las llaves:

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

Answer 4

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

entonces, aquí está mi respuesta

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

Answer 5

Prueba este, según http://www.regextester.com , funciona para js normaly.

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

Answer 6

Prueba esto:

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

Por ejemplo

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

devolverá gskinner.com , ssd.sd

Answer 7

Puedes usar esta recursión regex para hacer coincidir todo en medio, incluso otro {} (como un texto JSON):

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

Answer 8

Regex para obtener series de cadenas con llaves incluidas en cadena, en lugar de solo encontrar la primera aparición.

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

Answer 9

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

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

Answer 10

Tratar

/{(.*?)}/

Eso significa, unir cualquier personaje entre {y}, pero no seas codicioso: haz coincidir el hilo más corto que termina con} (el "stop" es codicioso). Los paréntesis le permiten extraer la parte coincidente.

Otra forma sería

/{([^}]*)}/

Esto coincide con cualquier personaje excepto a} char (otra forma de no ser codicioso)

Answer 11

//{([^}]+)/}/
/ - 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

Answer 12

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

El simple .replace(/.*{(.*)}.*/, ''$1'') desafortunadamente 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.