一、精准判断JavaScript数据类型

在JavaScript开发中，准确判断变量类型是基础且重要的技能。传统typeof操作符对null、数组、日期对象等返回"object"，无法满足精确判断需求。推荐使用Object.prototype.toString.call()配合闭包实现类型判断工厂函数：

function createTypeChecker(type) {
  const targetType = `[object ${type}]`;
  return function(obj) {
    return Object.prototype.toString.call(obj) === targetType;
  };
}
// 使用示例
const isArray = createTypeChecker('Array');
console.log(isArray([])); // true
console.log(isArray({})); // false

注意事项：

参数type需首字母大写（如'Array'而非'array'）
避免检测基本类型（如string/number），因call()会触发装箱操作导致误判
该方案可准确识别内置对象类型，包括Date、RegExp、Map等

二、数组方法的手动实现

1. map方法的两种实现方式

循环实现方案

Array.prototype.selfMap = function(callback, thisArg) {
  const result = [];
  for (let i = 0; i < this.length; i++) {
    if (this.hasOwnProperty(i)) {
      result.push(callback.call(thisArg, this[i], i, this));
    }
  }
  return result;
};

关键点解析：

使用hasOwnProperty过滤稀疏数组的空位
第二个参数thisArg指定回调函数的this绑定
箭头函数因词法绑定会忽略thisArg参数

reduce实现方案

Array.prototype.reduceMap = function(callback, thisArg) {
  return this.reduce((acc, curr, index, array) => {
    return [...acc, callback.call(thisArg, curr, index, array)];
  }, []);
};

2. filter方法的两种实现

循环实现

Array.prototype.selfFilter = function(callback, thisArg) {
  const result = [];
  for (let i = 0; i < this.length; i++) {
    if (this.hasOwnProperty(i) && callback.call(thisArg, this[i], i, this)) {
      result.push(this[i]);
    }
  }
  return result;
};

reduce实现

Array.prototype.reduceFilter = function(callback, thisArg) {
  return this.reduce((acc, curr, index, array) => {
    return callback.call(thisArg, curr, index, array) 
      ? [...acc, curr] 
      : acc;
  }, []);
};

3. some方法的实现要点

Array.prototype.selfSome = function(callback, thisArg) {
  if (this.length === 0) return false; // 空数组特殊处理
  for (let i = 0; i < this.length; i++) {
    if (this.hasOwnProperty(i) && callback.call(thisArg, this[i], i, this)) {
      return true;
    }
  }
  return false;
};

边界条件处理：

空数组直接返回false
找到第一个满足条件的元素立即返回
必须检查hasOwnProperty避免稀疏数组误判

4. reduce方法的完整实现

Array.prototype.selfReduce = function(callback, initialValue) {
  let accumulator = initialValue !== undefined ? initialValue : this[0];
  const startIndex = initialValue !== undefined ? 0 : 1;
  for (let i = startIndex; i < this.length; i++) {
    if (this.hasOwnProperty(i)) {
      accumulator = callback(accumulator, this[i], i, this);
    }
  }
  return accumulator;
};

初始化逻辑：

当提供初始值时，从索引0开始处理
未提供初始值时，使用数组首个元素作为初始值，从索引1开始

三、数组降维的深度实现

1. flat方法的递归实现

Array.prototype.selfFlat = function(depth = 1) {
  if (depth < 1) return this.slice(); // depth=0时返回原数组
  return this.reduce((acc, curr) => {
    if (Array.isArray(curr)) {
      // 递归调用时需绑定this，避免指向全局对象
      return [...acc, ...curr.selfFlat(depth - 1)];
    }
    return [...acc, curr];
  }, []);
};

关键特性：

默认降维深度为1
传入Infinity可完全展平嵌套数组
使用ES6展开运算符或ES5的concat方法
递归调用时必须绑定this指向

2. 性能优化方案

对于大型嵌套数组，可采用迭代方式替代递归：

function flatIterative(arr, depth = 1) {
  const result = [];
  const stack = [[...arr], depth];
  while (stack.length) {
    const [currentArray, currentDepth] = stack.pop();
    for (const item of currentArray) {
      if (Array.isArray(item) && currentDepth > 0) {
        stack.push([item, currentDepth - 1]);
      } else {
        result.push(item);
      }
    }
  }
  return result.reverse(); // 保持原始顺序
}

四、ES6 Class的继承本质

ES6的class语法本质是寄生组合式继承的语法糖，其实现包含三个核心步骤：

原型链继承：
```javascript
function Parent() {}
Parent.prototype.sayHi = function() { console.log(‘Hi’); };

function Child() {}
// 关键步骤：继承原型方法
Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child;


2. **构造函数继承**：
```javascript
function Child() {
  Parent.call(this); // 调用父类构造函数
}

完整实现示例：
```javascript
class Parent {
constructor(name) {
this.name = name;
}

greet() {
console.log(Hello, ${this.name});
}
}

// 等价于以下ES5代码
function ParentES5(name) {
this.name = name;
}
ParentES5.prototype.greet = function() {
console.log(Hello, ${this.name});
};

// Class继承的编译结果
function Child(name) {
Parent.call(this, name); // 构造函数继承
}
Child.prototype = Object.create(Parent.prototype); // 原型链继承
Child.prototype.constructor = Child; // 修复constructor
```

优势分析：

避免传统原型链继承的属性共享问题
消除构造函数继承的重复调用问题
比混入模式（Mix-in）更清晰直观
支持super关键字调用父类方法

五、最佳实践建议

类型判断：优先使用Object.prototype.toString.call()方案，避免instanceof的跨框架问题
数组方法：手动实现时务必处理稀疏数组和this绑定问题
性能优化：对于大型数组操作，考虑使用迭代替代递归
继承设计：复杂场景推荐使用组合模式替代深层继承
ES6迁移：逐步将构造函数模式升级为Class语法，提升代码可读性

通过掌握这些底层实现原理，开发者能够编写出更健壮、高效的JavaScript代码，在处理复杂数据结构和继承关系时游刃有余。这些技术不仅适用于前端开发，在Node.js等后端环境中同样具有重要价值。

JavaScript高级技巧：数组方法实现与ES6特性深度解析