This should work :

str = str.replace(/[^a-z0-9-]/g, '');

Everything between the indicates what your are looking for

1. / is here to delimit your pattern so you have one to start and one to end
2. [] indicates the pattern your are looking for on one specific character
3. ^ indicates that you want every character NOT corresponding to what follows
4. a-z matches any character between 'a' and 'z' included
5. 0-9 matches any digit between '0' and '9' included (meaning any digit)
6. - the '-' character
7. g at the end is a special parameter saying that you do not want you regex to stop on the first character matching your pattern but to continue on the whole string

Then your expression is delimited by / before and after. So here you say "every character not being a letter, a digit or a '-' will be removed from the string".

In your case there are a couple of easy solutions. This first solution uses only basic regex:

[\.\w]+$

This captures every word character \w or period \. from the end $, stopping when it reaches any other type of character. This works because the space is not a word character or a period.

If you would like to select the region you want to remove, you can just use:

.*

Read this as match every character .* until the last space . The reason this matches until the last space, is because the star is a greedy quantifier. This means it matches everything it can, then starts giving back characters as needed for the rest of the pattern to match. To match until the first space, use .*? . The question mark next to the star makes the star lazy. This means the star will match as little as it has to in order for the next part of the expression to find a match.

However, capture groups are ideal for problems like this, where you would like to remove part of a line and keep the rest. A simple formula for this is:

^(.*)pattern_to_remove(.*)$

You can then recover the rest using backreferences. These store the capture groups (anything in parenthesis) from you regex into preset variables. In the pattern above, this would be \1\2 or 2 depending on the language you are using. This brings me to probably the easiest answer to your problem:

(.*)

The first capture group contains everything after the space. This regex is very straightforward and easy to read. Move to the first space , then capture everything after (.*).

For a comprehensive reference on regex, check out regular-expressions.info. Here is a link to the page on capture groups.

You may use a regex that will match the first [....] followed with [ and capture that part into a group (that you will be able to refer to via a backreference), and then match 1+ chars other than ] to replace them with your replacement:

var str = "asd[595442/A][30327][0]";
var strToReplace = "30333";
console.log(str.replace(/(\[[^\]]*]\[)[^\]]*/, "$1" + strToReplace));

var strDesiredResult = "asd[595442/A][30333][0]";
console.log(strDesiredResult);

The /(\[[^\]]*]\[)[^\]]*/ has no gmodifier, it will be looking for one match only.

Since regex engine searches a string for a match from left to right, you will get the first match from the left.

The \[[^\]]*]\[ matches [, then any 0+ chars other than ] and then ][. The (...) forms a capturing group #1, it will remember the value that you will be able to get into the replacement with $1 backreference. [^\]]* matches 0+ chars other than ] and this will be replaced.

Details:

• ( - a capturing group start
  • \[ - a literal [ symbol (if unescaped, it starts a character class)
  • [^\]]* - a negated character class that matches zero or more (due to the * quantifier)
  • ] - a literal ] (outside a character class, it does not have to be escaped)
  • \[ - a literal [
• ) - end of capturing group #1 (its value can be accessed with $1 backreference from the replacement pattern)
• [^\]]* - 0+ (as the * quantifier matches zero or more occurrences, replace with + if you need to only match where there is 1 or more occurrences) chars other than ] (inside a character class in JS regex, ] must be escaped in any position).

You can do it this with two replace's

//let stw be "John Smith $100,000.00 M"

sb_trim = Regex.Replace(stw, @"\s+\$|\s+(?=\w+$)", ",");
//sb_trim becomes "John Smith,100,000.00,M"

sb_trim = Regex.Replace(sb_trim, @"(?<=\d),(?=\d)|[.]0+(?=,)", "");
//sb_trim becomes "John Smith,100000,M"

sw.WriteLine(sb_trim);