AI 辅助金融表单设计：从监管要求到字段校验的自动生成

AI 辅助金融表单设计：从监管要求到字段校验的自动生成

一、引言：一份"开户表"背后的 37 条监管规则，不应该由前端开发者逐条背诵

金融表单有一个让你绝望的现实：它不是你"设计"出来的，而是监管文件"抄"出来的。

我就职金融科技公司的第一个项目，是重新开发一个基金的"风险测评问卷"。产品经理给了我一份 Excel 表格，里面有 87 个字段、214 条校验规则、16 种字段联动逻辑。每一条规则的背后，都引用了一份监管文件——《证券期货投资者适当性管理办法》《基金募集机构投资者适当性管理实施指引》《公开募集证券投资基金销售机构监督管理办法》……

在接下来的三周里，我把这 214 条规则一条一条地翻译成代码。if (annualIncome < 500000 && investmentAmount > 100000) return error("…") —— 我写了 173 个这样的条件判断。写到第 50 个时我已经开始感到眩晕，因为我的大脑正在执行一个没有任何创造力的机械翻译工作。

这件事可以做得更聪明。如果有一个 AI 系统能够"理解"监管文档，自动识别其中的约束条件（"年度收入低于 50 万时，投资金额不得超过 10 万"），然后将这些约束自动转化为前后端一致的校验规则——前端开发者的角色就从"规则翻译员"变成了"规则验证员"。你的工作不再是逐条写 if-else，而是检查 AI 翻译的正确性。

这就是 AI 辅助金融表单设计的核心价值：把前端开发者从"合规文件翻译工作"中解放出来。

二、底层机制与原理深度剖析

规则分类

金融表单的校验规则可以归纳为四类：

三、生产级代码实现

/**
* AI 辅助金融表单规则生成引擎
*
* 输入：监管规则的抽象描述
* 输出：前后端一致的校验规则 Schema
*/

/** 校验规则分类 */
type RuleType = 'type' | 'cross' | 'threshold' | 'required' | 'format';

/** 抽象规则描述 */
interface RuleDescription {
/** 规则编号（引用监管文件条款） */
regulationRef: string;
/** 规则类型 */
type: RuleType;
/** 目标字段 */
targetField: string;
/** 约束条件 */
constraints: RuleConstraint[];
/** 违规提示文案（合规要求必须使用特定措辞） */
errorMessage: string;
/** 规则优先级 */
priority: 'block' | 'warn'; // block=阻断提交, warn=仅提示
}

/** 规则约束 */
interface RuleConstraint {
type: 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq' | 'regex' | 'depends';
value: unknown;
/** 依赖字段（type=depends 时使用） */
dependField?: string;
/** 依赖条件映射 */
dependMapping?: Record<string, RuleConstraint[]>;
}

/**
* 规则生成器
* 将监管规则描述转化为可执行的校验函数
*/
class RuleGenerator {
/**
* 从规则描述生成校验规则集
*/
generateValidators(rules: RuleDescription[]): Map<string, ValidationRule[]> {
const validators = new Map<string, ValidationRule[]>();

for (const rule of rules) {
const field = rule.targetField;

if (!validators.has(field)) {
validators.set(field, []);
}

const validator = this.buildValidator(rule);
validators.get(field)!.push({
…validator,
regulationRef: rule.regulationRef
});
}

return validators;
}

/**
* 构建单条校验规则
*/
private buildValidator(rule: RuleDescription): Omit<ValidationRule, 'regulationRef'> {
switch (rule.type) {
case 'type':
return this.buildTypeValidator(rule);
case 'threshold':
return this.buildThresholdValidator(rule);
case 'cross':
return this.buildCrossValidator(rule);
case 'required':
return { required: true, message: rule.errorMessage };
case 'format':
return this.buildFormatValidator(rule);
default:
return { validator: () => true, message: '' };
}
}

/**
* 构建阈值校验规则
*
* 例：年龄必须在 18-65 岁之间
* 约束: [{ type: 'gte', value: 18 }, { type: 'lte', value: 65 }]
*/
private buildThresholdValidator(rule: RuleDescription) {
const constraints = rule.constraints;

return {
validator: (value: unknown, allValues?: Record<string, unknown>) => {
if (value === undefined || value === null) return true;

return constraints.every(c => {
const numValue = Number(value);
const numConstraint = Number(c.value);

switch (c.type) {
case 'gt': return numValue > numConstraint;
case 'gte': return numValue >= numConstraint;
case 'lt': return numValue < numConstraint;
case 'lte': return numValue <= numConstraint;
default: return true;
}
});
},
message: rule.errorMessage,
priority: rule.priority
};
}

/**
* 构建交叉校验规则
*
* 例：如果年收入 < 50万，投资金额 ≤ 10万
* 约束: [{
* type: 'depends',
* dependField: 'annualIncome',
* dependMapping: {
* 'lt_500000': [{ type: 'lte', value: 100000 }]
* }
* }]
*/
private buildCrossValidator(rule: RuleDescription) {
return {
validator: (value: unknown, allValues?: Record<string, unknown>) => {
if (!allValues) return true;

for (const constraint of rule.constraints) {
if (constraint.type !== 'depends' || !constraint.dependField) continue;

const dependValue = allValues[constraint.dependField];
if (dependValue === undefined) return true; // 依赖字段未填，暂不校验

const numDependValue = Number(dependValue);
const currentValue = Number(value);

// 检查依赖条件
if (constraint.dependMapping) {
for (const [condition, subConstraints] of Object.entries(constraint.dependMapping)) {
const [, cmp, threshold] = condition.match(/^(lt|gt|lte|gte)_(\\d+)$/) || [];
if (!cmp) continue;

const thresholdNum = Number(threshold);
let conditionMet = false;
switch (cmp) {
case 'lt': conditionMet = numDependValue < thresholdNum; break;
case 'gt': conditionMet = numDependValue > thresholdNum; break;
case 'lte': conditionMet = numDependValue <= thresholdNum; break;
case 'gte': conditionMet = numDependValue >= thresholdNum; break;
}

if (conditionMet) {
// 条件满足时，应用子约束
for (const subConstraint of subConstraints) {
switch (subConstraint.type) {
case 'lte':
if (currentValue > Number(subConstraint.value)) return false;
break;
case 'gte':
if (currentValue < Number(subConstraint.value)) return false;
break;
}
}
}
}
}
}

return true;
},
message: rule.errorMessage,
priority: rule.priority
};
}

/**
* 构建格式校验规则
*
* 身份号码、统一社会信用代码等金融领域特定格式
*/
private buildFormatValidator(rule: RuleDescription) {
return {
validator: (value: unknown) => {
if (!value || typeof value !== 'string') return true;
return rule.constraints.every(c => {
if (c.type === 'regex') {
return new RegExp(String(c.value)).test(value as string);
}
return true;
});
},
message: rule.errorMessage,
priority: rule.priority
};
}

private buildTypeValidator(rule: RuleDescription) {
return {
validator: (value: unknown) => {
if (value === undefined || value === null) return true;
return rule.constraints.every(c => {
switch (c.type) {
case 'eq': return typeof value === c.value;
default: return true;
}
});
},
message: rule.errorMessage,
priority: rule.priority
};
}
}

/** 校验规则 */
interface ValidationRule {
required?: boolean;
validator?: (value: unknown, allValues?: Record<string, unknown>) => boolean;
message: string;
regulationRef?: string;
priority?: 'block' | 'warn';
}

/**
* 前后端校验一致性检查
*
* AI 生成校验规则后，需要自动化验证前后端的校验逻辑是否一致。
* 生数万条随机测试数据，同时在前端和后端执行校验，
* 发现不一致时自动报告。
*/
class ConsistencyChecker {
/**
* 生成测试数据
*/
generateTestData(rules: RuleDescription[], count: number = 1000): Record<string, unknown>[] {
const testCases: Record<string, unknown>[] = [];

for (let i = 0; i < count; i++) {
const testCase: Record<string, unknown> = {};
const fields = […new Set(rules.map(r => r.targetField))];

for (const field of fields) {
// 随机生成有效值和边界值
testCase[field] = this.generateRandomValue(rules, field);
}

testCases.push(testCase);
}

return testCases;
}

/**
* 对每条规则生成边界测试数据
*/
generateBoundaryTestData(rule: RuleDescription): Record<string, unknown>[] {
const testCases: Record<string, unknown>[] = [];

for (const constraint of rule.constraints) {
const value = Number(constraint.value);
if (isNaN(value)) continue;

// 边界值和边界附近的值
switch (constraint.type) {
case 'gte':
testCases.push(
{ [rule.targetField]: value – 1 }, // 期望失败
{ [rule.targetField]: value }, // 期望成功
{ [rule.targetField]: value + 1 } // 期望成功
);
break;
case 'lte':
testCases.push(
{ [rule.targetField]: value – 1 }, // 期望成功
{ [rule.targetField]: value }, // 期望成功
{ [rule.targetField]: value + 1 } // 期望失败
);
break;
case 'gt':
testCases.push(
{ [rule.targetField]: value }, // 期望失败
{ [rule.targetField]: value + 1 } // 期望成功
);
break;
case 'lt':
testCases.push(
{ [rule.targetField]: value – 1 }, // 期望成功
{ [rule.targetField]: value } // 期望失败
);
break;
}
}

return testCases;
}

private generateRandomValue(rules: RuleDescription[], field: string): unknown {
// 简化的随机值生成
return Math.floor(Math.random() * 1000000);
}
}

四、边界分析与架构权衡

关键缺点：

适用边界：

五、总结

AI 辅助金融表单设计最打动我的，不是效率提升，而是它让前端开发者从"合规代码的搬运工"回归为"产品体验的创造者"。

当 AI 帮你整理了那 214 条校验规则后，你不需要再为"riskAssessmentScore 的取值范围到底是 0-100 还是 1-5"这种问题消耗脑力。你终于可以把注意力放在真正需要创造力的地方：如何让这 87 个字段的表单在移动端填写时不那么痛苦？如何让用户在填写过程中持续获得填写进度感？如何让错误提示不那么"吓人"而是"有帮助"？

这些才是前端开发者真正的价值所在。规则翻译不是。

作者：李慕杰（Leo / 8limujie）一个终于不再逐条背诵监管文件的前端匠人