JavaScript夯实基础

console.log('1');
 
setTimeout(() => {
  console.log('2');
  Promise.resolve().then(() => console.log('3'));
}, 0);
 
Promise.resolve().then(() => {
  console.log('4');
  setTimeout(() => console.log('5'), 0);
});
 
console.log('6');
 
// 输出顺序：1 6 4 2 3 5

class MyPromise {
  /**
   * 构造函数，接收一个执行器函数(executor)
   * @param {Function} executor - 包含resolve和reject两个参数的函数
   */
  constructor(executor) {
    // 初始状态为pending
    this.state = 'pending';
    // 存储成功或失败的值
    this.value = undefined;
    // 存储成功回调函数数组
    this.onFulfilledCallbacks = [];
    // 存储失败回调函数数组
    this.onRejectedCallbacks = [];
 
    /**
     * 定义resolve函数
     * @param {any} value - 要解析的值
     */
    const resolve = (value) => {
      // 如果解析的值是Promise，则等待这个Promise解决
      if (value instanceof MyPromise) {
        return value.then(resolve, reject);
      }
      
      // 只有pending状态可以转换为fulfilled
      if (this.state === 'pending') {
        this.state = 'fulfilled';
        this.value = value;
        // 执行所有成功回调
        this.onFulfilledCallbacks.forEach(fn => fn());
      }
    };
 
    /**
     * 定义reject函数
     * @param {any} reason - 拒绝原因
     */
    const reject = (reason) => {
      // 只有pending状态可以转换为rejected
      if (this.state === 'pending') {
        this.state = 'rejected';
        this.value = reason;
        // 执行所有失败回调
        this.onRejectedCallbacks.forEach(fn => fn());
      }
    };
 
    // 立即执行executor函数
    try {
      // 传入resolve和reject函数
      executor(resolve, reject);
    } catch (err) {
      // 如果执行器抛出错误，直接reject
      reject(err);
    }
  }
 
  /**
   * then方法，接收两个可选参数：onFulfilled和onRejected
   * @param {Function} onFulfilled - 成功回调
   * @param {Function} onRejected - 失败回调
   * @returns {MyPromise} 返回一个新的Promise
   */
  then(onFulfilled, onRejected) {
    // 创建新的Promise实例以实现链式调用
    const promise2 = new MyPromise((resolve, reject) => {
      /**
       * 处理成功情况的函数
       */
      const handleFulfilled = () => {
        // 使用queueMicrotask确保异步执行
        queueMicrotask(() => {
          try {
            // 如果onFulfilled是函数则执行它，否则直接传递值
            const x = typeof onFulfilled === 'function' 
              ? onFulfilled(this.value)
              : this.value;
            // 解析返回的值
            this.resolvePromise(promise2, x, resolve, reject);
          } catch (err) {
            // 如果回调函数抛出错误，reject新Promise
            reject(err);
          }
        });
      };
 
      /**
       * 处理失败情况的函数
       */
      const handleRejected = () => {
        // 使用queueMicrotask确保异步执行
        queueMicrotask(() => {
          try {
            // 如果onRejected是函数则执行它，否则直接传递原因
            const x = typeof onRejected === 'function' 
              ? onRejected(this.value)
              : this.value;
            // 解析返回的值
            this.resolvePromise(promise2, x, resolve, reject);
          } catch (err) {
            // 如果回调函数抛出错误，reject新Promise
            reject(err);
          }
        });
      };
 
      // 根据当前状态决定如何处理
      if (this.state === 'fulfilled') {
        // 如果已经是fulfilled状态，异步执行回调
        handleFulfilled();
      } else if (this.state === 'rejected') {
        // 如果已经是rejected状态，异步执行回调
        handleRejected();
      } else {
        // 如果是pending状态，将回调函数存入数组
        this.onFulfilledCallbacks.push(handleFulfilled);
        this.onRejectedCallbacks.push(handleRejected);
      }
    });
 
    return promise2;
  }
 
  /**
   * 解析Promise返回值的方法
   * @param {MyPromise} promise2 - 新的Promise实例
   * @param {any} x - then回调返回的值
   * @param {Function} resolve - 新Promise的resolve函数
   * @param {Function} reject - 新Promise的reject函数
   */
  resolvePromise(promise2, x, resolve, reject) {
    // 如果返回的Promise和then返回的Promise相同，抛出循环引用错误
    if (promise2 === x) {
      return reject(new TypeError('Chaining cycle detected for promise'));
    }
 
    // 如果x是Promise实例，则等待它的结果
    if (x instanceof MyPromise) {
      x.then(resolve, reject);
    } 
    // 如果x是对象或函数，可能是一个thenable对象
    else if (typeof x === 'object' && x !== null || typeof x === 'function') {
      let then;
      try {
        // 尝试获取x的then方法
        then = x.then;
      } catch (err) {
        // 如果获取then方法时出错，reject
        return reject(err);
      }
 
      // 如果then是函数，则认为x是thenable对象
      if (typeof then === 'function') {
        let called = false; // 防止多次调用
        try {
          // 调用then方法
          then.call(
            x,
            // 成功回调
            y => {
              if (called) return;
              called = true;
              // 递归解析y
              this.resolvePromise(promise2, y, resolve, reject);
            },
            // 失败回调
            r => {
              if (called) return;
              called = true;
              reject(r);
            }
          );
        } catch (err) {
          if (called) return;
          reject(err);
        }
      } else {
        // 普通对象，直接resolve
        resolve(x);
      }
    } else {
      // 基本类型值，直接resolve
      resolve(x);
    }
  }
 
  /**
   * catch方法 - 错误处理快捷方式
   * @param {Function} onRejected - 失败回调
   * @returns {MyPromise} 返回一个新的Promise
   */
  catch(onRejected) {
    return this.then(null, onRejected);
  }
 
  /**
   * finally方法 - 无论成功失败都会执行
   * @param {Function} callback - 回调函数
   * @returns {MyPromise} 返回一个新的Promise
   */
  finally(callback) {
    return this.then(
      // 成功情况
      value => MyPromise.resolve(callback()).then(() => value),
      // 失败情况
      reason => MyPromise.resolve(callback()).then(() => { throw reason })
    );
  }
 
  /**
   * 静态resolve方法
   * @param {any} value - 要解析的值
   * @returns {MyPromise} 返回一个已解决的Promise
   */
  static resolve(value) {
    // 如果已经是Promise实例，直接返回
    if (value instanceof MyPromise) {
      return value;
    }
    // 否则创建新的已解决Promise
    return new MyPromise(resolve => resolve(value));
  }
 
  /**
   * 静态reject方法
   * @param {any} reason - 拒绝原因
   * @returns {MyPromise} 返回一个已拒绝的Promise
   */
  static reject(reason) {
    return new MyPromise((_, reject) => reject(reason));
  }
 
  /**
   * 静态all方法
   * @param {Iterable} promises - 可迭代的Promise集合
   * @returns {MyPromise} 返回一个新的Promise
   */
  static all(promises) {
    return new MyPromise((resolve, reject) => {
      const results = []; // 存储结果
      let completed = 0;  // 完成计数器
      
      // 空数组直接resolve
      if (promises.length === 0) {
        return resolve(results);
      }
 
      // 遍历所有Promise
      promises.forEach((promise, index) => {
        // 确保每个值都是Promise
        MyPromise.resolve(promise).then(
          // 成功处理
          value => {
            results[index] = value; // 按索引存储结果
            completed++;
            // 全部完成时resolve
            if (completed === promises.length) {
              resolve(results);
            }
          },
          // 任何一个失败立即reject
          reject
        );
      });
    });
  }
 
  /**
   * 静态race方法
   * @param {Iterable} promises - 可迭代的Promise集合
   * @returns {MyPromise} 返回一个新的Promise
   */
  static race(promises) {
    return new MyPromise((resolve, reject) => {
      // 遍历所有Promise
      promises.forEach(promise => {
        // 确保每个值都是Promise
        MyPromise.resolve(promise).then(
          // 第一个解决或拒绝的结果决定race的结果
          resolve,
          reject
        );
      });
    });
  }
 
  /**
   * 静态allSettled方法
   * @param {Iterable} promises - 可迭代的Promise集合
   * @returns {MyPromise} 返回一个新的Promise
   */
  static allSettled(promises) {
    return new MyPromise(resolve => {
      const results = []; // 存储结果
      let completed = 0;  // 完成计数器
      
      // 空数组直接resolve
      if (promises.length === 0) {
        return resolve(results);
      }
 
      // 遍历所有Promise
      promises.forEach((promise, index) => {
        // 确保每个值都是Promise
        MyPromise.resolve(promise).then(
          // 成功处理
          value => {
            results[index] = { status: 'fulfilled', value };
            completed++;
            // 全部完成时resolve
            if (completed === promises.length) {
              resolve(results);
            }
          },
          // 失败处理
          reason => {
            results[index] = { status: 'rejected', reason };
            completed++;
            // 全部完成时resolve
            if (completed === promises.length) {
              resolve(results);
            }
          }
        );
      });
    });
  }
 
  /**
   * 静态any方法
   * @param {Iterable} promises - 可迭代的Promise集合
   * @returns {MyPromise} 返回一个新的Promise
   */
  static any(promises) {
    return new MyPromise((resolve, reject) => {
      const errors = []; // 存储所有错误
      let rejected = 0;  // 拒绝计数器
      
      // 空数组直接reject
      if (promises.length === 0) {
        return reject(new AggregateError([], 'All promises were rejected'));
      }
 
      // 遍历所有Promise
      promises.forEach((promise, index) => {
        // 确保每个值都是Promise
        MyPromise.resolve(promise).then(
          // 任何一个成功立即resolve
          resolve,
          // 失败处理
          reason => {
            errors[index] = reason; // 存储错误
            rejected++;
            // 全部失败时reject
            if (rejected === promises.length) {
              reject(new AggregateError(errors, 'All promises were rejected'));
            }
          }
        );
      });
    });
  }
}

function memoize(fn, resolver) {
  // 使用WeakMap保存缓存，键为this对象时更安全
  const cache = new Map();
  
  const memoized = function(...args) {
    // 生成缓存key：使用resolver或直接JSON.stringify
    const key = resolver 
      ? resolver.apply(this, args)
      : JSON.stringify(args);
    
    // 检查缓存
    if (cache.has(key)) {
      return cache.get(key);
    }
    
    // 执行原函数并缓存结果
    const result = fn.apply(this, args);
    cache.set(key, result);
    return result;
  };
  
  // 允许手动清除缓存
  memoized.clear = () => cache.clear();
  
  return memoized;
}
 
// 测试用例
const add = (a, b) => {
  console.log('Calculating...');
  return a + b;
};
 
const memoizedAdd = memoize(add);
console.log(memoizedAdd(1, 2)); // Calculating... 3
console.log(memoizedAdd(1, 2)); // 3 (from cache)
 
// 带对象参数的案例
const getUser = memoize(
  (userId, obj) => ({...obj, id: userId}),
  (userId, obj) => `user-${userId}-${obj.lang}`
);
 
console.log(getUser(1, {lang: 'en'})); // Calculating...
console.log(getUser(1, {lang: 'en'})); // From cache

class Scheduler {
  constructor(concurrency) {
    this.max = concurrency;
    this.queue = [];
    this.running = 0;
  }
 
  add(promiseCreator) {
    return new Promise((resolve, reject) => {
      // 包装任务以处理执行和计数
      const task = () => {
        this.running++;
        promiseCreator()
          .then(resolve)
          .catch(reject)
          .finally(() => {
            this.running--;
            this.next();
          });
      };
      
      // 根据当前运行数量决定立即执行或入队
      if (this.running < this.max) {
        task();
      } else {
        this.queue.push(task);
      }
    });
  }
 
  next() {
    if (this.queue.length > 0 && this.running < this.max) {
      const task = this.queue.shift();
      task();
    }
  }
}
 
// 测试用例
const timeout = (time) => new Promise(r => setTimeout(r, time));
 
const scheduler = new Scheduler(2);
const addTask = (time, order) => {
  scheduler.add(() => timeout(time))
    .then(() => console.log(order));
};
 
addTask(1000, '1');
addTask(500, '2');
addTask(300, '3');
addTask(400, '4');
// 输出：2 3 1 4

function isEqual(obj1, obj2) {
  // 基本类型直接比较
  if (obj1 === obj2) return true;
  
  // 处理null/undefined
  if (obj1 == null || obj2 == null) {
    return obj1 === obj2;
  }
  
  // 类型不同直接返回false
  if (Object.prototype.toString.call(obj1) !== 
      Object.prototype.toString.call(obj2)) {
    return false;
  }
  
  // 处理Date/RegExp等特殊对象
  if (obj1 instanceof Date) return +obj1 === +obj2;
  if (obj1 instanceof RegExp) return obj1.toString() === obj2.toString();
  
  // 处理原始值包装对象
  if (typeof obj1 !== 'object') return obj1 === obj2;
  
  // 处理数组
  if (Array.isArray(obj1)) {
    if (obj1.length !== obj2.length) return false;
    return obj1.every((item, i) => isEqual(item, obj2[i]));
  }
  
  // 处理普通对象
  const keys1 = Object.keys(obj1);
  const keys2 = Object.keys(obj2);
  
  if (keys1.length !== keys2.length) return false;
  
  return keys1.every(key => {
    // 递归比较每个属性
    return isEqual(obj1[key], obj2[key]);
  });
}
 
// 测试用例
console.log(isEqual(
  { a: 1, b: { c: [1,2,3], d: new Date('2020-01-01') } },
  { a: 1, b: { c: [1,2,3], d: new Date('2020-01-01') } }
)); // true
 
console.log(isEqual(
  { a: 1, b: { c: [1,2,3] } },
  { a: 1, b: { c: [1,2,4] } }
)); // false

<body>
  <button id="create">创建闭包泄漏</button>
  <button id="release">释放闭包</button>
  <script>
    let closureLeak;                // ① 全局变量始终引用闭包
    document.getElementById('create').onclick = () => {
      const big = new Array(1e6).fill('leak');  // ~8 MB
      closureLeak = function () {                // ② 内部函数被长期持有
        console.log(big.length);                 // ③ big 无法被 GC
      };
    };
    document.getElementById('release').onclick = () => {
      closureLeak = null;          // ④ 解除引用 → 稍后 GC
    };
  </script>
</body>

<ul id="list"></ul>
<button id="add">新增 li</button>
<button id="clear">清空 DOM</button>
<script>
  const cache = {};                   // ① 手动缓存
  let counter = 0;
  document.getElementById('add').onclick = () => {
    const li = document.createElement('li');
    li.textContent = 'item ' + (++counter);
    cache[counter] = li;              // ② 强引用
    document.getElementById('list').appendChild(li);
  };
  document.getElementById('clear').onclick = () => {
    document.getElementById('list').innerHTML = ''; // ③ 节点脱离文档
    // cache 未清理 → 节点仍存活
  };
</script>

document.getElementById('clear').onclick = () => {
  document.getElementById('list').innerHTML = '';
  Object.keys(cache).forEach(k => delete cache[k]); // 解除引用
};

import React, {
  useState,
  useRef,
  useEffect,
  useCallback,
  useMemo,
} from "react";
 
interface VirtualListProps<T> {
  data: T[]; // 数据源
  renderItem: (item: T, index: number) => React.ReactNode; // 单项渲染函数
  estimatedItemHeight?: number; // 预估行高（动态高度必传）
  bufferSize?: number; // 缓冲区大小
  className?: string;
}
 
/**
 * 高性能虚拟滚动列表
 * 核心功能：
 * 1. 仅渲染可视区域内的元素
 * 2. 支持动态高度（自动测量）
 * 3. Intersection Observer优化滚动性能
 * 4. DOM节点回收复用
 */
function VirtualList<T>({
  data,
  renderItem,
  estimatedItemHeight = 50,
  bufferSize = 3,
  className,
}: VirtualListProps<T>) {
  const containerRef = useRef<HTMLDivElement>(null);
  const itemRefs = useRef<Map<number, HTMLDivElement>>(new Map()); // 存储已渲染的DOM节点
  const [visibleRange, setVisibleRange] = useState({ start: 0, end: 0 });
  const [itemPositions, setItemPositions] = useState<number[]>([]); // 每个元素的位置缓存
 
  // 1. 初始化位置缓存（基于预估高度）
  const initPositions = useCallback(() => {
    const positions = [0];
    for (let i = 1; i <= data.length; i++) {
      positions[i] = positions[i - 1] + estimatedItemHeight;
    }
    setItemPositions(positions);
  }, [data.length, estimatedItemHeight]);
 
  // 2. 动态更新元素位置（实际测量高度）
  const updateItemPosition = useCallback(
    (index: number, height: number) => {
      if (Math.abs(itemPositions[index + 1] - itemPositions[index] - height) < 1) {
        return; // 高度无变化时不更新
      }
 
      setItemPositions((prev) => {
        const newPositions = [...prev];
        const diff = height - (newPositions[index + 1] - newPositions[index]);
        for (let i = index + 1; i <= data.length; i++) {
          newPositions[i] += diff;
        }
        return newPositions;
      });
    },
    [data.length, itemPositions]
  );
 
  // 3. 计算当前可视区域
  const calculateVisibleRange = useCallback(() => {
    if (!containerRef.current) return;
 
    const { scrollTop, clientHeight } = containerRef.current;
    const startIdx = findNearestIndex(itemPositions, scrollTop);
    const endIdx = findNearestIndex(itemPositions, scrollTop + clientHeight);
 
    setVisibleRange({
      start: Math.max(0, startIdx - bufferSize),
      end: Math.min(data.length - 1, endIdx + bufferSize),
    });
  }, [itemPositions, bufferSize, data.length]);
 
  // 4. 使用Intersection Observer监听可视区域变化
  useEffect(() => {
    const observer = new IntersectionObserver(
      (entries) => {
        entries.forEach((entry) => {
          if (entry.isIntersecting || entry.intersectionRatio > 0) {
            calculateVisibleRange();
          }
        });
      },
      {
        root: containerRef.current,
        rootMargin: `${bufferSize * estimatedItemHeight}px`,
        threshold: 0.1,
      }
    );
 
    // 观察底部哨兵元素
    const sentinel = document.createElement("div");
    sentinel.style.position = "absolute";
    sentinel.style.bottom = "0";
    sentinel.style.height = "1px";
    containerRef.current?.appendChild(sentinel);
    observer.observe(sentinel);
 
    return () => {
      observer.disconnect();
      containerRef.current?.removeChild(sentinel);
    };
  }, [calculateVisibleRange, bufferSize, estimatedItemHeight]);
 
  // 5. 初始化位置和可视区域
  useEffect(() => {
    initPositions();
    calculateVisibleRange();
  }, [initPositions, calculateVisibleRange]);
 
  // 6. 渲染可视区域内的元素
  const visibleItems = useMemo(() => {
    const items = [];
    for (let i = visibleRange.start; i <= visibleRange.end; i++) {
      items.push(
        <div
          key={i}
          ref={(node) => {
            if (node) {
              itemRefs.current.set(i, node);
              // 动态高度测量
              if (estimatedItemHeight > 0) {
                const realHeight = node.getBoundingClientRect().height;
                updateItemPosition(i, realHeight);
              }
            } else {
              itemRefs.current.delete(i);
            }
          }}
          style={{
            position: "absolute",
            top: `${itemPositions[i]}px`,
            width: "100%",
          }}
        >
          {renderItem(data[i], i)}
        </div>
      );
    }
    return items;
  }, [
    visibleRange,
    data,
    renderItem,
    itemPositions,
    updateItemPosition,
    estimatedItemHeight,
  ]);
 
  return (
    <div
      ref={containerRef}
      className={`virtual-list ${className}`}
      style={{
        height: "100%",
        overflowY: "auto",
        position: "relative",
        transform: "translateZ(0)", // GPU加速
      }}
      onScroll={calculateVisibleRange}
    >
      {/* 撑开容器高度的占位元素 */}
      <div
        style={{
          height: `${itemPositions[data.length] || 0}px`,
          position: "relative",
        }}
      >
        {visibleItems}
      </div>
    </div>
  );
}
 
/** 二分查找最近的元素索引（性能关键） */
function findNearestIndex(arr: number[], value: number): number {
  let low = 0;
  let high = arr.length - 1;
  while (low <= high) {
    const mid = Math.floor((low + high) / 2);
    if (arr[mid] === value) return mid;
    if (arr[mid] < value) {
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }
  return low;
}
 
export default React.memo(VirtualList);
 

console.log(a);     // 输出: undefined (变量提升)
var a = 1;
function a() {}     // 函数声明提升并覆盖变量a
console.log(a);     // 输出: 1 (赋值覆盖函数)
 
// 预编译后的等效代码：
/*
function a() {}
var a;
console.log(a); // 此时a是函数
a = 1;
console.log(a);
*/

function test(b) {
  console.log(b);    // 输出: function b() {} (函数声明覆盖形参)
  var b = 2;
  console.log(b);    // 输出: 2 (赋值覆盖)
  function b() {}    // 提升到AO顶部
}
test(1);
 
// 预编译后的等效代码：
/*
function test(b) {
  function b() {}    // 函数声明提升
  var b;             // 已存在同名函数，忽略
  b = 1;             // 形参赋值
  console.log(b);    // 输出函数
  b = 2;             // 重新赋值
  console.log(b);
}
*/

console.log(c); // ReferenceError
let c = 3;

foo(); // TypeError: foo is not a function
var foo = function() {};

var x = 1;
function foo(
  x,
  y = function() { x = 2; }
) {
  var x = 3;
  y();
  console.log(x); // 输出: 3
}
foo();
console.log(x);   // 输出: 1
 
/*
解析：
1. 函数参数作用域与函数体作用域分离
2. y()修改的是参数x（=2），而内部var x=3是新的局部变量
3. 最外层的x未被影响
*/

function myMap(arr, callback) {
  // 检查参数是否正确
  if (!Array.isArray(arr) || !arr.length || typeof callback !== 'function') {
      return [];
  } else {
      let result = [];
      for (let i = 0, len = arr.length; i < len; i++) {
          result.push(callback(arr[i], i, arr))
      }
      return result
  }
}

const _instanceof = (target, Fn) => {
    if ((typeof target !== 'object' && typeof target !== 'function') || target === null)
        return false;
 
    let proto = target.__proto__
    while (true) {
        if (proto === null) return false
        if (proto === Fn.prototype) return true
        proto = proto.__proto__
    }
}
 
function A() {}
const a = new A()
console.log(_instanceof(a, A)) // true
console.log(_instanceof(1, A)) // false

var name = '公众号：前端技术营';
var obj = {
    name: '张三'
};
 
function fn(a, b, c) {
    console.log(`${a} ${b} ${c} ${this.name}`);
};
// 模拟apply
Function.prototype.myApply = function(){
  let target = arguments[0]|| window || global;
  target.fn = this;
  let args = Array.from(arguments)[1];
  let result = target.fn(...args);
  delete target.fn;
  return result;
}
 
fn.myApply(obj, ['my', 'name', 'is']); // my name is 张三
fn.myApply(null, ['my', 'name', 'is']); // my name is 公众号：前端技术营
fn.myApply(undefined, ['my', 'name', 'is']); // my name is 公众号：前端技术营

var name = '公众号：前端技术营';
var obj = {
    name: '张三'
};
 
function fn(a, b, c) {
    console.log(`${a} ${b} ${c} ${this.name}`);
};
// 模拟call
Function.prototype.myBind = function(context) {
    const _this = this
    const args = [...arguments].slice(1);
    // 返回一个函数
    return function F() {
        // 因为返回了一个函数，我们可以 new F()，所以需要判断
        if (this instanceof F) {
            // 忽略传入的this
            return new _this(...args, ...arguments)
        }
        // 直接调用，将两边的参数拼接起来
 
        return _this.apply(context, args.concat(...arguments))
    }
}
 
const fn1 = fn.myBind(obj, 'my', 'name', 'is');
fn1(); // my name is 张三
 
const fn2 = fn.myBind(null, 'my', 'name', 'is');
fn2(); // my name is 公众号：前端技术营
 
const fn3 = fn.myBind(undefined, 'my', 'name', 'is');
fn3(); // my name is 公众号：前端技术营

function myNew() {
    // 创建一个空对象
    let obj = new Object();
    // shift删除数组第一个元素，并返回一个元素。原有arguments数组第一个参数是构造函数，返回值为构造函数。
    const Constructor = [].shift.call(arguments);
    // 将 obj 的原型指向构造函数，这样 obj 就可以访问到构造函数原型中的属性
    obj.__proto__ = Constructor.prototype;
    // 执行构造函数的方法
    const ret = Constructor.apply(obj, arguments);
    // 返回构造函数中有返回值且返回值是个引用类型，没有返回值则默认返回这个对象
    return typeof ret === 'object' ? ret : obj;
}
 
function Person(name, age) {
    this.name = name;
    this.age = age
    // 模拟有返回值且是个对象
    return {
        name: name,
        address: '上海市浦东新区'
    };
}
 
const a = myNew(Person, '公众号：前端技术营', 18);
console.log(a.name); // 公众号：前端技术营
console.log(a.address); // 上海市浦东新区
console.log(a.age); // undefined

function curry(fn, args) {
  // 获取函数需要的参数长度
  let length = fn.length;
 
  args = args || [];
 
  return function() {
    let subArgs = args.slice(0);
 
    // 拼接得到现有的所有参数
    for (let i = 0; i < arguments.length; i++) {
      subArgs.push(arguments[i]);
    }
 
    // 判断参数的长度是否已经满足函数所需参数的长度
    if (subArgs.length >= length) {
      // 如果满足，执行函数
      return fn.apply(this, subArgs);
    } else {
      // 如果不满足，递归返回科里化的函数，等待参数的传入
      return curry.call(this, fn, subArgs);
    }
  };
}
 
// es6 实现
function curry(fn, ...args) {
  return fn.length <= args.length ? fn(...args) : curry.bind(null, fn, ...args);
}

function objectCreate(obj){
  function F(){};  // 构造函数
  F.prototype = obj; // obj 作为构造函数原型的属性
  return new F(); // 返回一个实例对象 就像 `let ff = new F();  return ff`
}

// 1.利用Set
const res = Array.from(new Set(arr));
 
// 2.两层for循环+splice
const unique = arr => {
  let len = arr.length;
  for (let i = 0; i < len; i++) {
    for (let j = i + 1; j < len; j++) {
      if (arr[i] === arr[j]) {
        arr.splice(j, 1);
        len--;
        j--;
      }
    }
  }
  return arr;
}
 
// 3.利用indexOf
const unique = arr => {
  const res = [];
  for (let i = 0; i < arr.length; i++) {
    if (res.indexOf(arr[i]) === -1) res.push(arr[i]);
  }
  return res;
}
 
// 4.利用include
const unique = arr => {
  const res = [];
  for (let i = 0; i < arr.length; i++) {
    if (!res.includes(arr[i])) res.push(arr[i]);
  }
  return res;
}
 
// 5.利用filter
const unique = arr => {
  return arr.filter((item, index) => {
    return arr.indexOf(item) === index;
  });
}
 
// 6.利用Map
const unique = arr => {
  const map = new Map();
  const res = [];
  for (let i = 0; i < arr.length; i++) {
    if (!map.has(arr[i])) {
      map.set(arr[i], true);
      res.push(arr[i]);
    }
  }
  return res;
}

// 1.利用for循环
function getSum(arr){    
  let sum = 0;
  for(var i = 0;i<arr.length;i++){
      sum += arr[i]; 
  }
  return sum ;
}
 
// 2.利用reduce
const sum = arr.reduce(function (prev, cur) {
    return prev + cur;
}, 0);
 
// 3.利用forEach
function getSum(arr) {
  let sum = 0;
  arr.forEach((val) => {
    sum += val;
  });
  
  return sum;
};
 
// 4.使用递归实现数组求和
function sum(arr) {
  if (arr.length === 0) {
    return 0;
  }
  return arr[0] + sum(arr.slice(1));
}