mm_eslint 1.2.7 → 1.2.9

package/detector.js

@@ -0,0 +1,1214 @@
+/**
+ * 命名规范检测器类
+ */
+class Detector {
+  /**
+   * 构造函数
+   * @param {object} config 配置对象
+   */
+  constructor(config) {
+    // 直接将传入的配置对象赋值，确保原型方法不被丢失
+    this.config = config;
+    
+    // 添加命名类型的中文描述
+    this.config.name_type_map = {
+      'class-name': '类名',
+      'function-name': '函数名',
+      'method-name': '方法名',
+      'variable-name': '变量名',
+      'param-name': '参数名',
+      'constant-name': '常量名',
+      'property-class-name': '属性类名',
+      'property-instance-class-name': '属性实例类名',
+      'property-method-name': '属性方法名',
+      'property-value-name': '属性值名'
+    };
+  }
+}
+
+/**
+ * 检测类名
+ * @param {string} class_name 类名
+ * @param {object} node AST节点
+ * @returns {object|null} 错误信息或null
+ */
+Detector.prototype._checkClassName = function (class_name, node) {
+  try {
+    var rule = this.config.getRule('class-name');
+    if (!rule) {
+      return null;
+    }
+
+    // 检查是否为忽略词
+    if (this._isIgnoredWord(class_name, 'class-name')) {
+      return null;
+    }
+
+    // 检查命名风格
+    var style_err = this._validate_naming_style(class_name, rule.styles, 'class-name');
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
+
+    // 检查并推荐更合适的词汇
+    var rec_err = this._checkAndRecommend(class_name, 'class-name');
+    if (rec_err) {
+      return {
+        node: node,
+        message: rec_err,
+      };
+    }
+
+    // 检查长度
+    var len_err = this._checkNameLength(class_name, rule.min, rule.max, 'class-name');
+    if (len_err) {
+      return {
+        node: node,
+        message: len_err,
+      };
+    }
+
+    // 检查单词长度
+    var word_err = this._checkWordLength(class_name, rule.single_word_len, 'class-name');
+    if (word_err) {
+      return {
+        node: node,
+        message: word_err,
+      };
+    }
+
+    // 检查禁止词汇
+    var forbid_err = this._checkForbiddenWords(class_name, 'class-name');
+    if (forbid_err) {
+      return {
+        node: node,
+        message: forbid_err,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检测类名时出错:', error);
+    return null;
+  }
+};
+
+/**
+ * 检测方法名
+ * @param {string} method_name 方法名
+ * @param {object} node AST节点
+ * @returns {object|null} 错误信息或null
+ */
+Detector.prototype._checkMethodName = function (method_name, node) {
+  try {
+    var rule = this.config.getRule('method-name');
+    if (!rule) {
+      return null;
+    }
+
+    // 检查是否为忽略词（在所有检测之前）
+    if (this._isIgnoredWord(method_name, 'method-name')) {
+      return null;
+    }
+
+    // 检查命名风格（支持公开方法和私有方法）
+    var style_err = null;
+    if (method_name.startsWith('_')) {
+      // 私有方法：检查是否符合私有方法命名规范
+      style_err = this._validate_naming_style(method_name, ['_camelCase'], 'method-name');
+    } else {
+      // 公开方法：检查是否符合公开方法命名规范
+      style_err = this._validate_naming_style(method_name, rule.styles, 'method-name');
+    }
+
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
+
+    // 检查长度
+    var len_err = this._checkNameLength(method_name, rule.min, rule.max, 'method-name');
+    if (len_err) {
+      return {
+        node: node,
+        message: len_err,
+      };
+    }
+
+    // 检查单词长度
+    var word_err = this._checkWordLength(method_name, rule.single_word_len, 'method-name');
+    if (word_err) {
+      return {
+        node: node,
+        message: word_err,
+      };
+    }
+
+    // 检查禁止词汇
+    var forbid_err = this._checkForbiddenWords(method_name, 'method-name');
+    if (forbid_err) {
+      return {
+        node: node,
+        message: forbid_err,
+      };
+    }
+
+    // 检查并推荐更合适的词汇
+    var recommend_err = this._checkAndRecommend(method_name, 'method-name');
+    if (recommend_err) {
+      return {
+        node: node,
+        message: recommend_err,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检测方法名时出错:', error);
+    return null;
+  }
+};
+
+/**
+ * 检测函数名
+ * @param {string} function_name 函数名
+ * @param {object} node AST节点
+ * @returns {object|null} 错误信息或null
+ */
+Detector.prototype._checkFunctionName = function (function_name, node) {
+  try {
+    var rule = this.config.getRule('function-name');
+    if (!rule) {
+      return null;
+    }
+
+    // 检查是否为忽略词
+    if (this._isIgnoredWord(function_name, 'function-name')) {
+      return null;
+    }
+
+    // 检查命名风格
+    var style_err = this._validate_naming_style(function_name, rule.styles, 'function-name');
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
+
+    // 检查长度
+    var len_err = this._checkNameLength(function_name, rule.min, rule.max, 'function-name');
+    if (len_err) {
+      return {
+        node: node,
+        message: len_err,
+      };
+    }
+
+    // 检查单词长度
+    var word_err = this._checkWordLength(function_name, rule.single_word_len, 'function-name');
+    if (word_err) {
+      return {
+        node: node,
+        message: word_err,
+      };
+    }
+
+    // 检查禁止词汇
+    var forbid_err = this._checkForbiddenWords(
+      function_name,
+      'function-name',
+    );
+    if (forbid_err) {
+      return {
+        node: node,
+        message: forbid_err,
+      };
+    }
+
+    // 检查并推荐更合适的词汇
+    var recommend_err = this._checkAndRecommend(function_name, 'function-name');
+    if (recommend_err) {
+      return {
+        node: node,
+        message: recommend_err,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检测函数名时出错:', error);
+    return null;
+  }
+};
+
+/**
+ * 检测变量名
+ * @param {string} variable_name 变量名
+ * @param {object} node AST节点
+ * @returns {object|null} 错误信息或null
+ */
+Detector.prototype._checkVariableName = function (variable_name, node) {
+  try {
+    var rule = this.config.getRule('variable-name');
+    if (!rule) {
+      return null;
+    }
+
+    // 检查是否为忽略词
+    if (this._isIgnoredWord(variable_name, 'variable-name')) {
+      return null;
+    }
+
+    // 检查命名风格
+    var style_err = this._validate_naming_style(variable_name, rule.styles, 'variable-name');
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
+
+    // 检查长度
+    var len_err = this._checkNameLength(variable_name, rule.min, rule.max, 'variable-name');
+    if (len_err) {
+      return {
+        node: node,
+        message: len_err,
+      };
+    }
+
+    // 检查单词长度
+    var word_err = this._checkWordLength(variable_name, rule.single_word_len, 'variable-name');
+    if (word_err) {
+      return {
+        node: node,
+        message: word_err,
+      };
+    }
+
+    // 检查禁止词汇
+    var forbid_err = this._checkForbiddenWords(
+      variable_name,
+      'variable-name',
+    );
+    if (forbid_err) {
+      return {
+        node: node,
+        message: forbid_err,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检测变量名时出错:', error);
+    return null;
+  }
+};
+
+/**
+ * 检测参数名
+ * @param {string} param_name 参数名
+ * @param {object} node AST节点
+ * @returns {object|null} 错误信息或null
+ */
+Detector.prototype._checkParamName = function (param_name, node) {
+  try {
+    var rule = this.config.getRule('param-name');
+    if (!rule) {
+      return null;
+    }
+
+    // 检查是否为忽略词
+    if (this._isIgnoredWord(param_name, 'param-name')) {
+      return null;
+    }
+
+    // 检查命名风格
+    var style_err = this._validate_naming_style(param_name, rule.styles, 'param-name');
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
+
+    // 检查长度
+    var len_err = this._checkNameLength(param_name, rule.min, rule.max, 'param-name');
+    if (len_err) {
+      return {
+        node: node,
+        message: len_err,
+      };
+    }
+
+    // 检查单词长度
+    var word_err = this._checkWordLength(param_name, rule.single_word_len, 'param-name');
+    if (word_err) {
+      return {
+        node: node,
+        message: word_err,
+      };
+    }
+
+    // 检查禁止词汇
+    var forbid_err = this._checkForbiddenWords(param_name, 'param-name');
+    if (forbid_err) {
+      return {
+        node: node,
+        message: forbid_err,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检测参数名时出错:', error);
+    return null;
+  }
+};
+
+/**
+ * 检测常量名
+ * @param {string} constant_name 常量名
+ * @param {object} node AST节点
+ * @param {object} val_node 值节点（用于识别基础值）
+ * @returns {object|null} 错误信息或null
+ */
+Detector.prototype._checkConstantName = function (constant_name, node, val_node) {
+  try {
+    var rule = this.config.getRule('constant-name');
+    if (!rule) {
+      return null;
+    }
+
+    // 检查是否为忽略词
+    if (this._isIgnoredWord(constant_name, 'constant-name')) {
+      return null;
+    }
+
+    // 检查是否为解构导入（从模块导入的变量）
+    var is_destructured_import = this._isDestructuredImport(node);
+    
+    // 如果是解构导入，则不进行常量检测
+    if (is_destructured_import) {
+      return null;
+    }
+
+    // 检查是否为复杂类型（方法、函数、实例等）
+    var is_complex_type = this._isComplexType(val_node);
+
+    // 如果是复杂类型，则不进行常量检测
+    if (is_complex_type) {
+      return null;
+    }
+
+    // 检查是否为基础值类型
+    var is_base_value = this._isBaseValue(val_node);
+
+    // 如果不是基础值也不是复杂类型（可能是其他类型），则不进行常量检测
+    if (!is_base_value) {
+      return null;
+    }
+
+    // 检查命名风格
+    var style_err = this._validate_naming_style(constant_name, rule.styles, 'constant-name');
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
+
+    // 检查长度
+    var len_err = this._checkNameLength(constant_name, rule.min, rule.max, 'constant-name');
+    if (len_err) {
+      return {
+        node: node,
+        message: len_err,
+      };
+    }
+
+    // 检查单词长度
+    var word_err = this._checkWordLength(constant_name, rule.single_word_len, 'constant-name');
+    if (word_err) {
+      return {
+        node: node,
+        message: word_err,
+      };
+    }
+
+    // 检查禁止词汇
+    var forbid_err = this._checkForbiddenWords(constant_name, 'constant-name');
+    if (forbid_err) {
+      return {
+        node: node,
+        message: forbid_err,
+      };
+    }
+
+    // 检查并推荐更合适的词汇
+    var rec_err = this._checkAndRecommend(constant_name, 'constant-name');
+    if (rec_err) {
+      return {
+        node: node,
+        message: rec_err,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检测常量名时出错:', error);
+    return null;
+  }
+};
+
+/**
+ * 验证命名风格
+ * @param {string} name 名称
+ * @param {Array} styles 允许的风格列表
+ * @param {string} name_type 名称类型
+ * @returns {string|null} 错误信息或null
+ */
+Detector.prototype._validate_naming_style = function (name, styles, name_type) {
+  if (!name || !styles || !Array.isArray(styles)) {
+    return null;
+  }
+
+  for (var i = 0; i < styles.length; i++) {
+    var style = styles[i];
+    var regex = this.config.getRegex(style);
+    if (regex && regex.test(name)) {
+      return null;
+    }
+  }
+
+  var style_names = styles.join('或');
+
+  var name_type_desc = this.config.name_type_map[name_type] || '名称';
+
+  return name_type_desc + '\'' + name + '\'不符合' + style_names + '命名风格';
+};
+
+/**
+ * 检查名称长度
+ * @param {string} name 名称
+ * @param {number} min 最小长度
+ * @param {number} max 最大长度
+ * @returns {string|null} 错误信息或null
+ */
+Detector.prototype._checkNameLength = function (name, min, max, name_type) {
+  if (!name) {
+    return '名称不能为空';
+  }
+
+  var name_type_desc = this.config.name_type_map[name_type] || '名称';
+  var len = name.length;
+  if (len < min) {
+    return name_type_desc + '\'' + name + '\'长度过短，最小长度为' + min + '字符';
+  }
+
+  if (len > max) {
+    return name_type_desc + '\'' + name + '\'长度过长，最大长度为' + max + '字符';
+  }
+
+  return null;
+};
+
+/**
+ * 检查单词长度
+ * @param {string} name 名称
+ * @param {number} max_word_len 最大单词长度
+ * @returns {string|null} 错误信息或null
+ */
+Detector.prototype._checkWordLength = function (name, max_word_len, name_type) {
+  if (!name || !max_word_len) {
+    return null;
+  }
+
+  var name_type_desc = this.config.name_type_map[name_type] || '名称';
+  // 分割单词（根据命名风格）
+  var words = [];
+
+  // 处理私有标识符（开头的下划线）
+  var processed_name = name;
+  var has_private_prefix = false;
+
+  if (name.startsWith('_')) {
+    has_private_prefix = true;
+    processed_name = name.substring(1); // 去掉开头的下划线
+  }
+
+  if (processed_name.includes('_')) {
+    words = processed_name.split('_');
+  } else if (processed_name.includes('-')) {
+    words = processed_name.split('-');
+  } else {
+    // 驼峰命名法分割（保持原词大小写）
+    words = processed_name.split(/(?=[A-Z])/);
+  }
+
+  // 如果存在私有标识符，添加空字符串表示私有标识符（不检查长度）
+  if (has_private_prefix) {
+    words.unshift('_');
+  }
+
+  for (var i = 0; i < words.length; i++) {
+    var word = words[i];
+    // 跳过空字符串和私有标识符（单个下划线）
+    if (!word || word === '_') {
+      continue;
+    }
+
+    if (word.length > max_word_len) {
+      // 生成推荐命名
+      var recommended_name = this._generateRecommendedName(name, word, name_type);
+      var recommendation_text = '';
+      if (recommended_name) {
+        recommendation_text = '，推荐名为\'' + recommended_name + '\'';
+      }
+      
+      return (
+        name_type_desc +
+        '\'' +
+        name +
+        '\'中的单词\'' +
+        word +
+        '\'过长，最大长度为' +
+        max_word_len +
+        '字符' +
+        recommendation_text
+      );
+    }
+  }
+
+  return null;
+};
+
+/**
+ * 检查禁止词汇
+ * @param {string} name 名称
+ * @param {string} name_type 名称类型
+ * @returns {string|null} 错误信息或null
+ */
+Detector.prototype._checkForbiddenWords = function (name, name_type) {
+  if (!name || !name_type) {
+    return null;
+  }
+
+  var forbidden_words = this.config.getForbiddenWords(name_type);
+  if (!forbidden_words || !Array.isArray(forbidden_words)) {
+    return null;
+  }
+
+  var name_type_desc = this.config.name_type_map[name_type] || '名称';
+  var name_lower = name.toLowerCase();
+
+  // 如果名称本身就是禁止词汇（即单个单词），则允许使用
+  for (var i = 0; i < forbidden_words.length; i++) {
+    var forbidden_word = forbidden_words[i].toLowerCase();
+    if (name_lower === forbidden_word) {
+      return null; // 单个单词允许使用
+    }
+  }
+
+  // 检查名称是否包含禁止词汇作为拼接词（即名称由多个单词组成）
+  for (var i = 0; i < forbidden_words.length; i++) {
+    var forbidden_word = forbidden_words[i].toLowerCase();
+    if (name_lower.includes(forbidden_word) && name_lower !== forbidden_word) {
+      return name_type_desc + '\'' + name + '\'包含禁止拼接词\'' + forbidden_word + '\'';
+    }
+  }
+
+  return null;
+};
+
+/**
+ * 获取属性类型
+ * @param {object} val_node 属性值节点
+ * @param {string} prop_name 属性名
+ * @param {object} parent_node 父节点
+ * @returns {string} 属性类型
+ */
+Detector.prototype._getPropType = function (val_node, prop_name, parent_node) {
+  if (!val_node) {
+    return 'undefined_value'; // 未赋值类型
+  }
+
+  // 检查是否为null值
+  if (val_node.type === 'NullLiteral') {
+    return 'null_value'; // null值类型
+  }
+
+  // 检查是否为对象方法（在对象字面量中的函数）
+  if (
+    val_node &&
+    (val_node.type === 'FunctionExpression' ||
+      val_node.type === 'ArrowFunctionExpression')
+  ) {
+    return 'method'; // 对象方法类型
+  }
+
+  // 检查是否为类引用（属性类）
+  if (
+    val_node.type === 'Identifier' &&
+    val_node.name &&
+    val_node.name[0] === val_node.name[0].toUpperCase()
+  ) {
+    // 检查是否是类名引用（通常类名使用PascalCase）
+    return 'class'; // 属性类类型
+  }
+
+  // 检查是否为类实例（new表达式）
+  if (val_node.type === 'NewExpression') {
+    return 'instance_class'; // 属性实例类类型
+  }
+
+  // 检查是否为函数调用（可能返回实例）
+  if (val_node.type === 'CallExpression') {
+    // 检查是否调用的是构造函数
+    if (
+      val_node.callee &&
+      val_node.callee.type === 'Identifier' &&
+      val_node.callee.name &&
+      val_node.callee.name[0] === val_node.callee.name[0].toUpperCase()
+    ) {
+      return 'instance_class'; // 属性实例类类型
+    }
+    return 'value'; // 默认值类型
+  }
+
+  return 'value';
+};
+
+/**
+ * 检测属性名
+ * @param {string} prop_name 属性名
+ * @param {object} node AST节点
+ * @param {object} val_node 属性值节点
+ * @param {object} parent_node 父节点
+ * @returns {object|null} 错误信息或null
+ */
+Detector.prototype._checkPropertyName = function (
+  prop_name,
+  node,
+  val_node,
+  parent_node,
+) {
+  try {
+    // 检查是否为解构导入中的属性
+    var is_destructured_import = this._isDestructuredImportProperty(node, parent_node);
+    
+    // 如果是解构导入中的属性，则不进行属性名检测
+    if (is_destructured_import) {
+      return null;
+    }
+
+    // 获取属性类型
+    var prop_type = this._getPropType(val_node, prop_name, parent_node);
+    var rule_type = '';
+
+    // 根据属性类型选择对应的规则
+    // 对于null值和未赋值属性，直接跳过命名规范检测
+    if (prop_type === 'null_value' || prop_type === 'undefined_value') {
+      return null; // 不进行命名规范检测
+    }
+
+    switch (prop_type) {
+      case 'class':
+        rule_type = 'property-class-name';
+        break;
+      case 'instance_class':
+        rule_type = 'property-instance-class-name';
+        break;
+      case 'method':
+        rule_type = 'property-method-name';
+        break;
+      case 'value':
+      default:
+        rule_type = 'property-value-name';
+        break;
+    }
+
+    var rule = this.config.getRule(rule_type);
+    if (!rule) {
+      return null;
+    }
+
+    // 检查命名风格
+    var style_err = null;
+    
+    if (rule_type === 'property-value-name') {
+      // 对于属性值名，支持私有变量命名规范（_snake_case）、变量命名规范（snake_case）或常量命名规范（UPPER_SNAKE_CASE）
+      var private_style_err = this._validate_naming_style(prop_name, ['_snake_case'], rule_type);
+      var variable_style_err = this._validate_naming_style(prop_name, ['snake_case'], rule_type);
+      var constant_style_err = this._validate_naming_style(prop_name, ['UPPER_SNAKE_CASE'], rule_type);
+      
+      // 只有当所有风格检查都失败时才报错
+      if (private_style_err && variable_style_err && constant_style_err) {
+        style_err = '属性值名\'' + prop_name + '\'不符合_snake_case、snake_case或UPPER_SNAKE_CASE命名风格';
+      }
+    } else if (rule_type === 'property-method-name') {
+      // 属性方法：支持公开方法（camelCase）和私有方法（_camelCase）
+      if (prop_name.startsWith('_')) {
+        // 私有方法：检查是否符合私有方法命名规范
+        style_err = this._validate_naming_style(prop_name, ['_camelCase'], rule_type);
+      } else {
+        // 公开方法：检查是否符合公开方法命名规范
+        style_err = this._validate_naming_style(prop_name, rule.styles, rule_type);
+      }
+    } else {
+      // 其他属性类型：使用原有逻辑
+      style_err = this._validate_naming_style(prop_name, rule.styles, rule_type);
+    }
+
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
+
+    // 检查长度
+    var len_err = this._checkNameLength(prop_name, rule.min, rule.max, rule_type);
+    if (len_err) {
+      return {
+        node: node,
+        message: len_err,
+      };
+    }
+
+    // 检查单词长度
+    var word_err = this._checkWordLength(prop_name, rule.single_word_len, rule_type);
+    if (word_err) {
+      return {
+        node: node,
+        message: word_err,
+      };
+    }
+
+    // 检查禁止词汇
+    var forbid_err = this._checkForbiddenWords(prop_name, rule_type);
+    if (forbid_err) {
+      return {
+        node: node,
+        message: forbid_err,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检测属性名时出错:', error);
+    return null;
+  }
+};
+
+/**
+ * 检查并推荐更合适的词汇
+ * @param {string} name 名称
+ * @param {string} name_type 名称类型
+ * @returns {string|null} 推荐信息或null
+ */
+Detector.prototype._checkAndRecommend = function (name, name_type) {
+  try {
+    var rec_words = this.config.getRecommendedWords(name_type);
+    if (!rec_words || Object.keys(rec_words).length === 0) {
+      return null;
+    }
+
+    var name_lower = name.toLowerCase();
+
+    var name_type_desc = this.config.name_type_map[name_type] || '名称';
+    // 检查每个推荐词映射
+    for (var rec_word in rec_words) {
+      if (rec_words.hasOwnProperty(rec_word)) {
+        var original_words = rec_words[rec_word];
+
+        // 检查名称是否包含任何一个原词
+        for (var i = 0; i < original_words.length; i++) {
+          var original_word = original_words[i].toLowerCase();
+          if (name_lower.includes(original_word)) {
+            return name_type_desc + '建议使用\'' + rec_word + '\'替代\'' + original_words[i] + '\'以获得更短的命名';
+          }
+        }
+      }
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检查并推荐更合适的词汇时出错:', error);
+    return null;
+  }
+};
+
+/**
+ * 检查值是否为基础值类型
+ * @param {object} val_node 值节点
+ * @returns {boolean} 是否为基础值
+ */
+Detector.prototype._isBaseValue = function (val_node) {
+  try {
+    if (!val_node) {
+      return false;
+    }
+
+    // 检查是否为基础值类型
+    var is_base_value = false;
+
+    switch (val_node.type) {
+      case 'Literal': // 字面量：数字、字符串、布尔值
+        is_base_value = true;
+        break;
+      case 'ArrayExpression': // 数组字面量
+        is_base_value = true;
+        break;
+      case 'ObjectExpression': // 对象字面量
+        is_base_value = true;
+        break;
+      case 'UnaryExpression': // 一元表达式（如 -1, +100）
+        if (val_node.operator === '-' || val_node.operator === '+') {
+          is_base_value = true;
+        }
+        break;
+      default:
+        is_base_value = false;
+    }
+
+    return is_base_value;
+  } catch (error) {
+    console.error('检查值是否为基础值类型时出错:', error);
+    return false;
+  }
+};
+
+/**
+ * 检查值是否为复杂类型（方法、函数、实例等）
+ * @param {object} val_node 值节点
+ * @returns {boolean} 是否为复杂类型
+ */
+Detector.prototype._isComplexType = function (val_node) {
+  try {
+    if (!val_node) {
+      return false;
+    }
+
+    // 检查是否为复杂类型
+    var is_complex_type = false;
+
+    switch (val_node.type) {
+      case 'FunctionExpression': // 函数表达式
+      case 'ArrowFunctionExpression': // 箭头函数
+      case 'NewExpression': // new 实例化
+      case 'CallExpression': // 函数调用
+      case 'MemberExpression': // 成员表达式
+      case 'Identifier': // 标识符（可能是变量或函数）
+      case 'ClassExpression': // 类表达式
+      case 'ThisExpression': // this表达式
+      case 'TemplateLiteral': // 模板字符串
+        is_complex_type = true;
+        break;
+      default:
+        is_complex_type = false;
+    }
+
+    return is_complex_type;
+  } catch (error) {
+    console.error('检查值是否为复杂类型时出错:', error);
+    return false;
+  }
+};
+
+/**
+ * 检查是否为解构导入
+ * @param {object} node AST节点
+ * @returns {boolean} 是否为解构导入
+ */
+Detector.prototype._isDestructuredImport = function (node) {
+  try {
+    if (!node || !node.parent) {
+      return false;
+    }
+
+    // 检查是否为解构导入模式
+    var is_destructured = false;
+
+    // 情况1：节点是Property.key（解构赋值中的属性键）
+    if (node.parent.type === 'Property' && node.parent.key === node) {
+      var property = node.parent;
+      
+      // 检查Property的父节点是否为ObjectPattern
+      if (property.parent && property.parent.type === 'ObjectPattern') {
+        var object_pattern = property.parent;
+        
+        // 检查ObjectPattern的父节点是否为VariableDeclarator
+        if (object_pattern.parent && object_pattern.parent.type === 'VariableDeclarator') {
+          var declarator = object_pattern.parent;
+          
+          // 检查右侧是否为require调用或其他模块导入
+          if (declarator.init) {
+            var init_type = declarator.init.type;
+            
+            // 常见的模块导入方式
+            if (init_type === 'CallExpression' && 
+                declarator.init.callee && 
+                declarator.init.callee.name === 'require') {
+              is_destructured = true;
+            }
+            
+            // 如果是ImportDeclaration（ES6导入）
+            if (init_type === 'ImportExpression') {
+              is_destructured = true;
+            }
+          }
+        }
+      }
+    }
+    
+    // 情况2：节点是VariableDeclarator（简单变量声明）
+    else if (node.parent.type === 'VariableDeclarator') {
+      var declarator = node.parent;
+      
+      // 检查是否为解构模式（ObjectPattern或ArrayPattern）
+      if (declarator.id && declarator.id.type === 'ObjectPattern') {
+        // 检查右侧是否为require调用或其他模块导入
+        if (declarator.init) {
+          var init_type = declarator.init.type;
+          
+          // 常见的模块导入方式
+          if (init_type === 'CallExpression' && 
+              declarator.init.callee && 
+              declarator.init.callee.name === 'require') {
+            is_destructured = true;
+          }
+          
+          // 如果是ImportDeclaration（ES6导入）
+          if (init_type === 'ImportExpression') {
+            is_destructured = true;
+          }
+        }
+      }
+    }
+
+    return is_destructured;
+  } catch (error) {
+    console.error('检查是否为解构导入时出错:', error);
+    return false;
+  }
+};
+
+/**
+ * 检查是否为解构导入中的属性
+ * @param {object} node 属性节点
+ * @param {object} parent_node 父节点
+ * @returns {boolean} 是否为解构导入中的属性
+ */
+Detector.prototype._isDestructuredImportProperty = function (node, parent_node) {
+  try {
+    if (!node || !parent_node) {
+      return false;
+    }
+
+    // 检查父节点是否为ObjectPattern（解构模式）
+    if (parent_node.type === 'ObjectPattern') {
+      // 检查父节点的父节点是否为VariableDeclarator
+      if (parent_node.parent && parent_node.parent.type === 'VariableDeclarator') {
+        var declarator = parent_node.parent;
+        
+        // 检查右侧是否为require调用或其他模块导入
+        if (declarator.init) {
+          var init_type = declarator.init.type;
+          
+          // 常见的模块导入方式
+          if (init_type === 'CallExpression' && 
+              declarator.init.callee && 
+              declarator.init.callee.name === 'require') {
+            return true;
+          }
+          
+          // 如果是ImportDeclaration（ES6导入）
+          if (init_type === 'ImportExpression') {
+            return true;
+          }
+        }
+      }
+    }
+
+    return false;
+  } catch (error) {
+    console.error('检查是否为解构导入中的属性时出错:', error);
+    return false;
+  }
+};
+
+/**
+ * 检查常量名是否符合规范
+ * @param {string} constant_name 常量名
+ * @returns {boolean} 是否符合规范
+ */
+Detector.prototype._isConstantNameValid = function (constant_name) {
+  try {
+    var rule = this.config.getRule('constant-name');
+    if (!rule) {
+      return false;
+    }
+
+    // 检查命名风格
+    var style_err = this._validate_naming_style(constant_name, rule.styles, 'constant-name');
+    return !style_err;
+  } catch (error) {
+    console.error('检查常量名是否符合规范时出错:', error);
+    return false;
+  }
+};
+
+/**
+ * 检查是否为忽略词
+ * @param {string} name 名称
+ * @param {string} name_type 名称类型
+ * @returns {boolean} 是否为忽略词
+ */
+Detector.prototype._isIgnoredWord = function (name, name_type) {
+  try {
+    var ignored_words = this.config.getIgnoredWords(name_type);
+    if (!ignored_words || !Array.isArray(ignored_words)) {
+      return false;
+    }
+
+    var name_lower = name.toLowerCase();
+    for (var i = 0; i < ignored_words.length; i++) {
+      if (ignored_words[i].toLowerCase() === name_lower) {
+        return true;
+      }
+    }
+
+    return false;
+  } catch (error) { 
+    console.error('检查是否为忽略词时出错:', error);
+    return false;
+  }
+};
+
+/**
+ * 生成推荐命名
+ * @param {string} original_name 原始名称
+ * @param {string} long_word 过长的单词
+ * @param {string} name_type 名称类型
+ * @returns {string|null} 推荐命名或null
+ */
+Detector.prototype._generateRecommendedName = function (original_name, long_word, name_type) {
+  try {
+    // 获取推荐词映射
+    var recommended_words = this.config.getRecommendedWords(name_type);
+    if (!recommended_words || Object.keys(recommended_words).length === 0) {
+      return null;
+    }
+
+    var long_word_lower = long_word.toLowerCase();
+    
+    // 检查推荐词映射中是否有对应的缩写
+    for (var short_word in recommended_words) {
+      if (recommended_words.hasOwnProperty(short_word)) {
+        var original_words = recommended_words[short_word];
+        
+        // 检查过长的单词是否在推荐词的原词列表中
+        for (var i = 0; i < original_words.length; i++) {
+          var original_word = original_words[i].toLowerCase();
+          if (long_word_lower === original_word) {
+            // 生成推荐命名：将原始名称中的长单词替换为推荐的缩写
+            var recommended_name = original_name.replace(long_word, short_word);
+            return recommended_name;
+          }
+        }
+      }
+    }
+
+    return null;
+  } catch (error) {
+    console.error('生成推荐命名时出错:', error);
+    return null;
+  }
+};
+
+/**
+ * 检测解构赋值中的常量名
+ * @param {string} constant_name 常量名
+ * @param {object} node AST节点
+ * @returns {object|null} 错误信息或null
+ */
+Detector.prototype._checkConstantNameForDestructuring = function (constant_name, node) {
+  try {
+    var rule = this.config.getRule('constant-name');
+    if (!rule) {
+      return null;
+    }
+
+    // 检查是否为忽略词
+    if (this._isIgnoredWord(constant_name, 'constant-name')) {
+      return null;
+    }
+
+    // 检查是否为解构导入（从模块导入的变量）
+    var is_destructured_import = this._isDestructuredImport(node);
+    
+    // 如果是解构导入，则不进行常量检测
+    if (is_destructured_import) {
+      return null;
+    }
+
+    // 检查命名风格
+    var style_err = this._validate_naming_style(constant_name, rule.styles, 'constant-name');
+    if (style_err) {
+      return {
+        node: node,
+        message: style_err,
+      };
+    }
+
+    // 检查并推荐更合适的词汇
+    var rec_err = this._checkAndRecommend(constant_name, 'constant-name');
+    if (rec_err) {
+      return {
+        node: node,
+        message: rec_err,
+      };
+    }
+
+    // 检查长度
+    var len_err = this._checkNameLength(constant_name, rule.min, rule.max, 'constant-name');
+    if (len_err) {
+      return {
+        node: node,
+        message: len_err,
+      };
+    }
+
+    // 检查单词长度
+    var word_err = this._checkWordLength(constant_name, rule.single_word_len, 'constant-name');
+    if (word_err) {
+      return {
+        node: node,
+        message: word_err,
+      };
+    }
+
+    // 检查禁止词汇
+    var forbid_err = this._checkForbiddenWords(constant_name, 'constant-name');
+    if (forbid_err) {
+      return {
+        node: node,
+        message: forbid_err,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.error('检测解构赋值常量名时出错:', error);
+    return null;
+  }
+};
+
+module.exports = { Detector };