Can we make [Regex case-insensitive in *C#*][6]? : **Yes**

> Set option inline via [`(?i)` pattern construct][3] or via [`RegexOptions.IgnoreCase`][4] param

Can we make [Regex case-insensitive in *JavaScript*][7]? : **Yes**

> Set flag via [<code>/pattern/flags</code>][8] syntax or the insensitive flag `/REGEX/i`

(*Aside*) Can we make [Regex case-insensitive in *HTML5 Pattern Attribute*?][5] : **No**


As Chris R. Timmons points out on [`RegularExpressionValidator` doesn't ignore case][2]: 

> There is no property in the RegularExpressionValidator control that
allows regex options to be set.

> If your control does both client-side and server-side validation, **the
regex must use a subset of regular expression syntax that both
JS and .NET can execute**. In this case, to make a regex ignore
case it is necessary to use a character class construct like `[a-zA-Z]`
to match both upper and lower case characters.

> If your validation is done on the server-side only, you can use the
more powerful .NET regular expression syntax. In this case, you can
place the `(?i)` option at the beginning of the regex to tell it to
ignore case.

So, if you want to use the out of the box validator, you're stuck with Geoff's solution of using character sets like this: `[aA]`


[2]: https://www.thecodingforums.com/threads/regularexpressionvalidator-doesnt-ignore-case.79327/
[3]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference#regular-expression-options
[4]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-options
[5]: https://stackoverflow.com/a/5525111/1366033
[6]: https://stackoverflow.com/a/2439976/1366033
[7]: https://stackoverflow.com/q/3939715/1366033
[8]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Advanced_searching_with_flags_2

Given this regular expression: `"^[0-9]*\s*(lbs|kg|kgs)$"`  how do I make it case insensitive?  I am trying to use this in a .net regular expression validator, so I need to specify case insensitivity in the pattern.

**I can not use the RegexOptions programatically because I am specifying the regular expression in a RegularExpressionValidator**

Make regular expression case insensitive in ASP.NET RegularExpressionValidator

As noted in [this answer][0], if you're using **node.js** (fair assumption if you're dealing with file paths) - you can use the [`path`][1] module, call [`path.parse`][2], and retrieve the directory name with `dir` like this:

```js
const path = require("path")

let myPath = "folder/path/file.txt"
let myDir = path.parse(myPath).dir

console.log(myDir) // "folder/path"
```

This should be the most robust way to manage and parse file paths across different environments.

[0]: https://stackoverflow.com/a/58533864/1366033
[1]: https://nodejs.org/api/path.html
[2]: https://nodejs.org/api/path.html#path_path_parse_path

Using Javascript I'd like to remove the filename from the end of a string (path+filename), leaving me just the directory path.

Would regular expressions be ideal? Or, is there a simpler means of doing this using the string object?

Thanks for any help!


----ANSWERED & EXPLAINED---

The purpose of this code was to open finder to a directory. The data I was able to extract included a filename - since I was only trying to open finder (mac) to the location, I needed to strip the filename. Here's what I ended up with:

    var theLayer = app.project.activeItem.selectedLayers[0];
    //get the full path to the selected file
    var theSpot = theLayer.source.file.fsName;
    //strip filename from the path
    var r = /[^\/]*$/;
    var dirOnly = theSpot.replace(r, '');
    //use 'system' to open via shell in finder
    popen = "open"
    var runit = system.callSystem(popen+" "+"\""+dirOnly+"\"");

I'd like to remove the filename from a path using JavaScript

To validate cron expressions *in general*, it'll depend greatly on the specific implementation you're using

## Rules

### [General Format][1]

In general, most adhere to the the following format:



| Field name | Mandatory? | Allowed values | Special characters |
| ------------ | ---------- | --------------- | ------------------ |
| Seconds | No\* | 0-59 | `* / , -` |
| Minutes | Yes | 0-59 | `* / , -` |
| Hours | Yes | 0-23 | `* / , -` |
| Day of month | Yes | 1-31 | `* / , - L W` |
| Month | Yes | 1-12 or JAN-DEC | `* / , -` |
| Day of week | Yes | 0-6 or SUN-SAT | `* / , - L #` |
| Year | No\* | 1970–2099 | `* / , -` |



*where seconds and years are non-standard and sometimes not included

### [Predefined Scheduling Macros][2]:

Some flavors allow predefined time periods like this:



| Entry | Equivalent to |
| --------- | --------------- |
| @annually | `0 0 0 1 1 * *` |
| @yearly | `0 0 0 1 1 * *` |
| @monthly | `0 0 0 1 * * *` |
| @weekly | `0 0 0 * * 0 *` |
| @daily | `0 0 0 * * * *` |
| @hourly | `0 0 * * * * *` |
| @reboot | |


### [Intervals][3]

Some flavors allow using the `@every <duration>` syntax with the following timespan units:



| Unit | <a href="https://en.wikipedia.org/wiki/Orders_of_magnitude_(time)">Definition</a> |
| ---------- | --------------------------------------------------------------------------------- |
| `ns` | nanosecond |
| `us`, `µs` | microsecond |
| `ms` | millisecond |
| `s` | second |
| `m` | minute |
| `h` | hour |


## Validating

### Predefined Macros Regex

To validate predefined macros, you can use the [following regex][5]:

```js
/@(annually|yearly|monthly|weekly|daily|hourly|reboot)/
```

Which will pass the following test cases:

```none
@daily
@hourly
```

### `@every` Regex

To validate `@every` durations, you can use the [following regex][6]:

```js
/@every (\d+(ns|us|µs|ms|s|m|h))+/
```

Which will pass the following test cases:

```none
@every 5s
@every 20h30m
```

### Individual Cron Terms

Validating cron terms in the regular expression is a little trickier since there are so many variations.

**Just focusing in on a single term**, the following are all valid:

* Two *or more* numbers separated by a `,`
* Two numbers separated by a `/` or `-`
* A 1-2 digit number
* A single `*`

To validate a single term, we can use the [following regex][7]:

```js
/(\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*/
```

where `\d+` just guarantees you have 1 or more numeric digits

Which will pass the following test cases:

```none
1,2,3
1,2
1/2
1-2
1
*
```

### Combining Cron Terms

To check the full expression, we can just make sure we have `{5,7}` terms with the [following regex][8]:

```js
/(((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*) ?){5,7}/
```

If we wanted to distinguish between each term, we'd need to [validate numbers within a certain range][4]:



| Allowed values | Regex |
| -------------- | --------------------------- |
| 0-59 | `[1-5]?[0-9]` |
| 0-23 | `2[0-3]|1[0-9]|[0-9]` |
| 1-31 | `3[01]|[12][0-9]|[1-9]` |
| 1-12 | `1[0-2]|[1-9]` |
| 0-6 | `[0-6]` |
| 1970–2099 | `19[7-9][0-9]|20[0-9][0-9]` |


If however, we just want to make sure something *looks* like a regex expression without worrying about which term is days vs. hours, the expression stays a lot cleaner, so that's what I'll go with for simplicity

### Putting it all together

By combining the above statements, we can have a relatively simple sanity check that the term looks regex-y with the [following expression][9]:

```js
/(@(annually|yearly|monthly|weekly|daily|hourly|reboot))|(@every (\d+(ns|us|µs|ms|s|m|h))+)|((((\d+,)+\d+|(\d+(\/|-)\d+)|\d+|\*) ?){5,7})/
```

### Additional Resources

* [crontab.guru][10]
* [regexr.com][9]

[1]: https://en.wikipedia.org/wiki/Cron#CRON_expression
[2]: https://en.wikipedia.org/wiki/Cron#Nonstandard_predefined_scheduling_definitions
[3]: https://godoc.org/github.com/robfig/cron#hdr-Intervals
[4]: https://stackoverflow.com/a/57639368/1366033
[5]: https://regexr.com/4jp79
[6]: https://regexr.com/4jp7f
[7]: https://regexr.com/4jp7i
[8]: https://regexr.com/4jp7o
[9]: https://regexr.com/4jp54
[10]: https://crontab.guru/

I need to write an regular expression that matches [Cron time expressions][1], like these ones:

 - 28 2 7 1 1
 - 28 2 7 1 *
 - 28 2 7 * *
 - 28 2 * * *
 - 28 * * * *
 - \* * * * *

  [1]: https://en.wikipedia.org/wiki/Cron

Create a regular expression for Cron statement

`[DataType(DataType.PhoneNumber)]` does not come with any validation logic out of the box. 

According to the [docs][1]: 

> When you apply the `DataTypeAttribute` attribute to a data field you must do the following:
>
> * Issue validation errors as appropriate.

The `[Phone]` Attribute inherits from `[DataType]` and was introduced in .NET Framework 4.5+ and is in .NET Core which does provide it's own flavor of validation logic. So you can use like this:



 [Phone()]
 public string PhoneNumber { get; set; }

However, the out-of-the-box validation for Phone numbers is [pretty permissive][2], so you might find yourself wanting to inherit from DataType and implement your own `IsValid` method or, as others have suggested here, use a [regular expression][3] & `RegexValidator` to constrain input.

**Note**: Use caution with Regex against unconstrained input per the [best practices][4] as .NET has made the [pivot away from regular expressions in their own internal validation logic for phone numbers][5]

[1]: https://learn.microsoft.com/en-us/dotnet/api/System.ComponentModel.DataAnnotations.DataTypeAttribute?view=netframework-4.7.2
[2]: https://source.dot.net/#System.ComponentModel.Annotations.Tests/System/ComponentModel/DataAnnotations/PhoneAttributeTests.cs
[3]: https://stackoverflow.com/questions/9776231/regular-expression-to-validate-us-phone-numbers
[4]: https://learn.microsoft.com/en-us/dotnet/standard/base-types/best-practices
[5]: https://github.com/Microsoft/dotnet/blob/master/Documentation/compatibility/aspnet-472-compat-doc.md

I am trying to use a regular expression to validate a phone number and return an error when an invalid number or phone number is submitted. 
 
**MVC Code**:



 <ol class="row">
 <li class="cell" style="width: 20%;">Phone Number:</li>
 <li class="cell last" style="width: 60%;">
 @Html.TextBoxFor(model => model.PhoneNumber, new { @class = "textbox" }) 
 @Html.ValidationMessageFor(model => model.PhoneNumber)
 </li>
 </ol>



**C# Code**:



 [DataType(DataType.PhoneNumber)]
 [Display(Name = "Phone Number")]
 [Required(ErrorMessage = "Phone Number Required!")]
 [RegularExpression(@"^$?([0-9]{3})$?[-. ]?([0-9]{3})[-. ]?([0-9]{4})$",
 ErrorMessage = "Entered phone format is not valid.")]
 public string PhoneNumber { get; set; }



However, the input box will not show a message to the user indicating that the phone number which was submitted is not valid.

Phone Number Validation MVC

You can actually do this with [**line filters**][1].

1. Select the filter option from the Selection Dialog    
   ![Select Filter][2]
2. Go to the Linefilters tab, enable line filters and then compose a regular expression that *matches* lines you want to filter out.    
  ![Line Filter][3]
3. In the results, it will highlight filtered lines in a different color, but it won't treat them as differences in the individual file or folder summary.  
  ![Filtered Result][4]

----

In your particular case, you'll want to find a regex pattern that matches your naming convention, but something like this should work:

[`@version \$Revision: \d\.\d*`](http://regexr.com/)  

[![Regexr Demo][5]][6]


  [1]: http://manual.winmerge.org/Filters.html
  [2]: https://i.stack.imgur.com/f7EuA.png
  [3]: https://i.stack.imgur.com/8fLca.png
  [4]: https://i.stack.imgur.com/1J4vV.png
  [5]: https://i.stack.imgur.com/qIxOY.png
  [6]: http://regexr.com/3etqn

I have many files containing following types of line -                

    * @version $Revision: 1.xxx  

  
I want this type of line to be ignored while comparing using winmerge. I have tried with line filters. But, till not able to do that.
Can any one help me in this regard?

How to ignore a line containing a specific word using winmerge line filters?

Word boundaries (`\b`) are not characters, but the empty string between a sequence of letters and any non-letter character. Moreover, since Unicode support is still lacking in JavaScript, "letter" mean only ASCII letters.

Because of that, you

* generally shouldn't use `\b` unless your data is some kind of computer language that can't possibly include Unicode
* can't apply quantifiers to `\b` (an empty string times 10 is still one empty string)
* can't negate `\b` (it's not a character set, so it has no complement)
* can't include `\b` in a character set (in square brackets) since, again, it's not a character or character set

Since `\b` doesn't actually add any characters to the match, you can safely append it to your regex:

    /.+?\b/

will match all characters up until the first word boundary. It's in fact a superset of:

    /\w+/

which is probably what you want, since you're interested only in the words, not the stuff in between.

Based off [Regex Until But Not Including](https://stackoverflow.com/q/3850074/1366033), I'm trying to match all characters up until a word boundary. 

For example - matching `apple` in the following string:

<pre><code>apple&lt;
</code></pre>

I'm doing that using: 

* a [**negated set**][charclass] `[^]` 
* with a [**word boundary**][wordboundaries] `\b`
* and a plus `+` [**repeater**][repeat]

Like this:

 /a[^\b]+/

Which should look for an "a" and then grab one or more matches for any character that is not a word boundary. So I would expect it to stop before `<` which is at the end of the word

### [Demo in Regexr][regexr]

### Demo in StackSnippets





 var input = [ "apple<", "apple/" ];
 var myRegex = /a[^\b]+/;

 for (var i = 0; i < input.length; i++) {
 console.log(myRegex.exec(input[i])); 
 }



Couple other regex strings I tried:

I can use a negated word boundary or a negated set with a regular word boundary:

* `/a[\B]+/`
* `/a[^\b]+/`

I can specify several possible word ending characters and use them in a negated set:

* `/a[^|"<>\-\\\/;:,.]+/`

I can also look for a postive set and just restrict it to return for regular letters:

* `/a[\w]+/`
* `/a[a-zA-Z]+/`

But I'd like to know how to do it for a word boundary if that's possible. 

Here's a [MDN's listing of word boundary][1] and the [characters that it constitutes][2]

[charclass]: http://www.regular-expressions.info/charclass.html
[repeat]: http://www.regular-expressions.info/repeat.html
[wordboundaries]: http://www.regular-expressions.info/wordboundaries.html
[regexr]: http://regexr.com/3aruv

[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#special-word-boundary
[2]: http://www.ecma-international.org/ecma-262/5.1/#sec-15.10.2.6

Match all characters up until a word boundary

Here's some readymade regex expressions for a bunch of different [numbers within a certain range][1]:

| Range     | Label        | Regex                                  |
| --------- | ------------ | -------------------------------------- |
| 1 to 12   | hour / month | `1[0-2]|[1-9]`                         |
| 1 to 24   | hour         | `2[0-4]|1[0-9]|[1-9]`                  |
| 1 to 31   | day of month | `3[01]|[12][0-9]|[1-9]`                |
| 1 to 53   | week of year | `5[0-3]|[1-4][0-9]|[1-9]`              |
| 0 to 59   | min / sec    | `[1-5]?[0-9]`                          |
| 0 to 100  | percentage   | `100|[1-9]?[0-9]`                      |
| 0 to 127  | signed byte  | `12[0-7]|1[01][0-9]|[1-9]?[0-9]`       |
| 32 to 126 | ASCII codes  | `12[0-6]|1[01][0-9]|[4-9][0-9]|3[2-9]` |


[1]: https://www.oreilly.com/library/view/regular-expressions-cookbook/9781449327453/ch06s07.html

Regex to allow only number between 1 to 12

 I am trying `(12)|[1-9]\d?` but its not working, please help as i am new to regular expression

Regex to allow only number between 1 to 12

According to the powershell docs on [Regular Expressions > Groups, Captures, and Substitutions][1]:

When using the `-match` operator, powershell will create an [*automatic variable*][2] named **`$Matches`**

```cs
PS> "The last logged on user was CONTOSO\jsmith" -match "(.+was )(.+)"
```

The value returned from this expression is just `true`|`false`, but PS will add the `$Matches` *hashtable*

So if you output `$Matches`, you'll get all capture groups:

```none
PS> $Matches

Name     Value
----     -----
2        CONTOSO\jsmith
1        The last logged on user was
0        The last logged on user was CONTOSO\jsmith
```

And you can access each capture group individually with dot notation like this:

```
PS> "The last logged on user was CONTOSO\jsmith" -match "(.+was )(.+)"
PS> $Matches.2
CONTOSO\jsmith
```

**Additional Resources**:

* To Get Multiple Matches, see [How to capture multiple regex matches][3]
* To Pass Options/Flags, see [Pass regex options to PowerShell `[regex]` type][4]


[1]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_regular_expressions?view=powershell-7#groups-captures-and-substitutions
[2]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_automatic_variables?view=powershell-7#matches
[3]: https://stackoverflow.com/a/24190283/1366033
[4]: https://stackoverflow.com/a/52336328/1366033

I'm trying to extract text from a set of files on Windows using the Powershell (version 4):

 PS > Select-String -AllMatches -Pattern <mypattern-with(capture)> -Path file.jsp | Format-Table

So far, so good. That gives a nice set of `MatchInfo` objects:

	IgnoreCase LineNumber Line Filename Pattern Matches
	---------- ---------- ---- -------- ------- -------
		True 30 ... file.jsp ... {...}

Next, I see that the captures are in the matches member, so I take them out:

 PS > Select-String -AllMatches -Pattern <mypattern-with(capture)> -Path file.jsp | ForEach-Object -MemberName Matches | Format-Table

Which gives:

	Groups Success Captures Index Length Value
	------ ------- -------- ----- ------ -----
	{...} True {...} 49 47 ...

or as list with `| Format-List`:

	Groups : {matched text, captured group}
	Success : True
	Captures : {matched text}
	Index : 39
	Length : 33
	Value : matched text

Here's where I stop, I have no idea how to go further and obtain a list of *captured group* elements.

I've tried adding another `| ForEach-Object -MemberName Groups`, but it seems to return the same as the above.

The closest I get is with `| Select-Object -Property Groups`, which indeed gives me what I'd expect (a list of sets):

	Groups
	------
	{matched text, captured group}
	{matched text, captured group}
	...

But then I'm unable to extract the *captured group* from each of them, I tried with `| Select-Object -Index 1` I get only one of those sets.

---

Update: a possible solution
---------------------------

It seems that by adding `| ForEach-Object { $_.Groups.Groups[1].Value }` I got what I was looking for, but I don't understand why - so I can't be sure I would be able to get the right result when extending this method to whole sets of files.

Why is it working?

As a side note, this `| ForEach-Object { $_.Groups[1].Value }` (i.e. without the second `.Groups`) gives the same result.

I'd like to add that, upon further attempts, it seems the command can be shortened by removing the piped `| Select-Object -Property Groups`.

How to get the captured groups from Select-String?

When using the type <code>numeric(&lt;precision&gt;[,&lt;scale&gt;])</code> (*note*: [`numeric` and `decimal` are synonyms][1]), SQL Server actually stores a *fixed number of spaces to the left and right of the decimal point.*

So for the following type: `numeric(5,2)`

* SQL allocates up to **`2`** digits to the *right* of the decimal 
* SQL allocates up to `5-2` = **`3`** digits to the *left* of the decimal

Meaning `1234.1` is akin to `1234.10` and is **invalid!**

```sql
-- Will throw an Arithmetic Overflow Exception
DECLARE @Price AS NUMERIC(5,2) = 1234.1
```

So the regex to verify this is simpler than some of the examples here

Look for a number `\d` and you're allowed 0 to 3 of them `{0,3}` 
Then optionally `?`, you can have a period `\.` and then 0 to 2 more numbers `\d{0,2}`

The whole regex should look like this:

<pre><code><a href="https://regexr.com/4c74k">\d{0,3}(\.\d{0,2})?</a></code></pre>


**Further Reading**:

* [Regular Expression that Validates Decimal (18,3)][2]
* [Best Data annotation for a Decimal(18,2)][3]


[1]: https://learn.microsoft.com/en-us/sql/t-sql/data-types/decimal-and-numeric-transact-sql?view=sql-server-2017
[2]: https://stackoverflow.com/q/19076566/1366033
[3]: https://stackoverflow.com/q/19811180/1366033

Precision (p): Total number of digits to the left and right of the decimal

Scale (s): Total number of digits to the right of the decimal

Consider my following regex so far:

    ^-?[0-9]+(\.[0-9]{1,3})?$

 - -? optional negative number
 - [0-9] matches numbers 0-9
 - "+" any number of digits
 - "(\\.[0-9]{1,3})?" optional decimal with 1-3 digits

Example:

    100.95 has a precision of 5 and a scale of 2 (5,2)

I know how to restrict total numbers to the left, and total numbers to the right, but not sure how to encapsulate the entire value to limit the "p, precision" part, and ignore the period if it exists in that count. The **-** also needs to be ignored in that total count.

**UPDATE**:

This seems to be working... 

    ^(?=(\D*\d\D*){0,5}$)-?([0-9]+)?(\.?[0-9]{0,2})?$

    blank line matches
    0 - match
    1 - match
    123 - match
    123.12 - match
    -1 - match
    123.122 - no match
    


How do I create a regex that matches (p,s) precision and scale like the SQL decimal type?

While many of the URI operations are unavailable for [`UriKind.Relative`][2] (for whatever reason), you can build a fully qualified URI through one of the [overloads][0] that takes in a Base URI

Here's an example [from the docs on `Uri.Query`][1]:

```cs
Uri baseUri = new Uri ("http://www.contoso.com/");
Uri myUri = new Uri (baseUri, "catalog/shownew.htm?date=today");

Console.WriteLine(myUri.Query); // date=today
```

You can also get the current base from [`HttpContext.Current.Request.Url`][3] or even just create a mock URI base with `"http://localhost"` if all you care about is the path components.

So either of the following approaches should also return the QueryString from a relative path:


```cs
var path = "catalog/shownew.htm?date=today"
var query1 = new Uri(HttpContext.Current.Request.Url, path).Query;
var query2 = new Uri(new Uri("http://localhost"), path).Query;
```



[0]: https://learn.microsoft.com/en-us/dotnet/api/system.uri.-ctor?view=netframework-4.7.2
[1]:
https://learn.microsoft.com/en-us/dotnet/api/system.uri.query?view=netframework-4.7.2

[2]: https://learn.microsoft.com/en-us/dotnet/api/system.urikind?view=netframework-4.7.2
[3]: https://learn.microsoft.com/en-us/dotnet/api/system.web.httprequest.url?view=netframework-4.7.2

What's the most efficient way to get a specific parameter from a relative URL string using C#?

For example, how would you get the value of the `ACTION` parameter from the following relative URL string:

    string url = "/page/example?ACTION=data&FOO=test";

I have already tried using:

    var myUri = new Uri(url, UriKind.Relative);
    String action = HttpUtility.ParseQueryString(myUri.Query).Get("ACTION");

However, I get the following error: 

> This operation is not supported for a relative URI.

