# ga-reg-exp

**Repository Path**: lp9906/ga-reg-exp

## Basic Information

- **Project Name**: ga-reg-exp
- **Description**: No description available
- **Primary Language**: TypeScript
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2021-03-14
- **Last Updated**: 2022-01-20

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

#

## \\ 转义字符

```javascript
const rule = new GaRegExp(["\\(\\)"]);
rule.Test("()"); // true
```

## [] 字符组 [^] 反字符组

```javascript
const rule = new GaRegExp(["[123]"]);
rule.Test("1"); // true
rule.Test("2"); // true
rule.Test("3"); // true
rule.Test("4"); // false
```

## () 规则组 | 条件分支

```javascript
const rule = new GaRegExp(["^", "123|456|(789|7)", "$"]);
rule.Test("123"); // true
rule.Test("456"); // true
rule.Test("789"); // true
rule.Test("7"); // true
rule.Test("78"); // false
```

## {} 匹配个数 \*+?

```javascript
const rule = new GaRegExp(["^", "a*b{1,2}", "$"]);
rule.Test("aaab"); // true
rule.Test("abb"); // true
rule.Test("b"); // true
rule.Test("a"); // false
```

## - 字符区间 \u0000 元字符

```javascript
const rule = new GaRegExp(["\\u0061-\\u007a"]);
rule.Test("a"); // true
rule.Test("b"); // true
rule.Test("z"); // true
rule.Test("A"); // false
```

## CharHandle 字符处理函数

```javascript
const ruleData: CharHandle = (save, origin, rule, str, index, char, length) =>
	char === "5";
const rule = new GaRegExp([ruleData, "+"]);
rule.Test("5"); // true
rule.Test("55"); // true
rule.Test("6"); // false
```

## FuncHandle 执行函数

默认函数属于`CharHandle`，如使用`FuncHandle`需要包裹有`ruleType` 的对象

```javascript
const ruleData: FuncHandle = (save, origin, rule, str, index, char, length) => {
	console.log("test");
};
const rule = new GaRegExp([{ ruleType: "func", ruleData }, "123"]);
rule.Test("123"); // test true
```

## position 匹配位置

```javascript
const ruleData: CharHandle = (save, origin, rule, str, index, char, length) => {
	return index === 3;
};
const rule = new GaRegExp([
	"^123{1,2}",
	{ ruleType: "position", ruleData },
	"456$",
]);
rule.Test("123456"); // true
rule.Test("1233456"); // false
```

## once (~) 所有分支只匹配一次该位置的字符

```javascript
const ruleA = new GaRegExp(["^(\\s*abc\\s*)*$"]);
const ruleB = new GaRegExp(["^((~\\s*)abc(~\\s*))*$"]);
ruleA.Test(" abc  abc "); // error 存在多分支满足条件
// 因为第二个空格既符合`abc`前的空格匹配，也符合`abc`后的空格匹配
ruleB.Test(" abc  abc "); // true
```

## nested 正则嵌套-自我嵌套

```javascript
const ruleA = new GaRegExp(["7"]);
const ruleB = new GaRegExp();
ruleB.ParseRule([ruleA, "(", ruleB, "|4)"]);
ruleB.Test("74"); // true
ruleB.Test("774"); // true
ruleB.Test("7774"); // true
ruleB.Test("4"); // false
```

## (!) 捕获字符串

(`xxx`) 进入时新建创建捕获域，退出时也会退出捕获域，如有匹配个数，则每次进入退出会新建退出捕获域

(&`xxx`) 如有匹配个数，则每次进入退出会新建退出捕获域

(-`xxx`) 不操作捕获域

(!`xxx`) 捕获字符串，不操作捕获域

```javascript
const rule = new GaRegExp(["(!a)((!c))((!d))*(&(!e))*((-(!f))*)(!b)"]);
rule.MatchFormat("acddeeffb");
// ["a",["c"],[["d"],["d"]],["e"],["e"],["f","f"],"b"]
```

## 补充捕获内容

```javascript
const ruleData: FuncHandle = (save, origin, rule, str, index, char, length) => {
	GaRegExp.Supply(origin, "补充的内容");
	GaRegExp.Supply(origin, ["补充一组内容1", "补充一组内容2"]);
};
const rule = new GaRegExp(["^", { ruleType: "func", ruleData }, "(!456)", "$"]);
rule.MatchFormat("456"); // ["补充的内容",["补充一组内容1","补充一组内容2"],"456"]
```

## code format rule 代码格式化规则

- rule
  - dataRule 数据规则
    - utils/annotationRule 注解规则
      - variableNameRule
      - calcRule
    - utils/genericRule 泛型规则
      - variableNameRule
    - variableNameRule
    - arrayRule 数组规则
    - booleanRule 逻辑型规则
    - classRule 类规则
      - annotationRule
      - variableNameRule
      - genericRule
      - exportValueRule
    - functionRule 函数规则
      - variableNameRule
      - executeDataRule
      - calcRule
      - genericRule
      - typeCalcRule
    - hashMapRule 哈希表规则
      - variableNameRule
      - calcRule
    - interfaceRule 接口规则
      - variableNameRule
      - genericRule
      - typeMapRule
    - numberRule 数值规则
    - stringRule 字符串规则
    - structRule 结构体规则
      - variableNameRule
      - genericRule
      - typeMapRule
    - xmlRule 文档规则
  - executeDataRule 执行数据规则
    - classRule
    - functionRule
    - interfaceRule
    - structRule
    - typeCreatedRule
    - proceduralRule
    - variableCreatedlRule
    - calcRule
      - unaryRule
      - variableNameRule
  - exportDataRule 导出数据规则
    - exportValueRule 导出内容规则
      - classRule
      - functionRule
      - interfaceRule
      - hashMapRule
      - structRule
      - typeCreatedRule
      - variableCreatedlRule
    - exportRule 导出规则
      - exportValueRule
    - importRule 导入规则
      - variableNameRule
      - stringRule
  - proceduralRule 流程规则
    - doWhilelRule 后置循环规则
      - calcRule
      - executeRule
    - forRule 计数循环规则
      - calcRule
      - variableCreatedlRule
      - executeRule
    - ifRule 判断规则
      - calcRule
      - executeRule
    - loopRule 无条件循环规则
      - executeRule
    - tryCatchRule 异常处理规则
      - variableNameRule
      - executeRule
    - whilelRule 条件循环规则
      - calcRule
      - executeRule
  - typeDataRule 类型数据规则
    - numberRule
    - stringRule
    - booleanRule
    - typeArrayRule 数组类型规则
      - typeCalcRule
    - typeCalcRule 类型计算规则
      - typeDataRule
    - typeCreatedRule 类型创建规则
      - variableNameRule
      - genericRule
      - typeCalcRule
    - typeMapRule 类型表规则
      - variableNameRule
      - typeCalcRule
    - typeNameRule 类型名称规则
      - variableNameRule
  - variableDataRule 变量树规则
    - variableNameRule 变量名称规则
    - variableListRule 变量名称列表规则
    - variableMapRule 变量名称表规则
    - variableCreatedlRule 创建变量规则
      - variableDataRule
      - calcRule
      - typeCalcRule
  - executeRule 执行规则
    - executeDataRule
  - exportExecuteRule 导出执行规则
    - exportDataRule