Sostituire un regolare submatch espressione utilizzando una funzione

Question

Diciamo che ho stringhe come

input := `bla bla b:foo="hop" blablabla b:bar="hu?"` 

e voglio sostituire le parti tra virgolette in b:foo="hop" o b:bar="hu?" utilizzando una funzione.

E 'facile costruire un'espressione regolare per ottenere la partita e submatch, per esempio

r := regexp.MustCompile(`\bb:\w+="([^"]+)"`) 

e poi a chiamare ReplaceAllStringFunc ma il problema è che il callback riceve tutta la partita e non l'submatch:

fmt.Println(r.ReplaceAllStringFunc(input, func(m string) string { 
    // m is the whole match here. Damn. 
})) 

Come posso sostituire la richiesta?

In questo momento, non ho trovato una soluzione migliore di decomporre me stesso m all'interno del callback con un'espressione regolare, e per ricostruire la stringa dopo aver elaborato la submatch.

Avrei usato un approccio alternativo con un aspetto positivo dietro erano disponibili in Go ma non è il caso (e non dovrebbero essere necessari comunque).

Cosa posso fare qui?

---

EDIT: ecco la mia soluzione attuale che vorrei semplificare:

func complexFunc(s string) string { 
    return "dbvalue("+s+")" // this could be more complex 
} 
func main() { 
     input := `bla bla b:foo="hop" blablabla b:bar="hu?"` 
     r := regexp.MustCompile(`(\bb:\w+=")([^"]+)`) 
     fmt.Println(r.ReplaceAllStringFunc(input, func(m string) string { 
       parts := r.FindStringSubmatch(m) 
       return parts[1] + complexFunc(parts[2]) 
     })) 
} 

(playground link)

Quello che mi preoccupa è che ho per applicare l'espressione regolare due volte. Questo non suona bene.

Answer 1

Non mi piace il codice di muggito, ma sembra di fare ciò che ti sembra di volerlo fare:

package main 

import (
     "fmt" 
     "regexp" 
) 

func main() { 
     input := `bla bla b:foo="hop" blablabla b:bar="hu?"` 
     r := regexp.MustCompile(`\bb:\w+="([^"]+)"`) 
     r2 := regexp.MustCompile(`"([^"]+)"`) 
     fmt.Println(r.ReplaceAllStringFunc(input, func(m string) string { 
       return r2.ReplaceAllString(m, `"${2}whatever"`) 
     })) 
} 

Playground

---

uscita

bla bla b:foo="whatever" blablabla b:bar="whatever" 

---

MODIFICA: Take II.

---

package main 

import (
     "fmt" 
     "regexp" 
) 

func computedFrom(s string) string { 
     return fmt.Sprintf("computedFrom(%s)", s) 
} 

func main() { 
     input := `bla bla b:foo="hop" blablabla b:bar="hu?"` 
     r := regexp.MustCompile(`\bb:\w+="([^"]+)"`) 
     r2 := regexp.MustCompile(`"([^"]+)"`) 
     fmt.Println(r.ReplaceAllStringFunc(input, func(m string) string { 
       match := string(r2.Find([]byte(m))) 
       return r2.ReplaceAllString(m, computedFrom(match)) 
     })) 
} 

Playground

---

uscita:

bla bla b:foo=computedFrom("hop") blablabla b:bar=computedFrom("hu?")