Golang实现仅当新值大于当前值时更新返回变量的函数

要实现仅在获取的新价格高于当前值时更新返回变量的函数，需要维护一个状态来跟踪当前最高值。由于函数在循环中被调用，可以使用包级变量来存储当前最高买入价和卖出价。

以下是修改后的代码：

package main

import (
    "encoding/json"
    "io/ioutil"
    "net/http"
    "strings"
    "sync"
)

var (
    currentBid float64
    currentAsk float64
    mu         sync.RWMutex
)

type QUOTE struct {
    Quotes struct {
        Quote struct {
            Symbol           string      `json:"symbol"`
            Description      string      `json:"description"`
            Exch             string      `json:"exch"`
            Type             string      `json:"type"`
            Last             float64     `json:"last"`
            Change           float64     `json:"change"`
            ChangePercentage float64     `json:"change_percentage"`
            Volume           int         `json:"volume"`
            AverageVolume    int         `json:"average_volume"`
            LastVolume       int         `json:"last_volume"`
            TradeDate        int64       `json:"trade_date"`
            Open             interface{} `json:"open"`
            High             interface{} `json:"high"`
            Low              interface{} `json:"low"`
            Close            interface{} `json:"close"`
            Prevclose        float64     `json:"prevclose"`
            Week52High       float64     `json:"week_52_high"`
            Week52Low        float64     `json:"week_52_low"`
            Bid              float64     `json:"bid"`
            Bidsize          int         `json:"bidsize"`
            Bidexch          string      `json:"bidexch"`
            BidDate          int64       `json:"bid_date"`
            Ask              float64     `json:"ask"`
            Asksize          int         `json:"asksize"`
            Askexch          string      `json:"askexch"`
            AskDate          int64       `json:"ask_date"`
            OpenInterest     int         `json:"open_interest"`
            Underlying       string      `json:"underlying"`
            Strike           float64     `json:"strike"`
            ContractSize     int         `json:"contract_size"`
            ExpirationDate   string      `json:"expiration_date"`
            ExpirationType   string      `json:"expiration_type"`
            OptionType       string      `json:"option_type"`
            RootSymbol       string      `json:"root_symbol"`
        } `json:"quote"`
    } `json:"quotes"`
}

func optionHighQuote() (bidH, askH float64) {
    url := "https://api.com/v1/markets/quotes"
    payload := strings.NewReader("symbols=")
    req, _ := http.NewRequest("POST", url, payload)
    req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
    req.Header.Add("accept", "application/json")

    res, _ := http.DefaultClient.Do(req)
    defer res.Body.Close()
    body, _ := ioutil.ReadAll(res.Body)

    var jsonStockResponse QUOTE
    json.Unmarshal([]byte(body), &jsonStockResponse)

    newBid := jsonStockResponse.Quotes.Quote.Bid
    newAsk := jsonStockResponse.Quotes.Quote.Ask

    mu.Lock()
    defer mu.Unlock()

    if newBid > currentBid {
        currentBid = newBid
    }
    if newAsk > currentAsk {
        currentAsk = newAsk
    }

    return currentBid, currentAsk
}

这个实现使用了包级变量currentBid和currentAsk来存储当前最高值，并通过互斥锁mu来确保并发安全。每次调用函数时，会比较新获取的价格与当前存储的最高价格，只有当新价格更高时才更新对应的变量。

示例使用：

func main() {
    // 第一次调用：假设返回 bid=1.00, ask=2.00
    bid, ask := optionHighQuote()
    // bid=1.00, ask=2.00
    
    // 第二次调用：假设返回 bid=1.02, ask=1.98
    bid, ask = optionHighQuote()
    // bid=1.02, ask=2.00 (ask保持不变，因为1.98 < 2.00)
    
    // 第三次调用：假设返回 bid=0.95, ask=2.05
    bid, ask = optionHighQuote()
    // bid=1.02, ask=2.05 (bid保持不变，因为0.95 < 1.02)
}