其思想是创建一个函数，该函数将写入多个写入器并执行返回，以便：

• 将[]字节片写入所有写入程序
• 返回每个写入器写入的n个字节，索引位置与写入器的索引位置相对应。-如果切片为空，则返回（[]int{}）...等等

错误函数：

type Errors []error

func (m Errors) Error() string {
    count := 0
    for t := 0; t < len(m); t++ {
        if m[t] != nil {
            count += 1

        }
    }
    errindex := 0
    for t := 0; t < len(m); t++ {
        if m[t] != nil {
            errindex = t
            break
        }
    }

    if count == 0 {
        return fmt.Sprintf("(0 errors)")
    } else {
        if count == 1 {
            return fmt.Sprintf("%v", m[errindex])
        } else if count == 2 {
            return fmt.Sprintf("%v (and 1 other error)", m[errindex])
        } else {
            return fmt.Sprintf("%v (and %d other errors)", m[errindex], count-1)

        }

    }
}

验证码：

func WriteTo(b []byte, writers ...io.Writer) (n []int, errs errors.Errors) {
    if len(writers) == 0 {
        return []int{}, nil
    }
    for i := 0; i < len(writers); i++ {
        num, err := writers[i].Write(b) // write bytes to a current writer
        n = append(n, num)              // add bytes written by current write
        if err!=nil{
            switch err{
            case io.ErrShortWrite:
                errs = append(errs, err)
            default:
                errs = append(errs, err)
            }
        }
    }
    return n, errs
}

我尝试修复它，但有些测试没有通过。无法真正看到问题。不是在count == 1时返回，而是在count == 0时返回，在count == 2时返回，而是在count == 0时返回

[]error{nil, io.ErrShortWrite, nil},

    []error{nil, io.ErrShortWrite, io.ErrShortWrite},