Ligue e aplique funções raramente são usadas em algumas operações simples de JavaScript. Em outras grandes operações, como o desenvolvimento de aplicativos da Web, essas duas funções podem ser encontradas com frequência no desenvolvimento da estrutura JS. Há também muitas informações sobre as explicações dessas duas funções, mas acho que muitas informações são escritas ou altamente semelhantes e carecem de explicações realistas. Em seguida, tento analisar e explicar essas duas funções com uma idéia mais clara e simples.
A cópia do código é a seguinte:
Podemos considerar Call () e Apply () como métodos de um determinado objeto e indiretamente chamam as funções chamando a implementação do método. O primeiro argumento de Call () e Apply () é o objeto pai para chamar a função. É o contexto de chamada e uma referência a ele é obtida através disso no corpo da função. Para chamar a função f () no método do objeto O, você pode usar Call () e Aplicar () como este: F.Call (O) F.Apply (O). [1]
Vamos analisar a chamada primeiro. Aqui está a explicação da função de chamada pela 3ª edição do ECMAScript [2]: Quando o método de chamada é chamado por um objeto de função (func.call (0)), um parâmetro necessário e vários parâmetros não essenciais precisam ser transmitidos. Seu processo de execução é o seguinte:
A, se o objeto chamando a chamada não estiver em execução, um erro TypeError será lançado.
B, defina a lista de parâmetros para esvaziar
c, se o método chamado passar mais de um parâmetro, insira arg1, arg2 ... na lista de parâmetros por sua vez
D, retorna o resultado de chamar a chamada, substitua -a na função de chamada (func) pelo parâmetro 1 passado e trate a lista de parâmetros passados como o parâmetro desta função.
De fato, a função de chamada é o protótipo do objeto de função. Ou seja, a função que as chamadas também deve ser uma função. Ao chamar essa chamada, basta substituir isso na função que chama a chamada com o objeto aprovado. Aqui está um exemplo:
<Cript> função c1 () {this.name = 'zhang san'; this.age = '24 '; this.sayName = function () {console.log ("Aqui está a classe C1, meu nome é:"+this.name+"minha idade é"+this.age); }} função c2 () {this.name = 'li si'; this.age = '25 '; } var c1 = novo C1 (); var c2 = novo c2 (); C1.SayName (); C1.SayName.Call (C2); </SCRIPT>Resultados da execução:
Aqui está a categoria C1, meu nome é: Zhang San, minha idade é 24
Aqui está a categoria C1, meu nome é: li si my idade é 25
No código acima, duas classes são declaradas, C1 e C2. C1 possui duas propriedades, um método e C2 também possui duas propriedades iguais a C1. Após a instanciação, C1.SayName () imprime as propriedades reais, mas C1.Sayname.Call (C2) imprime as propriedades de C2, por que isso é? Como o SayName () é uma função e existe isso no corpo da função, quando a chamada é executada, isso será substituído por C2, portanto o atributo de C2 será impresso.
A diferença entre aplicar e chamar está na passagem de parâmetros opcionais. Todos os parâmetros opcionais do aplicativo são armazenados em uma matriz, pois um parâmetro é inserido, enquanto a chamada é passada para vários parâmetros.
Então, quais são as aplicações das funções de aplicação e chamada? O primeiro é encontrar o maior elemento na matriz numérica da rede. Você pode usar o math.max.apply (nulo, matriz) diretamente. O outro é usar se aplicar e chamar para herdar, como segue:
<Cript> função humano (nome, sexo) {this.name = name; this.sex = sexo; this.walk = function () {console.log ('estou andando'); }} function Child () {Human.Call (isto, "Xiao Ming", "masculino") this.paly = function () {console.log ('eu gosto muito de jogar'); } this.IntrudUce = function () {console.log ('Olá a todos, eu'+this.name); }} var jinp = new Human ('Jack', 'masculino'); var xiaoping = new Child (); xiaoping.walk (); xiaoping.paly (); xiaoping.Intluce (); </sCript>Resultados da execução:
Estou andando
Eu gosto muito de jogar
Olá a todos, eu sou Xiao Ming
A função semelhante a Call () e Apply () é Bind (), que é um novo método adicionado no ECMAScript 5, mas pode ser facilmente simulado no ECMAScript 3. A função de ligação também é o método da função.Protótipo no JavaScript. O principal conteúdo desse método é vincular a função a um objeto. Quando o método bind () está ligado à função f () e um objeto O é passado como um parâmetro, esse método retornará uma nova função e será chamado de método de o. Quaisquer argumentos passados para a nova função serão passados para a função original. do seguinte modo:
<Cript> Função Introdução (país, hobby) {return "Olá a todos, meu nome é"+this.name+", este ano"+this.age+"ano, de"+country+", como"+hobby; } var xiaoming = {nome: "xiao ming", idade: 20} var jieshao = introduce.bind (xiaoming); Console.log (Jieshao ("China", "Bolando"); </sCript>Resultados da execução:
Olá a todos, meu nome é Xiao Ming, tenho 20 anos, da China, gosto de jogar basquete
O exemplo acima é equivalente a:
<Cript> Função Introdução (país, hobby) {return "Olá a todos, meu nome é"+this.name+", este ano"+this.age+"ano, de"+country+", como"+hobby; } var xiaoming = {name: "xiaoming", idade: 20} console.log (introduce.apply (xiaoming, ["China", "play"])); // ou o console.log (Introduce.call (xiaoming, "China", "Play")); </script>Deve -se notar que, no modo rigoroso do ECMAScript 5, o primeiro argumento real de Call () e Apply () se tornará esse valor, mesmo que o aprovado em argumento real seja o valor original ou mesmo nulo ou indefinido. No ECMAScript 3 e no modo não estrito, o nulo e indefinido passados serão substituídos pelo confronto global, enquanto outros valores originais serão substituídos pelo objeto Wrapper correspondente.
Referências
[1], Guia de JavaScript autoritário, 6ª edição, página 189
[2], function.prototype.call (thisarg [, arg1 [, arg2,…]])
[3], function.prototype.apply (thisarg, argarray)