Regular expression to verify that string contains { } - regex

Question

I need to write a regular expression to verify that a string contains { } but not { or }.Can someone shine some light on this please?
Thanks for all the help , here are some examples.
e.g.
valid : {abc}, as09{02}dd, {sdjafkl}sdjk, sfdsjakl,00{00}00, aaaaa{d}
invalid: {sdsf , sdfadf},sdf{Sdfs ,333}333
*********Update*******************
^[a-zA-Z0-9_-. ](?:{[a-zA-Z0-9_-.]+})?[a-zA-Z0-9_-. ]$ is what I need,thanks for all your help :)

Answer 1

/.*\{.*\}.*/
This would ensure that the string contains an opening curly bracket somewhere before a closing curly bracket, occurring anywhere in the string. However, it wouldn't be able to ensure that there's only one opening and closing curly bracket -- to do that, the .* patterns would have to be changed to something more restrictive.
If you want to experiment and test these regexes out, here's a good site.

Answer 2

What flavor of regex? In JavaScript, for instance, this'll do it:
var re = /\{.*\}/;
alert("A: " + re.test("This {is} a match"));
alert("B: " + re.test("This {is not a match"));
alert("C: " + re.test("This } is not a match"));
Alerts A: true, B: false, and C: false.
Most other flavors will be similar.

Answer 3

For this problem regex-based solution is way too heavy.
If you have the opportunity of NOT using regexes - don't, simpler statement(s) can handle it just fine.
Even much general problem - checking, if the use of (potentially nested) parentheses is correct - is solvable using simple one-pass loop.
I.e. this is correct
{}{{{}{}}}
while this isn't
{{}
Solution in python (easy to translate to other language):
def check(s):
counter = 0
for character in s:
if character == "{":
counter += 1
elif character == "}":
counter -= 1
if counter < 0:
# not valid
return False
if counter == 0:
# valid
return True
else:
return False

Answer 4

There is exactly one opening brace and exactly one closing brace in the string, and the closing brace follows the opening brace:
^[^\{\}]\{[^\{\}]\}[^\{\}]$
There any number of braces in the string, but they are not nested (there is never another opening brace before the previous one has been closed), and they are always balanced:
^[^\{\}](\{[^\{\}]\})*[^\{\}]$
Nesting cannot be generally solved by regular expressions.