Case insensitive string replace in Go

Can NewReplacer.Replace do case insensitive string replacement?

r := strings.NewReplacer("html", "xml")
fmt.Println(r.Replace("This is <b>HTML</b>!"))

If not, what's the best way to do case insensitive string replace in Go?

You can use regular expressions for that:

re := regexp.MustCompile(`(?i)html`)
fmt.Println(re.ReplaceAllString("html HTML Html", "XML"))

Playground: http://play.golang.org/p/H0Gk6pbp2c.

It's worth noting that case is a thing that can be different depending on the language and locale. For example, the capital form of German letter "ß" is "SS". While this doesn't generally influence English texts, this is something to bear in mind when working with multi-lingual texts and programs that need to work them.

A generic solution would be as follows:

import (
    "fmt"
    "regexp"
)

type CaseInsensitiveReplacer struct {
    toReplace   *regexp.Regexp
    replaceWith string
}

func NewCaseInsensitiveReplacer(toReplace, replaceWith string) *CaseInsensitiveReplacer {
    return &CaseInsensitiveReplacer{
	    toReplace:   regexp.MustCompile("(?i)" + toReplace),
	    replaceWith: replaceWith,
    }
}

func (cir *CaseInsensitiveReplacer) Replace(str string) string {
    return cir.toReplace.ReplaceAllString(str, cir.replaceWith)
}

And then used via:

r := NewCaseInsensitiveReplacer("html", "xml")
fmt.Println(r.Replace("This is <b>HTML</b>!"))

Here's a link to an example in the playground.

Based on the documentation it does not.

I am not sure about the best way, but you can do this with replace in regular expressions and make it case-insensitive with i flag

> func IReplace to replace the substring is not case sensitive.
>
> Using a regular expression (as mentioned in previous posts) is not
> correct for all cases. Eg: for parameters: ("Alpha=? BETA",
> "ALPHA=?", ALPHA=1) the result should be "ALPHA=1 BETA", but it won't
> be.

import (
	"strings"
	"unicode/utf8"
)

    func IReplace(s, old, new string) string {  // replace all, case insensitive
    	if old == new || old == "" {
    		return s // avoid allocation
    	}
    	t := strings.ToLower(s)
    	o := strings.ToLower(old)
    
    	// Compute number of replacements.
    	n := strings.Count(t, o)
    	if n == 0 {
    		return s // avoid allocation
    	}
    	// Apply replacements to buffer.
    	var b strings.Builder
    	b.Grow(len(s) + n*(len(new)-len(old)))
    	start := 0
    	for i := 0; i < n; i++ {
    		j := start
    		if len(old) == 0 {
    			if i > 0 {
    				_, wid := utf8.DecodeRuneInString(s[start:])
    				j += wid
    			}
    		} else {
    			j += strings.Index(t[start:], o)
    		}
    		b.WriteString(s[start:j])
    		b.WriteString(new)
    		start = j + len(old)
    	}
    	b.WriteString(s[start:])
    	return b.String()
    }