Эквивалент Python string.format в Go?

Ответ 1

С strings.Replacer

Используя strings.Replacer, реализация форматирования вашего желания очень проста и компактна.

func main() {
    file, err := "/data/test.txt", "file not found"

    log("File {file} had error {error}", "{file}", file, "{error}", err)
}

func log(format string, args ...string) {
    r := strings.NewReplacer(args...)
    fmt.Println(r.Replace(format))
}

Вывод (попробуйте на Go Playground):

File /data/test.txt had error file not found

Мы можем сделать его более приятным для использования, добавив скобки к именам параметров автоматически в функции log():

func main() {
    file, err := "/data/test.txt", "file not found"

    log2("File {file} had error {error}", "file", file, "error", err)
}

func log2(format string, args ...string) {
    for i, v := range args {
        if i%2 == 0 {
            args[i] = "{" + v + "}"
        }
    }
    r := strings.NewReplacer(args...)
    fmt.Println(r.Replace(format))
}

Выход (попробуйте на Go Playground):

File /data/test.txt had error file not found

Да, вы могли бы сказать, что это только принимает значения параметра string. Это правда. С небольшим улучшением это будет не так:

func main() {
    file, err := "/data/test.txt", 666

    log3("File {file} had error {error}", "file", file, "error", err)
}

func log3(format string, args ...interface{}) {
    args2 := make([]string, len(args))
    for i, v := range args {
        if i%2 == 0 {
            args2[i] = fmt.Sprintf("{%v}", v)
        } else {
            args2[i] = fmt.Sprint(v)
        }
    }
    r := strings.NewReplacer(args2...)
    fmt.Println(r.Replace(format))
}

Выход (попробуйте на Go Playground):

File /data/test.txt had error 666

Вариант этого, чтобы принять параметры как map[string]interface{} и вернуть результат как string:

type P map[string]interface{}

func main() {
    file, err := "/data/test.txt", 666

    s := log33("File {file} had error {error}", P{"file": file, "error": err})
    fmt.Println(s)
}

func log33(format string, p P) string {
    args, i := make([]string, len(p)*2), 0
    for k, v := range p {
        args[i] = "{" + k + "}"
        args[i+1] = fmt.Sprint(v)
        i += 2
    }
    return strings.NewReplacer(args...).Replace(format)
}

Попробуйте на Go Playground.

С text/template

Ваш шаблонный раствор или предложение также слишком многословны. Его можно записать как компактный, как это (ошибка проверки опущена):

type P map[string]interface{}

func main() {
    file, err := "/data/test.txt", 666

    log4("File {{.file}} has error {{.error}}", P{"file": file, "error": err})
}

func log4(format string, p P) {
    t := template.Must(template.New("").Parse(format))
    t.Execute(os.Stdout, p)
}

Выход (попробуйте на Go Playground):

File /data/test.txt has error 666

Если вы хотите вернуть string (вместо того, чтобы печатать его на стандартный вывод), вы можете сделать это следующим образом (попробуйте на Go Playground):

func log5(format string, p P) string {
    b := &bytes.Buffer{}
    template.Must(template.New("").Parse(format)).Execute(b, p)
    return b.String()
}

Использование явных индексов аргументов

Это уже упоминалось в другом ответе, но, чтобы завершить его, знайте, что один и тот же индекс явного аргумента может использоваться произвольное число раз и, таким образом, в результате один и тот же параметр заменяется в несколько раз. Подробнее об этом в этом вопросе: Заменить все переменные в Sprintf той же переменной

Ответ 2

Я не знаю простого способа присвоения параметров, но вы можете легко изменить порядок аргументов, используя явные аргументы аргументов:

От docs:

В Printf, Sprintf и Fprintf по умолчанию используется для каждого глагола форматирования для форматирования последовательных аргументов, переданных в вызове. Тем не менее, нотация [n] непосредственно перед глаголом указывает, что n-й одноиндексный аргумент должен быть отформатирован. То же обозначение перед '*' для ширины или точности выбирает индекс аргумента, содержащий значение. После обработки выражения в скобках [n] последующие глаголы будут использовать аргументы n + 1, n + 2 и т.д., Если не указано иное.

Тогда вы можете, например:

fmt.Printf("File %[2]s had error %[1]s", err, myfile)

Ответ 3

Параметр также может быть картой, поэтому следующая функция будет работать, если вы не против разбора каждого формата ошибки каждый раз, когда вы его используете:

package main

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

func msg(fmt string, args map[string]interface{}) (str string) {
    var msg bytes.Buffer

    tmpl, err := template.New("errmsg").Parse(fmt)

    if err != nil {
        return fmt
    }

    tmpl.Execute(&msg, args)
    return msg.String()
}

func main() {
    fmt.Printf(msg("File {{.File}} has error {{.Error}}\n", map[string]interface{} {
        "File": "abc",
        "Error": "def",
    }))
}

Это все еще немного словнее, чем мне хотелось бы, но это лучше, чем некоторые другие варианты, я полагаю. Вы можете включить map[string]interface{} в локальный тип и уменьшить его до:

type P map[string]interface{}

fmt.Printf(msg("File {{.File}} has error {{.Error}}\n", P{
        "File": "abc",
        "Error": "def",
    }))

Ответ 4

Увы, нет встроенной функции в Go для строковой интерполяции с именованными параметрами (пока). Но вы не единственный, кто страдает там:) Некоторые пакеты должны существовать, например: https://github.com/imkira/go-interpol. Или, если вы чувствуете себя авантюристами, вы можете сами написать такого помощника, поскольку концепция на самом деле довольно проста.

Cheers, Деннис