_.chunk函数
我的实现
function chunk(array ,size) {
if (!Array.isArray(array) || typeof size != 'number') {
throw new TypeError('参数类型不正确')
}
let result = [];
let groupResult = [];
for (let i=0; i < array.length; i++) {
groupResult.push(array[i]);
if (i %size == size -1 || i == array.length -1) {
result.push(groupResult);
groupResult = []
}
}
return result
}
别人的实现
function chunk(array, size) {
size = Math.max(size, 0)
const length = array == null ? 0 : array.length
if (!length || size < 1) {
return []
}
let index = 0
let resIndex = 0
const result = new Array(Math.ceil(length / size))
while (index < length) {
result[resIndex++] = slice(array, index, (index += size))
}
return result
}
对比
1.我觉得这一次我的耗时应该比较少吧。哈哈哈哈哈，因为只循环了一遍数组
2.但是有一点，result是可以先定义定长的数组。这一点是不是耗时比push操作耗时少？
3.关于size的判断，我做得不是很好。这里需要学习。
slice 函数
我的实现
function slice(array, start,end) {
if (!Array.isArray(array)) {
throw new TypeError('第一个参数必须是数组')
}
let len = array.length;
if (start < 0) {
start = -start > length ? 0: (start + length)
}
end = end > length ? length: end
if (end < 0) {
end = -end > length ? length : (end + length)
}
let result = []
for (let index=start; index < end ; index++) {
result.push(array[index])
}
return result
}
别人的实现
function slice(array, start, end) {
let length = array == null ? 0 : array.length
if (!length) {
return []
}
start = start == null ? 0 : start
end = end === undefined ? length : end
if (start < 0) {
start = -start > length ? 0 : (length + start)
}
end = end > length ? length : end
if (end < 0) {
end += length
}
length = start > end ? 0 : ((end - start) >>> 0)
start >>>= 0
let index = -1
const result = new Array(length)
while (++index < length) {
result[index] = array[index + start]
}
return result
}
1.>>>符号是？
2.为了搞清楚push方法和loop中index方法，哪个效率高。我查了一下资料。只有一个说push（在chrome上的性能比array[i] 好）。其他都是array[i] 比push快（在重新定义array的情况下）
参考文件
https://stackoverflow.com/questions/21034662/why-push-method-is-significantly-slower-than-putting-values-via-array-indices-in
https://stackoverflow.com/questions/614126/why-is-array-push-sometimes-faster-than-arrayn-value
https://blog.scottlogic.com/2010/10/15/javascript-array-performance.html
https://stackoverflow.com/questions/21034662/why-push-method-is-significantly-slower-than-putting-values-via-array-indices-in
compact函数
我的实现
function compact(array) {
let result = []
for (let index=0; index < array.length; index++) {
if(array[index]) {
result.push(array[index])
}
}
return result
}
compact([0,1,2,null,undefined,false,NaN])
别人的实现
function compact(array) {
let resIndex = 0
const result = []
if (array == null) {
return result
}
for (const value of array) {
if (value) {
result[resIndex++] = value
}
}
return result
}
对比
1.for ...of loop循环，只循环value。
2.result[resIndex++] 来增加元素。
_difference函数
我的实现
function notEqualValues(item, values) {
return item != values
}
function notIncludeValues(item, array) {
return !array.includes(item)
}
function difference(array,values) {
if (!Array.isArray(array)) {
throw new TypeError('第一个参数不是数组')
}
let judgeFn = Array.isArray(values) ? notIncludeValues : notEqualValues
let result = []
let index = 0
for (let i=0; i < array.length;i++) {
if (judgeFn.call(this, array[i], values)) {
result[index++] = array[i]
}
}
return result
}
别人的实现
我大概整理出来的实现如下所示:
function isObjectLike(value) {
return typeof value == 'object' && value !== null
}
function isLength(value) {
return typeof value == 'number' &&
value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER
}
function isArray(value) {
return value !== null && typeof value != 'function' && isLength(value.length)
}
function flatternArray(values) {
let result = [];
for (value of values) {
if (isObjectLike(value) && isArray(value)) {
result.push(...value)
}
}
return result
}
function lodashDifference(array, ...values) {
let newValues = flatternArray(values);
let valuesLength = newValues.length++;
outer:
for (let val of array) {
let valuesIndex = valuesLength
while (valuesIndex--) {
if (newValues[valuesIndex] === val) {
continue outer
}
}
result.push(value)
}
return result
}
总结：
1.判断是否是数组，很奇怪。先判断是否是object，然后用length来判断是否是数组
2.我实现的时候，以为第二个入参可以是value也可以是array。但是其实这个函数，第二个参数只能是array。lodash实现时就非常奇怪。它将array这个参数包裹成二维数组之后，然后再拉平成一维数组（为什么？）而且拉平的一维数组时，用了result.push(...value)，我觉得这个技巧get到了。
3.它用了outer ，看代码的用法时，退出第二层循环，但是不退出第一层循环。很好玩，我再查查.
参考文档：
https://stackoverflow.com/questions/183161/best-way-to-break-from-nested-loops-in-javascript
