@cmtlyt/cl-utils
Version:
422 lines (421 loc) • 14.1 kB
JavaScript
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports", "./baseFunc"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.initial = exports.indexOf = exports.fromPairs = exports.flattenDepth = exports.flattenDeep = exports.flatten = exports.first = exports.head = exports.findLastIndex = exports.findIndex = exports.fill = exports.dropWhile = exports.dropRightWhile = exports.dropRight = exports.drop = exports.differenceWith = exports.differenceBy = exports.difference = exports.concat = exports.compact = exports.chunk = void 0;
const baseFunc_1 = require("./baseFunc");
function _checkType(obj, type) {
const checkFunc = (0, baseFunc_1.checkInString)(type);
if (checkFunc(obj))
return true;
throw new TypeError('参数类型错误');
}
function chunk(arr, size = 1) {
const newArr = [];
if (_checkType(arr, 'array')) {
if (size > 0) {
for (let j = 0; j < arr.length / size; j++) {
const subArr = [];
newArr.push(subArr);
for (let i = j * size; i < (j + 1) * size && i < arr.length; i++) {
subArr.push(arr[i]);
}
}
}
}
return newArr;
}
exports.chunk = chunk;
/**
* 剔除数组中的假值
* @param {array<any>} arr
* @returns {array<any>}
*/
function compact(arr) {
if (_checkType(arr, 'array')) {
const newArr = [];
for (let i = 0; i < arr.length; i++) {
const item = arr[i];
if (!!item && item !== item) {
newArr.push(item);
}
}
return newArr;
}
return arr;
}
exports.compact = compact;
/**
* 拼接数组(不修改原数组)
* @param {any} arrs
* @returns {array<any>}
*/
function concat(...arrs) {
const newArr = [];
for (let i = 0; i < arrs.length; i++) {
const item = arrs[i];
const itemType = (0, baseFunc_1.getType)(item);
if (itemType === 'array') {
for (let j = 0; j < item.length; j++) {
newArr.push(item[j]);
}
}
else {
newArr.push(item);
}
}
return newArr;
}
exports.concat = concat;
/**
* 根据传入的第二个数组过滤原数组返回一个新的数组(不改变原数组)
* @param {Array<any>} arr
* @param {Array<any>} filterArr
* @returns {Array<any>}
*/
function difference(arr, filterArr) {
if (_checkType(arr, 'array') && _checkType(filterArr, 'array')) {
const newArr = [];
for (let i = 0; i < arr.length; i++) {
const item = arr[i];
if (!~filterArr.indexOf(arr[i])) {
newArr.push(item);
}
}
return newArr;
}
return arr;
}
exports.difference = difference;
/**
* 过滤数组,每一项都通过iteratee处理后再匹配(不改变原数组)
* @param {Array<any>} arr
* @param {Array<any>} filterArr
* @param {function} iteratee
* @returns {Array<any>}
*
* todo iteratee提供Object,String,Array匹配支持
*/
function differenceBy(arr, filterArr, iteratee) {
if (_checkType(arr, 'array') && _checkType(filterArr, 'array') && _checkType(iteratee, 'function')) {
const newArr = [];
const _filterArray = [];
for (let j = 0; j < filterArr.length; j++) {
_filterArray.push(iteratee(filterArr[j]));
}
for (let i = 0; i < arr.length; i++) {
const item = iteratee(arr[i]);
if (!~_filterArray.indexOf(item)) {
newArr.push(arr[i]);
}
}
return newArr;
}
return arr;
}
exports.differenceBy = differenceBy;
function differenceWith(arr, filterArr, comparator) {
if (_checkType(arr, 'array') && _checkType(filterArr, 'array') && _checkType(comparator, 'function')) {
const newArr = [];
for (let i = 0; i < arr.length; i++) {
const item = arr[i];
for (let j = 0; j < filterArr.length; j++) {
if (comparator(item, filterArr[j])) {
newArr.push(item);
}
}
}
return newArr;
}
return arr;
}
exports.differenceWith = differenceWith;
/**
* 创建一个切片数组，去除array前面的n个元素。（n默认值为1。）
* @param {Array<any>} arr
* @param {number} skip
* @returns {Array<any>}
*/
function drop(arr, skip = 1) {
if (_checkType(arr, 'array') && _checkType(skip, 'number')) {
const newArr = [];
for (let i = skip; i < arr.length; i++) {
newArr.push(arr[i]);
}
return newArr;
}
return arr;
}
exports.drop = drop;
/**
* 创建一个切片数组，去除array尾部的n个元素。（n默认值为1。）
* @param {Array<any>} arr
* @param {number} skip
* @returns {Array<any>}
*/
function dropRight(arr, skip = 1) {
if (_checkType(arr, 'array') && _checkType(skip, 'number')) {
const newArr = [];
for (let i = 0; i < arr.length - skip; i++) {
newArr.push(arr[i]);
}
return newArr;
}
return arr;
}
exports.dropRight = dropRight;
/**
* 创建一个切片数组，去除array中从 predicate 返回假值开始到尾部的部分。predicate 会传入3个参数： (value, index, array)。
* @param {Array<any>} arr
* @param {Function} predicate
* @returns {Array<any>}
*/
function dropRightWhile(arr, predicate) {
if (_checkType(arr, 'array') && _checkType(predicate, 'function')) {
let flag = true;
const newArr = [];
for (let i = 0; i < arr.length; i++) {
flag = predicate(arr[i], i, arr);
if (flag) {
newArr.push(arr[i]);
}
else {
break;
}
}
return newArr;
}
return arr;
}
exports.dropRightWhile = dropRightWhile;
/**
* 创建一个切片数组，去除array中从起点开始到 predicate 返回假值结束部分。predicate 会传入3个参数： (value, index, array)。
* @param {Array<any>} arr
* @param {Function} predicate
* @returns {Array<any>}
*/
function dropWhile(arr, predicate) {
if (_checkType(arr, 'array') && _checkType(predicate, 'function')) {
const newArr = [];
let i = 0;
for (; i < arr.length; i++) {
const flag = predicate(arr[i], i, arr);
if (!flag) {
break;
}
}
for (; i < arr.length; i++) {
newArr.push(arr[i]);
}
return newArr;
}
return arr;
}
exports.dropWhile = dropWhile;
/**
* 使用 value 值来填充（替换） array，从start位置开始, 到end位置结束（但不包含end位置）。
* @param {Array<any>} arr
* @param {any} value
* @param {number} start
* @param {number} end
* @returns {Array<any>}
*/
function fill(arr, value, start = 0, end = arr.length) {
if (_checkType(arr, 'array') && _checkType(start, 'number') && _checkType(end, 'number')) {
for (let i = start; i < end; i++) {
arr[i] = value;
}
}
return arr;
}
exports.fill = fill;
/**
* 该方法类似_.find，区别是该方法返回第一个通过 predicate 判断为真值的元素的索引值（index），而不是元素本身。
* @param {Array<any>} arr
* @param {Function} predicate
* @param {number} formIndex
* @returns {Array<any>}
*
* todo predicate 提供Object,String,Array匹配支持
*/
function findIndex(arr, predicate, formIndex = 0) {
if (_checkType(arr, 'array') && _checkType(predicate, 'function') && _checkType(formIndex, 'number')) {
for (let i = formIndex; i < arr.length; i++) {
if (predicate(arr[i], i, arr)) {
return i;
}
}
}
return -1;
}
exports.findIndex = findIndex;
/**
* 这个方式类似_.findIndex， 区别是它是从右到左的迭代集合array中的元素。
* @param {Array<any>} arr
* @param {Function} predicate
* @param {number} formIndex
* @returns {Array<any>}
*
* todo predicate 提供Object,String,Array匹配支持
*/
function findLastIndex(arr, predicate, formIndex = arr.length - 1) {
if (_checkType(arr, 'array') && _checkType(predicate, 'function') && _checkType(formIndex, 'number')) {
for (let i = formIndex; i > -1; i--) {
if (predicate(arr[i], i, arr)) {
return i;
}
}
}
return -1;
}
exports.findLastIndex = findLastIndex;
/**
* 获取数组 array 的第一个元素。
* @param {Array<any>} arr
* @returns {any}
*/
function head(arr) {
if (_checkType(arr, 'array')) {
return arr[0];
}
return undefined;
}
exports.head = head;
/**
* 获取数组 array 的第一个元素。
* @param {Array<any>} arr
* @returns {any}
*/
exports.first = head;
/**
* 减少一级array嵌套深度。
* @param {Array} arr
* @returns {Array}
*/
function flatten(arr) {
if (_checkType(arr, 'array')) {
const newArr = [];
for (let i = 0; i < arr.length; i++) {
const item = arr[i];
if ((0, baseFunc_1.getType)(item) === 'array') {
for (let j = 0; j < item.length; j++) {
newArr.push(item[j]);
}
}
newArr.push(item);
}
return newArr;
}
return arr;
}
exports.flatten = flatten;
/**
* 将array递归为一维数组。
* @param {Array} arr
* @returns {Array}
*/
function flattenDeep(arr) {
if (_checkType(arr, 'array')) {
const newArr = [];
const _flat = (arr) => {
for (let i = 0; i < arr.length; i++) {
const item = arr[i];
if ((0, baseFunc_1.getType)(item) === 'array') {
_flat(item);
}
else {
newArr.push(item);
}
}
};
_flat(arr);
return newArr;
}
return arr;
}
exports.flattenDeep = flattenDeep;
/**
* 根据 depth 递归减少 array 的嵌套层级
* @param {Array} arr
* @param {number} depth
* @returns {Array}
*/
function flattenDepth(arr, depth = 1) {
if (_checkType(arr, 'array')) {
const newArr = [];
const _flat = (arr, depth) => {
for (let i = 0; i < arr.length; i++) {
const item = arr[i];
if ((0, baseFunc_1.getType)(item) === 'array' && depth > 0) {
_flat(item, depth - 1);
}
else {
newArr.push(item);
}
}
};
_flat(arr, depth);
return newArr;
}
return arr;
}
exports.flattenDepth = flattenDepth;
/**
* 与_.toPairs正好相反；这个方法返回一个由键值对pairs构成的对象。
* @param {Array} pairs
* @returns {Object}
*/
function fromPairs(pairs) {
const newObj = {};
if (_checkType(pairs, 'array')) {
for (let i = 0; i < pairs.length; i++) {
const [key, value] = pairs[i];
newObj[key] = value;
}
}
return newObj;
}
exports.fromPairs = fromPairs;
/**
* 使用SameValueZero 等值比较，返回首次 value 在数组array中被找到的 索引值， 如果 fromIndex 为负值，将从数组array尾端索引进行匹配。
* @param {Array} arr
* @param {any} value
* @param {number} formIndex
* @returns {number}
*/
function indexOf(arr, value, formIndex = 0) {
if (_checkType(arr, 'array') && _checkType(formIndex, 'number')) {
for (let i = formIndex; i < arr.length; i++) {
const item = arr[i];
if (item === value) {
return i;
}
}
}
return -1;
}
exports.indexOf = indexOf;
/**
* 获取数组array中除了最后一个元素之外的所有元素（注：去除数组array中的最后一个元素）。
* @param {Array} arr
* @returns {Array}
*/
function initial(arr) {
if (_checkType(arr, 'array')) {
const newArr = [];
for (let i = 0; i < arr.length - 1; i++) {
newArr.push(arr[i]);
}
return newArr;
}
return arr;
}
exports.initial = initial;
});