As funções JavaScript são diferentes de outras linguagens. Cada função é mantida e executada como um objeto. Através das propriedades dos objetos de função, você pode facilmente atribuir uma função a uma variável ou passar a função como parâmetro. Antes de continuar, vamos dar uma olhada na sintaxe do uso de funções:
Aqui está uma citação:
função func1(…){…}
var func2=função(…){…};
var func3=função func4(…){…};
var func5=nova Função();
Copie o código do código da seguinte forma:
<script type="texto/javascript">
// 1, modo de chamada de método
// Quando uma função é salva como propriedade de um objeto, chamamos ela de método do objeto, então isso é vinculado ao objeto
var meuObjeto={
nome: "meuObjeto",
valor: 0,
incremento : função(num){
este.valor += typeof(num) === 'número' num: 0;
devolva isso;
} ,
toString: função(){
return '[Objeto:' + this.name + ' {valor:' + this.value + '}]';
}
}
alert(myObject.increment(10).increment(20).toString()); // [Object:myObject {value:30}]
// 2, modo de chamada de função
// Quando uma função não é função de um objeto, ela é chamada como uma função e está vinculada ao objeto global. Este é um erro no design da linguagem. Se o design da linguagem estiver correto, quando a função interna for chamada, ela ainda deverá estar vinculada à variável this da função externa.
var meuObjeto={
nome: "meuObjeto",
valor: 0,
incremento : função(num){
este.valor += typeof(num) === 'número' num: 0;
devolva isso;
} ,
toString: função(){
return '[Objeto:' + this.name + ' {valor:' + this.value + '}]';
},
getInfo: função(){
var self = isto;
retornar (função(){
//return this.toString(); // Isso na função anônima interna aponta para a janela do objeto global e gera [janela do objeto]
return self.toString(); // Defina uma variável selft e atribua a ela o valor this, então a função interna pode acessar this apontando para o objeto através desta variável
})();
}
}
alert(myObject.increment(10).increment(20).toString()); // [Object:myObject {value:30}]
// 3, modo de chamada do construtor
// JavaScript é uma linguagem baseada em herança prototípica, o que significa que objetos podem herdar propriedades diretamente de outros objetos e a linguagem não tem classes.
// Se uma função for chamada com new na frente, será criado um novo objeto que oculta o membro protótipo conectado à função, e este será vinculado à instância do construtor.
function MeuObjeto(nome){
this.name = nome || 'MeuObjeto';
este.valor=0;
este.incremento = função(num){
este.valor += typeof(num) === 'número' num: 0;
};
this.toString = função(){
return '[Objeto:' + this.name + ' {valor:' + this.value + '}]';
}
este.alvo = isto;
}
MeuObjeto.prototype.getInfo = function(){
retornar this.toString();
}
// Cria um objeto MyObject.prototype ao mesmo tempo. myObject herda todas as propriedades de MyObject.prototype.
var meuObjeto = new MeuObjeto();
meuObjeto.increment(10);
alerta(meuObjeto.valor); //10
var outroObjeto = new MeuObjeto();
outroObject.increment(20);
alerta(outroObjeto.valor); //20
alerta(meuObjeto.target===meuObjeto);
alerta(meuObjeto.target.getInfo()); // [Objeto:MeuObjeto {valor:10}]
// 4, Aplicar modo de chamada
// JavaScript é uma linguagem de programação funcional orientada a objetos, portanto funções podem ter métodos. O método apply da função é como se o objeto tivesse esse método, e this aponta para o objeto.
//apply recebe dois parâmetros, o primeiro é o objeto a ser vinculado (o objeto apontado por this) e o segundo é o array de parâmetros.
function MeuObjeto(nome){
this.name = nome || 'MeuObjeto';
este.valor = 0;
este.incremento = função(num){
este.valor += typeof(num) === 'número' num: 0;
};
this.toString=função(){
return '[Objeto:'+este.nome+' {valor:'+este.valor+'}]';
}
este.target=este;
}
função getInfo(){
retornar this.toString();
}
var meuObj = new MeuObjeto();
alert(getInfo.apply(myObj)); //[Object:MyObject {value:0}], isso aponta para myObj
alert(getInfo.apply(window)); //[objeto Janela], aponta para janela
// por e enquanto
função função(a,b){
alerta(a); // 1
alerta(b); // 2
for(var i=0;i<argumentos.comprimento;i++){
alerta(argumentos[i]); // 1, 2, 1, 2, 3
}
var i=0;
while(i<argumentos.comprimento){
alerta(argumentos[i]); // 1, 2, 1, 2, 3
eu=eu+1;
}
}
função(1,2,3);
var i = 0
para (i=0;i<=10;i++) {
document.write("O número é " + i + "<br/>")
}
</script>