image/color 的 Color？Go 语言中是否有内置的解析器？
我希望能够解析 #XXXXXX 和 #XXX 颜色格式。
color 文档没有提到这一点：https://golang.org/pkg/image/color/
但这是一个非常常见的任务，因此我相信 Go 语言有一些函数可以做到这一点（我只是没有找到）。
更新：我基于被接受的答案创建了一个小型的Go库：github.com/g4s8/hexcolor
前言：我在github.com/icza/gox上发布了这个实用工具（2.快速解决方案），请参见colorx.ParseHexColor()。
这里是另一个使用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
如果性能很重要，fmt.Sscanf() 不是一个好的选择。它需要一个格式化字符串，实现必须解析它，根据它解析输入，并使用反射将结果存储到指向的值中。
由于任务基本上只是“解析”十六进制值，我们可以做得比这更好。我们甚至不必调用通用的十六进制解析库（例如 encoding/hex ），我们可以自己完成。我们甚至不必将输入视为string或一系列的rune，我们可以降低处理它的级别，将其视为一系列字节。 是的，Go将string值作为UTF-8字节序列存储在内存中，但是如果输入是有效的颜色字符串，则其所有字节必须在0..127范围内，这映射到字节1对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
让我们对这两个解决方案进行基准测试。 基准测试代码将包括使用长格式和短格式调用它们。 错误情况被排除在外。
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倍，并且不使用分配内存（与“优雅”的解决方案不同）。
ParseHexColorFast也能正确地给出颜色。谢谢。 - STEELRGBA颜色只有4个字节，分别是红、绿、蓝和透明度通道。对于三个或六个十六进制数字，透明度字节通常被默认为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
}
您可以使用strconv.ParseUint将任意2个十六进制数字转换为整数。
strconv.ParseUint(str, 16, 8)
16 表示十六进制（hex），而 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的更正
ParseUint而不是ParseInt，并将最后一个参数设置为8。否则像“＃-e-4-c”这样的内容会被视为有效输入。 - Peter