mimetype Go Package

The library uses a hierarchical detection structure to optimize performance. This approach is particularly useful for container formats; for example, once a file is identified as a ZIP archive, the library skips generic checks (like text vs. binary) and instead checks if it matches specific container formats like Microsoft Office files.

To maintain efficiency and avoid loading entire files into memory, mimetype.DetectReader and mimetype.DetectFile only read the header of the input by default.

Some file formats (such as Microsoft Office documents) store their magic number signatures towards the end of the file rather than the beginning. If a supported file is not being detected correctly, you can increase the number of bytes used for detection using mimetype.SetLimit().

• mimetype.SetLimit(1024*1024): Sets the detection limit to 1MB.
• mimetype.SetLimit(0): Disables the limit, using the entire file content for detection.

mimetype.SetLimit(1024*1024) // Set limit to 1MB.
// or
mimetype.SetLimit(0) // No limit, whole file content used.

mimetype.DetectFile("file.doc")

To add mimetype to your Go project, use the go get command:

go get github.com/gabriel-vasile/mimetype

The mimetype package provides three primary ways to detect a file's MIME type and extension based on magic numbers. Once detected, you can use the .String() method to get the MIME type string and .Extension() to get the file extension.

Note: Content type detection using magic numbers should be a last resort, as it is slower and less accurate than using protocol metadata like the Content-Type header in HTTP or SMTP.

Use DetectReader(r io.Reader) to identify the MIME type of a stream.

Important Considerations:

• Offset: The reader must be at the start of the data. If using an io.ReadSeeker that has already been read, you must rewind it using reader.Seek(0, io.SeekStart) before calling DetectReader.
• Error Handling: If identification fails, it returns application/octet-stream. Any returned error is specifically related to the reading process from the input reader.
• Limit: If SetLimit is greater than 0, only up to that many bytes are read. If SetLimit is 0, the entire reader is consumed.

Use SetLimit(limit uint32) to control the maximum number of bytes read from an input during detection.

• Default: 4096 bytes.
• Increasing the limit: Useful for file formats that store magic numbers towards the end of the file (e.g., docx, pptx, xlsx).
• Setting to 0: Tells the library to use the entire input file/stream for detection.
• Concurrency: This is safe to call from different goroutines.

Use Extend(detector func(raw []byte, limit uint32) bool, mime, extension string, aliases ...string) to add support for new file formats. This adds the new format to the root application/octet-stream MIME type.

The detector function should return true if the provided raw bytes match the format.

The Is(expectedMIME string) method checks if the current MIME type matches the expectedMIME string.

It is robust because it:

• Checks both the primary MIME type and any registered aliases.
• Performs equality tests on the type/subtype section only.
• Ignores optional MIME parameters (e.g., ; charset=utf-8).
• Ignores leading/trailing whitespace.
• Is case-insensitive.

func (m *MIME) Is(expectedMIME string) bool

You can add support for new sub-formats to an existing MIME type using the Extend method.

To extend a format, you must provide:

1. A detector function: func(raw []byte, limit uint32) bool. This function returns true if the input matches the signature.
2. The mime type string.
3. The extension (including the leading dot, e.g., ".ext").
4. Optional aliases.

Note: A sub-format will only be detected if all detectors in its parent chain also return true.