mm_eslint 1.2.6 → 1.2.8

package/index.js

@@ -1,2891 +1,323 @@
-"use strict";
-
-/**
- * 命名规范检测器类
- */
-class Detector {
-  static config = {
-    // 推荐词功能开关
-    recommen: true,
-    // 推荐词，当命名时较长时推荐使用的词
-    recommen_words: {
-      // 函数推荐词
-      function: {
-        // === 动词类 ===
-        // 增加
-        add: {
-          words: ["push", "insert"]
-        },
-        // 删除
-        del: {
-          words: ["remove", "delete"]
-        },
-        // 查询
-        get: {
-          words: ["query"]
-        },
-        // 修改
-        set: {
-          words: ["setting"]
-        },
-        // 转换
-        to: {
-          words: ["convert", "transform"]
-        },
-        // 检查
-        check: {
-          words: ["verify", "validate", "confirm"]
-        },
-        // 创建
-        create: {
-          words: ["construct"]
-        },
-        // 生成
-        gen: {
-          words: ["generate"]
-        },
-        // 初始化
-        init: {
-          words: ["initialize"]
-        },
-        // 处理
-        run: {
-          words: ["process", "handle"]
-        },
-        // 执行
-        exec: {
-          words: ["execute"]
-        },
-        // 计算
-        calc: {
-          words: ["calculate", "compute"]
-        },
-        // 加载
-        load: {
-          words: ["fetch", "retrieve"]
-        },
-        // 保存
-        save: {
-          words: ["store", "persist"]
-        },
-        // 比较
-        cmp: {
-          words: ["compare", "diff"]
-        },
-        // 排序
-        sort: {
-          words: ["order", "arrange"]
-        },
-        // 查找
-        find: {
-          words: ["search", "locate"]
-        },
-        // 删除
-        del: {
-          words: ["remove", "delete"]
-        },
-        // 解析
-        parse: {
-          words: ["analyze"]
-        },
-        // 复制
-        copy: {
-          words: ["duplicate", "clone"]
-        },
-        // 移动
-        move: {
-          words: ["transfer", "relocate"]
-        },
-        // 压缩
-        zip: {
-          words: ["compress"]
-        },
-        // 解压
-        unzip: {
-          words: ["decompress"]
-        },
-        // 反转
-        flip: {
-          words: ["reverse"]
-        },
-        // === 名词类 ===
-        // 函数
-        Func: {
-          words: ["Function"]
-        },
-        // 值
-        Val: {
-          words: ["Value"]
-        },
-        // 数组
-        Arr: {
-          words: ["Array"]
-        },
-        // 对象
-        Obj: {
-          words: ["Object"]
-        },
-        // 数值
-        Num: {
-          words: ["Number"]
-        },
-        // 字符串
-        Str: {
-          words: ["String"]
-        },
-        // 字典
-        Dict: {
-          words: ["Dictionary"]
-        }
-      },
-      variable: {
-        // 连接器
-        conn: {
-          words: ["connector"]
-        },
-        // 函数
-        func: {
-          words: ["function"]
-        },
-        // 值
-        val: {
-          words: ["value"]
-        },
-        // 枚举
-        enum: {
-          words: ["enumeration"]
-        },
-        // 数组
-        arr: {
-          words: ["array"]
-        },
-        // 对象
-        obj: {
-          words: ["object"]
-        },
-        // 数值
-        num: {
-          words: ["number"]
-        },
-        // 字符串
-        str: {
-          words: ["string"]
-        },
-        bool: {
-          words: ["boolean"]
-        },
-        // 字典
-        dict: {
-          words: ["dictionary"]
-        },
-        // 模块
-        mod: {
-          words: ["module"]
-        }
-      }
-    },
-    // 私有方法前缀列表：以这些前缀开头的方法名应该被检测为私有方法
-    private_method_prefixes: [
-      'setup', 'init', 'internal', 'private', 'helper', 'util'
-    ],
-    
-    // 忽略词列表：这些词汇在命名检测时会被忽略，不进行长度和风格检测
-    ignore_words: {
-      // 类名忽略词：这些词汇在类名中允许使用，即使超过8个字符
-      class: [
-        "Controller", "Middleware", "Component", "Repository", "Validator",
-        "Transformer", "Serializer", "Interceptor", "Decorator", "Provider"
-      ],
-      // 方法名忽略词：这些词汇在方法名中允许使用，即使超过8个字符
-      method: [
-        "middleware", "controller", "component", "repository", "validator",
-        "transformer", "serializer", "interceptor", "decorator", "provider"
-      ],
-      // 函数名忽略词：这些词汇在函数名中允许使用，即使超过8个字符
-      function: [
-        "middleware", "controller", "component", "repository", "validator",
-        "transformer", "serializer", "interceptor", "decorator", "provider"
-      ],
-      variable: [
-        "middleware", "controller", "component", "repository", "validator",
-        "transformer", "serializer", "interceptor", "decorator", "provider"
-      ]
-    },
-    
-    // 废话词
-    forbidden_words: {
-      // 类废话词：禁止在类名中使用的冗余拼接词汇（统一小写）
-      // 这些词汇在类名中属于过度设计或冗余描述，即使在某些场景下合理，但作为拼接命名仍然是冗余的
-      class: [
-        "manager", "handler", "processor", "controller", "service", "provider",
-        "factory", "builder", "adapter", "decorator", "proxy", "facade",
-        "mediator", "observer", "strategy", "command", "visitor",
-        "iterator", "template", "flyweight", "memento", "interpreter",
-        "model", "view", "route", "router", "component", "widget", "panel",
-        "dialog", "window", "form", "field", "property", "entity"
-        // 例如：UserModel → User (直接使用User)，UserController → User (直接使用User)
-      ],
-
-      // 函数废话词：禁止在函数名中使用的冗余拼接词汇（统一小写）
-      // 基于动词+名词组合分析：如果动词已经表达了动作，名词只是数据描述，则名词是废话词
-      // 有意义的词通常是拼接get、set、to后能有意义、直接表达的名词，如getUser、toJSON等
-      function: [
-        // 无意义的数据描述词汇（动词已经表达了动作，这些名词是冗余的）
-        "data", "result", "output", "input", "param", "params", "parameter", "parameters",
-        "value", "values", "item", "items",
-        // 通用处理词汇（动词已经表达了处理，这些名词是冗余的）
-        "process", "processor", "provider",
-        "builder", "adapter", "decorator", "proxy", "facade", "mediator",
-        "observer", "strategy", "command", "visitor", "iterator", "template",
-        "flyweight", "memento", "interpreter",
-        // 临时缓存词汇（动词已经表达了操作，这些名词是冗余的）
-        "temp", "tmp", "temporary", "cached", "buffered",
-        // 计数索引词汇（动词已经表达了计数索引，这些名词是冗余的）
-        "idx", "counter",
-        // 例如：getData → get（data是冗余），toResult → to（result是冗余）
-        // processData → process（data是冗余），handleRequest → handle（request是冗余）
-      ],
-
-      // 变量废话词：禁止在变量名中使用的冗余拼接词汇（统一小写）
-      // 这些词汇在变量名中属于"不用说也知道"的过度描述
-      variable: [
-        // 数据类型词：变量本身就有类型，不需要重复说明
-        "object", "array", "map", "set", "collection", "container", "instance",
-        // 通用数据词：变量本身就是数据/值，不需要重复说明
-        "value", "data", "item", "items", "element", "elements", "entry", "entries",
-        // 临时状态词：临时变量不需要说明是临时的
-        "temp", "tmp", "temporary", "cached", "buffer", "buffered",
-        // 输入输出词：变量本身就有用途，不需要重复说明
-        "input", "output", "result", "source", "target", "destination",
-        // 计数索引词：变量本身就有计数/索引功能，不需要重复说明
-        "index", "idx", "counter", "length", "total", "sum",
-        // 引用指针词：变量本身就是引用/指针，不需要重复说明
-        "pointer", "reference", "ref", "handle", "handler",
-        // 通用描述词：变量本身就是实体，不需要重复说明
-        "entity", "record", "row", "column", "cell", "property", "attr", "attribute"
-        // 例如：user_list → users（list是冗余），temp_value → temp（value是冗余）
-      ]
-    },
-    regex: {
-      PascalCase: /^[A-Z][a-zA-Z]*$/, // 大驼峰：大写字母开头，只包含字母。主要用于类名
-      camelCase: /^[a-z][a-zA-Z]*$/, // 小驼峰：小写字母开头，只包含字母。主要用于方法名、函数名
-      snake_case: /^[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 小写蛇形：小写字母开头，可包含下划线。主要用于变量名、入参名
-      UPPER_SNAKE_CASE: /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/, // 大写蛇形：大写字母开头，可包含下划线。主要用于常量名
-      "kebab-case": /^[a-z][a-z0-9-]*(-[a-z0-9]+)*$/, // 小写横杠：小写字母开头，可包含短横线，小写短横线。主要用于资源名、路由路径
-      "UPPER-KEBAB-CASE": /^[A-Z][A-Z0-9-]*(-[A-Z0-9]+)*$/, // 大写横杠：大写字母开头，可包含短横线，大写短横线。主要用于资源名、路由路径
-      lowercase: /^[a-z][a-z0-9]*$/, // 小写单词：小写字母开头，只包含小写字母和数字。主要用于对象、属性名
-      UPPERCASE: /^[A-Z][A-Z0-9]*$/, // 大写单词：大写字母开头，只包含大写字母和数字。主要用于枚举值、常量名
-      "camelCase-kebab": /^[a-z][a-z0-9-]*(-[a-z0-9]+)*$/, // 支持横杠小驼峰：小写字母开头，可包含短横线，小写短横线。主要用于资源名、路由路径
-      "PascalCase-kebab": /^[A-Z][a-zA-Z]*$/, // 支持横杠大驼峰：大写字母开头，只包含字母。主要用于资源名、路由路径
-      _camelCase: /^_[a-z][a-zA-Z]*$/, // 下划线小驼峰：下划线加小写字母开头，只包含字母。主要用于私有方法名
-      _snake_case: /^_[a-z][a-z0-9_]*(_[a-z0-9]+)*$/, // 下划线小写蛇形：下划线加小写字母开头，可包含下划线。主要用于私有变量名
-      _lowercase: /^_[a-z][a-z0-9]*$/, // 下划线小写单词：下划线加小写字母开头，只包含小写字母和数字。主要用于对象、属性名
-    },
-
-    // 类名大驼峰规则
-    "class-name": {
-      name: "类名",
-      message:
-        "必须使用大驼峰命名法（PascalCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ["PascalCase"],
-      single_word: true,
-      single_word_len: 8,
-    },
-
-    // 函数名小驼峰规则
-    "function-name": {
-      name: "函数名",
-      message:
-        "必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ["camelCase"],
-      single_word: true,
-      single_word_len: 8,
-    },
-
-    // 方法名小驼峰规则
-    "method-name": {
-      name: "方法名",
-      message:
-        "必须使用小驼峰命名法（camelCase），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ["camelCase"],
-      single_word: true,
-      single_word_len: 8,
-    },
-
-    // 入参名小写蛇形规则
-    "param-name": {
-      name: "入参名",
-      message:
-        "必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ["lowercase", "snake_case"],
-      single_word: true,
-      single_word_len: 8,
-    },
-
-    // 变量名小写蛇形规则
-    "variable-name": {
-      name: "变量名",
-      message:
-        "必须使用小写蛇形命名法（snake_case），长度{min}-{max}字符，且优先使用单个单词，每个单词不超过{word_len}字符",
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ["lowercase", "snake_case"],
-      single_word: true,
-      single_word_len: 8,
-    },
-
-    // 常量名大写蛇形规则
-    "constant-name": {
-      name: "常量名",
-      message:
-        "必须使用大写蛇形命名法（UPPER_SNAKE_CASE），长度{min}-{max}字符",
-      regex: null, // 使用styles属性进行验证
-      min: 1,
-      max: 20,
-      styles: ["UPPERCASE", "UPPER_SNAKE_CASE"],
-    },
-
-    // 属性名多风格规则（根据值类型应用不同规则）
-    "property-name": {
-      name: "属性名",
-      message: "根据属性值类型应用不同命名规则",
-      min: 1,
-      max: 20,
-      single_word: true,
-      single_word_len: 8,
-      styles: [
-        "lowercase",
-        "_lowercase",
-        "snake_case",
-        "_snake_case",
-        "UPPERCASE",
-        "UPPER_SNAKE_CASE"
-      ],
-      strong: true, // 强验证模式：根据属性值类型智能判断；false：弱验证模式：只需符合变量名或常量名规则
-    },
-
-    // 私有方法规则
-    "private-method-naming": {
-      name: "私有方法",
-      message:
-        "必须以单下划线开头，后跟小驼峰命名或小写单词，长度{min}-{max}字符",
-      regex: null, // 使用styles属性进行验证
-      min: 2,
-      max: 20,
-      styles: ["_lowercase", "_camelCase"],
-    },
-
-    // 私有变量规则
-    "private-variable-naming": {
-      name: "私有变量",
-      message:
-        "必须以单下划线开头，后跟小写蛇形命名或小写单词，长度{min}-{max}字符",
-      regex: null, // 使用styles属性进行验证
-      min: 2,
-      max: 20,
-      styles: ["_lowercase", "_snake_case"],
-    },
-  };
-
-  constructor(config) {
-    // 合并默认配置和传入配置
-    const merged_cfg = { ...Detector.config };
-    if (config && typeof config === "object") {
-      // 先合并顶层配置
-      Object.keys(config).forEach((key) => {
-        if (merged_cfg[key] && typeof merged_cfg[key] === "object" && !Array.isArray(merged_cfg[key])) {
-          // 如果是对象配置（如规则配置），则深度合并
-          merged_cfg[key] = this._deepMerge(merged_cfg[key], config[key]);
-
-          // 处理字符串形式的正则表达式
-          if (typeof merged_cfg[key].regex === "string") {
-            try {
-              // 从字符串中提取正则表达式模式和标志
-              const regex_match =
-                merged_cfg[key].regex.match(/^\/(.*)\/([gimuy]*)$/);
-              if (regex_match) {
-                merged_cfg[key].regex = new RegExp(
-                  regex_match[1],
-                  regex_match[2],
-                );
-              } else {
-                // 如果不是标准的正则表达式字符串格式，直接创建
-                merged_cfg[key].regex = new RegExp(merged_cfg[key].regex);
-              }
-            } catch (error) {
-              console.warn(`无效的正则表达式: ${merged_cfg[key].regex}`, error);
-              merged_cfg[key].regex = null;
-            }
-          }
-        } else {
-          // 如果是顶层字段（如recommen），直接覆盖
-          merged_cfg[key] = config[key];
-        }
-      });
-    }
-    this.config = merged_cfg;
-    this._initRule();
-  }
-
-  /**
-   * 深度合并两个对象
-   * @param {Object} target 目标对象
-   * @param {Object} source 源对象
-   * @returns {Object} 合并后的对象
-   * @private
-   */
-  _deepMerge(target, source) {
-    const result = { ...target };
-    
-    Object.keys(source).forEach((key) => {
-      const source_val = source[key];
-      const target_val = target[key];
-      
-      if (Array.isArray(source_val) && Array.isArray(target_val)) {
-        // 如果是数组，则合并数组（去重）
-        result[key] = [...new Set([...target_val, ...source_val])];
-      } else if (typeof source_val === 'object' && source_val !== null && 
-                 typeof target_val === 'object' && target_val !== null && 
-                 !Array.isArray(source_val) && !Array.isArray(target_val)) {
-        // 如果是对象，则递归深度合并
-        result[key] = this._deepMerge(target_val, source_val);
-      } else {
-        // 其他情况直接覆盖
-        result[key] = source_val;
-      }
-    });
-    
-    return result;
-  }
-}
-
-/**
- * 创建新的规则模型
- * @returns {Object} 规则模型
- * @private
- */
-Detector.prototype._newModel = function () {
-  return {
-    name: "",
-    message: "",
-    regex: null,
-    min: 1,
-    max: 20,
-  };
-};
-
-/**
- * 初始化规则检查方法
- * @private
- */
-Detector.prototype._initRule = function () {
-  // 绑定规则检查方法
-  this._rules = {
-    "class-name": this._checkName.bind(this, "class-name"),
-    "function-name": this._checkName.bind(this, "function-name"),
-    "method-name": this._checkName.bind(this, "method-name"),
-    "param-name": this._checkName.bind(this, "param-name"),
-    "variable-name": this._checkName.bind(this, "variable-name"),
-    "constant-name": this._checkName.bind(this, "constant-name"),
-    "property-name": this._checkPropName.bind(this),
-    "private-method-naming": this._checkName.bind(
-      this,
-      "private-method-naming",
-    ),
-    "private-variable-naming": this._checkName.bind(
-      this,
-      "private-variable-naming",
-    ),
-  };
-};
-
-/**
- * 通用命名检查方法
- * @param {string} rule_type - 规则类型
- * @param {string} name - 名称
- * @returns {Object} 检查结果
- * @private
- */
-Detector.prototype._checkName = function (rule_type, name) {
-  if (!name) {
-    throw new TypeError("名称不能为空");
-  }
-
-  const config = this.config[rule_type];
-  if (!config) {
-    throw new Error(`不支持的规则类型: ${rule_type}`);
-  }
-
-  const errors = [];
-  const warnings = [];
-  const recommendations = [];
-
-  // 首先检查是否为忽略词，如果是则跳过其他检测
-  if (this._isIgnoreWord(name, rule_type)) {
-    return {
-      valid: true,
-      errors: [],
-      warnings: [],
-      recommendations: []
-    };
-  }
-
-  this._checkNameLength(name, config, errors);
-  this._checkNameFormat(name, rule_type, config, errors);
-  this._checkBadWords(name, config, errors);
-  this._checkSingleWord(name, rule_type, config, warnings);
-  this._checkWordLength(name, rule_type, config, errors);
-  this._checkRecommen(name, rule_type, config, recommendations);
-
-  return {
-    valid: errors.length === 0,
-    errors: errors,
-    warnings: warnings,
-    recommendations: recommendations,
-  };
-};
-
-/**
- * 检查名称长度限制
- * @private
- */
-Detector.prototype._checkNameLength = function (name, config, errors) {
-  if (name.length < config.min) {
-    errors.push(`${config.name}长度不能少于${config.min}个字符`);
-  }
-  if (name.length > config.max) {
-    errors.push(`${config.name}长度不能超过${config.max}个字符`);
-  }
-};
-
-/**
- * 检查名称格式
- * @private
- */
-Detector.prototype._checkNameFormat = function (
-  name,
-  rule_type,
-  config,
-  errors,
-) {
-  let name_valid = false;
-
-  if (config.regex && config.regex.toString() !== "/(?:)/") {
-    name_valid = config.regex.test(name);
-    if (!name_valid) {
-      const error_message = config.message
-        .replace("{name}", `"${name}"`)
-        .replace("{type}", config.name)
-        .replace("{min}", config.min)
-        .replace("{max}", config.max)
-        .replace("{word_len}", config.single_word_len || 8)
-        .replace("{regex}", config.regex.toString());
-      errors.push(error_message);
-    }
-  } else if (config.styles && config.styles.length > 0) {
-    name_valid = this._checkStyle(name, config.styles);
-    if (!name_valid) {
-      const allowed_styles = config.styles.join("、");
-      errors.push(`${config.name}必须符合以下命名风格之一：${allowed_styles}`);
-    }
-  } else {
-    name_valid = true;
-  }
-};
-
-/**
- * 检查禁止词汇
- * @private
- */
-Detector.prototype._checkBadWords = function (name, config, errors) {
-  // 根据配置类型确定代码实体类型
-  let type = 'variable'; // 默认变量类型
-
-  if (config.name.includes('类名')) {
-    type = 'class';
-  } else if (config.name.includes('函数名') || config.name.includes('方法名')) {
-    type = 'function';
-  }
-
-  const bad_word = this._checkBadWord(name, type);
-  if (bad_word) {
-    errors.push(`${config.name}包含禁止的废话词"${bad_word}"`);
-  }
-};
-
-/**
- * 检查是否优先使用单个单词
- * @private
- */
-Detector.prototype._checkSingleWord = function (
-  name,
-  rule_type,
-  config,
-  warnings,
-) {
-  if (!config.single_word) return;
-
-  const has_uppercase = /[A-Z]/.test(name.slice(1));
-  const has_separators = name.includes("_") || name.includes("-");
-  const is_func_or_method =
-    rule_type === "function-name" || rule_type === "method-name";
-  let is_multi_word = has_uppercase || has_separators;
-
-  if (is_func_or_method && is_multi_word) {
-    const prefix_match = name.match(
-      /^(add|del|set|get|is|has|can|not)([A-Z][a-z]*)$/,
-    );
-    if (prefix_match && prefix_match[2]) {
-      is_multi_word = false;
-    }
-  }
-
-  if (is_multi_word) {
-    warnings.push(`${config.name}应优先使用单个单词`);
-  }
-};
-
-/**
- * 检查单词长度限制
- * @private
- */
-Detector.prototype._checkWordLength = function (
-  name,
-  rule_type,
-  config,
-  errors,
-) {
-  if (!config.single_word_len || config.single_word_len <= 0) return;
-
-  const words = this._splitWords(name, rule_type);
-  const long_words = words.filter(
-    (word) => word.length > config.single_word_len,
-  );
-
-  if (long_words.length > 0) {
-    errors.push(
-      `${config.name}中的单词"${long_words.join("、")}"超过${config.single_word_len}个字符限制`,
-    );
-  }
-};
-
-/**
- * 根据styles列表检查名称是否符合命名风格
- * @param {string} name - 名称
- * @param {Array} styles - 命名风格列表
- * @returns {boolean} 是否符合任一风格
- * @private
- */
-Detector.prototype._checkStyle = function (name, styles) {
-  if (!name || !styles || styles.length === 0) {
-    return false;
-  }
-
-  // 检查名称是否符合任一指定的命名风格
-  for (const style of styles) {
-    const regex = this.config.regex[style];
-    if (regex && regex.test(name)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-/**
- * 拆分名称中的单词
- * @param {string} name - 名称
- * @param {string} rule_type - 规则类型
- * @returns {Array} 拆分后的单词数组
- * @private
- */
-Detector.prototype._splitWords = function (name, rule_type) {
-  if (!name) {
-    return [];
-  }
-
-  const words = [];
-
-  // 根据命名风格拆分单词
-  if (name.includes("_")) {
-    // 蛇形命名：user_name → ["user", "name"]
-    words.push(...name.split("_").filter((word) => word.length > 0));
-  } else if (name.includes("-")) {
-    // 横杠命名：user-name → ["user", "name"]
-    words.push(...name.split("-").filter((word) => word.length > 0));
-  } else {
-    // 检查是否是纯小写单词（不包含大写字母）
-    if (!/[A-Z]/.test(name)) {
-      // 纯小写单词：configuration → ["configuration"]
-      words.push(name);
-    } else {
-      // 驼峰命名：userName → ["user", "Name"]
-      // 使用正则表达式拆分驼峰命名
-      const camel_case_words = name.split(/(?=[A-Z])/);
-
-      // 对于函数名和方法名，处理常见前缀
-      if (rule_type === "function-name" || rule_type === "method-name") {
-        const prefix_match = name.match(
-          /^(add|del|set|get|is|has|can|not)([A-Z].*)$/,
-        );
-        if (prefix_match) {
-          // 如果是前缀+单词的组合，将前缀作为单独单词
-          words.push(prefix_match[1]);
-          // 拆分剩余部分
-          const remaining_words = prefix_match[2].split(/(?=[A-Z])/);
-          words.push(...remaining_words);
-        } else {
-          words.push(...camel_case_words);
-        }
-      } else {
-        words.push(...camel_case_words);
-      }
-    }
-  }
-
-  // 过滤空字符串并转换为小写进行比较
-  return words
-    .filter((word) => word.length > 0)
-    .map((word) => word.toLowerCase());
-};
-
-/**
- * 属性名检查方法（根据属性值类型应用不同规则）
- * @param {string} name - 属性名
- * @param {Object} val_node - 属性值AST节点
- * @param {Object} parent_node - 父节点AST节点（可选，用于上下文感知检测）
- * @returns {Object} 检查结果
- * @private
- */
-Detector.prototype._checkPropName = function (name, val_node, parent_node) {
-  if (!name) {
-    throw new TypeError("属性名不能为空");
-  }
-
-  const config = this.config["property-name"];
-  if (!config) {
-    throw new Error("属性名规则配置不存在");
-  }
-
-  const errors = [];
-  const warnings = [];
-
-  this._checkPropLength(name, config, errors);
-  this._checkBadWords(name, config, errors);
-
-  const use_strong_val = config.strong !== false;
-  const val_type = this._getPropType(val_node, name, parent_node);
-
-  if (use_strong_val) {
-    this._checkPropStrong(name, val_type, config, errors, val_node);
-  } else {
-    this._checkPropWeak(name, val_type, config, errors);
-  }
-
-  this._checkPropSingleWord(name, config, warnings);
-
-  return {
-    valid: errors.length === 0,
-    errors: errors,
-    warnings: warnings,
-    value_type: val_type,
-  };
-};
-
-/**
- * 检查属性名长度
- * @private
- */
-Detector.prototype._checkPropLength = function (name, config, errors) {
-  if (name.length < config.min) {
-    errors.push(`${config.name}长度不能少于${config.min}个字符`);
-  }
-  if (name.length > config.max) {
-    errors.push(`${config.name}长度不能超过${config.max}个字符`);
-  }
-};
-
-/**
- * 强验证模式检查
- * @param {string} name - 属性名
- * @param {string} val_type - 值类型
- * @param {Object} config - 配置对象
- * @param {Array} errors - 错误数组
- * @param {Object} val_node - 属性值AST节点（可选）
- * @private
- */
-Detector.prototype._checkPropStrong = function (
-  name,
-  val_type,
-  config,
-  errors,
-  val_node,
-) {
-  switch (val_type) {
-    case "function":
-      this._checkFuncProp(name, config, errors);
-      break;
-    case "method":
-      this._checkMethodProp(name, config, errors);
-      break;
-    case "class":
-      this._checkClassProp(name, config, errors, val_node);
-      break;
-    case "constant":
-      this._checkConstProp(name, config, errors);
-      break;
-    case "value":
-    default:
-      this._checkValueProp(name, config, errors);
-      break;
-  }
-};
-
-/**
- * 弱验证模式检查
- * @private
- */
-Detector.prototype._checkPropWeak = function (name, val_type, config, errors) {
-  switch (val_type) {
-    case "function":
-      this._checkFuncProp(name, config, errors);
-      break;
-    case "method":
-      this._checkMethodProp(name, config, errors);
-      break;
-    case "class":
-      this._checkClassProp(name, config, errors);
-      break;
-    case "constant":
-    case "value":
-    default:
-      this._checkWeakValue(name, config, errors);
-      break;
-  }
-};
-
-/**
- * 检查函数属性
- * @private
- */
-Detector.prototype._checkFuncProp = function (name, config, errors) {
-  const func_res = this._checkName("function-name", name);
-  if (!func_res.valid) {
-    errors.push(`${config.name}（函数）${func_res.errors.join(", ")}`);
-  }
-};
-
-/**
- * 检查类属性
- * @param {string} name - 属性名
- * @param {Object} config - 配置对象
- * @param {Array} errors - 错误数组
- * @param {Object} val_node - 属性值AST节点（可选）
- * @private
- */
-Detector.prototype._checkClassProp = function (name, config, errors, val_node) {
-  // 根据值节点类型和属性名模式判断是类定义还是类实例
-  // 1. 如果值节点是require调用，则是类定义
-  // 2. 如果属性名符合PascalCase命名规范，优先认为是类定义
-  const is_class_definition = (val_node && val_node.type === "CallExpression" && 
-                             val_node.callee && val_node.callee.name === "require") ||
-                             (name && /^[A-Z][a-zA-Z0-9]*$/.test(name));
-  const is_class_instance = !is_class_definition;
-  
-  if (is_class_definition) {
-    // 类定义要求使用PascalCase
-    const cls_res = this._checkName("class-name", name);
-    if (!cls_res.valid) {
-      errors.push(`${config.name}（类）${cls_res.errors.join(", ")}`);
-    }
-  } else {
-    // 类实例允许使用小驼峰命名
-    const func_res = this._checkName("function-name", name);
-    if (!func_res.valid) {
-      errors.push(`${config.name}（类实例）${func_res.errors.join(", ")}`);
-    }
-  }
-};
-
-/**
- * 检查常量属性
- * @private
- */
-Detector.prototype._checkConstProp = function (name, config, errors) {
-  const is_valid_const = this._checkStyle(name, [
-    "UPPERCASE",
-    "UPPER_SNAKE_CASE",
-  ]);
-  if (!is_valid_const) {
-    this._suggestConstName(name, config, errors);
-  }
-};
-
-/**
- * 检查方法属性
- * @private
- */
-Detector.prototype._checkMethodProp = function (name, config, errors) {
-  const method_res = this._checkName("method-name", name);
-  if (!method_res.valid) {
-    errors.push(`${config.name}（方法）${method_res.errors.join(", ")}`);
-  }
-};
-
-/**
- * 建议常量命名
- * @private
- */
-Detector.prototype._suggestConstName = function (name, config, errors) {
-  if (/^[a-z][a-zA-Z0-9]*$/.test(name)) {
-    const sug_name = name.replace(/([A-Z])/g, "_$1").toUpperCase();
-    errors.push(
-      `${config.name}（常量）必须使用大写命名风格，建议改为：${sug_name}`,
-    );
-  } else if (/^[a-z][a-z0-9_]*$/.test(name)) {
-    const sug_name = name.toUpperCase();
-    errors.push(
-      `${config.name}（常量）必须使用大写命名风格，建议改为：${sug_name}`,
-    );
-  } else {
-    errors.push(
-      `${config.name}（常量）必须使用大写命名风格（如API或API_BASE_URL）`,
-    );
-  }
-};
-
-/**
- * 检查值属性
- * @private
- */
-Detector.prototype._checkValueProp = function (name, config, errors) {
-  // 检查常量规则
-  const const_res = this._checkName("constant-name", name);
-  if (const_res.valid) {
-    return; // 满足常量规则，通过
-  }
-  
-  // 检查变量规则
-  const var_res = this._checkName("variable-name", name);
-  if (var_res.valid) {
-    return; // 满足变量规则，通过
-  }
-  
-  // 都不满足，报告错误
-  errors.push(`${config.name}（值）必须符合变量或常量命名规则`);
-};
-
-/**
- * 建议值属性命名
- * @private
- */
-Detector.prototype._suggestValueName = function (name, config, errors) {
-  if (/^[A-Z][a-zA-Z0-9]*$/.test(name)) {
-    const sug_name = name
-      .replace(/([A-Z])/g, "_$1")
-      .toLowerCase()
-      .replace(/^_/, "");
-    errors.push(
-      `${config.name}（值）必须使用小写命名风格，建议改为：${sug_name}`,
-    );
-  } else if (/^[a-z][a-zA-Z0-9]*$/.test(name)) {
-    const sug_name = name.replace(/([A-Z])/g, "_$1").toLowerCase();
-    errors.push(
-      `${config.name}（值）必须使用小写命名风格，建议改为：${sug_name}`,
-    );
-  } else {
-    const allowed_styles = config.styles.join("、");
-    errors.push(
-      `${config.name}（值）必须符合以下命名风格之一：${allowed_styles}`,
-    );
-  }
-};
-
-/**
- * 弱验证模式值检查
- * @private
- */
-Detector.prototype._checkWeakValue = function (name, config, errors) {
-  const is_valid_var = this._checkStyle(name, ["lowercase", "snake_case"]);
-  const is_valid_const = this._checkStyle(name, [
-    "UPPERCASE",
-    "UPPER_SNAKE_CASE",
-  ]);
-
-  if (!is_valid_var && !is_valid_const) {
-    errors.push(
-      `${config.name}（值）必须符合变量名（小写蛇形）或常量名（大写蛇形）规则`,
-    );
-  }
-};
-
-/**
- * 检查属性名是否优先使用单个单词
- * @private
- */
-Detector.prototype._checkPropSingleWord = function (name, config, warnings) {
-  if (!config.single_word) return;
-
-  const has_uppercase = /[A-Z]/.test(name.slice(1));
-  const has_separators = name.includes("_") || name.includes("-");
-
-  if (has_uppercase || has_separators) {
-    warnings.push(`${config.name}应优先使用单个单词`);
-  }
-};
-
-/**
- * 获取属性值类型
- * @param {Object} val_node - 属性值AST节点
- * @param {string} prop_name - 属性名
- * @param {Object} parent_node - 父节点AST节点（可选，用于上下文感知检测）
- * @returns {string} 属性值类型（'function', 'method', 'class', 'value'）
- * @private
- */
-Detector.prototype._getPropType = function (val_node, prop_name, parent_node) {
-  if (!val_node) {
-    return "value"; // 默认值类型
-  }
-
-  // 检查是否为对象方法（在对象字面量中的函数）
-  if (parent_node && parent_node.type === "Property" && 
-      (val_node.type === "FunctionExpression" || val_node.type === "ArrowFunctionExpression")) {
-    return "method"; // 对象方法类型
-  }
-
-  // 优先检查属性名是否符合类命名规范（PascalCase）
-  // 当属性名符合PascalCase时，优先考虑类类型
-  if (prop_name && /^[A-Z][a-zA-Z0-9]*$/.test(prop_name)) {
-    const common_config_names = ['config', 'options', 'params', 'settings', 'props'];
-    const is_common_config = common_config_names.includes(prop_name.toLowerCase());
-    
-    // 如果属性名符合PascalCase且不是常见配置参数名，优先认为是类类型
-    if (!is_common_config) {
-      return "class";
-    }
-  }
-
-  // 检查是否为函数
-  if (
-    val_node.type === "FunctionExpression" ||
-    val_node.type === "ArrowFunctionExpression" ||
-    (val_node.type === "Identifier" &&
-      val_node.name &&
-      (val_node.name.endsWith("Function") ||
-        val_node.name.endsWith("Func") ||
-        val_node.name.startsWith("on") ||
-        val_node.name.startsWith("handle") ||
-        // 新增：常见函数命名模式识别
-        val_node.name.endsWith("Manager") ||
-        val_node.name.endsWith("Admin") ||
-        val_node.name.endsWith("Handler") ||
-        val_node.name.endsWith("Service") ||
-        val_node.name.endsWith("Util") ||
-        val_node.name.endsWith("Helper") ||
-        val_node.name.endsWith("Factory") ||
-        val_node.name.endsWith("Provider") ||
-        // 检查是否为小驼峰命名（函数常见命名风格）
-        (/^[a-z][a-zA-Z0-9]*$/.test(val_node.name) && 
-         val_node.name !== val_node.name.toLowerCase() &&
-         !val_node.name.includes("_") &&
-         !val_node.name.includes("-"))))
-  ) {
-    return "function";
-  }
-
-  // 检查是否为类
-  if (val_node.type === "ClassExpression" || val_node.type === "NewExpression") {
-    return "class";
-  }
-  
-  // 对于标识符类型的值，采用保守策略
-  // 只有当明显是类名时才认为是类类型
-  if (val_node.type === "Identifier" && val_node.name) {
-    // 检查标识符名称是否符合类名模式（PascalCase）
-    const is_pascal_case = /^[A-Z][a-zA-Z0-9]*$/.test(val_node.name);
-    
-    // 如果标识符名称符合PascalCase，且不是常见的配置参数名，则认为是类类型
-    const common_config_names = ['config', 'options', 'params', 'settings', 'props'];
-    const is_common_config = common_config_names.includes(val_node.name.toLowerCase());
-    
-    if (is_pascal_case && !is_common_config) {
-      return "class";
-    }
-  }
-
-  // 检查是否为常量/配置值（应该使用UPPERCASE风格）
-  if (this._isConst(val_node, prop_name)) {
-    return "constant";
-  }
-
-  // 默认为值类型
-  return "value";
-};
-
-/**
- * 检查是否为常量值（应该使用UPPERCASE风格命名）
- * @param {Object} val_node - 属性值AST节点
- * @param {string} prop_name - 属性名（可选，用于更智能的判断）
- * @returns {boolean} 是否为常量值
- * @private
- */
-Detector.prototype._isConst = function (val_node, prop_name) {
-  if (!val_node) {
-    return false;
-  }
-
-  const is_prim_const = this._isPrimConst(val_node);
-  const is_cfg_obj = this._isCfgObj(val_node);
-  const is_const_id = this._isConstId(val_node);
-
-  if (prop_name) {
-    return this._isConstWithName(
-      val_node,
-      prop_name,
-      is_prim_const,
-      is_cfg_obj,
-      is_const_id,
-    );
-  }
-
-  return this._isConstWithoutName(is_prim_const, is_cfg_obj, is_const_id);
-};
-
-/**
- * 判断标识符是否为类名（基于上下文分析）
- * @param {string} name - 标识符名称
- * @param {Object} context_node - 上下文AST节点
- * @returns {boolean} 是否为类名
- * @private
- */
-Detector.prototype._isClassName = function (name, context_node) {
-  if (!name || typeof name !== 'string') {
-    return false;
-  }
-
-  // 首先检查是否为大驼峰命名（类名的基本要求）
-  if (!/^[A-Z][a-zA-Z]*$/.test(name)) {
-    return false;
-  }
-
-  // 如果有上下文节点，进行更精确的分析
-  if (context_node) {
-    // 检查是否在类声明中
-    if (context_node.type === 'ClassDeclaration' || 
-        context_node.type === 'ClassExpression') {
-      return true;
-    }
-    
-    // 检查是否在 extends 或 implements 中
-    if (context_node.type === 'Identifier' && 
-        context_node.parent && 
-        (context_node.parent.type === 'ClassDeclaration' || 
-         context_node.parent.type === 'ClassExpression')) {
-      return true;
-    }
-    
-    // 检查是否在 new 表达式中
-    if (context_node.type === 'NewExpression' && 
-        context_node.callee && 
-        context_node.callee.name === name) {
-      return true;
-    }
-  }
-
-  // 对于没有上下文的情况，采用保守策略
-  // 只对明显是类名的标识符返回 true
-  const class_suffixes = [
-    'Manager', 'Controller', 'Service', 'Factory', 'Builder', 
-    'Provider', 'Middleware', 'Component', 'Repository', 'Handler',
-    'Adapter', 'Decorator', 'Validator', 'Generator', 'Processor'
-  ];
-
-  return class_suffixes.some(suffix => name.endsWith(suffix));
-};
-
-/**
- * 检查是否为基本类型常量
- * @private
- */
-Detector.prototype._isPrimConst = function (val_node) {
-  return (
-    val_node.type === "Literal" &&
-    (typeof val_node.value === "string" ||
-      typeof val_node.value === "number" ||
-      typeof val_node.value === "boolean")
-  );
-};
-
-/**
- * 检查是否为配置对象
- * @private
- */
-Detector.prototype._isCfgObj = function (val_node) {
-  // 配置对象应该是包含大写标识符的对象，而不是普通对象字面量
-  return (
-    val_node.type === "ObjectExpression" &&
-    val_node.properties &&
-    val_node.properties.length > 0 &&
-    val_node.properties.every(
-      (prop) =>
-        prop.value &&
-        prop.value.type === "Identifier" &&
-        /^[A-Z_][A-Z0-9_]*$/.test(prop.value.name)
-    )
-  );
-};
-
-/**
- * 检查是否为常量标识符
- * @private
- */
-Detector.prototype._isConstId = function (val_node) {
-  return (
-    val_node.type === "Identifier" && /^[A-Z_][A-Z0-9_]*$/.test(val_node.name)
-  );
-};
-
-/**
- * 有属性名时的常量判断
- * @private
- */
-Detector.prototype._isConstWithName = function (
-  val_node,
-  prop_name,
-  is_prim_const,
-  is_cfg_obj,
-  is_const_id,
-) {
-  const is_upper_name = /^[A-Z_][A-Z0-9_]*$/.test(prop_name);
-  const is_inst_data_name =
-    /^[a-z][a-z0-9_]*$/.test(prop_name) ||
-    /^[a-z][a-zA-Z0-9]*$/.test(prop_name);
-  const is_val_const = this._isValConst(val_node, prop_name);
-
-  if (is_inst_data_name && is_prim_const) {
-    return false; // 实例数据的属性名，即使值是基本类型，也不应视为常量
-  }
-
-  if (is_upper_name && (is_prim_const || is_cfg_obj)) {
-    return true;
-  }
-
-  return is_cfg_obj || is_const_id;
-};
-
-/**
- * 无属性名时的常量判断
- * @private
- */
-Detector.prototype._isConstWithoutName = function (
-  is_prim_const,
-  is_cfg_obj,
-  is_const_id,
-) {
-  if (is_cfg_obj || is_const_id) {
-    return true;
-  }
-  return is_prim_const;
-};
-
-/**
- * 通过值内容分析判断是否为常量
- * @param {Object} val_node - 属性值AST节点
- * @param {string} prop_name - 属性名
- * @returns {boolean} 值内容是否为常量特征
- * @private
- */
-Detector.prototype._isValConst = function (val_node, prop_name) {
-  if (!val_node || val_node.type !== "Literal") {
-    return false;
-  }
-
-  const value = val_node.value;
-
-  switch (typeof value) {
-    case "string":
-      return this._isStringConst(value, prop_name);
-    case "number":
-      return this._isNumberConst(value, prop_name);
-    case "boolean":
-      return this._isBooleanConst(value, prop_name);
-    default:
-      return this._isConstSem(prop_name, value);
-  }
-};
-
-/**
- * 检查字符串值是否为常量
- * @private
- */
-Detector.prototype._isStringConst = function (value, prop_name) {
-  const is_url_const = this._isUrlConst(value, prop_name);
-  if (is_url_const) return true;
-
-  const is_config_const = this._isConfigConst(value, prop_name);
-  if (is_config_const) return true;
-
-  return false;
-};
-
-/**
- * 检查URL相关的字符串常量
- * @private
- */
-Detector.prototype._isUrlConst = function (value, prop_name) {
-  const is_url_related_name =
-    /(url|uri|endpoint|api|base|host|domain|path)$/i.test(prop_name);
-  const is_url_value =
-    /^(https?:\/\/|\/\/|www\.|ftp:\/\/)/.test(value) ||
-    /\.[a-z]{2,6}(\/|$)/.test(value);
-
-  return is_url_related_name && is_url_value;
-};
-
-/**
- * 检查配置相关的字符串常量
- * @private
- */
-Detector.prototype._isConfigConst = function (value, prop_name) {
-  const is_config_related_name =
-    /(config|setting|option|default|mode|env|version)$/i.test(prop_name);
-  const is_config_value =
-    /^(v?\d+\.\d+|true|false|null|undefined|production|development|test)$/i.test(
-      value,
-    );
-
-  return is_config_related_name && is_config_value;
-};
-
-/**
- * 检查数字值是否为常量
- * @private
- */
-Detector.prototype._isNumberConst = function (value, prop_name) {
-  const is_config_num = this._isConfigNumber(value, prop_name);
-  if (is_config_num) return true;
-
-  const is_common_const = this._isCommonNumber(value);
-  if (is_common_const) return true;
-
-  return false;
-};
-
-/**
- * 检查配置相关的数字常量
- * @private
- */
-Detector.prototype._isConfigNumber = function (value, prop_name) {
-  const is_config_number_name =
-    /(timeout|delay|interval|retry|count|limit|max|min|size|length|port)$/i.test(
-      prop_name,
-    );
-  return is_config_number_name;
-};
-
-/**
- * 检查常见数字常量
- * @private
- */
-Detector.prototype._isCommonNumber = function (value) {
-  const common_constants = [
-    0, 1, 10, 100, 1000, 60, 3600, 86400, 1024, 2048, 4096, 8192,
-  ];
-  return common_constants.includes(value);
-};
-
-/**
- * 检查布尔值是否为常量
- * @private
- */
-Detector.prototype._isBooleanConst = function (value, prop_name) {
-  const is_config_bool = this._isConfigBoolean(prop_name);
-  const is_inst_state = this._isInstanceState(prop_name);
-
-  if (is_config_bool && !is_inst_state) {
-    return true;
-  }
-
-  if (is_inst_state) {
-    return false;
-  }
-
-  return false;
-};
-
-/**
- * 检查配置相关的布尔值
- * @private
- */
-Detector.prototype._isConfigBoolean = function (prop_name) {
-  return /^(is_)?(enabled|disabled|debug|verbose|strict|lazy|secure|ssl|tls|compressed|cached)$/i.test(
-    prop_name,
-  );
-};
-
-/**
- * 检查实例数据状态的布尔值
- * @private
- */
-Detector.prototype._isInstanceState = function (prop_name) {
-  return /^(is_)?(active|inactive|visible|hidden|required|optional|valid|invalid|available|busy|online|offline|open|closed|locked|unlocked)$/i.test(
-    prop_name,
-  );
-};
-
-/**
- * 通过属性名语义分析判断是否为常量
- * @param {string} prop_name - 属性名
- * @param {any} value - 属性值
- * @returns {boolean} 根据语义分析是否为常量
- * @private
- */
-Detector.prototype._isConstSem = function (prop_name, value) {
-  // 精确匹配常量相关词汇（使用单词边界匹配）
-  const const_keys = [
-    "api",
-    "base",
-    "url",
-    "uri",
-    "endpoint",
-    "host",
-    "domain",
-    "timeout",
-    "delay",
-    "interval",
-    "retry",
-    "count",
-    "limit",
-    "max",
-    "min",
-    "size",
-    "length",
-    "port",
-    "version",
-    "config",
-    "setting",
-    "option",
-    "default",
-    "mode",
-    "env",
-    "debug",
-    "verbose",
-    "strict",
-    "lazy",
-    "secure",
-    "ssl",
-    "tls",
-    "compressed",
-    "cached",
-  ];
-
-  // 使用单词边界匹配，避免误匹配（如"active"匹配"is_active"）
-  const has_const_key = const_keys.some((keyword) => {
-    const regex = new RegExp(`\\b${keyword}\\b`, "i");
-    return regex.test(prop_name);
-  });
-
-  if (has_const_key) {
-    // 如果属性名包含常量相关词汇，且值是基本类型，更可能是常量
-    return (
-      typeof value === "string" ||
-      typeof value === "number" ||
-      typeof value === "boolean"
-    );
-  }
-
-  // 实例数据相关词汇（更精确的匹配）
-  const inst_keys = [
-    "user",
-    "person",
-    "customer",
-    "member",
-    "client",
-    "product",
-    "item",
-    "goods",
-    "article",
-    "order",
-    "cart",
-    "payment",
-    "invoice",
-    "name",
-    "age",
-    "email",
-    "phone",
-    "address",
-    "title",
-    "description",
-    "content",
-    "message",
-    "active",
-    "inactive",
-    "visible",
-    "hidden",
-    "required",
-    "optional",
-    "valid",
-    "invalid",
-    "available",
-    "busy",
-    "online",
-    "offline",
-    "open",
-    "closed",
-    "locked",
-    "unlocked",
-  ];
-
-  // 使用单词边界匹配
-  const has_inst_key = inst_keys.some((keyword) => {
-    const regex = new RegExp(`\\b${keyword}\\b`, "i");
-    return regex.test(prop_name);
-  });
-
-  if (has_inst_key) {
-    // 如果属性名包含实例数据相关词汇，更可能是实例数据
-    return false;
-  }
-
-  // 属性名模式分析
-  const is_likely_const_pat = this._isConstPat(prop_name, value);
-
-  return is_likely_const_pat;
-};
-
-/**
- * 通过属性名模式分析判断是否为常量
- * @param {string} prop_name - 属性名
- * @param {any} value - 属性值
- * @returns {boolean} 根据模式分析是否为常量
- * @private
- */
-Detector.prototype._isConstPat = function (prop_name, value) {
-  // UPPERCASE模式：全大写或大写蛇形
-  const is_uppercase_pattern = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/.test(prop_name);
-
-  // 配置前缀模式：包含config、setting、default等前缀
-  const has_config_prefix = /^(config|setting|option|default|env|mode)_/i.test(
-    prop_name,
-  );
-
-  // 常量后缀模式：包含url、timeout、count等后缀
-  const has_constant_suffix =
-    /_(url|uri|endpoint|api|base|host|domain|timeout|delay|interval|retry|count|limit|max|min|size|length|port|version)$/i.test(
-      prop_name,
-    );
-
-  // 实例数据模式：包含user、product、order等前缀或后缀
-  const has_instance_pattern =
-    /^(user|person|customer|member|client|product|item|goods|article|order|cart|payment|invoice)_/i.test(
-      prop_name,
-    ) ||
-    /_(user|person|customer|member|client|product|item|goods|article|order|cart|payment|invoice)$/i.test(
-      prop_name,
-    );
-
-  // 状态模式：以is_开头或包含状态相关词汇
-  const is_status_pattern =
-    /^is_/i.test(prop_name) ||
-    /_(active|inactive|visible|hidden|required|optional|valid|invalid|available|busy|online|offline|open|closed|locked|unlocked)$/i.test(
-      prop_name,
-    );
-
-  // 判断逻辑
-  if (is_uppercase_pattern || has_config_prefix || has_constant_suffix) {
-    return true; // 常量模式
-  }
-
-  if (has_instance_pattern || is_status_pattern) {
-    return false; // 实例数据模式
-  }
-
-  return false;
-};
-
-/**
- * 检查是否包含禁止的废话词（拼接命名检测）
- * @param {string} name - 名称
- * @param {string} type - 代码实体类型（class/function/variable）
- * @returns {string|null} 检测到的废话词，未检测到返回null
- * @private
- */
-Detector.prototype._checkBadWord = function (name, type) {
-  if (!name || !type) {
-    return null;
-  }
-
-  const forbidden_words = this.config.forbidden_words[type] || [];
-  const nameLower = name.toLowerCase();
-
-  // 检测拼接命名：名称由多个单词组成，且包含禁止词
-  // 例如：UserManager（包含manager）、DataHandler（包含handler）
-  // 但允许单个单词：Manager、Handler等
-
-  // 如果名称是单个单词，不进行废话词检测
-  if (!this._isCompoundName(name)) {
-    return null;
-  }
-
-  // 检查名称是否包含废话词作为独立的单词（而不是子字符串）
-  for (const word of forbidden_words) {
-    const wordLower = word.toLowerCase();
-    
-    // 检查是否作为独立的单词存在
-    // 1. 作为整个名称（单个单词）
-    if (nameLower === wordLower) {
-      continue; // 单个单词允许使用
-    }
-    
-    // 2. 作为复合名称的一部分（以下划线分隔）
-    if (nameLower.includes('_')) {
-      const words = nameLower.split('_');
-      if (words.includes(wordLower)) {
-        return word;
-      }
-    }
-    
-    // 3. 作为驼峰命名的一部分（包括小驼峰和大驼峰）
-    if (/^[a-z]+([A-Z][a-z]+)+$/.test(name) || /^[A-Z][a-z]+([A-Z][a-z]+)+$/.test(name)) {
-      const camelWords = name.replace(/([A-Z])/g, '_$1').toLowerCase().split('_');
-      if (camelWords.includes(wordLower)) {
-        // 返回原词，保持大小写格式
-        return word;
-      }
-    }
-  }
-  
-  return null;
-};
-
-/**
- * 检查是否为拼接命名（由多个单词组成）
- * @param {string} name - 名称
- * @returns {boolean} 是否为拼接命名
- * @private
- */
-Detector.prototype._isCompoundName = function (name) {
-  if (!name) {
-    return false;
-  }
-
-  // 检测大驼峰命名（PascalCase）：每个单词首字母大写
-  if (/^[A-Z][a-z]+([A-Z][a-z]+)+$/.test(name)) {
-    return true;
-  }
-
-  // 检测小驼峰命名（camelCase）：第一个单词小写，后续单词首字母大写
-  if (/^[a-z]+([A-Z][a-z]+)+$/.test(name)) {
-    return true;
-  }
-
-  // 检测蛇形命名（snake_case）：单词间以下划线分隔
-  if (/^[a-z]+(_[a-z]+)+$/.test(name)) {
-    return true;
-  }
-
-  // 检测横杠命名（kebab-case）：单词间以短横线分隔
-  if (/^[a-z]+(-[a-z]+)+$/.test(name)) {
-    return true;
-  }
-
-  return false;
-};
-
-/**
- * 检查是否为忽略词
- * @param {string} name - 名称
- * @param {string} rule_type - 规则类型
- * @returns {boolean} 是否为忽略词
- * @private
- */
-Detector.prototype._isIgnoreWord = function (name, rule_type) {
-  // 获取忽略词配置
-  const ignore_words_config = this.config.ignore_words;
-  if (!ignore_words_config) {
-    return false;
-  }
-
-  // 根据规则类型获取对应的忽略词列表
-  let ignore_list = [];
-  if (rule_type === "class-name") {
-    ignore_list = ignore_words_config.class || [];
-  } else if (rule_type === "method-name") {
-    ignore_list = ignore_words_config.method || [];
-  } else if (rule_type === "function-name") {
-    ignore_list = ignore_words_config.function || [];
-  } else if (rule_type === "variable-name") {
-    ignore_list = ignore_words_config.variable || [];
-  }
-
-  // 检查名称是否完全匹配忽略词列表中的任何一个词
-  // 支持精确匹配和包含匹配（如果名称包含忽略词，则整个名称都被忽略）
-  // 支持大小写不敏感匹配
-  const name_lower = name.toLowerCase();
-  for (const ignore_word of ignore_list) {
-    const ignore_word_lower = ignore_word.toLowerCase();
-    if (name_lower === ignore_word_lower || name_lower.includes(ignore_word_lower)) {
-      return true;
-    }
-  }
-
-  return false;
-};
-
-/**
- * 检查推荐词并生成推荐建议
- * @param {string} name - 名称
- * @param {string} rule_type - 规则类型
- * @param {Object} config - 配置
- * @param {Array} recommendations - 推荐建议数组
- * @private
- */
-Detector.prototype._checkRecommen = function (name, rule_type, config, recommendations) {
-  // 只对函数和方法名进行推荐词检测
-  if (rule_type !== "function-name" && rule_type !== "method-name") {
-    return;
-  }
-
-  const recommen_words = this.config.recommen_words.function;
-  
-  // 拆分命名中的单词
-  const words = this._splitWords(name, rule_type);
-
-  // 检查每个推荐词类别
-  Object.keys(recommen_words).forEach((category) => {
-    const category_config = recommen_words[category];
-    const category_words = category_config.words || [];
-
-    // 检查拆分后的单词是否包含推荐词类别对应的推荐词
-    let has_target_word = false;
-    words.forEach((word) => {
-      if (category_words.includes(word)) {
-        // 如果单词是目标词（如remove、delete），则生成建议
-        has_target_word = true;
-      }
-    });
-
-    // 如果包含目标词，则生成建议
-    if (has_target_word) {
-      // 检查是否需要生成推荐
-      let should_recommend = false;
-      
-      if (this.config.recommen) {
-        // recommen为true：所有符合条件的命名都应该推荐
-        should_recommend = true;
-      } else {
-        // recommen为false：只有当命名中出现单个词汇长度超过指定字符或命名总长度超过限制时才推荐
-        const has_long_word = words.some(word => word.length > (config.single_word_len || 8));
-        const has_long_name = name.length > config.max;
-        
-        should_recommend = has_long_word || has_long_name;
-      }
-
-      if (should_recommend) {
-        // 生成推荐建议：将目标词替换为推荐类别词
-        const suggestions = [];
-        
-        // 为每个检测到的目标词生成一个推荐
-        words.forEach((word) => {
-          if (category_words.includes(word)) {
-            // 只生成使用类别词替换的推荐，不包含原始词
-            const regex = new RegExp(word, 'gi');
-            const suggestion = name.replace(regex, (match) => {
-              // 保持原始大小写格式
-              if (match === match.toUpperCase()) {
-                return category.toUpperCase();
-              } else if (match[0] === match[0].toUpperCase()) {
-                return category[0].toUpperCase() + category.slice(1);
-              } else {
-                return category;
-              }
-            });
-            
-            // 只有当推荐结果与原始名称不同时才添加
-            if (suggestion !== name) {
-              suggestions.push(suggestion);
-            }
-          }
-        });
-
-        if (suggestions.length > 0) {
-          recommendations.push({
-            original: name,
-            category: category,
-            suggestions: suggestions,
-            message: `检测到"${category_words.join('、')}"，推荐使用: ${suggestions.join(', ')}`
-          });
-        }
-      }
-    }
-  });
-};
-
-/**
- * 检测名称是否符合规范
- * @param {string} name - 名称
- * @param {string} type - 类型（class/function/variable/constant/private）
- * @returns {Object} 检测结果
- */
-Detector.prototype.checkName = function (name, type) {
-  if (typeof name !== "string" || !name.trim()) {
-    return {
-      valid: false,
-      errors: ["名称必须是有效的字符串"],
-    };
-  }
-
-  if (typeof type !== "string" || !type.trim()) {
-    return {
-      valid: false,
-      errors: ["类型必须是有效的字符串"],
-    };
-  }
-
-  const rule_method = this._rules[type];
-  if (!rule_method) {
-    return {
-      valid: false,
-      errors: [`不支持的类型: ${type}`],
-    };
-  }
-
-  try {
-    return rule_method(name);
-  } catch (error) {
-    return {
-      valid: false,
-      errors: [`检测名称时出错: ${error.message}`],
-    };
-  }
-};
-
-/**
- * 批量检测名称
- * @param {Array} names - 名称数组
- * @param {string} type - 类型
- * @returns {Array} 检测结果数组
- */
-Detector.prototype.checkNames = function (names, type) {
-  if (!Array.isArray(names)) {
-    throw new TypeError("名称必须是数组");
-  }
-
-  return names.map((name) => this.check_name(name, type));
-};
-
-/**
- * ESLint规则实现
- */
-
 /**
- * 类名大驼峰规则
+ * ESLint命名规范检测插件
+ * 版本: 1.1.0 - 支持跳过null值和未赋值属性检测
  */
-const class_name_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "类名必须使用大驼峰命名法（PascalCase）且优先使用单个单词",
-      category: "Stylistic Issues",
-      recommen: true,
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
-          ignore_words: {
-            type: "object",
-            properties: {
-              class: { type: "array", items: { type: "string" } },
-              method: { type: "array", items: { type: "string" } },
-              function: { type: "array", items: { type: "string" } }
-            },
-            additionalProperties: false
-          }
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      ClassDeclaration(node) {
-        const class_name = node.id.name;
-        const detector = new Detector({ "class-name": options });
-        const result = detector.checkName(class_name, "class-name");
 
-        if (!result.valid) {
-          result.errors.forEach((error) => {
-            context.report({
-              node: node.id,
-              message: `类名"${class_name}"不符合规范: ${error}`,
-            });
-          });
-        }
-      },
-    };
-  },
-};
+const { Config } = require('./config');
+const { Detector } = require('./detector');
 
 /**
- * 函数名小驼峰规则
+ * 创建ESLint规则配置
+ * @returns {object} ESLint规则配置对象
  */
-const function_name_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "函数名必须使用小驼峰命名法（camelCase）且优先使用单个单词",
-      category: "Stylistic Issues",
-      recommen: true,
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
-          ignore_words: {
-            type: "object",
-            properties: {
-              class: { type: "array", items: { type: "string" } },
-              method: { type: "array", items: { type: "string" } },
-              function: { type: "array", items: { type: "string" } }
-            },
-            additionalProperties: false
-          }
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      FunctionDeclaration(node) {
-        const function_name = node.id ? node.id.name : "anonymous";
-        if (function_name !== "anonymous") {
-          const detector = new Detector({ "function-name": options });
-          const result = detector.checkName(function_name, "function-name");
+function createNamingRules() {
+  var config = new Config({});
+  var detector = new Detector(config);
 
-          if (!result.valid) {
-            result.errors.forEach((error) => {
-              context.report({
-                node: node.id,
-                message: `函数名"${function_name}"不符合规范: ${error}`,
-              });
-            });
-          }
-        }
+  return {
+    'class-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测类名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        schema: [],
       },
-
-      FunctionExpression(node) {
-        if (node.id) {
-          const function_name = node.id.name;
-          const detector = new Detector({ "function-name": options });
-          const result = detector.checkName(function_name, "function-name");
-
-          if (!result.valid) {
-            result.errors.forEach((error) => {
+      create: function (context) {
+        return {
+          ClassDeclaration: function (node) {
+            var class_name = node.id.name;
+            var err = detector._checkClassName(class_name, node);
+            if (err) {
               context.report({
-                node: node.id,
-                message: `函数表达式名"${function_name}"不符合规范: ${error}`,
+                node: err.node,
+                message: err.message,
               });
-            });
-          }
-        }
+            }
+          },
+        };
       },
-    };
-  },
-};
-
-/**
- * 方法名小驼峰规则
- */
-const method_name_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "方法名必须使用小驼峰命名法（camelCase）且优先使用单个单词",
-      category: "Stylistic Issues",
-      recommen: true,
     },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
-          ignore_words: {
-            type: "object",
-            properties: {
-              class: { type: "array", items: { type: "string" } },
-              method: { type: "array", items: { type: "string" } },
-              function: { type: "array", items: { type: "string" } }
-            },
-            additionalProperties: false
-          }
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    
-    function checkMethodName(node, method_name) {
-      // 跳过私有方法的检测（私有方法由private-naming规则处理）
-      if (method_name.startsWith("_")) {
-        return;
-      }
-
-      // 跳过JavaScript内置特殊方法名
-      const builtin_methods = [
-        "constructor",
-        "toString",
-        "valueOf",
-        "toJSON",
-      ];
-      if (builtin_methods.includes(method_name)) {
-        return;
-      }
 
-      const detector = new Detector({ "method-name": options });
-      const result = detector.checkName(method_name, "method-name");
-
-      if (!result.valid) {
-        result.errors.forEach((error) => {
-          context.report({
-            node: node.key || node,
-            message: `方法名"${method_name}"不符合规范: ${error}`,
-          });
-        });
-      }
-    }
-    
-    return {
-      // 处理类中的方法
-      MethodDefinition(node) {
-        checkMethodName(node, node.key.name);
-      },
-      
-      // 处理对象字面量中的方法
-      Property(node) {
-        // 检查是否是方法（函数表达式或箭头函数或方法简写）
-        if (node.key.type === "Identifier" && !node.key.name.startsWith("_")) {
-          const is_method = node.value && 
-            (node.value.type === "FunctionExpression" || 
-             node.value.type === "ArrowFunctionExpression" ||
-             (node.method === true)); // 方法简写语法
-          
-          if (is_method) {
-            checkMethodName(node, node.key.name);
-          }
-        }
-      },
-    };
-  },
-};
-
-/**
- * 变量名小写蛇形规则
- */
-const variable_name_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "变量名必须使用小写蛇形命名法（snake_case）",
-      category: "Stylistic Issues",
-      recommen: true,
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
-          ignore_words: {
-            type: "object",
-            properties: {
-              variable: { type: "array", items: { type: "string" } }
-            },
-            additionalProperties: false
-          }
+    'function-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测函数名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
         },
-        additionalProperties: false,
+        schema: [],
       },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-
-    function isRealConstant(node) {
-      // 真正的常量特征：
-      // 1. 在模块顶层作用域（不在函数或块内）
-      // 2. 名称符合常量命名模式（全大写或大写蛇形）
-      // 3. 不是模块导入（避免将require导入识别为常量）
-
-      // 检查是否在模块顶层
-      let scope_node = node;
-      while (scope_node.parent) {
-        scope_node = scope_node.parent;
-        if (
-          scope_node.type === "FunctionDeclaration" ||
-          scope_node.type === "FunctionExpression" ||
-          scope_node.type === "ArrowFunctionExpression" ||
-          scope_node.type === "BlockStatement"
-        ) {
-          return false; // 在函数或块内，不是真正的常量
-        }
-      }
-
-      // 检查是否是模块导入（避免将require导入识别为常量）
-      if (node.init &&
-        (node.init.type === "CallExpression" &&
-          node.init.callee &&
-          node.init.callee.name === "require")) {
-        return false; // 这是模块导入，不是真正的常量
-      }
-
-      // 检查名称是否符合常量命名模式
-      const name = node.id.name;
-
-      // 常量命名模式：全大写或大写蛇形
-      const is_uppercase = /^[A-Z][A-Z0-9]*$/.test(name); // 全大写：PORT, DEBUG
-      const is_upper_snake = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/.test(name); // 大写蛇形：API_BASE_URL
-
-      // 只有符合常量命名模式的才被认为是真正的常量
-      return is_uppercase || is_upper_snake;
-    }
-
-    return {
-      VariableDeclarator(node) {
-        if (node.id.type === "Identifier") {
-          // 对于const声明，只对不是真正常量的应用变量命名规则
-          if (node.parent.kind === "const" && isRealConstant(node)) {
-            return; // 这是真正的常量，由常量规则处理
-          }
-
-          // 检查是否是函数声明（由函数名规则处理，这里跳过）
-          if (node.init &&
-            (node.init.type === "FunctionExpression" ||
-              node.init.type === "ArrowFunctionExpression")) {
-            // 这是函数声明，由函数名规则处理，这里跳过避免重复检测
-            return;
-          }
-
-          // 检查是否是类实例
-          if (node.init &&
-            node.init.type === "NewExpression" &&
-            node.init.callee &&
-            node.init.callee.type === "Identifier" &&
-            /^[A-Z][a-zA-Z]*$/.test(node.init.callee.name)) {
-            // 这是类实例，应该使用函数名规则（camelCase）
-            const class_instance_name = node.id.name;
-            const detector = new Detector({ "function-name": options });
-            const result = detector.checkName(class_instance_name, "function-name");
-
-            if (!result.valid) {
-              result.errors.forEach((error) => {
+      create: function (context) {
+        return {
+          FunctionDeclaration: function (node) {
+            if (node.id) {
+              var function_name = node.id.name;
+              var err = detector._checkFunctionName(function_name, node);
+              if (err) {
                 context.report({
-                  node: node.id,
-                  message: `类实例名"${class_instance_name}"不符合规范: ${error}`,
-                });
-              });
-            }
-            return;
-          }
-
-          // 检查是否是模块导入
-          if (node.init &&
-            node.init.type === "CallExpression" &&
-            node.init.callee &&
-            node.init.callee.name === "require") {
-            // 这是模块导入，应用模块导入命名规则
-            const module_name = node.id.name;
-
-            // 智能判断模块导入的命名风格
-            if (/^[A-Z][a-zA-Z]*$/.test(module_name)) {
-              // 类/构造函数导入：Koa, Express - 应该使用PascalCase
-              const detector = new Detector({ "class-name": options });
-              const result = detector.checkName(module_name, "class-name");
-
-              if (!result.valid) {
-                result.errors.forEach((error) => {
-                  context.report({
-                    node: node.id,
-                    message: `模块导入名"${module_name}"不符合规范: ${error}`,
-                  });
-                });
-              }
-            } else if (/^[a-z][a-zA-Z]*$/.test(module_name)) {
-              // 默认导出导入：express, config - 应该使用camelCase
-              const detector = new Detector({ "function-name": options });
-              const result = detector.checkName(module_name, "function-name");
-
-              if (!result.valid) {
-                result.errors.forEach((error) => {
-                  context.report({
-                    node: node.id,
-                    message: `模块导入名"${module_name}"不符合规范: ${error}`,
-                  });
+                  node: err.node,
+                  message: err.message,
                 });
               }
-            } else {
-              // 其他情况（如path, fs） - 使用变量名规则
-              const detector = new Detector({ "variable-name": options });
-              const result = detector.checkName(module_name, "variable-name");
-
-              if (!result.valid) {
-                result.errors.forEach((error) => {
-                  context.report({
-                    node: node.id,
-                    message: `模块导入名"${module_name}"不符合规范: ${error}`,
-                  });
+            }
+          },
+          FunctionExpression: function (node) {
+            if (node.id) {
+              var function_name = node.id.name;
+              var err = detector._checkFunctionName(function_name, node);
+              if (err) {
+                context.report({
+                  node: err.node,
+                  message: err.message,
                 });
               }
             }
-            return;
-          }
-
-          // 真正的变量声明
-          const variable_name = node.id.name;
-          const detector = new Detector({ "variable-name": options });
-          const result = detector.checkName(variable_name, "variable-name");
-
-          if (!result.valid) {
-            result.errors.forEach((error) => {
-              context.report({
-                node: node.id,
-                message: `变量名"${variable_name}"不符合规范: ${error}`,
-              });
-            });
-          }
-        }
+          },
+        };
       },
-    };
-  },
-};
-
-/**
- * 常量名大写蛇形规则
- */
-const constant_name_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "常量名必须使用大写蛇形命名法（UPPER_SNAKE_CASE）",
-      category: "Stylistic Issues",
-      recommen: true,
     },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
+
+    'method-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测方法名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
         },
-        additionalProperties: false,
+        schema: [],
       },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-
-    function isRealConstant(node) {
-      // 真正的常量特征：
-      // 1. 在模块顶层作用域（不在函数或块内）
-      // 2. 名称符合常量命名模式（全大写或大写蛇形）
-      // 3. 不是模块导入（避免将require导入识别为常量）
-
-      // 检查是否在模块顶层
-      let scope_node = node;
-      while (scope_node.parent) {
-        scope_node = scope_node.parent;
-        if (
-          scope_node.type === "FunctionDeclaration" ||
-          scope_node.type === "FunctionExpression" ||
-          scope_node.type === "ArrowFunctionExpression" ||
-          scope_node.type === "BlockStatement"
-        ) {
-          return false; // 在函数或块内，不是真正的常量
-        }
-      }
-
-      // 检查是否是模块导入（避免将require导入识别为常量）
-      if (node.init &&
-        (node.init.type === "CallExpression" &&
-          node.init.callee &&
-          node.init.callee.name === "require")) {
-        return false; // 这是模块导入，不是真正的常量
-      }
-
-      // 检查名称是否符合常量命名模式
-      const name = node.id.name;
-
-      // 常量命名模式：全大写或大写蛇形
-      const is_uppercase = /^[A-Z][A-Z0-9]*$/.test(name); // 全大写：PORT, DEBUG
-      const is_upper_snake = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/.test(name); // 大写蛇形：API_BASE_URL
-
-      // 只有符合常量命名模式的才被认为是真正的常量
-      return is_uppercase || is_upper_snake;
-    }
-
-    return {
-      VariableDeclarator(node) {
-        if (node.id.type === "Identifier" && node.parent.kind === "const") {
-          // 只对真正的常量应用常量命名规则
-          if (isRealConstant(node)) {
-            const constant_name = node.id.name;
-            const detector = new Detector({ "constant-name": options });
-            const result = detector.checkName(constant_name, "constant-name");
-
-            if (!result.valid) {
-              result.errors.forEach((error) => {
+      create: function (context) {
+        return {
+          MethodDefinition: function (node) {
+            if (node.key && node.key.name) {
+              var method_name = node.key.name;
+              var err = detector._checkMethodName(method_name, node);
+              if (err) {
                 context.report({
-                  node: node.id,
-                  message: `常量名"${constant_name}"不符合规范: ${error}`,
+                  node: err.node,
+                  message: err.message,
                 });
-              });
+              }
             }
-          }
-        }
-      },
-    };
-  },
-};
-
-/**
- * 入参名小写蛇形规则
- */
-const param_name_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "入参名必须使用小写蛇形命名法（snake_case）",
-      category: "Stylistic Issues",
-      recommen: true,
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
-        },
-        additionalProperties: false,
+          },
+        };
       },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-
-    function checkParam(node) {
-      // 处理不同节点类型的参数
-      let params = [];
-
-      if (node.type === "MethodDefinition") {
-        // MethodDefinition节点（包括构造函数）的参数在node.value.params中
-        params = node.value ? node.value.params || [] : [];
-      } else {
-        // 其他函数节点的参数在node.params中
-        params = node.params || [];
-      }
-
-      params.forEach((param) => {
-        if (param.type === "Identifier") {
-          const param_name = param.name;
-          const detector = new Detector({ "param-name": options });
-          const result = detector.checkName(param_name, "param-name");
-
-          if (!result.valid) {
-            result.errors.forEach((error) => {
-              context.report({
-                node: param,
-                message: `入参名"${param_name}"不符合规范: ${error}`,
-              });
-            });
-          }
-        }
-      });
-    }
-
-    return {
-      FunctionDeclaration: checkParam,
-      FunctionExpression: checkParam,
-      ArrowFunctionExpression: checkParam,
-      MethodDefinition: checkParam,
-    };
-  },
-};
-
-/**
- * 属性名小写蛇形规则
- */
-const prop_name_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "属性名必须使用小写蛇形命名法（snake_case）",
-      category: "Stylistic Issues",
-      recommen: true,
     },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      Property(node) {
-        // 检测所有非私有属性（不以_开头）
-        if (node.key.type === "Identifier" && !node.key.name.startsWith("_")) {
-          // 检查是否是方法（函数表达式或箭头函数或方法简写）
-          const is_method = node.value && 
-            (node.value.type === "FunctionExpression" || 
-             node.value.type === "ArrowFunctionExpression" ||
-             (node.method === true)); // 方法简写语法
-          
-          // 如果是方法，跳过属性检测（方法由method-name规则处理）
-          if (is_method) {
-            return;
-          }
-          
-          // 如果是真正的属性，使用属性规则检测
-          const prop_name = node.key.name;
-          const detector = new Detector({ "property-name": options });
-          const result = detector._checkPropName(prop_name, node.value, node);
-
-          if (!result.valid) {
-            result.errors.forEach((error) => {
-              context.report({
-                node: node.key,
-                message: `属性名"${prop_name}"不符合规范: ${error}`,
-                ruleId: "naming-convention/property-name",
-              });
-            });
-          }
-        }
-      },
-    };
-  },
-};
 
-/**
- * 私有方法命名规则
- */
-const private_method_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "私有方法必须以单下划线开头，后跟小驼峰命名或小写单词",
-      category: "Stylistic Issues",
-      recommen: true,
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
+    'variable-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测变量名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
         },
-        additionalProperties: false,
-      },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    
-    function checkPrivateMethodName(node, method_name) {
-      const detector = new Detector({ "private-method-naming": options });
-      const result = detector.checkName(
-        method_name,
-        "private-method-naming",
-      );
-
-      if (!result.valid) {
-        result.errors.forEach((error) => {
-          context.report({
-            node: node.key || node,
-            message: `私有方法名"${method_name}"不符合规范: ${error}`,
-          });
-        });
-      }
-    }
-    
-    // 检测应该是私有方法但没有_前缀的情况
-    function checkMissingPrivatePrefix(node, method_name) {
-      // 使用配置中的私有方法前缀列表
-      const detector = new Detector({ "private-method-naming": options });
-      const private_prefixes = detector.config.private_method_prefixes || [];
-      
-      // 判断是否应该是私有方法（基于前缀判断）
-      const should_be_private = private_prefixes.some(prefix => {
-        if (!method_name.toLowerCase().startsWith(prefix.toLowerCase())) {
-          return false;
-        }
-        
-        // 额外检查：只有多单词的方法名才需要是私有方法
-        // 例如：init() 可以非私有，但initService() 必须私有
-        const remaining_part = method_name.substring(prefix.length);
-        const is_multi_word = remaining_part.length > 0 && 
-                             remaining_part[0].toUpperCase() === remaining_part[0];
-        
-        return is_multi_word;
-      });
-      
-      if (should_be_private && !method_name.startsWith("_")) {
-        context.report({
-          node: node.key || node,
-          message: `方法名"${method_name}"应该是私有方法，但缺少_前缀`,
-        });
-      }
-    }
-    
-    return {
-      // 处理类中的私有方法
-      MethodDefinition(node) {
-        const method_name = node.key.name;
-        if (method_name.startsWith("_")) {
-          checkPrivateMethodName(node, method_name);
-        } else {
-          // 检测应该是私有方法但没有_前缀的情况
-          checkMissingPrivatePrefix(node, method_name);
-        }
+        schema: [],
       },
-      
-      // 处理对象字面量中的私有方法
-      Property(node) {
-        if (node.key.type === "Identifier") {
-          // 检查是否是方法（函数表达式或箭头函数或方法简写）
-          const is_method = node.value && 
-            (node.value.type === "FunctionExpression" || 
-             node.value.type === "ArrowFunctionExpression" ||
-             (node.method === true)); // 方法简写语法
-          
-          if (is_method) {
-            if (node.key.name.startsWith("_")) {
-              checkPrivateMethodName(node, node.key.name);
-            } else {
-              // 检测应该是私有方法但没有_前缀的情况
-              checkMissingPrivatePrefix(node, node.key.name);
+      create: function (context) {
+        return {
+          VariableDeclarator: function (node) {
+            // 排除const声明，只检测let和var声明的变量
+            if (node.parent && node.parent.kind !== 'const') {
+              if (node.id && node.id.name) {
+                var variable_name = node.id.name;
+                var err = detector._checkVariableName(variable_name, node);
+                if (err) {
+                  context.report({
+                    node: err.node,
+                    message: err.message,
+                  });
+                }
+              }
             }
-          }
-        }
+          },
+        };
       },
-    };
-  },
-};
-
-/**
- * 私有变量命名规则
- */
-const private_variable_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "私有变量必须以单下划线开头，后跟小写蛇形命名或小写单词",
-      category: "Stylistic Issues",
-      recommen: true,
     },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
+
+    'param-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测参数名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
         },
-        additionalProperties: false,
+        schema: [],
       },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      Property(node) {
-        if (node.key.type === "Identifier" && node.key.name.startsWith("_")) {
-          // 检查是否是方法（函数表达式或箭头函数）
-          const is_method = node.value && 
-            (node.value.type === "FunctionExpression" || 
-             node.value.type === "ArrowFunctionExpression");
-          
-          // 如果是方法，应该使用私有方法规则检测，而不是私有变量规则
-          if (is_method) {
-            const detector = new Detector({ "private-method-naming": options });
-            const result = detector.checkName(
-              node.key.name,
-              "private-method-naming",
-            );
-
-            if (!result.valid) {
-              result.errors.forEach((error) => {
-                context.report({
-                  node: node.key,
-                  message: `私有方法名"${node.key.name}"不符合规范: ${error}`,
-                });
-              });
+      create: function (context) {
+        return {
+          FunctionDeclaration: function (node) {
+            if (node.params) {
+              for (var i = 0; i < node.params.length; i++) {
+                var param = node.params[i];
+                if (param.name) {
+                  var param_name = param.name;
+                  var err = detector._checkParamName(param_name, param);
+                  if (err) {
+                    context.report({
+                      node: err.node,
+                      message: err.message,
+                    });
+                  }
+                }
+              }
             }
-          } else {
-            // 如果是真正的属性，使用私有变量规则检测
-            const detector = new Detector({ "private-variable-naming": options });
-            const result = detector.checkName(
-              node.key.name,
-              "private-variable-naming",
-            );
-
-            if (!result.valid) {
-              result.errors.forEach((error) => {
-                context.report({
-                  node: node.key,
-                  message: `私有属性名"${node.key.name}"不符合规范: ${error}`,
-                });
-              });
+          },
+          FunctionExpression: function (node) {
+            if (node.params) {
+              for (var i = 0; i < node.params.length; i++) {
+                var param = node.params[i];
+                if (param.name) {
+                  var param_name = param.name;
+                  var err = detector._checkParamName(param_name, param);
+                  if (err) {
+                    context.report({
+                      node: err.node,
+                      message: err.message,
+                    });
+                  }
+                }
+              }
             }
-          }
-        }
+          },
+          ArrowFunctionExpression: function (node) {
+            if (node.params) {
+              for (var i = 0; i < node.params.length; i++) {
+                var param = node.params[i];
+                if (param.name) {
+                  var param_name = param.name;
+                  var err = detector._checkParamName(param_name, param);
+                  if (err) {
+                    context.report({
+                      node: err.node,
+                      message: err.message,
+                    });
+                  }
+                }
+              }
+            }
+          },
+        };
       },
-    };
-  },
-};
-
-/**
- * 实例属性赋值命名规则（检测 this.property = value 模式）
- */
-const instance_property_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "实例属性赋值必须符合命名规范",
-      category: "Stylistic Issues",
-      recommen: true,
     },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      AssignmentExpression(node) {
-        // 检测 this.property = value 模式
-        if (
-          node.left.type === "MemberExpression" &&
-          node.left.object.type === "ThisExpression" &&
-          node.left.property.type === "Identifier" &&
-          !node.left.property.name.startsWith("_")
-        ) {
-          const prop_name = node.left.property.name;
-          // 实例属性应该符合属性命名规范（小写蛇形）
-          const detector = new Detector({ "property-name": options });
-          const result = detector._checkPropName(prop_name, node.right, node);
 
-          if (!result.valid) {
-            result.errors.forEach((error) => {
-              context.report({
-                node: node.left.property,
-                message: `实例属性名"${prop_name}"不符合规范: ${error}`,
-              });
-            });
-          }
-        }
+    'constant-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测常量名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
+        },
+        schema: [],
       },
-      // 检测构造函数内的属性声明
-      PropertyDefinition(node) {
-        if (
-          node.parent && 
-          node.parent.type === "ClassBody" &&
-          node.key.type === "Identifier" &&
-          !node.key.name.startsWith("_")
-        ) {
-          const prop_name = node.key.name;
-          // 实例属性应该符合属性命名规范（小写蛇形）
-          const detector = new Detector({ "property-name": options });
-          const result = detector._checkPropName(prop_name, node.value, node);
-
-          if (!result.valid) {
-            result.errors.forEach((error) => {
-              context.report({
-                node: node.key,
-                message: `实例属性名"${prop_name}"不符合规范: ${error}`,
-              });
-            });
-          }
-        }
+      create: function (context) {
+        return {
+          VariableDeclarator: function (node) {
+            if (node.parent && node.parent.kind === 'const') {
+              if (node.id && node.id.name) {
+                var constant_name = node.id.name;
+                var err = detector._checkConstantName(constant_name, node, node.init);
+                if (err) {
+                  context.report({
+                    node: err.node,
+                    message: err.message,
+                  });
+                }
+              }
+            }
+          },
+        };
       },
-    };
-  },
-};
-
-/**
- * 原型方法命名规则（检测 ClassName.prototype.methodName = function() {} 模式）
- */
-const prototype_method_rule = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "原型方法名必须使用小驼峰命名法（camelCase）且优先使用单个单词",
-      category: "Stylistic Issues",
-      recommen: true,
     },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          regex: { type: "string" },
-          min: { type: "number" },
-          max: { type: "number" },
-          message: { type: "string" },
-          single_word: { type: "boolean" },
-          single_word_len: { type: "number" },
-          styles: { type: "array", items: { type: "string" } },
+
+    'property-name': {
+      meta: {
+        type: 'suggestion',
+        docs: {
+          description: '检测属性名是否符合命名规范',
+          category: 'Stylistic Issues',
+          recommended: true,
         },
-        additionalProperties: false,
+        schema: [],
       },
-    ],
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    return {
-      AssignmentExpression(node) {
-        // 检测 ClassName.prototype.methodName = function() {} 模式
-        if (
-          node.left.type === "MemberExpression" &&
-          node.left.object.type === "MemberExpression" &&
-          node.left.object.property.type === "Identifier" &&
-          node.left.object.property.name === "prototype" &&
-          node.left.property.type === "Identifier" &&
-          (node.right.type === "FunctionExpression" ||
-            node.right.type === "ArrowFunctionExpression")
-        ) {
-          const method_name = node.left.property.name;
-
-          // 跳过JavaScript内置特殊方法名
-          const builtin_methods = [
-            "constructor",
-            "toString",
-            "valueOf",
-            "toJSON",
-          ];
-          if (builtin_methods.includes(method_name)) {
-            return;
-          }
-
-          // 根据方法名是否以下划线开头，选择不同的检测规则
-          const rule_name = method_name.startsWith("_") ? "private-method-naming" : "method-name";
-          const detector = new Detector({ [rule_name]: options });
-          const result = detector.checkName(method_name, rule_name);
-
-          if (!result.valid) {
-            result.errors.forEach((error) => {
+      create: function (context) {
+        return {
+          Property: function (node) {
+          if (node.key && node.key.name) {
+            var prop_name = node.key.name;
+            
+            // 直接跳过null值和未赋值属性的检测
+            // 注意：null值的类型是Literal，但value为null
+            var is_null_value = node.value && node.value.type === 'Literal' && node.value.value === null;
+            var is_undefined_value = !node.value;
+            
+            if (is_null_value || is_undefined_value) {
+              // 对于null值和未赋值属性，直接跳过检测，不报错
+              return;
+            }
+            
+            var err = detector._checkPropertyName(
+              prop_name,
+              node,
+              node.value,
+              node.parent,
+            );
+            
+            if (err) {
               context.report({
-                node: node.left.property,
-                message: `原型方法名"${method_name}"不符合规范: ${error}`,
+                node: err.node,
+                message: err.message,
               });
-            });
+            }
           }
-        }
+        },
+          AssignmentExpression: function (node) {
+            if (
+              node.left &&
+              node.left.type === 'MemberExpression' &&
+              node.left.property &&
+              node.left.property.name
+            ) {
+              var prop_name = node.left.property.name;
+              
+              // 直接跳过null值和未赋值属性的检测
+              // 注意：null值的类型是Literal，但value为null
+              var is_null_value = node.right && node.right.type === 'Literal' && node.right.value === null;
+              var is_undefined_value = !node.right;
+              
+              if (is_null_value || is_undefined_value) {
+                // 对于null值和未赋值属性，直接跳过检测，不报错
+                return;
+              }
+              
+              var err = detector._checkPropertyName(
+                prop_name,
+                node,
+                node.right,
+                node.parent,
+              );
+              
+              if (err) {
+                context.report({
+                  node: err.node,
+                  message: err.message,
+                });
+              }
+            }
+          },
+        };
       },
-    };
-  },
-};
-
-/**
- * 命名规范ESLint插件
- */
-const naming_rules = {
-  "class-name": class_name_rule,
-  "function-name": function_name_rule,
-  "method-name": method_name_rule,
-  "variable-name": variable_name_rule,
-  "constant-name": constant_name_rule,
-  "private-method-naming": private_method_rule,
-  "private-variable-naming": private_variable_rule,
-  "param-name": param_name_rule,
-  "property-name": prop_name_rule,
-  "instance-property": instance_property_rule,
-  "prototype-method": prototype_method_rule,
-};
+    },
+  };
+}
 
 module.exports = {
-  Detector,
-  rules: naming_rules,
+  rules: createNamingRules(),
 };