Эта статья приняла участие"Проект "Звезда раскопок"", чтобы выиграть творческие подарочные пакеты и бросить вызов творческим поощрениям.
xdm, мы все знаем, что golang — это, естественно, высококонкурентный, эффективный компилируемый язык.
Но все мы знаем, что каким бы хорошим ни был инструмент, неправильное его использование — все напрасно.
Кто используется для struct и map?
Когда объем вычислений небольшой, трудоемкая разница между использованием временной структуры и карты может быть не видна, но когда число увеличивается, разрыв становится очевидным, а по мере увеличения числа разрыв становится более очевидным.
Когда мы сталкиваемся с ключами и значениями, которые можно исправить, мы выбираем struct эффективнее, чем map
- Давайте смоделируем вычисление цикла 100 миллионов раз, чтобы увидеть, сколько времени потребуется для использования соответствующих структур данных.
- Рассчитать текущее время перед циклом
- Вычислить текущее время после цикла
- Наконец, вычислите разницу между двумя временами, здесь мы используеммиллисекунды
func main() {
t1 :=time.Now().UnixNano()/1e6
for i := 0; i < 100000000; i++ {
var test struct {
Name string
hobby string
}
test.Name = "xiaomotong"
test.hobby = "program"
}
t2 :=time.Now().UnixNano()/1e6
fmt.Println("t2 - t1 == ", t2-t1)
}
Запустите программу, чтобы увидеть эффект:
# go run main.go
t1 == 1634377149185
t2 == 1634377149221
t2 - t1 == 36
Способ использования структуры отнимает много времени36 ms, как вы относитесь к этому времени?
Давайте посмотрим, как использовать карту
func main() {
t1 :=time.Now().UnixNano()/1e6
fmt.Println("t1 == ", t1)
for i := 0; i < 100000000; i++ {
var test = map[string]interface{}{}
test["name"] = "xiaomotong"
test["hobby"] = "program"
}
t2 :=time.Now().UnixNano()/1e6
fmt.Println("t2 == ", t2)
fmt.Println("t2 - t1 == ", t2-t1)
}
Запустите программу, чтобы увидеть эффект:
# go run main.go
t1 == 1634377365927
t2 == 1634377373525
t2 - t1 == 7598
Способ использования структуры отнимает много времени7598 ms
Используя карту и используя структуру для выполнения одной и той же обработки данных, разница во времени отличается212 раз, Вот и все, когда мы обычно кодируем,Какую структуру данных вы бы выбрали для приведенного выше сценария?
Причина, по которой вышеупомянутый разрыв настолько велик, заключается в том, что
В случае, когда мы можем определить поле, мы используем временную структуру, которой не нужно динамически распределять содержимое во время выполнения,
Но карта другая, карта тоже должна проверять индекс, что очень долго.
Как объединить строки?
Как реализовать сращивание строк при кодировании xdm на работе? Наши инструменты временно обеспечивают следующее:
- использовать
+Путь - использовать
fmt.Sprintf()Путь - использовать
strings.JoinПуть - использовать
bufferПуть
Видя это, возможно, у нас есть свои ответы, но давайте попрактикуемся еще раз и посмотрим, как тратится их соответствующее время обработки в случае сращивания одной и той же строки.
использовать+Путь
- Давайте подсчитаем, сколько времени потребуется, чтобы добавить строку 500 000 раз в цикле.
func main() {
t1 := time.Now().UnixNano() / 1e6
fmt.Println("t1 == ", t1)
s := "xiao"
for i := 0; i < 500000; i++ {
s += "motong"
}
t2 := time.Now().UnixNano() / 1e6
fmt.Println("t2 == ", t2)
fmt.Println("t2 - t1 == ", t2-t1)
}
Посмотреть эффект от запуска программы:
# go run main.go
t1 == 1634378595642
t2 == 1634378743119
t2 - t1 == 147477
Вы удивлены, увидев, что эти данные xdm настолько медленны и отнимают много времени?147477 msЭто нормально2 минуты 27 секундАх
используется в го+Обработка строк очень требовательна к производительности, как видно из данных
использоватьfmt.Sprintf() Путь
func main() {
t1 := time.Now().UnixNano() / 1e6
fmt.Println("t1 == ", t1)
s := "xiao"
for i := 0; i < 500000; i++ {
s = fmt.Sprintf("%s%s",s,"motong")
}
t2 := time.Now().UnixNano() / 1e6
fmt.Println("t2 == ", t2)
fmt.Println("t2 - t1 == ", t2-t1)
}
Посмотреть эффект от запуска программы:
# go run main.go
t1 == 1634378977361
t2 == 1634379240292
t2 - t1 == 262931
Увидев эти данные, мы тоже обалдели, на самом деле это заняло 262931 мс, итого4 минуты 22 секунды, xdm не догадался использоватьfmt.Sprintfчем использовать+все еще медленно
использоватьstrings.JoinПуть
func main() {
t1 := time.Now().UnixNano() / 1e6
fmt.Println("t1 == ", t1)
s := []string{}
s = append(s,"xiao")
for i := 0; i < 500000; i++ {
s = append(s ,"motong")
}
strings.Join(s,"")
t2 := time.Now().UnixNano() / 1e6
fmt.Println("t2 == ", t2)
fmt.Println("t2 - t1 == ", t2-t1)
}
Посмотреть эффект от запуска программы:
# go run main.go
t1 == 1634570001216
t2 == 1634570001294
t2 - t1 == 78
Занимает 142923 мс, всего** 78 мс**
использоватьbufferПуть
использоватьbufferПуть должен быть назван лучшим путем,
func main() {
t1 := time.Now().UnixNano() / 1e6
fmt.Println("t1 == ", t1)
s := bytes.NewBufferString("xiao")
for i := 0; i < 500000; i++ {
s.WriteString("motong")
}
t2 := time.Now().UnixNano() / 1e6
fmt.Println("t2 == ", t2)
fmt.Println("t2 - t1 == ", t2-t1)
}
# go run main.go
t1 == 1634378506021
t2 == 1634378506030
t2 - t1 == 9
Из приведенных выше данных мы видим, что одни и те же данные 500 000 раз объединяются.
- Во-первых, используйте
+способ, требует147477 ms - Во-вторых, используйте
fmt.Sprintf()способ, требует262931 ms - В-третьих, используйте
strings.Joinспособ, требует78 ms - В-четвертых, используйте
bufferспособ, требует9ms
использоватьbufferпуть первый16 386 раз, это второй29 214 раз, это третийв 8 раз больше
xdm , если вы столкнетесь с описанным выше сценарием, какой метод вы выберете? Вы можете обсудить его вместе в области комментариев, чтобы увидеть, есть ли более эффективный способ
Добро пожаловать лайк, подписка, избранное
Друзья, ваша поддержка и поощрение мотивируют меня продолжать делиться и улучшать качество.
Хорошо, вот и на этот раз
Технологии открыты, и наш менталитет должен быть открытым. Примите перемены, живите на солнце и двигайтесь вперед.
ямаленький дьяволенок Нежа, добро пожаловать, лайкайте, подписывайтесь и добавляйте в избранное, увидимся в следующий раз~