检查value是否是一个原生函数

/**
 * 检查value是否是一个原生函数
 * Checks if `value` is a pristine native function
 * @param {*} value The value to check
 * @returns {boolean} Returns `true` if `value` is a native function, else `false`
 * @example
 * isNative(Array.prototype.push)
 * // => true
 * isNative(function(){})
 * // => false
 */

import isObject from "./isObject" // 我的博客搜索【判断是否是对象】
import isFunction from "./isFunction" // 我的博客搜索【判断是否是函数】

/**
 * Used to match `RegExp`
 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
 */
var reRegExpChar = /[\\^$.*+?()[\]{}|]/g

/** Used to detect if a method is native. */
var reIsNative = new RegExp(
  "^" +
    Function.prototype.toString
      .call(Object.prototype.hasOwnProperty)
      .replace(reRegExpChar, "\\$&")
      .replace(
        /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,
        "$1.*?"
      ) +
    "$"
)

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/

/**
 * Converts `func` to its source code
 * @param {Function} func The function to convert
 * @returns {string} Returns the source code
 */
function toSource(func) {
  if (func != null) {
    try {
      return Function.prototype.toString.call(func)
    } catch (e) {}
    try {
      return func + ""
    } catch (e) {}
  }
  return ""
}

function isNative(value) {
  if (!isObject(value)) {
    return false
  }
  var pattern = isFunction(value) ? reIsNative : reIsHostCtor
  return pattern.test(toSource(value))
}

export default isNative