README ¶
filetype
Small and dependency free Go package to infer file and MIME type checking the magic numbers signature.
For SVG file type checking, see go-is-svg package.
Features
- Supports a wide range of file types
- Provides file extension and proper MIME type
- File discovery by extension or MIME type
- File discovery by class (image, video, audio...)
- Provides a bunch of helpers and file matching shortcuts
- Pluggable: add custom new types and matchers
- Simple and semantic API
- Blazing fast, even processing large files
- Only first 261 bytes representing the max file header is required, so you can just pass a slice
- Dependency free (just Go code, no C compilation needed)
- Cross-platform file recognition
Installation
go get gopkg.in/h2non/filetype.v1
API
See Godoc reference.
Subpackages
Examples
Simple file type checking
package main
import (
"fmt"
"gopkg.in/h2non/filetype.v1"
"io/ioutil"
)
func main() {
buf, _ := ioutil.ReadFile("sample.jpg")
kind, unknown := filetype.Match(buf)
if unknown != nil {
fmt.Printf("Unknown: %s", unknown)
return
}
fmt.Printf("File type: %s. MIME: %s\n", kind.Extension, kind.MIME.Value)
}
Check type class
package main
import (
"fmt"
"gopkg.in/h2non/filetype.v1"
"io/ioutil"
)
func main() {
buf, _ := ioutil.ReadFile("sample.jpg")
if filetype.IsImage(buf) {
fmt.Println("File is an image")
} else {
fmt.Println("Not an image")
}
}
Supported type
package main
import (
"fmt"
"gopkg.in/h2non/filetype.v1"
)
func main() {
// Check if file is supported by extension
if filetype.IsSupported("jpg") {
fmt.Println("Extension supported")
} else {
fmt.Println("Extension not supported")
}
// Check if file is supported by extension
if filetype.IsMIMESupported("image/jpeg") {
fmt.Println("MIME type supported")
} else {
fmt.Println("MIME type not supported")
}
}
File header
package main
import (
"fmt"
"gopkg.in/h2non/filetype.v1"
"io/ioutil"
)
func main() {
// Open a file descriptor
file, _ := os.Open("movie.mp4")
// We only have to pass the file header = first 261 bytes
head := make([]byte, 261)
file.Read(head)
if filetype.IsImage(head) {
fmt.Println("File is an image")
} else {
fmt.Println("Not an image")
}
}
Add additional file type matchers
package main
import (
"fmt"
"gopkg.in/h2non/filetype.v1"
)
var fooType = filetype.NewType("foo", "foo/foo")
func fooMatcher(buf []byte) bool {
return len(buf) > 1 && buf[0] == 0x01 && buf[1] == 0x02
}
func main() {
// Register the new matcher and its type
filetype.AddMatcher(fooType, fooMatcher)
// Check if the new type is supported by extension
if filetype.IsSupported("foo") {
fmt.Println("New supported type: foo")
}
// Check if the new type is supported by MIME
if filetype.IsMIMESupported("foo/foo") {
fmt.Println("New supported MIME type: foo/foo")
}
// Try to match the file
fooFile := []byte{0x01, 0x02}
kind, _ := filetype.Match(fooFile)
if kind == filetype.Unknown {
fmt.Println("Unknown file type")
} else {
fmt.Printf("File type matched: %s\n", kind.Extension)
}
}
Supported types
Image
- jpg -
image/jpeg
- png -
image/png
- gif -
image/gif
- webp -
image/webp
- cr2 -
image/x-canon-cr2
- tif -
image/tiff
- bmp -
image/bmp
- jxr -
image/vnd.ms-photo
- psd -
image/vnd.adobe.photoshop
- ico -
image/x-icon
Video
- mp4 -
video/mp4
- m4v -
video/x-m4v
- mkv -
video/x-matroska
- webm -
video/webm
- mov -
video/quicktime
- avi -
video/x-msvideo
- wmv -
video/x-ms-wmv
- mpg -
video/mpeg
- flv -
video/x-flv
Audio
- mid -
audio/midi
- mp3 -
audio/mpeg
- m4a -
audio/m4a
- ogg -
audio/ogg
- flac -
audio/x-flac
- wav -
audio/x-wav
- amr -
audio/amr
Archive
- epub -
application/epub+zip
- zip -
application/zip
- tar -
application/x-tar
- rar -
application/x-rar-compressed
- gz -
application/gzip
- bz2 -
application/x-bzip2
- 7z -
application/x-7z-compressed
- xz -
application/x-xz
- pdf -
application/pdf
- exe -
application/x-msdownload
- swf -
application/x-shockwave-flash
- rtf -
application/rtf
- eot -
application/octet-stream
- ps -
application/postscript
- sqlite -
application/x-sqlite3
- nes -
application/x-nintendo-nes-rom
- crx -
application/x-google-chrome-extension
- cab -
application/vnd.ms-cab-compressed
- deb -
application/x-deb
- ar -
application/x-unix-archive
- Z -
application/x-compress
- lz -
application/x-lzip
- rpm -
application/x-rpm
- elf -
application/x-executable
Documents
- doc -
application/msword
- docx -
application/vnd.openxmlformats-officedocument.wordprocessingml.document
- xls -
application/vnd.ms-excel
- xlsx -
application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
- ppt -
application/vnd.ms-powerpoint
- pptx -
application/vnd.openxmlformats-officedocument.presentationml.presentation
Font
- woff -
application/font-woff
- woff2 -
application/font-woff
- ttf -
application/font-sfnt
- otf -
application/font-sfnt
Benchmarks
Measured using real files.
Environment: OSX x64 i7 2.7 Ghz
BenchmarkMatchTar-8 1000000 1083 ns/op
BenchmarkMatchZip-8 1000000 1162 ns/op
BenchmarkMatchJpeg-8 1000000 1280 ns/op
BenchmarkMatchGif-8 1000000 1315 ns/op
BenchmarkMatchPng-8 1000000 1121 ns/op
License
MIT - Tomas Aparicio
Documentation ¶
Index ¶
- Constants
- Variables
- func AddMatcher(fileType types.Type, matcher matchers.Matcher) matchers.TypeMatcher
- func AddType(ext, mime string) types.Type
- func Archive(buf []byte) (types.Type, error)
- func Audio(buf []byte) (types.Type, error)
- func Font(buf []byte) (types.Type, error)
- func Get(buf []byte) (types.Type, error)
- func GetType(ext string) types.Type
- func Image(buf []byte) (types.Type, error)
- func Is(buf []byte, ext string) bool
- func IsArchive(buf []byte) bool
- func IsAudio(buf []byte) bool
- func IsExtension(buf []byte, ext string) bool
- func IsFont(buf []byte) bool
- func IsImage(buf []byte) bool
- func IsMIME(buf []byte, mime string) bool
- func IsMIMESupported(mime string) bool
- func IsSupported(ext string) bool
- func IsType(buf []byte, kind types.Type) bool
- func IsVideo(buf []byte) bool
- func Match(buf []byte) (types.Type, error)
- func MatchFile(filepath string) (types.Type, error)
- func MatchMap(buf []byte, matchers matchers.Map) types.Type
- func MatchReader(reader io.Reader) (types.Type, error)
- func Matches(buf []byte) bool
- func MatchesMap(buf []byte, matchers matchers.Map) bool
- func Video(buf []byte) (types.Type, error)
Constants ¶
const Version = "1.0.5"
Version exposes the current package version.
Variables ¶
var ErrEmptyBuffer = errors.New("Empty buffer")
ErrEmptyBuffer represents an empty buffer error
var ErrUnknownBuffer = errors.New("Unknown buffer type")
ErrUnknownBuffer represents a unknown buffer error
var Matchers = matchers.Matchers
Matchers is an alias to matchers.Matchers
var NewMatcher = matchers.NewMatcher
NewMatcher is an alias to matchers.NewMatcher
var NewType = types.NewType
NewType creates and registers a new type
var Types = types.Types
Types stores a map of supported types
var Unknown = types.Unknown
Unknown represents an unknown file type
Functions ¶
func AddMatcher ¶
AddMatcher registers a new matcher type
func IsMIMESupported ¶
IsMIMESupported checks if a given MIME type is supported
func IsSupported ¶
IsSupported checks if a given file extension is supported
func MatchReader ¶
MatchReader is convenient wrapper to Match() any Reader
func MatchesMap ¶
MatchesMap is an alias to Matches() but using matching againts a map of match functions
Types ¶
This section is empty.