mirror of https://github.com/octoleo/syncthing.git synced 2024-11-09 23:00:58 +00:00

Jakob Borg 4c3cd4c9e3 lib/ignore: Replace lib/fnmatch with github.com/gobwas/glob

Because it's literally ten times faster:



	benchmark                  old ns/op     new ns/op     delta

	BenchmarkMatch-8           13842         1200          -91.33%

	BenchmarkMatchCached-8     139           147           +5.76%



	benchmark                  old allocs     new allocs     delta

	BenchmarkMatch-8           0              0              +0.00%

	BenchmarkMatchCached-8     0              0              +0.00%



	benchmark                  old bytes     new bytes     delta

	BenchmarkMatch-8           12            0             -100.00%

	BenchmarkMatchCached-8     0             0             +0.00%

2016-04-02 20:03:24 +01:00

5.1 KiB

Raw Blame History

glob.go

Go Globbing Library.

Install

    go get github.com/gobwas/glob

Example


package main

import "github.com/gobwas/glob"

func main() {
    var g glob.Glob
    
    // create simple glob
    g = glob.MustCompile("*.github.com")
    g.Match("api.github.com") // true
    
    // quote meta characters and then create simple glob 
    g = glob.MustCompile(glob.QuoteMeta("*.github.com"))
    g.Match("*.github.com") // true
    
    // create new glob with set of delimiters as ["."]
    g = glob.MustCompile("api.*.com", '.')
    g.Match("api.github.com") // true
    g.Match("api.gi.hub.com") // false
    
    // create new glob with set of delimiters as ["."]
    // but now with super wildcard
    g = glob.MustCompile("api.**.com", '.')
    g.Match("api.github.com") // true
    g.Match("api.gi.hub.com") // true
        
    // create glob with single symbol wildcard
    g = glob.MustCompile("?at")
    g.Match("cat") // true
    g.Match("fat") // true
    g.Match("at") // false
    
    // create glob with single symbol wildcard and delimiters ['f']
    g = glob.MustCompile("?at", 'f')
    g.Match("cat") // true
    g.Match("fat") // false
    g.Match("at") // false 
    
    // create glob with character-list matchers 
    g = glob.MustCompile("[abc]at")
    g.Match("cat") // true
    g.Match("bat") // true
    g.Match("fat") // false
    g.Match("at") // false
    
    // create glob with character-list matchers 
    g = glob.MustCompile("[!abc]at")
    g.Match("cat") // false
    g.Match("bat") // false
    g.Match("fat") // true
    g.Match("at") // false 
    
    // create glob with character-range matchers 
    g = glob.MustCompile("[a-c]at")
    g.Match("cat") // true
    g.Match("bat") // true
    g.Match("fat") // false
    g.Match("at") // false
    
    // create glob with character-range matchers 
    g = glob.MustCompile("[!a-c]at")
    g.Match("cat") // false
    g.Match("bat") // false
    g.Match("fat") // true
    g.Match("at") // false 
    
    // create glob with pattern-alternatives list 
    g = glob.MustCompile("{cat,bat,[fr]at}")
    g.Match("cat") // true
    g.Match("bat") // true
    g.Match("fat") // true
    g.Match("rat") // true
    g.Match("at") // false 
    g.Match("zat") // false 
}

Performance

This library is created for compile-once patterns. This means, that compilation could take time, but strings matching is done faster, than in case when always parsing template.

If you will not use compiled glob.Glob object, and do g := glob.MustCompile(pattern); g.Match(...) every time, then your code will be much more slower.

Run go test -bench=. from source root to see the benchmarks:

Pattern	Fixture	Match	Speed (ns/op)
`[a-z][!a-x]cat[h][!b]eyes`	`my cat has very bright eyes`	`true`	432
`[a-z][!a-x]cat[h][!b]eyes`	`my dog has very bright eyes`	`false`	199
`https://.google.`	`https://account.google.com`	`true`	96
`https://.google.`	`https://google.com`	`false`	66
`{https://.google.,yandex.,yahoo.,*mail.ru}`	`http://yahoo.com`	`true`	163
`{https://.google.,yandex.,yahoo.,*mail.ru}`	`http://google.com`	`false`	197
`{https://*gobwas.com,http://exclude.gobwas.com}`	`https://safe.gobwas.com`	`true`	22
`{https://*gobwas.com,http://exclude.gobwas.com}`	`http://safe.gobwas.com`	`false`	24
`abc*`	`abcdef`	`true`	8.15
`abc*`	`af`	`false`	5.68
`*def`	`abcdef`	`true`	8.84
`*def`	`af`	`false`	5.74
`ab*ef`	`abcdef`	`true`	15.2
`ab*ef`	`af`	`false`	10.4

The same things with regexp package:

Pattern	Fixture	Match	Speed (ns/op)
`^[a-z][^a-x].cat.[h][^b].eyes.$`	`my cat has very bright eyes`	`true`	2553
`^[a-z][^a-x].cat.[h][^b].eyes.$`	`my dog has very bright eyes`	`false`	1383
`^https:\/\/.\.google\..$`	`https://account.google.com`	`true`	1205
`^https:\/\/.\.google\..$`	`https://google.com`	`false`	767
`^(https://..google..	.yandex..	.yahoo..	.*mail.ru)$`
`^(https://..google..	.yandex..	.yahoo..	.*mail.ru)$`
`^(https://.*gobwas.com	http://exclude.gobwas.com)$`	`https://safe.gobwas.com`	`true`
`^(https://.*gobwas.com	http://exclude.gobwas.com)$`	`http://safe.gobwas.com`	`false`
`^abc.*$`	`abcdef`	`true`	237
`^abc.*$`	`af`	`false`	100
`^.*def$`	`abcdef`	`true`	464
`^.*def$`	`af`	`false`	265
`^ab.*ef$`	`abcdef`	`true`	375
`^ab.*ef$`	`af`	`false`	145

Syntax

Syntax is inspired by standard wildcards, except that ** is aka super-asterisk, that do not sensitive for separators.

5.1 KiB Raw Blame History