Question

如何将web color格式（3或6个十六进制数字）的RGB颜色从Color解析为image/color？ go是否有任何内置的解析器？我希望能够解析#XXXXXX和#XXX颜色格式。 color个文档对此一无所获：https://golang.org/pkg/image/color/ 但是此任务非常常见，因此我相信go具有一些功能（我只是没有找到）。

Answer 1

RGBA颜色只有4个字节，每个红色，绿色，蓝色和alpha通道一个。对于三到六个十六进制数字，通常将alpha字节隐含为0xFF（AABBCC与AABBCCFF相同，ABC也一样）。

因此，解析颜色字符串就像对其进行标准化一样简单，因此它的格式为“ RRGGBBAA”（4个十六进制编码的字节），然后对其进行解码：

package main

import (
    "encoding/hex"
    "fmt"
    "image/color"
    "log"
)

func main() {
    colorStr := "102030FF"

    colorStr, err := normalize(colorStr)
    if err != nil {
        log.Fatal(err)
    }

    b, err := hex.DecodeString(colorStr)
    if err != nil {
        log.Fatal(err)
    }

    color := color.RGBA{b[0], b[1], b[2], b[3]}

    fmt.Println(color) // Output: {16 32 48 255}
}

func normalize(colorStr string) (string, error) {
    // left as an exercise for the reader
    return colorStr, nil
}

在操场上尝试：https://play.golang.org/p/aCX-vyfMG4G

Answer 2

1。优雅的解决方案

这是使用fmt.Sscanf()的另一种解决方案。它当然不是最快的解决方案，但它很优雅。它会直接扫描到color.RGBA结构的字段中：

func ParseHexColor(s string) (c color.RGBA, err error) {
    c.A = 0xff
    switch len(s) {
    case 7:
        _, err = fmt.Sscanf(s, "#%02x%02x%02x", &c.R, &c.G, &c.B)
    case 4:
        _, err = fmt.Sscanf(s, "#%1x%1x%1x", &c.R, &c.G, &c.B)
        // Double the hex digits:
        c.R *= 17
        c.G *= 17
        c.B *= 17
    default:
        err = fmt.Errorf("invalid length, must be 7 or 4")

    }
    return
}

测试：

hexCols := []string{
    "#112233",
    "#123",
    "#000233",
    "#023",
    "invalid",
    "#abcd",
    "#-12",
}
for _, hc := range hexCols {
    c, err := ParseHexColor(hc)
    fmt.Printf("%-7s = %3v, %v\n", hc, c, err)
}

输出（在Go Playground上尝试）：

#112233 = { 17  34  51 255}, <nil>
#123    = { 17  34  51 255}, <nil>
#000233 = {  0   2  51 255}, <nil>
#023    = {  0  34  51 255}, <nil>
invalid = {  0   0   0 255}, input does not match format
#abcd   = {  0   0   0 255}, invalid length, must be 7 or 4
#-12    = {  0   0   0 255}, expected integer

2。快速解决方案

如果性能确实很重要，那么fmt.Sscanf()是一个非常糟糕的选择。它需要实现必须解析的格式字符串，并根据它解析输入，并使用反射将结果存储到指定的值。

由于任务基本上只是“解析”一个十六进制值，因此我们可以做得更好。我们甚至不必调用通用的十六进制解析库（例如encoding/hex），我们可以自己完成此操作。我们甚至不必将输入视为string或什至一系列rune，我们可能会降低到将其视为一系列字节的级别。是的，Go将string的值作为UTF-8字节序列存储在内存中，但是如果输入是有效的颜色字符串，则其所有字节必须在0..127的范围内，该范围映射到字节1-to -1。如果不是这种情况，则输入将已经是无效的，我们将检测到该输入，但是在这种情况下返回的颜色无关紧要（无关紧要）。

现在让我们来看一个快速的实现：

var errInvalidFormat = errors.New("invalid format")

func ParseHexColorFast(s string) (c color.RGBA, err error) {
    c.A = 0xff

    if s[0] != '#' {
        return c, errInvalidFormat
    }

    hexToByte := func(b byte) byte {
        switch {
        case b >= '0' && b <= '9':
            return b - '0'
        case b >= 'a' && b <= 'f':
            return b - 'a' + 10
        case b >= 'A' && b <= 'F':
            return b - 'A' + 10
        }
        err = errInvalidFormat
        return 0
    }

    switch len(s) {
    case 7:
        c.R = hexToByte(s[1])<<4 + hexToByte(s[2])
        c.G = hexToByte(s[3])<<4 + hexToByte(s[4])
        c.B = hexToByte(s[5])<<4 + hexToByte(s[6])
    case 4:
        c.R = hexToByte(s[1]) * 17
        c.G = hexToByte(s[2]) * 17
        c.B = hexToByte(s[3]) * 17
    default:
        err = errInvalidFormat
    }
    return
}

使用与第一个示例相同的输入对其进行测试，其输出为（在Go Playground上尝试）：

#112233 = { 17  34  51 255}, <nil>
#123    = { 17  34  51 255}, <nil>
#000233 = {  0   2  51 255}, <nil>
#023    = {  0  34  51 255}, <nil>
invalid = {  0   0   0 255}, invalid format
#abcd   = {  0   0   0 255}, invalid format
#-12    = {  0  17  34 255}, invalid format

3。基准

让我们对这两种解决方案进行基准测试。基准测试代码将包括使用长格式和短格式调用它们。错误情况除外。

func BenchmarkParseHexColor(b *testing.B) {
    for i := 0; i < b.N; i++ {
        ParseHexColor("#112233")
        ParseHexColor("#123")
    }
}

func BenchmarkParseHexColorFast(b *testing.B) {
    for i := 0; i < b.N; i++ {
        ParseHexColorFast("#112233")
        ParseHexColorFast("#123")
    }
}

这是基准测试结果：

go test -bench . -benchmem

BenchmarkParseHexColor-4         500000     2557 ns/op      144 B/op    9 allocs/op
BenchmarkParseHexColorFast-4   100000000      10.3 ns/op      0 B/op    0 allocs/op

我们可以看到，“快速”解决方案的速度大约快了 250倍，并且不使用任何分配方式（不同于“优雅”解决方案）。

Answer 3

您可以使用strconv.ParseUint

将任意2个十六进制数字转换为整数

strconv.ParseUint(str, 16, 8)

16表示基数为16（十六进制），而8表示位计数，在这种情况下为一个字节。

您可以使用它来将每个2个字符解析为其组件

https://play.golang.org/p/B56B8_NvnVR

func ParseHexColor(v string) (out color.RGBA, err error) {
    if len(v) != 7 {
        return out, errors.New("hex color must be 7 characters")
    }
    if v[0] != '#' {
        return out, errors.New("hex color must start with '#'")
    }
    var red, redError = strconv.ParseUint(v[1:3], 16, 8)
    if redError != nil {
        return out, errors.New("red component invalid")
    }
    out.R = uint8(red)
    var green, greenError = strconv.ParseUint(v[3:5], 16, 8)
    if greenError != nil {
        return out, errors.New("green component invalid")
    }
    out.G = uint8(green)
    var blue, blueError = strconv.ParseUint(v[5:7], 16, 8)
    if blueError != nil {
        return out, errors.New("blue component invalid")
    }
    out.B = uint8(blue)
    return
}

编辑：感谢Peter的纠正

将十六进制字符串解析为图像/颜色

3 个答案:

1。优雅的解决方案

2。快速解决方案

3。基准