Implementing dynamic strings in golang

If your input gets bigger (more complex) or if you need to substitute different values multiple times, then templates are more effective, cleaner and more flexible. Check out the text/template package.

The template package parses your template once, builts a tree from it, and once you need to replace values, it builds the output on the fly.

Take a look at this example:

const templ = `Hi {{.Name}}!
Welcome {{.Place}}.
Please bring {{.ToBring}}
`

You can parse such a template with this line:

t := template.Must(template.New("").Parse(templ))

Prepare its input data either as a struct or as a map:

data := map[string]string{
    "Name":    "Bob",
    "Place":   "Home",
    "ToBring": "some beers",
}

And you can have the result with Template.Execute():

err := t.Execute(os.Stdout, data) // Prints result to the standard output

Here's the complete, runnable example: (try it on the Go Playground)

package main

import (
    "os"
    "text/template"
)

func main() {
    data := map[string]string{
        "Name":    "Bob",
        "Place":   "Home",
        "ToBring": "some beers",
    }
    t := template.Must(template.New("").Parse(templ))
    if err := t.Execute(os.Stdout, data); err != nil { // Prints result to the standard output
        panic(err)
    }

    // Now change something:
    data["Name"] = "Alice"
    data["ToBring"] = "a Teddy Bear"
    if err := t.Execute(os.Stdout, data); err != nil {
        panic(err)
    }
}

const templ = `
Hi {{.Name}}!
Welcome {{.Place}}.
Please bring {{.ToBring}}
`

Output:

Hi Bob!
Welcome Home.
Please bring some beers

Hi Alice!
Welcome Home.
Please bring a Teddy Bear

Getting the result as a string:

If you want the result as a string, you can write the result to a bytes.Buffer and get the string using the Buffer.String() method:

buf := bytes.Buffer{}
t.Execute(&buf, data)
var result string = buf.String()

Complete program (try it on the Go Playground):

package main

import (
    "bytes"
    "fmt"
    "text/template"
)

func main() {
    data := map[string]string{
        "Name":    "Bob",
        "Place":   "Home",
        "ToBring": "some beers",
    }
    fmt.Print(Execute(data))
}

var t = template.Must(template.New("").Parse(templ))

func Execute(data interface{}) string {
    buf := bytes.Buffer{}
    if err := t.Execute(&buf, data); err != nil {
        fmt.Println("Error:", err)
    }
    return buf.String()
}

const templ = `
Hi {{.Name}}!
Welcome {{.Place}}.
Please bring {{.ToBring}}
`

You could consider the function strings.Replace

return Replace(studentName, "? ", name, 1)

With '1', it replaces the first "? " it finds in studentName.
Replace returns a copy of studentName, with "? " substituted with name.

This strictly respect the original question (global var with that exact content)

Now, if you start changing the question, like for instance with a different content (a global variable studentName := "Hi %s ,Welcome"), then you could use fmt.Sprintf() as in 425nesp's answer

return fmt.Sprintf(studentName, name)

That would use the format 'verbs' %s, default format for string.

Assuming the global string is always the same you could do.

func returnName(name string) string {
   buf := bytes.Buffer{}
   buf.WriteString("Hi ")
   buf.WriteString(name)
   buf.WriteString(", welcome")
   return buf.String()
}

or

func returnName(name string) string {
   return "Hi " + name + ", welcome"
}

if the string is a dynamic template you could use the template package or a simple Replace if there wont be other ? marks or Sprintf

You can also use template.Template combined with strings.Builder:

package main

import (
   "strings"
   "text/template"
)

func returnName(name string) string {
   t, b := new(template.Template), new(strings.Builder)
   template.Must(t.Parse("Hi {{.}}, welcome.")).Execute(b, name)
   return b.String()
}

func main() {
   println(returnName("Akash"))
}