问题[golang]

http.HandleFunc 向客户端请求数据。有没有办法以某种方式指定此方法只能通过 GET 或 POST 工作？

http.HandleFunc("/olock_open/all", func(w http.ResponseWriter, r *http.Request) {
  username, password, ok := r.BasicAuth()
  check_auth := authfunc.CheckAuth(w, username, password, ok)
  if !check_auth {
   return
  }

  for i := 0; i < len(online_locks_list_active); i++ {
   _, err := tcpcommandolock.SendCommandOlock(online_locks_list_active[i].Connection, []byte{0x02, 0x0A, 0x30, 0x51, 0x03, 0x90})
   if err != nil {
    syslogging.LogToSys("Error, can't send command to BU"+online_locks_list_active[i].Address+": "+err.Error(), "Info")
   }
  }
  defer r.Body.Close()
 })```

有一个Go项目。我编译了一个二进制文件，我需要通过带有参数的命令行运行它来找出版本，例如像这样 script_name -version 之后它将程序版本写入控制台并关闭。如何实施？

例子取自《100 Go Mistakes》一书

我不明白为什么使用通道比简单地添加数组更有利可图？他们不仅要承担创作成本，还要承担经营活动的成本，因为它们的背后是结构。

小澄清：

Count并Count3使用类似的结构Result

Count2使用类型结构Result2

type Input struct {
    a int64
    b int64
}

type Result struct {
    sumA int64
    sumB int64
}

//[56]byte используется для расположение sumA и SumB в разных сегментах кеша
type Result2 struct {
    sumA int64
    _    [56]byte
    sumB int64
}

// 1048576 - 2^20 для наглядности
func CreateInput() []Input {
    input := make([]Input, 0, 1048576)

    for i := int64(0); i < 1048576; i++ {
        input = append(input, Input{
            a: i,
            b: i,
        })
    }

    return input
}

func Count(inputs []Input) Result {
    wg := sync.WaitGroup{}
    wg.Add(2)

    result := Result{}

    go func() {
        for i := 0; i < len(inputs); i++ {
            result.sumA += inputs[i].a
        }

        wg.Done()
    }()

    go func() {
        for i := 0; i < len(inputs); i++ {
            result.sumB += inputs[i].b
        }

        wg.Done()
    }()

    wg.Wait()

    return result
}

func Count2(inputs []Input) Result2 {
    wg := sync.WaitGroup{}
    wg.Add(2)

    result := Result2{}

    go func() {
        for i := 0; i < len(inputs); i++ {
            result.sumA += inputs[i].a
        }

        wg.Done()
    }()

    go func() {
        for i := 0; i < len(inputs); i++ {
            result.sumB += inputs[i].b
        }

        wg.Done()
    }()

    wg.Wait()

    return result
}

func Count3(inputs []Input) Result {
    var result Result
    sumAChan := make(chan int64)
    sumBChan := make(chan int64)

    go func() {
        var sumA int64
        for i := 0; i < len(inputs); i++ {
            sumA += inputs[i].a
        }
        sumAChan <- sumA
    }()

    go func() {
        var sumB int64
        for i := 0; i < len(inputs); i++ {
            sumB += inputs[i].b
        }
        sumBChan <- sumB
    }()

    result.sumA = <-sumAChan
    result.sumB = <-sumBChan

    return result
}

更新：结果在很大程度上取决于参数-coverprofile

Count2和Count3非常接近，但为什么-coverprofile它只在 上产生如此大的差异Count2？如果没有它，平均结果是：

          │  stats.txt   │
          │    sec/op    │
Count-12    18.24m ±  2%
Count2-12   677.0µ ±  7%
Count3-12   689.8µ ± 12%
geomean     2.042m

          │  stats.txt  │
          │    B/op     │
Count-12    162.5 ± 19%
Count2-12   192.0 ±  6%
Count3-12   288.0 ±  0%
geomean     207.9

          │ stats.txt  │
          │ allocs/op  │
Count-12    4.000 ± 0%
Count2-12   4.000 ± 0%
Count3-12   4.000 ± 0%
geomean     4.000

以下是包含 1,048,576 个元素的基准测试结果c -coverprofile

cpu: AMD Ryzen 5 5600G with Radeon Graphics         
BenchmarkCount-12             49      25359128 ns/op         237 B/op          4 allocs/op
BenchmarkCount2-12           295       3661261 ns/op         300 B/op          4 allocs/op
BenchmarkCount3-12          1946        644967 ns/op         288 B/op          4 allocs/op

以下是基准测试结果：без -coverprofile

BenchmarkCount-12             67          18467245 ns/op             209 B/op          4 allocs/op
BenchmarkCount2-12          1833            597416 ns/op             211 B/op          4 allocs/op
BenchmarkCount3-12          1938            734245 ns/op             288 B/op          4 allocs/op

基准代码

var res test.Result
var res2 test.Result2
var res3 test.Result

// BenchmarkResult placeholder.
func BenchmarkCount(b *testing.B) {
    var sum test.Result
    b.StopTimer()

    input := test.CreateInput()

    b.StartTimer()

    for i := 0; i < b.N; i++ {
        sum = test.Count(input)
    }

    res = sum
}

func BenchmarkCount2(b *testing.B) {
    var sum test.Result2
    b.StopTimer()

    input := test.CreateInput()

    b.StartTimer()

    for i := 0; i < b.N; i++ {
        sum = test.Count2(input)
    }

    res2 = sum
}

func BenchmarkCount3(b *testing.B) {
    var sum test.Result
    b.StopTimer()

    input := test.CreateInput()

    b.StartTimer()

    for i := 0; i < b.N; i++ {
        sum = test.Count3(input)
    }

    res3 = sum
}

运行基准测试的命令，通过 vscode 中的图形界面启动

go test -benchmem -run=^$ -coverprofile=/tmp/vscode-govayH6A/go-code-cover -bench . alice/effective/internal/test

一个行计算器，在测试系统检查时，给出错误：超出了程序执行时间限制（某些情况下程序进入死循环，我认为有些错误情况没有被考虑到。

使用两个堆栈实现，其中一个是操作，另一个是数字。

我从视频中获取了操作原理：https://youtu.be/Vk-tGND2bfc?si= c4RzRBDehfykDRlm

这是问题陈述：

实现一个函数func Calc(expression string) (float64, error)，其中表达式是由单字符标识符和算术运算符号组成的字符串表达式 输入数据 - 数字（有理数）、运算 +、-、*、/、优先运算（和 ） 写入错误的情况表达式，该函数会生成错误。

这是代码：

package main

import (
    "errors"
    "fmt"
    "strconv"
    "unicode"
)

func Calc(expression string) (float64, error) {
    priority := map[rune]int{'+': 1, '-': 1, '*': 2, '/': 2}
    var num []float64
    var operator []rune
    var hasNumber bool

    for _, ch := range expression {
        if unicode.IsDigit(ch) {
            hasNumber = true
        }
    }

    if !hasNumber {
        return 0, errors.New("no number")
    }

    if len(expression) == 0 {
        return 0, errors.New("empty expression")
    }

    check := rune(expression[len(expression)-1])
    if !unicode.IsDigit(check) && check != ')' {
        return 0, errors.New("invalid, last char is not digits or closing bracket")
    }

    applyOperator := func(a, b float64, op rune) float64 {
        switch op {
        case '+':
            return a + b
        case '-':
            return a - b
        case '*':
            return a * b
        case '/':
            if b == 0 {
                panic("division by zero")
            }
            return a / b
        default:
            return 0
        }
    }

    calculate := func() {
        if len(operator) == 0 || len(num) < 2 {
            return
        }
        b := num[len(num)-1]
        a := num[len(num)-2]
        op := operator[len(operator)-1]
        num = num[:len(num)-2]
        operator = operator[:len(operator)-1]
        result := applyOperator(a, b, op)
        num = append(num, result)
    }

    for i := 0; i < len(expression); i++ {
        ch := rune(expression[i])

        if unicode.IsDigit(ch) || ch == '.' {
            start := i
            for i < len(expression) && (unicode.IsDigit(rune(expression[i])) || expression[i] == '.') {
                i++
            }
            numer, err := strconv.ParseFloat(expression[start:i], 64)
            if err != nil {
                return 0, fmt.Errorf("failed to parse number: %v", err)
            }
            num = append(num, numer)
            i--
        } else if ch == '+' || ch == '-' {
            if i == 0 || expression[i-1] == '(' || len(operator) > 0 && operator[len(operator)-1] == '(' {
                num = append(num, 0)
            }
            for len(operator) > 0 && priority[operator[len(operator)-1]] >= priority[ch] {
                calculate()
            }
            operator = append(operator, ch)
        } else if ch == '*' || ch == '/' {
            for len(operator) > 0 && priority[operator[len(operator)-1]] >= priority[ch] {
                calculate()
            }
            operator = append(operator, ch)
        } else if ch == '(' {
            operator = append(operator, ch)
        } else if ch == ')' {
            for len(operator) > 0 && operator[len(operator)-1] != '(' {
                calculate()
            }
            if len(operator) == 0 {
                return 0, errors.New("mismatched parentheses")
            }
            operator = operator[:len(operator)-1]
        } else if !unicode.IsSpace(ch) {
            return 0, errors.New("invalid character")
        }
    }

    for len(operator) > 0 {
        calculate()
    }

    if len(num) == 1 {
        return num[0], nil
    }

    return 0, errors.New("invalid expression")
}

是的map，或者更确切地说map[string]int

默认情况下，据我了解，Golang它按字母顺序按键对元素进行排序。如何map按给定顺序按键排序？

这段代码：

package main

import (
    "fmt"
)

func main() {
    output := make(map[string]int)

    basket := map[string]int{
        "orange": 5, 
        "apple": 7,
        "mango": 3,
        "strawberry": 9,
    }

    //нужный порядок
    keys := []string{
        "strawberry",
        "mango",
        "orange",
    }

    for _, k := range keys {
        output[k] = basket[k]
    }

    fmt.Printf("вывод output : %+v \n", output)
}

将生成带有按字母顺序排列的键的行：

mango, orange, strawberry