Package mimetype

▾ Example (Detect)

Code:

testBytes := []byte("This random text has a MIME type of text/plain; charset=utf-8.")

mtype := mimetype.Detect(testBytes)
fmt.Println(mtype.Is("text/plain"), mtype.String(), mtype.Extension())

mtype, err := mimetype.DetectReader(bytes.NewReader(testBytes))
fmt.Println(mtype.Is("text/plain"), mtype.String(), mtype.Extension(), err)

mtype, err = mimetype.DetectFile("a nonexistent file")
fmt.Println(mtype.Is("application/octet-stream"), mtype.String(), os.IsNotExist(err))

Output:

true text/plain; charset=utf-8 .txt
true text/plain; charset=utf-8 .txt <nil>
true application/octet-stream true

▾ Example (DetectReader)

Pure io.Readers (meaning those without a Seek method) cannot be read twice. This means that once DetectReader has been called on an io.Reader, that reader is missing the bytes representing the header of the file. To detect the MIME type and then reuse the input, use a buffer, io.TeeReader, and io.MultiReader to create a new reader containing the original, unaltered data. If the input is an io.ReadSeeker instead, call input.Seek(0, io.SeekStart) before reusing it.

Code:

package mimetype_test

import (
    "bytes"
    "fmt"
    "io"

    "github.com/gabriel-vasile/mimetype"
)

// Pure io.Readers (meaning those without a Seek method) cannot be read twice.
// This means that once DetectReader has been called on an io.Reader, that reader
// is missing the bytes representing the header of the file.
// To detect the MIME type and then reuse the input, use a buffer, io.TeeReader,
// and io.MultiReader to create a new reader containing the original, unaltered data.
//
// If the input is an io.ReadSeeker instead, call input.Seek(0, io.SeekStart)
// before reusing it.
func Example_detectReader() {
    testBytes := []byte("This random text has a MIME type of text/plain; charset=utf-8.")
    input := bytes.NewReader(testBytes)

    mtype, recycledInput, err := recycleReader(input)

    // Verify recycledInput contains the original input.
    text, _ := io.ReadAll(recycledInput)
    fmt.Println(mtype, bytes.Equal(testBytes, text), err)
    // Output: text/plain; charset=utf-8 true <nil>
}

// recycleReader returns the MIME type of input and a new reader
// containing the whole data from input.
func recycleReader(input io.Reader) (mimeType string, recycled io.Reader, err error) {
    // header will store the bytes mimetype uses for detection.
    header := bytes.NewBuffer(nil)

    // After DetectReader, the data read from input is copied into header.
    mtype, err := mimetype.DetectReader(io.TeeReader(input, header))
    if err != nil {
        return
    }

    // Concatenate back the header to the rest of the file.
    // recycled now contains the complete, original data.
    recycled = io.MultiReader(header, input)

    return mtype.String(), recycled, err
}

▾ Example (Extend)

Use Extend to add support for a file format which is not detected by mimetype. https://www.garykessler.net/library/file_sigs.html and https://github.com/file/file/tree/master/magic/Magdir have signatures for a multitude of file formats.

Code:

foobarDetector := func(raw []byte, limit uint32) bool {
    return bytes.HasPrefix(raw, []byte("foobar"))
}

mimetype.Lookup("text/plain").Extend(foobarDetector, "text/foobar", ".fb")
mtype := mimetype.Detect([]byte("foobar file content"))

fmt.Println(mtype.String(), mtype.Extension())

Output:

text/foobar .fb

▾ Example (TextVsBinary)

Considering the definition of a binary file as "a computer file that is not a text file", they can differentiated by searching for the text/plain MIME in their MIME hierarchy.

Code:

testBytes := []byte("This random text has a MIME type of text/plain; charset=utf-8.")
detectedMIME := mimetype.Detect(testBytes)

isBinary := true
for mtype := detectedMIME; mtype != nil; mtype = mtype.Parent() {
    if mtype.Is("text/plain") {
        isBinary = false
    }
}

fmt.Println(isBinary, detectedMIME)

Output:

false text/plain; charset=utf-8

▾ Example (Whitelist)

Code:

testBytes := []byte("This random text has a MIME type of text/plain; charset=utf-8.")
allowed := []string{"text/plain", "application/zip", "application/pdf"}
mtype := mimetype.Detect(testBytes)

if mimetype.EqualsAny(mtype.String(), allowed...) {
    fmt.Printf("%s is allowed\n", mtype)
} else {
    fmt.Printf("%s is now allowed\n", mtype)
}

Output:

text/plain; charset=utf-8 is allowed