Skip to content

W
WebPublic
提交 2651542b authored 作者: 徐立's avatar 徐立
浏览文件
操作

完成中台函数库 数据断言函数封装

上级 cc906839
隐藏空白字符变更
内嵌 并排
正在显示 包含 1335 行增加 和 89 行删除
one_stop_public/Table/index.jsx
浏览文件 @ 2651542b
...@@ -358,7 +358,15 @@ export default class ZdyTable extends Component { ...@@ -358,7 +358,15 @@ export default class ZdyTable extends Component {
render() { render() {
let { width, isBorder, sqlData, mapData, defaultBinds, defaultValues, items, init, currentFormKey, isEdit, datas, isReady, formConfig, formCode, formId } = this.state let { width, isBorder, sqlData, mapData, defaultBinds, defaultValues, items, init, currentFormKey, isEdit, datas, isReady, formConfig, formCode, formId } = this.state
let { border, get, obj, index, fatherCode,routerState } = this.props let {
border,
get,
obj,
index,
fatherCode,
routerState, // 场景设计器共享路由参数
messageData, // 场景设计器共享变量参数 设计器监听到参数发生变化后会重新渲染组件
} = this.props
let style = {} let style = {}
if (formConfig.style != null) { if (formConfig.style != null) {
try { try {
...@@ -481,6 +489,7 @@ export default class ZdyTable extends Component { ...@@ -481,6 +489,7 @@ export default class ZdyTable extends Component {
sqlData={sqlData} sqlData={sqlData}
defaultValues={defaultValues || {}} // 接口中的默认值 defaultValues={defaultValues || {}} // 接口中的默认值
routerState={routerState} // 兼容表单设计器路由传参 routerState={routerState} // 兼容表单设计器路由传参
messageData={messageData} // 场景设计器共享变量参数
/> />
</td> </td>
} }
...@@ -561,7 +570,9 @@ export default class ZdyTable extends Component { ...@@ -561,7 +570,9 @@ export default class ZdyTable extends Component {
json={ary.content} json={ary.content}
uuid={ary.uuid} uuid={ary.uuid}
routerState={routerState} // 兼容表单设计器路由传参 routerState={routerState} // 兼容表单设计器路由传参
defaultValues={defaultValues || {}} /></> defaultValues={defaultValues || {}}
messageData={messageData} // 场景设计器共享变量参数
/></>
}) })
} }
</div>) </div>)
......
one_stop_public/excelInitFuc/functionList.js
浏览文件 @ 2651542b
...@@ -1658,7 +1658,6 @@ const List = [ ...@@ -1658,7 +1658,6 @@ const List = [
value: function(...ary) { value: function(...ary) {
let num = 0 let num = 0
ary.map(item=>{ ary.map(item=>{
console.log(item)
num+=item num+=item
}) })
return num return num
...@@ -1675,122 +1674,985 @@ const List = [ ...@@ -1675,122 +1674,985 @@ const List = [
}, },
], ],
}, },
{
name: '集合操作函数',
images: ObjectPng,
pitchImages: Object2Png,
children:[
{
name:'集合指定规则生成对象', // 函数代表名
funcName: '创建一个组成对象，key（键）是经过 iteratee（迭代函数） 执行处理collection中每个元素后返回的结果，每个key（键）对应的值是 iteratee（迭代函数）返回该key（键）的次数', // 函数名字
function: CollectCountBy, // 当前函数
callKey: 'CollectCountBy',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的数组。', // 第一个参数代表含义
},
{
text:'一个迭代函数', // 第二个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:['one', 'two', 'three'],// 传入函数中的值
text:`['one', 'two', 'three']`, // 展示页面所用值
},
{
value:'length',// 传入函数中的值
text:'length', // 展示页面所用值
},
],
},
{
name:'集合制定规则遍历', // 函数代表名
funcName: '调用 iteratee 遍历 collection(集合) 中的每个元素，如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。', // 函数名字
function: CollectForEach, // 当前函数
callKey: 'CollectForEach',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的集合。', // 第一个参数代表含义
},
{
text:'函数用来组合分组的值。', // 第二个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:{ 'a': 1, 'b': 2 },// 传入函数中的值
text:`{ 'a': 1, 'b': 2 }`, // 展示页面所用值
},
{
value:function(value, key) {
console.log(value,key);
},// 传入函数中的值
text:`function(value, key) {
console.log(value,key);
}`, // 展示页面所用值
},
],
},
{
name:'集合制定规则反向遍历', // 函数代表名
funcName: '调用 iteratee 反方向遍历 collection(集合) 中的每个元素，如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。', // 函数名字
function: CollectForEachRight, // 当前函数
callKey: 'CollectForEachRight',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的集合。', // 第一个参数代表含义
},
{
text:'函数用来组合分组的值。', // 第二个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:{ 'a': 1, 'b': 2 },// 传入函数中的值
text:`{ 'a': 1, 'b': 2 }`, // 展示页面所用值
},
{
value:function(value, key) {
console.log(value,key);
},// 传入函数中的值
text:`function(value, key) {
console.log(value,key);
}`, // 展示页面所用值
},
],
},
{
name:'集合指定规则断言', // 函数代表名
funcName: '通过 predicate（断言函数） 检查 collection（集合）中的 所有 元素是否都返回真值。一旦 predicate（断言函数） 返回假值，迭代就马上停止。', // 函数名字
function: CollectEvery, // 当前函数
callKey: 'CollectEvery',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的集合。', // 第一个参数代表含义
},
{
text:'函数用来组合分组的值。', // 第二个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:[
{ 'user': 'barney', 'age': 36, 'active': false },
{ 'user': 'fred', 'age': 40, 'active': false }
],// 传入函数中的值
text:`[
{ 'user': 'barney', 'age': 36, 'active': false },
{ 'user': 'fred', 'age': 40, 'active': false }
]`, // 展示页面所用值
},
{
value:{ 'user': 'barney', 'active': false },// 传入函数中的值
text:`{ 'user': 'barney', 'active': false }`, // 展示页面所用值
},
],
},
{
name:'集合指定规则筛选', // 函数代表名
funcName: '遍历 collection（集合）元素，返回 predicate（断言函数）返回真值 的所有元素的数组。', // 函数名字
function: CollectFilter, // 当前函数
callKey: 'CollectFilter',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的集合。', // 第一个参数代表含义
},
{
text:'每次迭代调用的函数。', // 第二个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:[
{ 'user': 'barney', 'age': 36, 'active': true },
{ 'user': 'fred', 'age': 40, 'active': false }
],// 传入函数中的值
text:`[
{ 'user': 'barney', 'age': 36, 'active': true },
{ 'user': 'fred', 'age': 40, 'active': false }
]`, // 展示页面所用值
},
{
value:function(o) { return !o.active; },// 传入函数中的值
text:`function(o) { return !o.active; }`, // 展示页面所用值
},
],
},
{
name:'集合指定规则筛选第一个符合对象', // 函数代表名
funcName: '遍历 collection（集合）元素，返回 predicate（断言函数）第一个返回真值的第一个元素。', // 函数名字
function: CollectFind, // 当前函数
callKey: 'CollectFind',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的集合。', // 第一个参数代表含义
},
{
text:'每次迭代调用的函数。', // 第二个参数代表含义
},
{
text:'开始搜索的索引位置。不传为从头开始'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:[
{ 'user': 'barney', 'age': 36, 'active': true },
{ 'user': 'fred', 'age': 40, 'active': false },
{ 'user': 'pebbles', 'age': 1, 'active': true }
],// 传入函数中的值
text:`[
{ 'user': 'barney', 'age': 36, 'active': true },
{ 'user': 'fred', 'age': 40, 'active': false },
{ 'user': 'pebbles', 'age': 1, 'active': true }
]`, // 展示页面所用值
},
{
value:function(o) { return o.age < 30; },// 传入函数中的值
text:`function(o) { return o.age < 30; }`, // 展示页面所用值
},
],
},
{
name:'集合指定规则筛选从右至左第一个符合对象', // 函数代表名
funcName: '遍历 collection（集合）元素，从右至左返回 predicate（断言函数）第一个返回真值的第一个元素。', // 函数名字
function: CollectFindLast, // 当前函数
callKey: 'CollectFindLast',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的集合。', // 第一个参数代表含义
},
{
text:'每次迭代调用的函数。', // 第二个参数代表含义
},
{
text:'开始搜索的索引位置。不传为从右至左开始'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:[
{ 'user': 'barney', 'age': 36, 'active': true },
{ 'user': 'fred', 'age': 40, 'active': false },
{ 'user': 'pebbles', 'age': 1, 'active': true }
],// 传入函数中的值
text:`[
{ 'user': 'barney', 'age': 36, 'active': true },
{ 'user': 'fred', 'age': 40, 'active': false },
{ 'user': 'pebbles', 'age': 1, 'active': true }
]`, // 展示页面所用值
},
{
value:function(o) { return o.age < 30; },// 传入函数中的值
text:`function(o) { return o.age < 30; }`, // 展示页面所用值
},
],
},
{
name:'集合进行一层扁平化合并', // 函数代表名
funcName: '创建一个扁平化（注：同阶数组）的数组，这个数组的值来自collection（集合）中的每一个值经过 iteratee（迭代函数） 处理后返回的结果，并且扁平化合并。', // 函数名字
function: CollectFlatMap, // 当前函数
callKey: 'CollectFlatMap',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的集合。', // 第一个参数代表含义
},
{
text:'每次迭代调用的函数。', // 第二个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:[1, 2],// 传入函数中的值
text:`[1, 2]`, // 展示页面所用值
},
{
value:function duplicate(n) {
return [n, n];
},// 传入函数中的值
text:`function duplicate(n) {
return [n, n];
}`, // 展示页面所用值
},
],
},
{
name:'集合进行多层扁平化合并', // 函数代表名
funcName: '创建一个扁平化（注：同阶数组）的数组，这个数组的值来自collection（集合）中的每一个值经过 iteratee（迭代函数） 处理后返回的结果，并且多层扁平化合并。', // 函数名字
function: CollectFlatMapDeep, // 当前函数
callKey: 'CollectFlatMapDeep',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的集合。', // 第一个参数代表含义
},
{
text:'每次迭代调用的函数。', // 第二个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:[1, 2],// 传入函数中的值
text:`[1, 2]`, // 展示页面所用值
},
{
value:function duplicate(n) {
return [[[n, n]]];
},// 传入函数中的值
text:`function duplicate(n) {
return [[[n, n]]];
}`, // 展示页面所用值
},
],
},
{
name:'集合指定层数扁平化合并', // 函数代表名
funcName: '创建一个扁平化（注：同阶数组）的数组，这个数组的值来自collection（集合）中的每一个值经过 iteratee（迭代函数） 处理后返回的结果，并且根据指定的 depth（递归深度）继续扁平化递归映射结果', // 函数名字
function: CollectFlatMapDepth, // 当前函数
callKey: 'CollectFlatMapDepth',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'一个用来迭代的集合。', // 第一个参数代表含义
},
{
text:'每次迭代调用的函数。', // 第二个参数代表含义
},
{
text: '最大递归深度。'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:[1, 2],// 传入函数中的值
text:`[1, 2]`, // 展示页面所用值
},
{
value:function duplicate(n) {
return [[[n, n]]];
},// 传入函数中的值
text:`function duplicate(n) {
return [[[n, n]]];
}`, // 展示页面所用值
},
{
value: 2,
text: 2,
}
],
},
],
},
{ {
name: '对象操作函数', name: '对象操作函数',
images: ObjectPng, images: ObjectPng,
pitchImages: Object2Png, pitchImages: Object2Png,
children:[ children:[
]
},
{
name: '数据断言转换函数',
images: ObjectPng,
pitchImages: Object2Png,
children:[
{
name:'数组判断并转换', // 函数代表名
funcName: ' 如果 value 不是数组, 那么强制转为数组。', // 函数名字
function: LangCastArray, // 当前函数
callKey: 'LangCastArray',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要处理的值。', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:{ 'a': 1 },// 传入函数中的值
text:`{ 'a': 1 }`, // 展示页面所用值
}
],
},
{
name:'浅拷贝', // 函数代表名
funcName: ' 创建一个 value 的浅拷贝。不支持error objects、functions, DOM nodes, 以及 WeakMaps 会返回空对象。', // 函数名字
function: LangClone, // 当前函数
callKey: 'LangClone',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要拷贝的值', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:{ 'a': 1 },// 传入函数中的值
text:`{ 'a': 1 }`, // 展示页面所用值
}
],
},
{
name:'深拷贝', // 函数代表名
funcName: '递归拷贝数据', // 函数名字
function: LangCloneDeep, // 当前函数
callKey: 'LangCloneDeep',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要拷贝的值', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:[{ 'a': 1 }, { 'b': 2 }],// 传入函数中的值
text:`[{ 'a': 1 }, { 'b': 2 }]`, // 展示页面所用值
}
],
},
{
name:'浅克隆页面元素', // 函数代表名
funcName: '递归拷贝数据,它接受一个 customizer 定制返回的克隆值。 如果 customizer 返回 undefined 将会使用拷贝方法代替处理', // 函数名字
function: LangCloneWith, // 当前函数
callKey: 'LangCloneWith',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要拷贝的值', // 第一个参数代表含义
},
{
text:'用来自定义克隆的函数。'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:document.body,// 传入函数中的值
text:`document.body`, // 展示页面所用值
},
{
value: function customizer(value) {
if (isElement(value)) {
return value.cloneNode(false);
}
},
text:`function customizer(value) {
if (isElement(value)) {
return value.cloneNode(false);
}
}`
}
],
},
{
name:'深度克隆页面元素', // 函数代表名
funcName: '它会递归克隆 value。支持页面元素', // 函数名字
function: LangCloneDeepWith, // 当前函数
callKey: 'LangCloneDeepWith',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'用来递归克隆的值', // 第一个参数代表含义
},
{
text:'用来自定义克隆的函数。'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:document.body,// 传入函数中的值
text:`document.body`, // 展示页面所用值
},
{
value: function customizer(value) {
if (isElement(value)) {
return value.cloneNode(true);
}
},
text:`function customizer(value) {
if (isElement(value)) {
return value.cloneNode(true);
}
}`
}
],
},
{
name:'对象数据断言', // 函数代表名
funcName: '通过调用断言对象的属性与 对象 的相应属性值，检查对象是否符合 断言。', // 函数名字
function: LangConformsTo, // 当前函数
callKey: 'LangConformsTo',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的对象。', // 第一个参数代表含义
},
{
text:'要断言属性是否符合的对象。'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:{ 'a': 1, 'b': 2 },// 传入函数中的值
text:`{ 'a': 1, 'b': 2 }`, // 展示页面所用值
},
{
value:{ 'b': function(n) { return n > 1; } },
text:`{ 'b': function(n) { return n > 1; } }`
}
],
},
{
name:'数据相等比较', // 函数代表名
funcName: '比较两者的值，来确定它们是否相等。如果两个值相等返回 true ，否则返回 false 。', // 函数名字
function: LangEq, // 当前函数
callKey: 'LangEq',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要比较的值。', // 第一个参数代表含义
},
{
text: '另一个要比较的值。'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:NaN,// 传入函数中的值
text:`NaN`, // 展示页面所用值
},
{
value:NaN,
text:`NaN`
}
],
},
{
name:'类数组(伪数组)断言', // 函数代表名
funcName: '检查 value 是否是一个类 arguments 对象(伪数组)。', // 函数名字
function: LangIsArguments, // 当前函数
callKey: 'LangIsArguments',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值。', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:function() { return arguments; }(),// 传入函数中的值
text:`function() { return arguments; }()`, // 展示页面所用值
}
],
},
{
name:'数组断言', // 函数代表名
funcName: '检查 value 是否是 Array 类对象。', // 函数名字
function: LangIsArray, // 当前函数
callKey: 'LangIsArray',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值。', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:function() { return arguments; }(),// 传入函数中的值
text:`function() { return arguments; }()`, // 展示页面所用值
}
],
},
{
name:'ArrayBuffer(数组缓冲)断言', // 函数代表名
funcName: '检查 value 是否是 Array 类对象。', // 函数名字
function: LangIsArrayBuffer, // 当前函数
callKey: 'LangIsArrayBuffer',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值。', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:new ArrayBuffer(2),// 传入函数中的值
text:`new ArrayBuffer(2)`, // 展示页面所用值
}
],
},
{
name:'布尔值断言', // 函数代表名
funcName: '检查 value 是否是原始 boolean 类型或者对象。', // 函数名字
function: LangIsBooean, // 当前函数
callKey: 'LangIsBooean',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值。', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:false,// 传入函数中的值
text:`false`, // 展示页面所用值
}
],
},
{
name:'date(时间)对象断言', // 函数代表名
funcName: '检查 value 是否是 Date 对象。', // 函数名字
function: LangIsDate, // 当前函数
callKey: 'LangIsDate',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值。', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:'Mon April 23 2012',// 传入函数中的值
text:`Mon April 23 2012`, // 展示页面所用值
}
],
},
{
name:'DOM元素断言', // 函数代表名
funcName: '检查 value 是否是可能是 DOM 元素。', // 函数名字
function: LangIsElement, // 当前函数
callKey: 'LangIsElement',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值。', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:document.body,// 传入函数中的值
text:`document.body`, // 展示页面所用值
}
],
},
{
name:'集合空断言', // 函数代表名
funcName: '检查 value 是否为一个空对象，集合，映射或者set。', // 函数名字
function: LangIsEmpty, // 当前函数
callKey: 'LangIsEmpty',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值。', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:null,// 传入函数中的值
text:`null`, // 展示页面所用值
}
],
},
{
name:'判断对象是否完全相等', // 函数代表名
funcName: '执行深比较来确定两者的值是否相等。', // 函数名字
function: LangIsEqual, // 当前函数
callKey: 'LangIsEqual',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'用来比较的值。', // 第一个参数代表含义
},
{
text:'另一个用来比较的值。'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:{ 'a': 1 },// 传入函数中的值
text:`{ 'a': 1 }`, // 展示页面所用值
},
{
value:{ 'a': 1 },
text:`{ 'a': 1 }`,
}
],
},
{
name:'指定规则进行对象是否相等判断', // 函数代表名
funcName: '它接受一个对比函数用来定制比较值。如果对比函数返回 undefined 将会比较处理方法代替。', // 函数名字
function: LangIsEqualWith, // 当前函数
callKey: 'LangIsEqualWith',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'用来比较的值。', // 第一个参数代表含义
},
{
text:'另一个用来比较的值。'
},
{
text: '用来定制比较值的函数。'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:['hello', 'goodbye'],// 传入函数中的值
text:`['hello', 'goodbye']`, // 展示页面所用值
},
{
value:['hi', 'goodbye'],
text:`['hi', 'goodbye']`,
},
{
value:function customizer(objValue, othValue) {
function isGreeting(value) {
return /^h(?:i|ello)$/.test(value);
}
if (isGreeting(objValue) && isGreeting(othValue)) {
return true;
}
},
text: `function customizer(objValue, othValue) {
function isGreeting(value) {
return /^h(?:i|ello)$/.test(value);
}
if (isGreeting(objValue) && isGreeting(othValue)) {
return true;
}
}`
}
],
},
{
name:'判断是否为error对象', // 函数代表名
funcName: '检查 value 是否是 Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, 或者 URIError对象。', // 函数名字
function: LangIsError, // 当前函数
callKey: 'LangIsError',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:new Error,// 传入函数中的值
text:`new Error`, // 展示页面所用值
}
],
},
{
name:'判断数据是否为原始有限数值', // 函数代表名
funcName: '检查 value 是否是原始有限数值。', // 函数名字
function: LangIsFinite, // 当前函数
callKey: 'LangIsFinite',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:56,// 传入函数中的值
text:`56`, // 展示页面所用值
}
],
},
{
name:'判断数据是否为整数', // 函数代表名
funcName: '检查 value 是否为一个整数。', // 函数名字
function: LangIsInteger, // 当前函数
callKey: 'LangIsInteger',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:6.25,// 传入函数中的值
text:`6.25`, // 展示页面所用值
}
],
},
{
name:'判断数据是否为Map 对象', // 函数代表名
funcName: '检查 value 是否为Map 对象', // 函数名字
function: LangIsMap, // 当前函数
callKey: 'LangIsMap',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:new Map,// 传入函数中的值
text:`new Map`, // 展示页面所用值
}
],
},
{
name:'深度比较对象指定key值value是否相同', // 函数代表名
funcName: '执行一个深度比较，来确定 object 是否含有和 source 完全相等的属性值。', // 函数名字
function: LangIsMatch, // 当前函数
callKey: 'LangIsMatch',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值', // 第一个参数代表含义
},
{
text: '属性值相匹配的对象。'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:{ 'a': 1, 'b': 2 },// 传入函数中的值
text:`{ 'a': 1, 'b': 2 }`, // 展示页面所用值
},
{
value: { 'b': 2 },
text:`{ 'b': 2 }`,
}
],
},
{
name:'指定规则,深度比较对象指定key值value是否相同', // 函数代表名
funcName: '它接受一个对比函数定制比较的值。 如果对比函数返回 undefined 将会比较处理方法代替', // 函数名字
function: LangIsMatchWith, // 当前函数
callKey: 'LangIsMatchWith',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的对象。', // 第一个参数代表含义
},
{
text: '属性值相匹配的对象。'
},
{
text: '这个函数用来定制比较。'
}
],
demo: [ // 展示给用户看的案例传入值
{
value:{ 'greeting': 'hello' },// 传入函数中的值
text:`{ 'greeting': 'hello' }`, // 展示页面所用值
},
{
value:{ 'greeting': 'hi' },
text: `{ 'greeting': 'hi' }`
},
{
value: function customizer(objValue, srcValue) {
function isGreeting(value) {
return /^h(?:i|ello)$/.test(value);
}
if (isGreeting(objValue) && isGreeting(srcValue)) {
return true;
}
},
text: `function customizer(objValue, srcValue) {
function isGreeting(value) {
return /^h(?:i|ello)$/.test(value);
}
if (isGreeting(objValue) && isGreeting(srcValue)) {
return true;
}
}`
},
],
},
{
name:'判断数据是否为NaN对象', // 函数代表名
funcName: '检查 value 是否是 NaN。', // 函数名字
function: LangIsNaN, // 当前函数
callKey: 'LangIsNaN',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值', // 第一个参数代表含义
}
],
demo: [ // 展示给用户看的案例传入值
{
value:NaN,// 传入函数中的值
text:`NaN`, // 展示页面所用值
}
],
},
// {
// name:'判断数据是否为原生函数', // 函数代表名
// funcName: '检查 value 是否是一个原生函数。', // 函数名字
// function: LangIsNative, // 当前函数
// callKey: 'LangIsNative',
// params: [ // 函数所需要传入值内容 为空为不传值
// {
// text:'要检查的值', // 第一个参数代表含义
// }
// ],
// demo: [ // 展示给用户看的案例传入值
// {
// value:Array.prototype.push,// 传入函数中的值
// text:`Array.prototype.push`, // 展示页面所用值
// }
// ],
// },
{ {
name:'数组指定规则生成对象', // 函数代表名 name:'判断数据是否已经定义', // 函数代表名
funcName: '创建一个组成对象，key（键）是经过 iteratee（迭代函数） 执行处理collection中每个元素后返回的结果，每个key（键）对应的值是 iteratee（迭代函数）返回该key（键）的次数', // 函数名字 funcName: '检查 value 是否是 null 或者 undefined。', // 函数名字
function: ObjectCountBy, // 当前函数 function: LangIsNil, // 当前函数
callKey: 'ObjectCountBy', callKey: 'LangIsNil',
params: [ // 函数所需要传入值内容 为空为不传值 params: [ // 函数所需要传入值内容 为空为不传值
{ {
text:'一个用来迭代的数组。', // 第一个参数代表含义 text:'要检查的值', // 第一个参数代表含义
},
{
text:'一个迭代函数', // 第二个参数代表含义
} }
], ],
demo: [ // 展示给用户看的案例传入值 demo: [ // 展示给用户看的案例传入值
{ {
value:['one', 'two', 'three'],// 传入函数中的值 value:undefined,// 传入函数中的值
text:`['one', 'two', 'three']`, // 展示页面所用值 text:`undefined`, // 展示页面所用值
}, }
{
value:'length',// 传入函数中的值
text:'length', // 展示页面所用值
},
], ],
}, },
{ {
name:'对象制定规则遍历', // 函数代表名 name:'判断数据是否为null', // 函数代表名
funcName: '调用 iteratee 遍历 collection(集合) 中的每个元素，如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。', // 函数名字 funcName: '检查 value 是否是 null ', // 函数名字
function: ObjectForEach, // 当前函数 function: LangIsNull, // 当前函数
callKey: 'ObjectForEach', callKey: 'LangIsNull',
params: [ // 函数所需要传入值内容 为空为不传值 params: [ // 函数所需要传入值内容 为空为不传值
{ {
text:'一个用来迭代的集合。', // 第一个参数代表含义 text:'要检查的值', // 第一个参数代表含义
},
{
text:'函数用来组合分组的值。', // 第二个参数代表含义
} }
], ],
demo: [ // 展示给用户看的案例传入值 demo: [ // 展示给用户看的案例传入值
{ {
value:{ 'a': 1, 'b': 2 },// 传入函数中的值 value:undefined,// 传入函数中的值
text:`{ 'a': 1, 'b': 2 }`, // 展示页面所用值 text:`undefined`, // 展示页面所用值
}, }
{
value:function(value, key) {
console.log(value,key);
},// 传入函数中的值
text:`function(value, key) {
console.log(value,key);
}`, // 展示页面所用值
},
], ],
}, },
{ {
name:'对象制定规则反向遍历', // 函数代表名 name:'判断数据是否为数字(number)', // 函数代表名
funcName: '调用 iteratee 反方向遍历 collection(集合) 中的每个元素，如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。', // 函数名字 funcName: '检查 value 是否是原始Number数值型 或者 对象。', // 函数名字
function: ObjectForEachRight, // 当前函数 function: LangIsNumber, // 当前函数
callKey: 'ObjectForEachRight', callKey: 'LangIsNumber',
params: [ // 函数所需要传入值内容 为空为不传值 params: [ // 函数所需要传入值内容 为空为不传值
{ {
text:'一个用来迭代的集合。', // 第一个参数代表含义 text:'要检查的值', // 第一个参数代表含义
}, }
],
demo: [ // 展示给用户看的案例传入值
{ {
text:'函数用来组合分组的值。', // 第二个参数代表含义 value:585,// 传入函数中的值
text:`585`, // 展示页面所用值
}
],
},
{
name:'判断数据是否为对象', // 函数代表名
funcName: '检查 value 是否是对象。', // 函数名字
function: LangIsObject, // 当前函数
callKey: 'LangIsObject',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值', // 第一个参数代表含义
} }
], ],
demo: [ // 展示给用户看的案例传入值 demo: [ // 展示给用户看的案例传入值
{ {
value:{ 'a': 1, 'b': 2 },// 传入函数中的值 value:{},// 传入函数中的值
text:`{ 'a': 1, 'b': 2 }`, // 展示页面所用值 text:`{}`, // 展示页面所用值
}, }
],
},
{
name:'判断数据是否为正则表达式', // 函数代表名
funcName: '检查 value 是否为正则表达式对象。', // 函数名字
function: LangIsRegExp, // 当前函数
callKey: 'LangIsRegExp',
params: [ // 函数所需要传入值内容 为空为不传值
{ {
value:function(value, key) { text:'要检查的值', // 第一个参数代表含义
console.log(value,key); }
},// 传入函数中的值 ],
text:`function(value, key) { demo: [ // 展示给用户看的案例传入值
console.log(value,key); {
}`, // 展示页面所用值 value:/^[0-9]*[1-9][0-9]*$/,// 传入函数中的值
}, text:`/^[0-9]*[1-9][0-9]*$/`, // 展示页面所用值
}
], ],
}, },
{ {
name:'对象制定规则断言', // 函数代表名 name:'将数据转为数组', // 函数代表名
funcName: '通过 predicate（断言函数） 检查 collection（集合）中的 所有 元素是否都返回真值。一旦 predicate（断言函数） 返回假值，迭代就马上停止。', // 函数名字 funcName: '转换 value 为一个数组。', // 函数名字
function: ObjectEvery, // 当前函数 function: LangToArray, // 当前函数
callKey: 'ObjectEvery', callKey: 'LangToArray',
params: [ // 函数所需要传入值内容 为空为不传值 params: [ // 函数所需要传入值内容 为空为不传值
{ {
text:'一个用来迭代的集合。', // 第一个参数代表含义 text:'要检查的值', // 第一个参数代表含义
}, }
],
demo: [ // 展示给用户看的案例传入值
{ {
text:'函数用来组合分组的值。', // 第二个参数代表含义 value:'23gfdojbn',// 传入函数中的值
text:`23gfdojbn`, // 展示页面所用值
}
],
},
{
name:'将数据转为整数', // 函数代表名
funcName: '转换 value 为一个数组。', // 函数名字
function: LangToInteger, // 当前函数
callKey: 'LangToInteger',
params: [ // 函数所需要传入值内容 为空为不传值
{
text:'要检查的值', // 第一个参数代表含义
} }
], ],
demo: [ // 展示给用户看的案例传入值 demo: [ // 展示给用户看的案例传入值
{ {
value:[ value:'3.8',// 传入函数中的值
{ 'user': 'barney', 'age': 36, 'active': false }, text:`3.8`, // 展示页面所用值
{ 'user': 'fred', 'age': 40, 'active': false } }
],// 传入函数中的值 ],
text:`[ },
{ 'user': 'barney', 'age': 36, 'active': false }, {
{ 'user': 'fred', 'age': 40, 'active': false } name:'将数据转为字符串', // 函数代表名
]`, // 展示页面所用值 funcName: '转换 value 为字符串。 null 和 undefined 将返回空字符串。-0 将被转换为字符串"-0"。', // 函数名字
}, function: LangToString, // 当前函数
callKey: 'LangToString',
params: [ // 函数所需要传入值内容 为空为不传值
{ {
value:{ 'user': 'barney', 'active': false },// 传入函数中的值 text:'要检查的值', // 第一个参数代表含义
text:`{ 'user': 'barney', 'active': false }`, // 展示页面所用值 }
},
], ],
} demo: [ // 展示给用户看的案例传入值
], {
value:2342,// 传入函数中的值
text:`2342`, // 展示页面所用值
}
],
},
]
}, },
{ {
name: '数字操作函数', name: '数字操作函数',
...@@ -4925,13 +5787,13 @@ export function ArrayZipWith(ary,func) { ...@@ -4925,13 +5787,13 @@ export function ArrayZipWith(ary,func) {
} }
} }
/** /**
* 对象操作函数 * 集合操作函数
* 创建一个组成对象，key（键）是经过 iteratee（迭代函数） 执行处理collection中每个元素后返回的结果，每个key（键）对应的值是 iteratee（迭代函数）返回该key（键）的次数 * 创建一个组成对象，key（键）是经过 iteratee（迭代函数） 执行处理collection中每个元素后返回的结果，每个key（键）对应的值是 iteratee（迭代函数）返回该key（键）的次数
* @param { Array } ary 一个用来迭代的集合。 * @param { Array } ary 一个用来迭代的集合。
* @param { Array|Function|Object|string } func 一个迭代函数，用来转换key（键） * @param { Array|Function|Object|string } func 一个迭代函数，用来转换key（键）
* @returns { Object } 返回一个组成集合对象。 * @returns { Object } 返回一个组成集合对象。
*/ */
export function ObjectCountBy(ary,func) { export function CollectCountBy(ary,func) {
if(isArray(ary)){ if(isArray(ary)){
return countBy(ary,func) return countBy(ary,func)
} else { } else {
...@@ -4939,33 +5801,406 @@ export function ObjectCountBy(ary,func) { ...@@ -4939,33 +5801,406 @@ export function ObjectCountBy(ary,func) {
} }
} }
/** /**
* 对象操作函数 * 集合操作函数
* 调用 iteratee 遍历 collection(集合) 中的每个元素，如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。 * 调用 iteratee 遍历 collection(集合) 中的每个元素，如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。
* @param { Array|Object } ary 一个用来迭代的集合。 * @param { Array|Object } ary 一个用来迭代的集合。
* @param { Function } func 函数用来组合分组的值。 * @param { Function } func 函数用来组合分组的值。
* @returns 返回集合 collection。 * @returns 返回集合 collection。
*/ */
export function ObjectForEach(ary,func) { export function CollectForEach(ary,func) {
return forEach(ary,func) return forEach(ary,func)
} }
/** /**
* 对象操作函数 * 集合操作函数
* 调用 iteratee 反方向遍历 collection(集合) 中的每个元素，如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。 * 调用 iteratee 反方向遍历 collection(集合) 中的每个元素，如果迭代函数（iteratee）显式的返回 false ，迭代会提前退出。
* @param { Array|Object } ary 一个用来迭代的集合。 * @param { Array|Object } ary 一个用来迭代的集合。
* @param { Function } func 函数用来组合分组的值。 * @param { Function } func 函数用来组合分组的值。
* @returns 返回集合 collection。 * @returns 返回集合 collection。
*/ */
export function ObjectForEachRight(ary,func) { export function CollectForEachRight(ary,func) {
return forEachRight(ary,func) return forEachRight(ary,func)
} }
/** /**
* 对象操作函数 * 集合操作函数
* 通过 predicate（断言函数） 检查 collection（集合）中的 所有 元素是否都返回真值。一旦 predicate（断言函数） 返回假值，迭代就马上停止。 * 通过 predicate（断言函数） 检查 collection（集合）中的 所有 元素是否都返回真值。一旦 predicate（断言函数） 返回假值，迭代就马上停止。
* @param { Array|Object } ary 一个用来迭代的集合。 * @param { Array|Object } ary 一个用来迭代的集合。
* @param { Array|Function|Object|string } func 每次迭代调用的函数。 * @param { Array|Function|Object|string } func 每次迭代调用的函数。
* @returns 如果所有元素经 predicate（断言函数） 检查后都都返回真值，那么就返回true，否则返回 false 。 * @returns 如果所有元素经 predicate（断言函数） 检查后都都返回真值，那么就返回true，否则返回 false 。
*/ */
export function ObjectEvery(ary, func) { export function CollectEvery(ary, func) {
return every(ary,func) return every(ary,func)
} }
/**
* 集合操作函数
* 遍历 collection（集合）元素，返回 predicate（断言函数）返回真值 的所有元素的数组。
* @param { Array|Object } ary 一个用来迭代的集合。
* @param { Array|Function|Object|string } func 每次迭代调用的函数。
* @returns 返回一个新的过滤后的数组。
*/
export function CollectFilter(ary, func) {
return filter(ary,func)
}
/**
* 集合操作函数
* 遍历 collection（集合）元素，返回 predicate（断言函数）第一个返回真值的第一个元素。
* @param { Array|Object } ary 一个用来迭代的集合。
* @param { Array|Function|Object|string } func 每次迭代调用的函数。
* @param { number } num 开始搜索的索引位置。
* @returns 返回匹配元素，否则返回 undefined。
*/
export function CollectFind(ary,func,num) {
return find(ary,func,num)
}
/**
* 集合操作函数
* 遍历 collection（集合）元素，从右至左返回 predicate（断言函数）第一个返回真值的第一个元素。
* @param { Array|Object } ary 一个用来迭代的集合。
* @param { Array|Function|Object|string } func 每次迭代调用的函数。
* @param { number } num 开始搜索的索引位置。
* @returns 返回匹配元素，否则返回 undefined。
*/
export function CollectFindLast(ary, func, num) {
return findLast(ary, func, num)
}
/**
* 集合操作函数
* 创建一个扁平化（注：同阶数组）的数组，这个数组的值来自collection（集合）中的每一个值经过 iteratee（迭代函数） 处理后返回的结果，并且扁平化合并。
* @param { Array|Object } ary 一个用来迭代的集合。
* @param { Array|Function|Object|string } func 每次迭代调用的函数。
* @returns 返回新扁平化数组。
*/
export function CollectFlatMap(ary,func) {
return flatMap(ary,func)
}
/**
* 集合操作函数
* 创建一个扁平化（注：同阶数组）的数组，这个数组的值来自collection（集合）中的每一个值经过 iteratee（迭代函数） 处理后返回的结果，并且多层扁平化合并。
* @param { Array|Object } ary 一个用来迭代的集合。
* @param { Array|Function|Object|string } func 每次迭代调用的函数。
* @returns 返回新扁平化数组。
*/
export function CollectFlatMapDeep(ary,func) {
return flatMapDeep(ary,func)
}
/**
* 集合操作函数
* 创建一个扁平化（注：同阶数组）的数组，这个数组的值来自collection（集合）中的每一个值经过 iteratee（迭代函数） 处理后返回的结果，并且根据指定的 depth（递归深度）继续扁平化递归映射结果
* @param { Array|Object } ary 一个用来迭代的集合。
* @param { Array|Function|Object|string } func 每次迭代调用的函数。
* @param { number } num 最大递归深度。
*/
export function CollectFlatMapDepth(ary,func,num) {
return flatMapDepth(ary,func,num)
}
/**
* 断言操作函数
* 如果 value 不是数组, 那么强制转为数组。
* @param { * } value 要处理的值。
* @returns { Array } 返回转换后的数组。
*/
export function LangCastArray(value) {
return castArray(value)
}
/**
* 断言操作函数
* 创建一个 value 的浅拷贝。
* @param { * } value 要拷贝的值
* @returns 拷贝后的数据
*/
export function LangClone(value) {
return clone(value)
}
/**
* 断言操作函数
* 递归拷贝数据
* @param { * } value 要拷贝的值
* @returns 深拷贝后的数据
*/
export function LangCloneDeep(value) {
return cloneDeep(value)
}
/**
* 断言操作函数
* 深度克隆数据
* @param { * } value 用来递归克隆的值
* @param { Array|Function|Object|string } func 每次迭代调用的函数。
* @returns 返回深度克隆的值
*/
export function LangCloneDeepWith(value,func) {
return cloneDeepWith(value,func)
}
/**
* 断言操作函数
* 递归拷贝数据,它接受一个 customizer 定制返回的克隆值。 如果 customizer 返回 undefined 将会使用拷贝方法代替处理
* @param { * } value 用来递归克隆的值
* @param { Array|Function|Object|string } func 用来自定义克隆的函数。
* @returns 返回克隆值。
*/
export function LangCloneWith(value,func) {
return cloneWith(value,func)
}
/**
* 断言操作函数
* 通过调用断言对象的属性与 对象 的相应属性值，检查对象是否符合 断言。
* @param { Object } obj 要检查的对象。
* @param { Object } obj2 要断言属性是否符合的对象。
* @returns { Object } 如果 object 符合，返回 true，否则 false。
*/
export function LangConformsTo(obj,obj2) {
return conformsTo(obj,obj2)
}
/**
* 断言操作函数
* 比较两者的值，来确定它们是否相等。如果两个值相等返回 true ，否则返回 false 。
* @param { * } value 要比较的值。
* @param { * } other 另一个要比较的值。
* @returns 如果两个值相等返回 true ，否则返回 false 。
*/
export function LangEq(value,other) {
return eq(value,other)
}
/**
* 断言操作函数
* 检查 value 是否是一个类 arguments 对象(伪数组)。
* @param { * } value 要检查的值。
* @returns { Boolean } 如果value是一个 arguments 对象 返回 true，否则返回 false。
*/
export function LangIsArguments(value) {
return isArguments(value)
}
/**
* 断言操作函数
* 检查 value 是否是 Array 类对象。
* @param { * } value 要检查的值。
* @returns { Boolean } 如果value是一个数组返回 true，否则返回 false。
*/
export function LangIsArray(value) {
return LIsArray(value)
}
/**
* 断言操作函数
* 检查 value 是否是 Array 类对象。
* @param { * } value 要检查的值
* @returns { Boolean } 如果value是一个数组 buffer 返回 true，否则返回 false。
*/
export function LangIsArrayBuffer(value) {
return isArrayBuffer(value)
}
/**
* 断言操作函数
* 检查 value 是否是原始 boolean 类型或者对象
* @param { * } value 要检查的值
* @returns { Boolean } 如果 value 是一个布尔对象，那么返回 true，否则返回 false。
*/
export function LangIsBooean(value) {
return isBoolean(value)
}
/**
* 断言操作函数
* 检查 value 是否是 Date 对象。
* @param { * } value 要检查的值
* @returns { Boolean } 如果 value 是一个日期对象，那么返回 true，否则返回 false。
*/
export function LangIsDate(value) {
return isDate(value)
}
/**
* 断言操作函数
* 检查 value 是否是可能是 DOM 元素。
* @param { * } value 要检查的值
* @returns { Boolean } 如果 value 是一个DOM元素，那么返回 true，否则返回 false。
*/
export function LangIsElement(value) {
return isElement(value)
}
/**
* 断言操作函数
* 检查 value 是否为一个空对象，集合，映射或者set。
* @param { * } value 要检查的值
* @returns { Boolean } 如果 value 为空，那么返回 true，否则返回 false。
*/
export function LangIsEmpty(value) {
return isEmpty(value)
}
/**
* 断言操作函数
* 执行深比较来确定两者的值是否相等。
* @param { * } obj 用来比较的值。
* @param { * } obj1 另一个用来比较的值。
* @returns 如果 两个值完全相同，那么返回 true，否则返回 false。
*/
export function LangIsEqual(obj,obj1) {
return isEqual(obj,obj1)
}
/**
* 断言操作函数
* 它接受一个对比函数用来定制比较值。如果对比函数返回 undefined 将会比较处理方法代替。
* @param { * } obj 用来比较的值。
* @param { * } obj1 另一个用来比较的值。
* @param { Function } func 用来定制比较值的函数。
* @returns 如果 两个值完全相同，那么返回 true，否则返回 false。
*/
export function LangIsEqualWith(obj,obj1,func){
return isEqualWith(obj,obj1,func)
}
/**
* 断言操作函数
* 检查 value 是否是 Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, 或者 URIError对象。
* @param { * } value 要检查的值
* @returns 如果 value 是一个错误（Error）对象，那么返回 true，否则返回 false。
*/
export function LangIsError(value) {
return isError(value)
}
/**
* 断言操作函数
* 检查 value 是否是原始有限数值。
* @param { * } value 要检查的值
* @returns 如果 value 是一个有限数值，那么返回 true，否则返回 false。
*/
export function LangIsFinite(value) {
return isFinite(value)
}
/**
* 断言操作函数
* 检查 value 是否是 Function 对象。
* @param { * } value 要检查的值
* @returns 如果 value 是一个函数，那么返回 true，否则返回 false。
*/
export function LangIsFunction(value) {
return isFunction(value)
}
/**
* 断言操作函数
* 检查 value 是否为一个整数。
* @param { * } value 要检查的值
* @returns 如果 value 是一个整数，那么返回 true，否则返回 false。
*/
export function LangIsInteger(value) {
return isInteger(value)
}
/**
* 断言操作函数
* 检查 value 是否为一个 Map 对象。
* @param { * } value 要检查的值
* @returns 如果 value 是一个 Map 对象，那么返回 true，否则返回 false。
*/
export function LangIsMap(value) {
return isMap(value)
}
/**
* 断言操作函数
* 执行一个深度比较，来确定 object 是否含有和 source 完全相等的属性值。
* @param { * } value 要检查的对象。
* @param { * } obj 属性值相匹配的对象。
* @returns 如果object匹配，那么返回 true，否则返回 false。
*/
export function LangIsMatch(value,obj) {
return isMatch(value,obj)
}
/**
* 断言操作函数
* 它接受一个对比函数定制比较的值。 如果对比函数返回 undefined 将会比较处理方法代替
* @param { * } value 要检查的对象。
* @param { * } obj 属性值相匹配的对象。
* @param { * } func 这个函数用来定制比较。
* @returns 如果object匹配，那么返回 true，否则返回 false。
*/
export function LangIsMatchWith(value, obj, func) {
return isMatchWith(value, obj, func)
}
/**
* 断言操作函数
* 检查 value 是否是 NaN。
* @param { * } value 要检查的值
* @returns 如果 value 是一个 NaN，那么返回 true，否则返回 false。
*/
export function LangIsNaN(value) {
return isNaN(value)
}
/**
* 断言操作函数
* 检查 value 是否是一个原生函数。
* @param { * } value 要检查的值
* @returns 如果 value 是一个 原生函数，那么返回 true，否则返回 false。
* core-js 不支持该方法
*/
export function LangIsNative(value) {
return isNative(value)
}
/**
* 断言操作函数
* 检查 value 是否是 null 或者 undefined。
* @param { * } value 要检查的值
* @returns 如果 value 为null 或 undefined，那么返回 true，否则返回 false。
*/
export function LangIsNil(value) {
return isNil(value)
}
/**
* 断言操作函数
* 检查 value 是否是 null
* @param { * } value 要检查的值
* @returns 如果 value 为null，那么返回 true，否则返回 false。
*/
export function LangIsNull(value) {
return isNull(value)
}
/**
* 断言操作函数
* 检查 value 是否是原始Number数值型 或者 对象。
* @param { * } value 要检查的值
* @returns 如果 value 为一个数值，那么返回 true，否则返回 false。
*/
export function LangIsNumber(value){
return isNumber(value)
}
/**
* 断言操作函数
* 检查 value 是否是对象。
* @param { * } value 要检查的值
* @returns 如果 value 为一个对象，那么返回 true，否则返回 false。
*/
export function LangIsObject(value) {
return isObject(value)
}
/**
* 断言操作函数
* 检查 value 是否为RegExp对象。
* @param { * } value 要检查的值
* @returns 如果 value 为一个正则表达式，那么返回 true，否则返回 false。
*/
export function LangIsRegExp(value) {
return isRegExp(value)
}
/**
* 断言操作函数
* 转换 value 为一个数组。
* @param { * } value 要检查的值
* @returns 返回转换后的数组。
*/
export function LangToArray(value) {
return toArray(value)
}
/**
* 断言操作函数
* 转换 value 为一个整数。
* @param { * } value 要转换的值
* @returns 返回转换后的整数。
*/
export function LangToInteger(value) {
return toInteger(value)
}
/**
* 断言操作函数
* 转换 value 为字符串。 null 和 undefined 将返回空字符串。-0 将被转换为字符串"-0"。
* @param { * } value 要转换的值
* @returns 返回字符串。
*/
export function LangToString(value) {
return toString(value)
}
export default List export default List
one_stop_public/tableCompon/index.jsx
浏览文件 @ 2651542b
...@@ -1127,7 +1127,7 @@ export default class tableCom extends Component { ...@@ -1127,7 +1127,7 @@ export default class tableCom extends Component {
}) })
}) })
try { try {
var fun1 = new Function("obj","init", "defaultValues", "env", "index", "fatherCode", "utils","$","routerState", fun); var fun1 = new Function("obj","init", "defaultValues", "env", "index", "fatherCode", "utils","$","routerState",'shareData', fun);
let obj let obj
if(!this.props.isEdit&&this.props.fatherCode){ if(!this.props.isEdit&&this.props.fatherCode){
...@@ -1150,7 +1150,8 @@ export default class tableCom extends Component { ...@@ -1150,7 +1150,8 @@ export default class tableCom extends Component {
render:this.getRender,base64:getBase64, render:this.getRender,base64:getBase64,
}, },
functionObj, functionObj,
this.props.routerState this.props.routerState,
this.props.messageData,
) )
if (base52) { if (base52) {
......
one_stop_public/utils/request.js
浏览文件 @ 2651542b
...@@ -33,12 +33,11 @@ var canReportError = true; ...@@ -33,12 +33,11 @@ var canReportError = true;
const errorHandler = error => { const errorHandler = error => {
const { response } = error; const { response } = error;
console.log(process.env.NODE_ENV)
if (response && response.status) { if (response && response.status) {
const errorText = codeMessage[response.status] || response.statusText; const errorText = codeMessage[response.status] || response.statusText;
notification.error({ notification.error({
message: `请求错误`, message: `请求错误`,
description: process.env.NODE_ENV==='development'? errorText:'', description:errorText,
}); });
if (response.status === 401) { if (response.status === 401) {
...@@ -98,14 +97,14 @@ export const request = (url, data, options = {}) => { ...@@ -98,14 +97,14 @@ export const request = (url, data, options = {}) => {
if (response.errCode || response.errMsg) { if (response.errCode || response.errMsg) {
notification.error({ notification.error({
message: `请求错误`, message: `请求错误`,
description: process.env.NODE_ENV==='development'? response.errMsg:'', description:response.errMsg,
}); });
return; return;
} }
if (response.errcode) { if (response.errcode) {
notification.error({ notification.error({
message: `请求错误`, message: `请求错误`,
description: process.env.NODE_ENV==='development'? response.errmsg:'', description: response.errmsg,
}); });
return; return;
} }
......
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论