# Update in .NET Core 2.0+ (August 2017)

This is natively available in .NET Core 2.0+ with [`String.Replace`][1] which has the following overloads

```cs
public string Replace (string oldValue, string newValue, StringComparison comparisonType);
public string Replace (string oldValue, string newValue, bool ignoreCase, System.Globalization.CultureInfo culture);
```


So you can use either like this:

```cs
"A".Replace("a", "b", StringComparison.CurrentCultureIgnoreCase);
"A".Replace("a", "b", true, CultureInfo.CurrentCulture);
```


> **PS**: You can [browse .NET Core source][6] if you want to see how MS implemented it

----

### Legacy .NET Framework 4.8- option for VB Projects

Visual Basic has an [**`Option Compare`**][2] setting which can be set to `Binary` or `Text`

Setting to `Text` will make all string comparisons across your project case insensitive by default.

So, as other answers have suggested, if you are pulling in the `Microsoft.VisualBasic.dll`, when calling [`Strings.Replace`][3] if you don't explicitly pass a [`CompareMethod`][4] the method will [actually defer to the `Compare` option for your file or project][5] using the `[OptionCompare]` Parameter Attribute

So either of the following will also work (*top option only available in VB , but both rely on VisualBasic.dll*) 

```vb
Option Compare Text

Replace("A","a","b")
```

```vb
Replace("A","a","b", Compare := CompareMethod.Text)
```


[1]: https://learn.microsoft.com/en-us/dotnet/api/system.string.replace?view=netcore-2.0#System_String_Replace_System_String_System_String_System_StringComparison_
[2]: https://learn.microsoft.com/en-us/dotnet/visual-basic/language-reference/statements/option-compare-statement
[3]: https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualbasic.strings.replace?view=netframework-4.8
[4]: https://learn.microsoft.com/en-us/dotnet/api/microsoft.visualbasic.comparemethod?view=netframework-4.8
[5]: https://referencesource.microsoft.com/#Microsoft.VisualBasic/Microsoft/VisualBasic/Strings.cs,61
[6]: https://source.dot.net/#System.Private.CoreLib/String.Manipulation.cs,998

I recently had to perform some string replacements in .net and found myself developing a regular expression replacement function for this purpose. After getting it to work I couldn't help but think there must be a built in case insensitive replacement operation in .Net that I'm missing?

Surely when there are so many other string operations that support case insensitive comparission such as;

    var compareStrings  = String.Compare("a", "b", blIgnoreCase);
    var equalStrings    = String.Equals("a", "b", StringComparison.CurrentCultureIgnoreCase);

then there must be a built in equivalent for replace?

Is there a case insensitive string replace in .Net without using Regex?

Since the question is about what is the *fastest* method, I thought I'd throw up add some perf metrics.  

**TL;DR** The winner, by a wide margin, is the `+` operator, and *please* never use regex

https://jsperf.com/prepend-text-to-string/1

[![enter image description here][1]][2]


  [1]: https://i.stack.imgur.com/k8enV.png
  [2]: https://jsperf.com/prepend-text-to-string/1

What is the fastest method, to add a new value at the beginning of a string?




Prepend text to beginning of string

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

<strike>That expression is not legal C#.

You aren't getting an error because the FuncEval (the ability to execute code in the watch or immediate windows) uses a different parser with various issues.

These issues may eventually be fixed by replacing this parser with Roslyn.</strike>

----
## EDIT

<strike>I suspect that the VB.Net parser used by FuncEval doesn't intern strings.

If you run this expression outside of FuncEval (eg, LINQPad), it returns true.</strike>

----

## Second EDIT

You have an unprintable character in the first string.

Notepad++ shows it as a `?` because your text file is using an encoding that doesn't support the character. 
To find out what it actually is, paste it into [this site](http://codepoints.net/).

The expression `"a"="a"` returns `False`.  What the heck is going on?

![Watch List][1]

**Edit**: Sorry, I'm working in VB.NET, not C#

**Update**: When I copy the expression into Notepad++, it shows `"?a"="a"`. Can it have something to do with encoding?

  [1]: http://i.imgur.com/JHnMloo.png

Why does "a"="a" return False

### Consider using [*mark.js*][1]

Replacing nodes in the DOM can be tricky and lead to unintended consequences as elements shift and fire events. Although it adds a third party dependency, it has a pretty clean API and abstracts away the logic so you don't have to own it.

[1]: https://markjs.io/





 var instance = new Mark(".mark-context");
 instance.mark("100 bruss");



 <script src="https://cdnjs.cloudflare.com/ajax/libs/mark.js/8.11.1/mark.min.js"></script>

 
 1000, Brussels, Belgium

I have an algorithm which calculates the characters to highlight in text based on query.

For example, if I pass to the algorithm text "1000, Brussels, Belgium" and
query "1000 bruss" it will return me `[[0, 4], [6, 11]]`. But now, I need to write an algorithm which will wrap the characters with ``, so the result should be `1000, Brussels, Belgium`.
I wrote the algorithm, but i have a feeling it might be better or it might be solved more elegant.

```javascript
const highlight = (content, query, matches) => {
 if (!query) {
 return content;
 }

 const openTag = "";
 const closeTag = "";

 let result = content;
 let shift = 0;

 matches.forEach(([startIndex, endIndex]) => {
 const s =
 openTag +
 result.slice(startIndex + shift, endIndex + shift) +
 closeTag +
 result.slice(endIndex + shift);

 if (shift) {
 result = result.slice(0, startIndex + shift) + s;
 } else {
 result = s;
 }

 shift += openTag.length + closeTag.length;
 });

 return result;
};
```

Is there any better way to solve the problem?

Another example:

- Text: 'Amsterdam, North-Holland, Netherlands'
- Query: 'amst'
- Matches: `[0, 4]`