data-utils-grok/src/formUtils.js

A comprehensive JavaScript utility library for data processing, organized by data types (arrays, objects, strings, forms, tables)

// src/formUtils.js
/**
 * 表单类型处理工具函数
 */

/**
 * 验证邮箱格式
 * @param {string} email - 邮箱地址
 * @returns {boolean} 是否有效
 */
function validateEmail(email) {
  if (typeof email !== 'string') {
    return false;
  }
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

/**
 * 验证手机号格式（中国大陆）
 * @param {string} phone - 手机号
 * @returns {boolean} 是否有效
 */
function validatePhone(phone) {
  if (typeof phone !== 'string') {
    return false;
  }
  const phoneRegex = /^1[3-9]\d{9}$/;
  return phoneRegex.test(phone);
}

/**
 * 验证身份证号格式（中国大陆）
 * @param {string} idCard - 身份证号
 * @returns {boolean} 是否有效
 */
function validateIdCard(idCard) {
  if (typeof idCard !== 'string') {
    return false;
  }
  const idCardRegex = /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/;
  return idCardRegex.test(idCard);
}

/**
 * 验证URL格式
 * @param {string} url - URL地址
 * @returns {boolean} 是否有效
 */
function validateUrl(url) {
  if (typeof url !== 'string') {
    return false;
  }
  try {
    new URL(url);
    return true;
  } catch {
    return false;
  }
}

/**
 * 验证密码强度
 * @param {string} password - 密码
 * @param {Object} options - 验证选项
 * @returns {Object} 验证结果 { isValid, score, suggestions }
 */
function validatePassword(password, options = {}) {
  if (typeof password !== 'string') {
    return { isValid: false, score: 0, suggestions: ['密码必须是字符串'] };
  }

  const {
    minLength = 8,
    requireUppercase = true,
    requireLowercase = true,
    requireNumbers = true,
    requireSpecialChars = true
  } = options;

  const suggestions = [];
  let score = 0;

  // 长度检查
  if (password.length < minLength) {
    suggestions.push(`密码长度至少需要${minLength}个字符`);
  } else {
    score += 1;
  }

  // 大写字母检查
  if (requireUppercase && !/[A-Z]/.test(password)) {
    suggestions.push('密码需要包含大写字母');
  } else if (/[A-Z]/.test(password)) {
    score += 1;
  }

  // 小写字母检查
  if (requireLowercase && !/[a-z]/.test(password)) {
    suggestions.push('密码需要包含小写字母');
  } else if (/[a-z]/.test(password)) {
    score += 1;
  }

  // 数字检查
  if (requireNumbers && !/\d/.test(password)) {
    suggestions.push('密码需要包含数字');
  } else if (/\d/.test(password)) {
    score += 1;
  }

  // 特殊字符检查
  if (requireSpecialChars && !/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
    suggestions.push('密码需要包含特殊字符');
  } else if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
    score += 1;
  }

  const isValid = suggestions.length === 0;

  return {
    isValid,
    score,
    suggestions: isValid ? [] : suggestions
  };
}

/**
 * 序列化表单数据
 * @param {Object} formData - 表单数据对象
 * @returns {string} 序列化后的字符串
 */
function serializeForm(formData) {
  if (!formData || typeof formData !== 'object') {
    throw new TypeError('Form data must be an object');
  }

  const params = new URLSearchParams();
  
  for (const [key, value] of Object.entries(formData)) {
    if (value !== null && value !== undefined) {
      if (Array.isArray(value)) {
        value.forEach(item => params.append(key, item));
      } else {
        params.append(key, value);
      }
    }
  }

  return params.toString();
}

/**
 * 反序列化表单数据
 * @param {string} queryString - 查询字符串
 * @returns {Object} 反序列化后的对象
 */
function deserializeForm(queryString) {
  if (typeof queryString !== 'string') {
    throw new TypeError('Query string must be a string');
  }

  const params = new URLSearchParams(queryString);
  const result = {};

  for (const [key, value] of params.entries()) {
    // 尝试转换为数字
    let parsedValue = value;
    if (!isNaN(value) && value !== '') {
      parsedValue = Number(value);
    }
    
    if (key in result) {
      if (Array.isArray(result[key])) {
        result[key].push(parsedValue);
      } else {
        result[key] = [result[key], parsedValue];
      }
    } else {
      result[key] = parsedValue;
    }
  }

  return result;
}

/**
 * 获取表单字段值
 * @param {HTMLFormElement} form - 表单元素
 * @returns {Object} 表单数据对象
 */
function getFormData(form) {
  if (!form || form.tagName !== 'FORM') {
    throw new TypeError('Input must be a form element');
  }

  const formData = new FormData(form);
  const result = {};

  for (const [key, value] of formData.entries()) {
    if (key in result) {
      if (Array.isArray(result[key])) {
        result[key].push(value);
      } else {
        result[key] = [result[key], value];
      }
    } else {
      result[key] = value;
    }
  }

  return result;
}

/**
 * 设置表单字段值
 * @param {HTMLFormElement} form - 表单元素
 * @param {Object} data - 要设置的数据
 */
function setFormData(form, data) {
  if (!form || form.tagName !== 'FORM') {
    throw new TypeError('Form must be a form element');
  }
  if (!data || typeof data !== 'object') {
    throw new TypeError('Data must be an object');
  }

  for (const [key, value] of Object.entries(data)) {
    const field = form.elements[key];
    if (field) {
      if (field.type === 'checkbox') {
        field.checked = Boolean(value);
      } else if (field.type === 'radio') {
        field.checked = field.value === value;
      } else if (field.tagName === 'SELECT' && field.multiple) {
        Array.from(field.options).forEach(option => {
          option.selected = Array.isArray(value) ? value.includes(option.value) : option.value === value;
        });
      } else {
        field.value = value;
      }
    }
  }
}

/**
 * 重置表单
 * @param {HTMLFormElement} form - 表单元素
 */
function resetForm(form) {
  if (!form || form.tagName !== 'FORM') {
    throw new TypeError('Input must be a form element');
  }
  form.reset();
}

/**
 * 验证表单数据
 * @param {Object} formData - 表单数据
 * @param {Object} rules - 验证规则
 * @returns {Object} 验证结果 { isValid, errors }
 */
function validateForm(formData, rules) {
  if (!formData || typeof formData !== 'object') {
    throw new TypeError('Form data must be an object');
  }
  if (!rules || typeof rules !== 'object') {
    throw new TypeError('Rules must be an object');
  }

  const errors = {};
  let isValid = true;

  for (const [field, fieldRules] of Object.entries(rules)) {
    const value = formData[field];
    const fieldErrors = [];

    for (const rule of fieldRules) {
      const { type, message, required, min, max, pattern } = rule;

      // 必填检查
      if (required && (value === undefined || value === null || value === '')) {
        fieldErrors.push(message || `${field} 是必填项`);
        continue;
      }

      // 如果值为空且不是必填，跳过其他验证
      if (!required && (value === undefined || value === null || value === '')) {
        continue;
      }

      // 类型检查
      switch (type) {
        case 'email':
          if (!validateEmail(value)) {
            fieldErrors.push(message || `${field} 格式不正确`);
          }
          break;
        case 'phone':
          if (!validatePhone(value)) {
            fieldErrors.push(message || `${field} 格式不正确`);
          }
          break;
        case 'url':
          if (!validateUrl(value)) {
            fieldErrors.push(message || `${field} 格式不正确`);
          }
          break;
        case 'number':
          if (isNaN(Number(value))) {
            fieldErrors.push(message || `${field} 必须是数字`);
          }
          break;
      }

      // 长度检查
      if (min !== undefined && value.length < min) {
        fieldErrors.push(message || `${field} 长度不能少于 ${min} 个字符`);
      }
      if (max !== undefined && value.length > max) {
        fieldErrors.push(message || `${field} 长度不能超过 ${max} 个字符`);
      }

      // 正则表达式检查
      if (pattern && !pattern.test(value)) {
        fieldErrors.push(message || `${field} 格式不正确`);
      }
    }

    if (fieldErrors.length > 0) {
      errors[field] = fieldErrors;
      isValid = false;
    }
  }

  return { isValid, errors };
}

module.exports = {
  validateEmail,
  validatePhone,
  validateIdCard,
  validateUrl,
  validatePassword,
  serializeForm,
  deserializeForm,
  getFormData,
  setFormData,
  resetForm,
  validateForm,
};