bonus
/
SafetyAlertSystem-ui
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

表单验证bug修复

This commit is contained in:
jjLv 2024-09-30 14:08:10 +08:00
parent 07d44db10b
commit 637b5abd5d
1 changed files with 283 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

366
src/views/base/warning/components/form-warning.vue
View File

@ -396,7 +396,8 @@ export default {
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'） // 检查前导零（例如 '0000' 或 '000.000000'）
if (value !== valueTemp.toString() || valueTemp.toString() === "0") { // if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
} }
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
@ -432,6 +433,11 @@ export default {
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@ -458,25 +464,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请正确输入噪声阈值(小数点后最多保留六位)')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请正确输入噪声阈值(小数点后最多保留六位)')); callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback(); callback();
}
} }
},
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal3Max: [ configVal3Max: [
{ {
@ -487,25 +502,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请正确输入噪声阈值(小数点后最多保留六位)')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请正确输入噪声阈值(小数点后最多保留六位)')); callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback(); callback();
}
} }
},
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal4Min: [ configVal4Min: [
{ {
@ -516,25 +540,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请正确输入PM2.5阈值(小数点后最多保留六位)')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请正确输入PM2.5阈值(小数点后最多保留六位)')); callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback(); callback();
}
} }
},
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal4Max: [ configVal4Max: [
{ {
@ -545,25 +578,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请正确输入PM2.5阈值(小数点后最多保留六位)')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请正确输入PM2.5阈值(小数点后最多保留六位)')); callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback(); callback();
}
} }
},
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal5Min: [ configVal5Min: [
{ {
@ -574,25 +616,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请正确输入PM10阈值(小数点后最多保留六位)')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请正确输入PM10阈值(小数点后最多保留六位)')); callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback(); callback();
}
} }
},
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal5Max: [ configVal5Max: [
{ {
@ -603,25 +654,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请正确输入PM10阈值(小数点后最多保留六位)')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/; const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
if(!regexTwo.test(value)){ if(!regexTwo.test(value)){
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请正确输入PM10阈值(小数点后最多保留六位)')); callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}else{ }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback(); callback();
}
} }
},
trigger: 'blur' trigger: 'blur'
} }
}
], ],
}, },
projectParams2Rules: { projectParams2Rules: {
@ -641,19 +701,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请必须输入0~90的数')); return callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
} }
// const numValue = value.trim(); const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
// 正则表达式：负数、零和正整数 if(!regexTwo.test(value)){
const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/; return callback(new Error('请勿输入非数字'));
if (!integerPattern.test(value) && value <= 90) { }
callback(new Error('请必须输入0~90的数')); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}, }else{
if (valueTemp < 0 || valueTemp > 90) {
callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
} else {
callback();
}
}
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal1Max: [ configVal1Max: [
{ {
@ -664,19 +739,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请必须输入0~90的数')); return callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
} }
// const numValue = value.trim(); const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
// 正则表达式：负数、零和正整数 if(!regexTwo.test(value)){
const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/; return callback(new Error('请勿输入非数字'));
if (!integerPattern.test(value) && value <= 90) { }
callback(new Error('请必须输入0~90的数')); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}, }else{
if (valueTemp < 0 || valueTemp > 90) {
callback(new Error('请输入0~90内的数据且小数点后最多保留六位'));
} else {
callback();
}
}
trigger: 'blur' trigger: 'blur'
} }
}
], ],
}, },
projectParams3Rules: { projectParams3Rules: {
@ -696,19 +786,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请必须输入非负数')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
// const numValue = value.trim(); const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
// 正则表达式：负数、零和正整数 if(!regexTwo.test(value)){
const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/; return callback(new Error('请勿输入非数字'));
if (!integerPattern.test(value)) { }
callback(new Error('请必须输入非负数')); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}, }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback();
}
}
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal1Max: [ configVal1Max: [
{ {
@ -719,19 +824,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请必须输入非负数')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
// const numValue = value.trim(); const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
// 正则表达式：负数、零和正整数 if(!regexTwo.test(value)){
const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/; return callback(new Error('请勿输入非数字'));
if (!integerPattern.test(value)) { }
callback(new Error('请必须输入非负数')); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}, }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback();
}
}
trigger: 'blur' trigger: 'blur'
} }
}
], ],
}, },
projectParams4Rules: { projectParams4Rules: {
@ -758,6 +878,11 @@ export default {
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@ -791,6 +916,11 @@ export default {
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@ -817,19 +947,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请必须输入非负数')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
// const numValue = value.trim(); const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
// 正则表达式：负数、零和正整数 if(!regexTwo.test(value)){
const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/; return callback(new Error('请勿输入非数字'));
if (!integerPattern.test(value)) { }
callback(new Error('请必须输入非负数')); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}, }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback();
}
}
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal2Max: [ configVal2Max: [
{ {
@ -840,19 +985,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请必须输入非负数')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
// const numValue = value.trim(); const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
// 正则表达式：负数、零和正整数 if(!regexTwo.test(value)){
const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/; return callback(new Error('请勿输入非数字'));
if (!integerPattern.test(value)) { }
callback(new Error('请必须输入非负数')); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}, }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback();
}
}
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal3Min: [ configVal3Min: [
{ {
@ -870,6 +1030,11 @@ export default {
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@ -883,9 +1048,9 @@ export default {
callback(); callback();
} }
} }
},
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal3Max: [ configVal3Max: [
{ {
@ -903,6 +1068,11 @@ export default {
return callback(new Error('请勿输入非数字')); return callback(new Error('请勿输入非数字'));
} }
const valueTemp = parseFloat(value); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){ if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) { if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入0~100内的数据且小数点后最多保留六位')); callback(new Error('请输入0~100内的数据且小数点后最多保留六位'));
@ -916,9 +1086,9 @@ export default {
callback(); callback();
} }
} }
},
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal4Min: [ configVal4Min: [
{ {
@ -929,19 +1099,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请必须输入非负数')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
// const numValue = value.trim(); const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
// 正则表达式：负数、零和正整数 if(!regexTwo.test(value)){
const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/; return callback(new Error('请勿输入非数字'));
if (!integerPattern.test(value)) { }
callback(new Error('请必须输入非负数')); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}, }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback();
}
}
trigger: 'blur' trigger: 'blur'
} }
}
], ],
configVal4Max: [ configVal4Max: [
{ {
@ -952,19 +1137,34 @@ export default {
{ {
validator: (rule, value, callback) => { validator: (rule, value, callback) => {
if (value === '' || value === null) { if (value === '' || value === null) {
return callback(new Error('请必须输入非负数')); return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} }
// const numValue = value.trim(); const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
// 正则表达式：负数、零和正整数 if(!regexTwo.test(value)){
const integerPattern = /^(0|[1-9]\d*(\.\d+)?|0\.\d+)$/; return callback(new Error('请勿输入非数字'));
if (!integerPattern.test(value)) { }
callback(new Error('请必须输入非负数')); const valueTemp = parseFloat(value);
// 检查前导零（例如 '0000' 或 '000.000000'）
// if(valueTemp.toString()==="0")
if (value !== valueTemp.toString() && value !== "0") {
return callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
}
if(valueTemp.toString().includes('.')==true){
if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>6) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else { } else {
callback(); callback();
} }
}, }else{
if (valueTemp < 0 ) {
callback(new Error('请输入大于零的数据且小数点后最多保留六位'));
} else {
callback();
}
}
trigger: 'blur' trigger: 'blur'
} }
}
], ],
}, },
// 各类下拉 // 各类下拉