antstyle

package module
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 25, 2023 License: MIT Imports: 5 Imported by: 0

README

Ant-Style

默认实现是AntPathMatcher，支持* Ant-Style的模式语法。 该描述来自java spring框架。

ant path 通配规则

Table Ant Wildcard Characters

Wildcard Description
? 匹配任何单字符
* 匹配0或者任意数量的字符
** 匹配0或者更多的目录

Table Example Ant-Style Path Patterns

Path Description
/app/*.x 匹配(Matches)所有在app路径下的.x文件
/app/p?ttern 匹配(Matches) /app/pattern 和 /app/pXttern,但是不包括/app/pttern
/**/example 匹配(Matches) /app/example, /app/foo/example, 和 /example
/app/**/dir/file. 匹配(Matches) /app/dir/file.jsp, /app/foo/dir/file.html,/app/foo/bar/dir/file.pdf, 和 /app/dir/file.java
/**/*.jsp 匹配(Matches)任何的.jsp 文件

基本使用PathMatcher接口

使用demo

package main

import "fmt"
import "github.com/aluka-7/antstyle"

func main(){
	fmt.Println(antstyle.Match("test","test"))
	fmt.Println(antstyle.Match("test*aaa", "testblaaaa"))
	fmt.Println(antstyle.Match("t?st", "test"))
	fmt.Println(antstyle.Match("/{bla}.*", "/testing.html"))
}

Documentation

Index

Constants

View Source 
const (
	DefaultVariablePattern = "(.*)"
	MaxFindCount           = 1 << 5 // MaxFindCount默认值= 32
)
View Source 
const (
	DefaultPathSeparator  = "/"   // DefaultPathSeparator默认路径分隔符：“ /”
	CacheTurnoffThreshold = 65536 // 缓存关闭阈值
)

Variables

View Source 
var (
	Asterisk        rune           = '\u002a'                                 // *
	QuestionMark    rune           = '\u003f'                                 // ?
	Brackets        rune           = '\u007b'                                 // {
	WildcardChars   []rune         = []rune{Asterisk, QuestionMark, Brackets} // 通配符字符首字母'*'，'？'，'{'
	VariablePattern *regexp.Regexp                                            // pattern

)
View Source 
var GlobPattern *regexp.Regexp

Functions

func Increment 

func Increment(value *int)

func IsPattern 

func IsPattern(path string) bool

func Match 

func Match(pattern, path string) bool

func MatchStart 

func MatchStart(pattern, path string) bool

func SetCachePatterns 

func SetCachePatterns(cachePatterns bool)

func SetCaseSensitive 

func SetCaseSensitive(caseSensitive bool)

func SetPathSeparator 

func SetPathSeparator(pathSeparator string)

func SetTrimTokens 

func SetTrimTokens(trimTokens bool)

Types

type AntPathMatcher 

type AntPathMatcher struct {
	// contains filtered or unexported fields
}

AntPathMatcher 实现了接口 PathMatcher

func New 

func New() *AntPathMatcher

func NewS 

func NewS(separator string) *AntPathMatcher

func (*AntPathMatcher) Combine 

func (ant *AntPathMatcher) Combine(pattern1, pattern2 string) string

@Override Combine 将pattern1和pattern2联合成一个新的pattern

func (*AntPathMatcher) ExtractPathWithinPattern 

func (ant *AntPathMatcher) ExtractPathWithinPattern(pattern, path string) string

@Override ExtractPathWithinPattern

func (*AntPathMatcher) ExtractUriTemplateVariables 

func (ant *AntPathMatcher) ExtractUriTemplateVariables(pattern, path string) *map[string]string

@Override ExtractUriTemplateVariables

func (*AntPathMatcher) GetPatternComparator 

func (ant *AntPathMatcher) GetPatternComparator(path string) *AntPatternComparator

@Override GetPatternComparator

func (*AntPathMatcher) IsPattern 

func (ant *AntPathMatcher) IsPattern(path string) bool

@Override IsPattern

func (*AntPathMatcher) Match 

func (ant *AntPathMatcher) Match(pattern, path string) bool

@Override Match

func (*AntPathMatcher) MatchStart 

func (ant *AntPathMatcher) MatchStart(pattern, path string) bool

@Override MatchStart

func (*AntPathMatcher) PatternCacheSize 

func (ant *AntPathMatcher) PatternCacheSize() int64

func (*AntPathMatcher) SetCachePatterns 

func (ant *AntPathMatcher) SetCachePatterns(cachePatterns bool)

SetCachePatterns *

  • Specify whether to cache parsed pattern metadata for patterns passed
  • into this matcher's {@link #match} method. A value of {@code true}
  • activates an unlimited pattern cache; a value of {@code false} turns
  • the pattern cache off completely.
  • <p>Default is for the cache to be on, but with the variant to automatically
  • turn it off when encountering too many patterns to cache at runtime
  • (the threshold is 65536), assuming that arbitrary permutations of patterns
  • are coming in, with little chance for encountering a recurring pattern.

func (*AntPathMatcher) SetCaseSensitive 

func (ant *AntPathMatcher) SetCaseSensitive(caseSensitive bool)

SetCaseSensitive 区分大小写 The default is false

  • Specify whether to perform pattern matching in a case-sensitive fashion.
  • Default is {@code true}. Switch this to {@code false} for case-insensitive matching.

func (*AntPathMatcher) SetPathSeparator 

func (ant *AntPathMatcher) SetPathSeparator(pathSeparator string)

SetPathSeparator The default is "/",as in ant. * 

*Set the path separator to use for pattern parsing.

func (*AntPathMatcher) SetTrimTokens 

func (ant *AntPathMatcher) SetTrimTokens(trimTokens bool)

SetTrimTokens 是否去除空格 The default is false * 

*Specify whether to trim tokenized paths and patterns.

type AntPathStringMatcher 

type AntPathStringMatcher struct {
	// contains filtered or unexported fields
}

* * Tests whether or not a string matches against a pattern via a {@link Pattern}. * <p>The pattern may contain special characters: '*' means zero or more characters; '?' means one and * only one character; '{' and '}' indicate a URI template pattern. For example <tt>/users/{user}</tt>.

AntPathStringMatcher

func NewDefaultStringMatcher 

func NewDefaultStringMatcher(pattern string, caseSensitive bool) *AntPathStringMatcher

NewDefaultStringMatcher part match

func NewMatchesStringMatcher 

func NewMatchesStringMatcher(pattern string, caseSensitive bool) *AntPathStringMatcher

NewMatchesStringMatcher full match

func (*AntPathStringMatcher) FindSubMatch 

func (sm *AntPathStringMatcher) FindSubMatch(source []byte, index int) *string

FindSubMatch 子查询

func (*AntPathStringMatcher) GroupCount 

func (sm *AntPathStringMatcher) GroupCount() int

GroupCount

func (*AntPathStringMatcher) MatchStrings 

func (sm *AntPathStringMatcher) MatchStrings(str string, uriTemplateVariables *map[string]string) bool

* * Main entry point. * * @return {@code true} if the string matches against the pattern, or {@code false} otherwise.

MatchStrings

type AntPatternComparator 

type AntPatternComparator struct {
	// contains filtered or unexported fields
}

AntPatternComparator * 

*由返回的默认{@link Comparator}实现
*按顺序，最“通用”的模式由以下内容确定:
*如果它为null或捕获所有模式(即等于“ / **”)
*如果其他模式是实际匹配项
*如果它是一个包罗万象的模式\(即以“ **”结尾)
*如果它的"*"比其他模式多
*如果"{foo}"比其他模式多
*如果比其他格式短

func NewDefaultAntPatternComparator 

func NewDefaultAntPatternComparator(path string) *AntPatternComparator

func (*AntPatternComparator) Compare 

func (comparator *AntPatternComparator) Compare(pattern1, pattern2 string) int

type PathMatcher 

type PathMatcher interface {

	/**
	 *给定的{@code path}是否表示可以通过此接口的实现匹配的模式？
	 *如果返回值为{@code false}，则不必使用{@link #match}方法，因为在静态路径Strings上进行直接相等比较将得出相同的结果。
	 *@param path要检查的路径字符串
	 *@return {true}，如果给定的{path}表示一个模式
	 */
	IsPattern(path string) bool

	/**
	 *根据此PathMatcher的匹配策略，将给定的{@code路径}与给定的{@code模式}相匹配。
	 *@param pattern要匹配的模式
	 *@param path要测试的路径字符串
	 *@return {@code true}如果提供的{@code path}匹配，
	 *{@code false}（如果没有）
	 */
	Match(pattern, path string) bool

	/**
	 *根据此PathMatcher的匹配策略，将给定的{@code路径}与给定的{@code模式}的对应部分进行匹配。
	 *确定模式是否至少匹配给定的基本路径，并假设一条完整路径也可以匹配。
	 *@param pattern要匹配的模式
	 *@param path要测试的路径字符串
	 *@return {true}如果提供的{path}匹配，{false}（如果没有）
	 */
	MatchStart(pattern, path string) bool

	/**
	 *给定图案和完整路径，确定图案映射的零件.
	 *该方法应该找出通过实际模式动态匹配路径的哪一部分，即，它从给定的完整路径中剥离静态定义的引导路径，仅返回的实际模式匹配部分路径.
	 *例如:对于"root/*.html"作为模式,"root/file.html"作为完整路径，此方法应返回"file.html".详细的确定规则已指定为此PathMatcher的匹配策略.
	 *如果是实际模式,简单的实现可以按原样返回给定的完整路径,如果模式不包含任何动态部分(即{pattern}参数为静态路径),则为空String则不符合实际的{#isPattern模式}).
	 *复杂的实现将区分给定路径模式的静态部分和动态部分.
	 *@param  pattern 路径模式
	 *@param  path 进行内省的完整路径
	 *@return 给定的{@code path}的模式映射部分
	 *(从不{null})
	 */
	ExtractPathWithinPattern(pattern, path string) string

	/**
	 *给定模式和完整路径,提取URI模板变量.URI模板变量通过大括号("{"和"}")表示.
	 *例如:对于模式"/hotels/{hotel}"和路径"/hotels/1"，此方法将返回包含"hotel"->"1"的地图.
	 *@param pattern string 模式路径模式，可能包含URI模板
	 *@param path string 从中提取模板变量的完整路径
	 *@return map[string]string 其中包含变量名作为键;将变量值作为值
	 */
	ExtractUriTemplateVariables(pattern, path string) *map[string]string

	/**
	 *给定完整路径后，将返回一个{@link Comparator}，适用于按照该路径的显式顺序对模式进行排序。
	 *所使用的完整算法取决于基础实现，但是通常，返回的{AntPatternComparator}一个列表，因此 更具体的模式先于通用模式。
	 *@param path string用于比较的完整路径
	 *@return *AntPatternComparator 能够按显式顺序对模式进行排序的比较器
	 */
	GetPatternComparator(path string) *AntPatternComparator

	/**
	 *将两个模式组合成一个返回的新模式。
	 *用于组合两种模式的完整算法取决于基础实现。
	 *@param pattern1 第一个模式
	 *@param pattern2 第二种模式
	 *@return string 两个模式的组合
	 */
	Combine(pattern1, pattern2 string) string
	SetPathSeparator(pathSeparator string)
	SetCaseSensitive(caseSensitive bool)
	SetTrimTokens(trimTokens bool)
	SetCachePatterns(cachePatterns bool)
	PatternCacheSize() int64
}

*   *策略界面，用于基于路径的匹配。   *   *默认实现是AntPathMatcher，支持Ant-style风格的模式语法。

type PathSeparatorPatternCache 

type PathSeparatorPatternCache struct {
	// contains filtered or unexported fields
}

*

  • 用于依赖配置的路径分隔符的模式的简单缓存。

func NewDefaultPathSeparatorPatternCache 

func NewDefaultPathSeparatorPatternCache(pathSeparator string) *PathSeparatorPatternCache

NewDefaultPathSeparatorPatternCache 构造函数

func (*PathSeparatorPatternCache) GetEndsOnDoubleWildCard 

func (patternCache *PathSeparatorPatternCache) GetEndsOnDoubleWildCard() string

GetEndsOnDoubleWildCard 返回 "**"

func (*PathSeparatorPatternCache) GetEndsOnWildCard 

func (patternCache *PathSeparatorPatternCache) GetEndsOnWildCard() string

GetEndsOnWildCard 返回 "*"

type PatternInfo 

type PatternInfo struct {
	// contains filtered or unexported fields
}

PatternInfo * 

*包含有关模式信息的值类，例如 “ *”，“ **”和“ {”模式元素的出现次数

func NewDefaultPatternInfo 

func NewDefaultPatternInfo(pattern string) *PatternInfo

func (*PatternInfo) GetDoubleWildcards 

func (pi *PatternInfo) GetDoubleWildcards() int

func (*PatternInfo) GetLength 

func (pi *PatternInfo) GetLength() int

返回给定模式的长度，其中模板变量被认为是1长。

func (*PatternInfo) GetSingleWildcards 

func (pi *PatternInfo) GetSingleWildcards() int

func (*PatternInfo) GetTotalCount 

func (pi *PatternInfo) GetTotalCount() int

func (*PatternInfo) GetUriVars 

func (pi *PatternInfo) GetUriVars() int

func (*PatternInfo) IsLeastSpecific 

func (pi *PatternInfo) IsLeastSpecific() bool

func (*PatternInfo) IsPrefixPattern 

func (pi *PatternInfo) IsPrefixPattern() bool

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.