No meu trabalho de desenvolvimento, muitas vezes encontro situações em que preciso determinar se uma função é uma função nativa JavaScript. Às vezes, essa é uma tarefa muito necessária. Você precisa saber se essa função é fornecida pelo próprio navegador ou é encapsulado e disfarçado de função nativa por terceiros. Obviamente, a melhor maneira é examinar o valor de retorno do método de toques que executa essa função.
O javascript
A maneira de realizar esta tarefa é muito simples:
A cópia do código é a seguinte:
função énativa (fn) {
return (// {/s*/[código nativo/]/s*/}/). test ('' + fn);
}
O método da tostragem retornará o formulário de string desse método e, em seguida, usará uma expressão regular para determinar os caracteres contidos nele.
Um método mais forte
John-David Dalton, o fundador da Lodash, encontrou uma solução melhor:
A cópia do código é a seguinte:
; (function () {
// usado para resolver o interno `[[classe]]` de valores
var tostring = object.prototype.toString;
// usado para resolver a fonte de funções descompiladas
var fntoString = function.prototype.ToString;
// usado para detectar construtores de host (Safari> 4; Matriz realmente digitada específica)
var rehostctor =/^/[object.+? Construtor/] $/;
// Compile um regexp usando um método nativo comum como modelo.
// Escolhemos `objeto#tostring` porque há uma boa chance de que não esteja sendo lhado.
var renative = regexp ('^' +
// coerce `objeto#tostring` para uma string
String (ToString)
// Escape qualquer caractere de regexp especial
.place (/[.*+?^$ {} () | [/] ////]/g, '// $ &')
// Substitua as menções de `ToString` com`.*? `Para manter o modelo genérico.
// substitua coisa como `para ...` para suportar ambientes como o rinoceronte que adicionam informações extras
// como o método arity.
.plique (/tostring | (função).*? (? = /// () | para. +? (? = ///])/g, '$ 1.*?') + '$'
);
função énativa (valor) {
var tipo = tipoof valor;
Tipo de retorno == 'função'
// Use `função#ToString` para ignorar o próprio método` ToString` do valor
// e evite ser falsificado.
? Renative.test (ftostring.call (valor))
// fallback para uma verificação de objeto host porque alguns ambientes representarão
// coisas como matrizes digitadas como métodos DOM que podem não estar em conformidade com o
// padrão nativo normal.
: (value && type == 'object' && rehostctor.test (tostring.call (value))) || falso;
}
// exportar como você quiser
module.exports = isnative;
} ());
Agora você também vê isso, é muito complexo, mas mais poderoso. Obviamente, isso não é para proteção de segurança, apenas fornece informações relevantes sobre se é uma função nativa.