indexOf & lastIndexOf
-
underscore中通过内置的工厂函数createIndexFinder来创建一个索引查询器。 -
_.indexOf及_.lastIndexOf正是该函数所创建的。
createIndexFinder(dir, predicateFind, sortedIndex) 接收 3 个参数
-
dir查询方向，_.indexOf是正向查询，_.lastIndexOf是反向查询。 -
predicateFind真值检测函数，该函数只能在查询元素不是数字时（NaN）才会使用。 -
sortedIndex有序数组的索引获得函数。如果设置了该参数，将假定数组已经有序，从而更加高效地通过针对有序数组的查询函数（比如二分查找等）来优化查询性能。
_.indexOf
- _.indexOf(array, item, sorted)：查询
item在array中第一次出现的位置。
// 源码
_.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);
_.indexOf 方法的创建过程中，被传递了 _.findIndex 作为元素的真值预测函数，以及 _.sortedIndex 作为当数组有序时获取索引的方式。
_.lastIndexOf
- _.lastIndexOf(array, item, sorted)：查询 item 在 array 中最后一次出现的位置
// 源码
_.lastIndexOf = createIndexFinder(-1, _findLastIndex);
下面我们开始源码实现：
test.js
(function(root) {
const toString = Object.prototype.toString;
const push = Array.prototype.push;
const _ = function(obj) {
if (obj instanceof _) {
return obj;
}
if (!(this instanceof _)) {
return new _(obj);
}
this._wrapped = obj;
};
const createPredicateIndexFinder = function(dir) {
return function (array, predicate, context) {
predicate = cb(predicate, context);
const length = array.length;
let index = dir > 0? 0 : length - 1;
for (index; index >= 0 && index < length; index += dir) {
if (predicate(array[index], index, array)) {
return index;
}
}
return -1;
};
};
_.findIndex = createPredicateIndexFinder(1);
_.findLastIndex = createPredicateIndexFinder(-1);
// 下面是一个二分查找
_.sortedIndex = function(array, obj, iteratee, context) {
iteratee = cb(iteratee, context, 1);
console.log(iteratee);
const value = iteratee(obj);
let low = 0;
let high = array.length;
while(low < high) {
let mid = Math.floor((low + high) / 2);
if (iteratee(array[mid]) < value) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
};
_.isBoolean = function(obj) {
return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
};
// 判断数据类型为 NaN
_.isNaN = function(obj) {
return _.isNumber(obj) && isNaN(obj);
};
const createIndexFinder = function(dir, predicateFind, sortedIndex) {
return function(array, item, idx) {
let i = 0;
let length = array.length;
// idx 布尔值代表是否是已经排序好的数组
if (sortedIndex && _.isBoolean(idx) && length) {
// 满足条件则使用二分查找
idx = sortedIndex(array, item);
return array[idx] === item ? idx : -1;
}
// 特殊情况 如果要查找的元素是 NaN 类型 NaN !== NaN
if (item != item) {
idx = predicateFind(slice.call(array, i, length), _.isNaN);
return idx >= 0 ? idx + i : -1;
}
// 非上述情况正常遍历
for (idx = dir > 0? i : length -1; idx >=0 && idx < length; idx += dir) {
if (array[idx] === item) return idx;
}
return -1;
};
};
_.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);
_.lastIndexOf = createIndexFinder(-1, _.findLastIndex);
// 以上 ----------------------------------
_.filter = function(obj, predicate, context) {
predicate = cb(predicate, context);
const results = [];
_.each(obj, function(value, index, list) {
if (predicate(value, index, list)) {
results.push(value);
}
});
return results;
};
// （direction）dir 为 1，从左到右累加；dir 为 -1，从右到左累加。
const createReduce = function(dir) {
const reducer = function(obj, iteratee, memo, initial) {
const keys = !_.isArray(obj) && Object.keys(obj);
const length = (keys || obj).length;
let index = dir > 0? 0 : length - 1;
// 如果不包含初始值，则使用 第一个或最后一个值 作为初始化值，并相应移动 index dir 步。
if (!initial) {
memo = obj[keys? keys[index] : index];
index += dir;
}
for (index; index >= 0 && index < length; index += dir) {
const currentKey = keys? keys[index] : index;
memo = iteratee(memo, obj[currentKey], currentKey, obj);
}
return memo;
};
return function(obj, iteratee, memo, context) {
// 如果值的个数大于等于 3，说明存在初始化值
const initial = arguments.length >= 3;
return reducer(obj, optimizeCb(iteratee, context, 4), memo, initial);
};
};
_.reduce = createReduce(1);
_.reduceRight = createReduce(-1);
// rest 参数
_.restArguments = function(func) {
// rest 参数位置
const startIndex = func.length - 1;
return function() {
const length = arguments.length - startIndex;
const rest = Array(length);
// rest 数组中的成员
for (let index = 0; index < length; index++) {
rest[index] = arguments[index + startIndex];
}
// 非 rest 参数成员的值一一对应
const args = Array(startIndex + 1);
for (let index = 0; index < startIndex; index++) {
args[index] = arguments[index];
}
args[startIndex] = rest;
return func.apply(this, args);
};
};
_.isFunction = function(obj) {
return typeof obj === 'function';
};
const cb = function(iteratee, context, count) {
if (iteratee === void 0) {
return _.identity;
}
if (_.isFunction(iteratee)) {
return optimizeCb(iteratee, context, count);
}
};
const optimizeCb = function(func, context, count) {
if (context === void 0) {
return func;
}
switch (count == null ? 3 : count) {
case 1:
return function(value) {
return func.call(context, value);
};
case 3:
return function(value, index, obj) {
return func.call(context, value, index, obj);
};
case 4:
return function(memo, value, index, obj) {
return func.call(context, memo, value, index, obj);
}
}
};
_.identity = function(value) {
return value;
};
_.map = function(obj, iteratee, context) {
// 生成不同功能迭代器
const cbIteratee = cb(iteratee, context);
const keys = !_.isArray(obj) && Object.keys(obj);
const length = (keys || obj).length;
const result = Array(length);
for (let index = 0; index < length; index++) {
const currentKey = keys? keys[index] : index;
result[index] = cbIteratee(obj[currentKey], index, obj);
}
return result;
};
_.unique = function(obj, callback) {
const res = [];
for (let i = 0; i < obj.length; i++) {
const val = callback? callback(obj[i]) : obj[i];
if (res.indexOf(val) === -1) {
res.push(val);
}
}
return res;
};
_.isArray = function(obj) {
return toString.call(obj) === "[object Array]";
};
_.functions = function(obj) {
const res = [];
for (let key in obj) {
res.push(key);
}
return res;
};
_.each = _.forEach = function(obj, iteratee, context) {
iteratee = optimizeCb(iteratee, context);
if (_.isArray(obj)) {
for (let i = 0;i < obj.length; i++) {
iteratee(obj[i], i, obj);
}
} else {
for (let key in obj) {
iteratee(obj[key], key, obj);
}
}
return obj;
};
_.chain = function(obj) {
const instance = _(obj);
instance._chain = true;
return instance;
};
const result = function(instance, obj) {
return instance._chain? _(obj).chain() : obj;
};
_.prototype.value = function() {
return this._wrapped;
};
_.mixin = function(obj) {
_.each(_.functions(obj), (name) => {
const func = obj[name];
_.prototype[name] = function() {
let args = [this._wrapped];
push.apply(args, arguments);
return result(this, func.apply(this, args));
};
});
};
_.mixin(_);
root._ = _;
})(this);
index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>underscore</title>
</head>
<body>
<script src="./test.js"></script>
<script>
console.log(_.indexOf([1,2,3,4,5,6,7,8,9], 3, true));
console.log(_.lastIndexOf([1,2,3,4,5,6,7,8,9], 6));
</script>
</body>
</html>
结果显示如下：
