Develop Reference

How to format mobile phone number with country code using regex

I have been trying to format properly the phone number so that all country can use at least. I am trying to use this format to accept as many regions as possible
Here is my pattern
$pattern = '^\+[0-9]?()[0-9](\s|\S)(\d[0-9]{9})$^';
the pattern matches well these formats but once I add a country code with 3 digits and space, it
fails
+441213315000
+1 2323214316
+2923432432432
I would like to match this format
+225 0546568022

Use
^\+[0-9]{1,3} ?[0-9]{10}$
See regex proof.
EXPLANATION
--------------------------------------------------------------------------------
^ the beginning of the string
--------------------------------------------------------------------------------
\+ '+'
--------------------------------------------------------------------------------
[0-9]{1,3} any character of: '0' to '9' (between 1
and 3 times (matching the most amount
possible))
--------------------------------------------------------------------------------
? ' ' (optional (matching the most amount
possible))
--------------------------------------------------------------------------------
[0-9]{10} any character of: '0' to '9' (10 times)
--------------------------------------------------------------------------------
$ before an optional \n, and the end of the
string
PHP:
preg_match('/^\+[0-9]{1,3} ?[0-9]{10}$/', $string)
JavaScript:
/^\+[0-9]{1,3} ?[0-9]{10}$/.test(string)

Unlike our friend. I tried to fix your own pattern:
^\+([0-9][0-9]?[0-9]?)(\ )?([0-9]{10})$
Note that i've removed the ^ from end of pattern because it represents start of a new line!
This guy is your friend: https://regex101.com/
Good luck

RegEx for match whole word in sentences - javascript

Trying to work out what the right RegEx would be for finding "s***" in a series of strings, e.g:
match for "find s*** in s*** foobar"
match for "s***"
don't match for "s******"
don't match for "s****** foobar"
I'm using a match because I want to count the number of instances of matches in the sentence. I was trying "s*{3}" as a starting point, and variations on $ and \b or \B but I can't quite figure it out.
I created some tests here to try it out, if that's helpful.
https://regex101.com/r/VdLyOY/2

You may use this regex with a negative lookahead:
/\bs\*{3}(?!\*)/g
RegEx Demo
or with a positive lookahead:
/\bs\*{3}(?=\s|$)/g
RegEx Details:
\bs: Match letter s after a word bounday
\*{3}: Match * 3 times i.e. ***
(?!\*): Negative lookahead to assert that we don't have a * ahead
(?=\s|$): Positive lookahead to assert that we have a whitespace or line end at next position

/\bs\*{3}(\s|$)/g might work depending on exactly what your criteria are.

Use
/\bs\*{3}\B(?!\*)/g
See proof
EXPLANATION
EXPLANATION
--------------------------------------------------------------------------------
\b the boundary between a word char (\w) and
something that is not a word char
--------------------------------------------------------------------------------
s 's'
--------------------------------------------------------------------------------
\*{3} '*' (3 times)
--------------------------------------------------------------------------------
\B the boundary between two word chars (\w)
or two non-word chars (\W)
--------------------------------------------------------------------------------
(?! look ahead to see if there is not:
--------------------------------------------------------------------------------
\* '*'
--------------------------------------------------------------------------------
) end of look-ahead

Regex to exclude an entire line match if certain characters found

I'm stuck on the cleanest way to accomplish two bits of regex. Every solution I've come up with so far seems clunky.
Example text
Match: Choose: blah blah blah 123 for 100'ish characters, this matches
NoMatch: Choose: blah blah blah 123! for 100'ish characters?, .this potential match fails for the ! ? and .
The first regex (?:^\w+?:)(((?![.!?]).)*)$ needs to:
Match a line containing any word followed by a : so long as !?. are not found in the same line (the word: will always be at the beginning of a line)
Ideally, match every part of the line from the example EXCEPT Choose:. Matching the whole line is still a win.
The second regex ^(^\w+?:)(?:(?![.!?]).)*$ needs to:
Match a line containing any word followed by a : so long as !?. are not found in the same line (the word: will always be at the beginning of a line)
Match only Choose:
The regex is in a greasemonkey/tampermonkey script.

Use
^\w+:(?:(?!.*[.!?])(.*))?
See proof.
EXPLANATION
NODE EXPLANATION
--------------------------------------------------------------------------------
^ the beginning of the string
--------------------------------------------------------------------------------
\w+ word characters (a-z, A-Z, 0-9, _) (1 or
more times (matching the most amount
possible))
--------------------------------------------------------------------------------
: ':'
--------------------------------------------------------------------------------
(?: group, but do not capture (optional
(matching the most amount possible)):
--------------------------------------------------------------------------------
(?! look ahead to see if there is not:
--------------------------------------------------------------------------------
.* any character except \n (0 or more
times (matching the most amount
possible))
--------------------------------------------------------------------------------
[.!?] any character of: '.', '!', '?'
--------------------------------------------------------------------------------
) end of look-ahead
--------------------------------------------------------------------------------
( group and capture to \1:
--------------------------------------------------------------------------------
.* any character except \n (0 or more
times (matching the most amount
possible))
--------------------------------------------------------------------------------
) end of \1
--------------------------------------------------------------------------------
)? end of grouping

Does this do what you want?
(?:^\w+:)((?:(?![!?.]).)*)$
What makes you feel that this is clunky?
(?: ... ) non-capturing group
^ start with
\w+: a series of one or more word characters followed by a :
( ... )$ capturing group that continues to the end
(?: ... )* non-capturing group, repeated zero or more times, with
(?! ... ) negative look-ahead: no following character can be
[!?.] either ?, ! or .
. followed by any character

For the first pattern, you could first check that there is no ! ? or . present using a negative lookahead. Then capture in the first group 1+ word chars and : and the rest of the line in group 2.
^(?![^!?.\n\r]*[!?.])(\w+:)(.*)$
^ Start of string
(?! Negative lookahead, assert what is on the right is not
[^!?.\n\r]*[!?.] Match 0+ times any char except the listed using contrast, then match either ! ? .
) Close lookahead
(\w+:) Capture group 1, match 1+ word chars and a colon
(.*) Capture group 2, match any char except a newline 0+ times
$ End of string
Regex demo
For the second part, if you want a match only for Choose:, you could use the negative lookahead only without a capturing group.
^(?![^!?.\n\r]*[!?.])\w+:
Regex demo

Regex - starts with a particular string but does not end with another substring

Given two strings s1 and s2, I am trying to write a regex that will match a string that starts with s1 but does not end with s2
Example (s1=TEST, s2=BAD)
TEST-101 match
TEST-SOME-DESC match
TEST-101-BAD should not match
TEST-SOME-DESC-BAD should not match
Here is what I tried for this example but it does not work: /^TEST-.*((?!BAD))$/

Try this:
/^(?!.+BAD$)TEST-.*/
This matches the start, goes ahead and rejects anything ending in the bad string, then matches the desired pattern.
Here's a demo that passes all four of your tests (click "RUN TESTS" at the bottom to verify).

You can use startsWith and endsWith
let arr = [`TEST-101`, `TEST-SOME-DESC`,`TEST-101-BAD`,`TEST-SOME-DESC-BAD`]
arr.forEach(e=>{
console.log(e, e.startsWith('TEST') && !e.endsWith('BAD'))
})

Use in JavaScript:
/^TEST-(?!.*BAD$).*/
In Ruby:
/\ATEST-(?!.*BAD\z).*/
See regex proof.
EXPLANATION
--------------------------------------------------------------------------------
^ / \A the beginning of the string
--------------------------------------------------------------------------------
TEST- 'TEST-'
--------------------------------------------------------------------------------
(?! look ahead to see if there is not:
--------------------------------------------------------------------------------
.* any character except \n (0 or more times
(matching the most amount possible))
--------------------------------------------------------------------------------
BAD 'BAD'
--------------------------------------------------------------------------------
$ / \z the end of the string
--------------------------------------------------------------------------------
) end of look-ahead
--------------------------------------------------------------------------------
.* any character except \n (0 or more times
(matching the most amount possible))

Javascript Regex Input Validation to Prevent Duplicate Characters

I am attempting to validate text input with the following requirements:
allowed characters & length /^\w{8,15}$/
must contain /[a-z]+/
must contain /[A-Z]+/
must contain /[0-9]+/
must not contain repeated characters (ie. aba=pass and aab=fail)
Each test would return true when used with .test().
With modest familiarity, I am able to write the first 4 tests, albeit individually. The 5th test is not working out, negated lookahead (which is what i believe i need to be using) is challenging.
Here are a few value/result examples:
re.test("Fail1");//returns false, too short
re.test("StringFailsRule1");//returns false, too long
re.test("Fail!");//returns false, invalid !
re.test("FAILRULE2");//returns false, missing [a-z]+
re.test("failrule3");//returns false, missing [A-Z]+
re.test("failRuleFour");//returns false, missing [0-9]+
re.test("failRule55");//returns false, repeat of "5"
re.test("TestValue1");//returns true
Finally, the ideal would be a single combined test used to enforce all requirements.

This uses negative and positive lookaheads zero-length assertions for your tests and the .{8,15} bit validates length.
^(?!.*(.)\1)(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])\w{8,15}$
For your fifth rule I used a negative lookahead to make sure that a capture group of any character is never followed by itself.
Regexpal demo
NODE EXPLANATION
--------------------------------------------------------------------------------
^ the beginning of the string
--------------------------------------------------------------------------------
(?! look ahead to see if there is not:
--------------------------------------------------------------------------------
.* any character except \n (0 or more times
(matching the most amount possible))
--------------------------------------------------------------------------------
( group and capture to \1:
--------------------------------------------------------------------------------
. any character except \n
--------------------------------------------------------------------------------
) end of \1
--------------------------------------------------------------------------------
\1 what was matched by capture \1
--------------------------------------------------------------------------------
) end of look-ahead
--------------------------------------------------------------------------------
(?= look ahead to see if there is:
--------------------------------------------------------------------------------
.* any character except \n (0 or more times
(matching the most amount possible))
--------------------------------------------------------------------------------
[a-z] any character of: 'a' to 'z'
--------------------------------------------------------------------------------
) end of look-ahead
--------------------------------------------------------------------------------
(?= look ahead to see if there is:
--------------------------------------------------------------------------------
.* any character except \n (0 or more times
(matching the most amount possible))
--------------------------------------------------------------------------------
[A-Z] any character of: 'A' to 'Z'
--------------------------------------------------------------------------------
) end of look-ahead
--------------------------------------------------------------------------------
(?= look ahead to see if there is:
--------------------------------------------------------------------------------
.* any character except \n (0 or more times
(matching the most amount possible))
--------------------------------------------------------------------------------
[0-9] any character of: '0' to '9'
--------------------------------------------------------------------------------
) end of look-ahead
--------------------------------------------------------------------------------
\w{8,15} word characters (a-z, A-Z, 0-9, _)
(between 8 and 15 times (matching the most
amount possible))
--------------------------------------------------------------------------------
$ before an optional \n, and the end of the
string