As palavras anteriores
Os parâmetros das funções JavaScript são diferentes da das funções na maioria dos outros idiomas. As funções não se importam com quantos parâmetros são transmitidos, nem se preocupam com o tipo de dados dos parâmetros passados e nem podem passar os parâmetros.
argumentos
A definição de função no JavaScript não especifica o tipo de parâmetros de função e a chamada de função não executa nenhum tipo de verificação nos valores de parâmetros passados. De fato, as chamadas de função JavaScript nem sequer verificam o número de parâmetros formais recebidos.
function add (x) {return x+1;} console.log (add (1)); // 2console.log (add ('1')); // '11'console.log (add ()); // nanconsole.log (add (1,2); // 2Parâmetros formais de mesmo nome
No modo não estrito, um parâmetro formal de mesmo nome pode aparecer na função e apenas o último parâmetro formal do nome que aparece pode ser acessado
função add (x, x, x) {return x;} console.log (add (1,2,3)); // 3No modo rigoroso, ocorre um erro de sintaxe quando o mesmo nome está envolvido no erro de sintaxe.
função add (x, x, x) {'use strict'; return x;} console.log (add (1,2,3)); // syntaxError: nome do parâmetro duplicado não permitido neste contextoNúmero de parâmetros
Quando o número especificado de parâmetros formais declarados pela função de referência real é pequeno, os parâmetros formais restantes serão definidos como valores indefinidos
função add (x, y) {console.log (x, y); // 1 indefinido} add (1);Use lógica ou operadores frequentemente para definir um valor padrão razoável para parâmetros omitidos
função add (x, y) {y = y || 2; console.log (x, y); // 1 2} add (1);[Nota] De fato, usando Y || 2 não é rigoroso, definindo explicitamente valores falsos (indefinidos, nulos, falsos, 0, -0, '', NAN) também terá o mesmo resultado. Portanto, deve ser definido razoavelmente baseado no cenário real
Quando há muitos argumentos reais, os argumentos reais restantes não podem ser obtidos diretamente. Você precisa usar o objeto de argumentos mencionados em breve.
Os parâmetros no JavaScript são representados internamente por uma matriz. A função sempre recebe essa matriz e não se importa com quais parâmetros estão contidos na matriz. Essa matriz de parâmetros pode ser acessada através do objeto Argumentos no corpo da função, obtendo assim cada parâmetro passado para a função. O objeto de argumentos não é uma instância de matriz, é um objeto de matriz que pode acessar todos os elementos usando sintaxe de suporte quadrado.
function add (x) {console.log (argumentos [0], argumentos [1], argumentos [2]) // 1 2 3 Returno x+1;} add (1,2,3);O atributo de comprimento do objeto Argumentos mostra o número de parâmetros reais, e o atributo de comprimento da função mostra o número de parâmetros formais
função add (x, y) {console.log (argumentos.length) // 3return x+1;} add (1,2,3); console.log (add.length); // 2Os parâmetros formais são apenas convenientes, mas não necessários
function add () {retorna argumentos [0] + argumentos [1];} console.log (add (1,2)); // 3Parâmetros de objeto
Quando uma função contém mais de 3 parâmetros formais, é realmente uma dor de cabeça lembrar que a ordem correta dos parâmetros reais na função é chamada.
Função Arraycopy (/*Array*/de,/*index*/form_start,/*Array*/para,/*index*/to_start,/*Integer*/length) {// TODO}Passe os parâmetros na forma de pares de nome/valor, para que a ordem dos parâmetros seja irrelevante. Ao definir uma função, os parâmetros reais são gravados em um objeto separado. Um objeto é passado quando chamado. Os pares de nome/valor no objeto são os dados reais de parâmetros que são realmente necessários.
função easyCopy (args) {Arraycopy (args.from, args.form_start || 0, args.to, args.to_start || 0, args.length);} var a = [1,2,3,4], b = []; easycopy ({form: a, a: b, comprimento: 4});síncrono
Quando o número de parâmetros reais do formulário participante da mesma forma, o valor do objeto de argumentos e o valor dos parâmetros formais correspondentes permanecem sincronizados
Teste de função (num1, num2) {console.log (num1, argumentos [0]); // 1 1arguds [0] = 2; console.log (num1, argumentos [0]); // 2 2num1 = 10; console.log (num1, argumentos [0]); // 10 10} test (1);[Nota] Embora os parâmetros nomeados e o valor do objeto de argumentos correspondentes sejam iguais, eles não são o mesmo espaço de nome. Seus namespaces são independentes, mas os valores são síncronos
No entanto, no modo rigoroso, os valores do objeto de argumentos e os valores dos parâmetros formais são independentes
Teste de função (num1, num2) {'use strict'; console.log (num1, argumentos [0]); // 1 1argudents [0] = 2; console.log (num1, argumentos [0]); // 1 2num1 = 10; console.log (num1, num1, [0]);Quando os parâmetros formais não possuem parâmetros reais correspondentes, o valor do objeto de argumentos não corresponde ao valor dos parâmetros formais
Teste de função (num1, num2) {console.log (num1, argumentos [0]); // indefinido, indefinido1 = 10; argumentos [0] = 5; console.log (num1, argumentos [0]); // 10,5} test ();Propriedades internas
【Callee】
O objeto de argumentos possui uma propriedade chamada Callee, que é um ponteiro para a função que possui o objeto de argumentos.
Abaixo está a função fatorial clássica
função fatorial (num) {if (num <= 1) {return 1;} else {return num* fatorial (num-1);}} console.log (fatorial (5)); // 120No entanto, a execução da função acima está intimamente acoplada ao nome da função, e a dissociação da função pode ser eliminada usando argumentos.Callee
função fatorial (num) {if (num <= 1) {return 1;} else {return num* argumentos.callee (num-1);}} console.log (fatorial (5)); // 120Mas no modo rigoroso, o acesso a esta propriedade lançará um erro TypeError
Função Fatorial (num) {'Use Strict'; if (num <= 1) {return 1;} else {return num* argumentos.callee (num-1);}} // typeError: 'Caller', 'callee' e 'argumentos';Neste momento, uma expressão de função nomeada pode ser usada
var fatorial = function fn (num) {if (num <= 1) {return 1;} else {return num*fn (num-1);}}; console.log (fatorial (5)); // 120【Chamador】
Na verdade, existem dois atributos de chamadas
【1】 Chamador de função
A propriedade de chamadas da função mantém uma referência à função que chama a função atual. Se a função atual for chamada no escopo global, seu valor será nulo
função outer () {interna ();} função interna () {console.log (interna.caller); // outer () {interna ();}} outer (); function interno () {console.log (interno.caller); // null} interno ();No modo rigoroso, o acesso a esta propriedade lançará um erro TypeError
function interno () {'use strict'; // typeError: 'chamador' e 'argumentos' são propriedades de função restritas e não podem ser acessadas nesse contextoConsole.log (interna.caller);} interno ();【2】 Argumentos CALLOR DE ACEITO
Esta propriedade é sempre indefinida. Esta propriedade é definida para distinguir as propriedades do chamador de argumentos.Caller e função
função interna (x) {console.log (argumentos.caller); // indefinido} interno (1);Da mesma forma, no modo rigoroso, o acesso a esta propriedade lançará um erro TypeError
função interna (x) {'use strict'; // typeError: 'chamador' e 'argumentos' são propriedades de função restritas e não podem ser acessadas nesse contextoConsole.log (argumentos.caller);} interna (1);Sobrecarga da função
As funções JavaScript não podem implementar a sobrecarga como no sentido tradicional. Em outros idiomas, duas definições podem ser escritas para uma função, desde que as assinaturas dessas duas definições (tipos e quantidades de parâmetros aceitos) sejam diferentes
A função JavaScript não tem assinatura porque seus parâmetros são representados por uma matriz contendo 0 ou mais valores. Sem assinaturas de função, a sobrecarga real é impossível
// A declaração subsequente substitui a função de declaração anterior addSomenumber (num) {retorna num + 100;} função addSomenBumber (num) {retorna num + 200;} var resultado = addSomenumber (100); // 300A sobrecarga de métodos só pode ser simulada verificando os tipos e quantidades de parâmetros na função passada e fazendo reações diferentes.
function doadd () {if (argumentos.Length == 1) {alert (argumentos [0] + 10);} else if (argumentos.Length == 2) {alert (argumentos [0] + argumentos [1];PASSO DE PARAMETRO
Todas as funções no JavaScript são passadas por valor. Ou seja, copiar o valor fora da função para os parâmetros dentro da função é o mesmo que copiar o valor de uma variável para outra
【1】 Valor do tipo básico
Ao passar um valor do tipo primitivo para um parâmetro, o valor passado é copiado para uma variável local (um elemento de um parâmetro nomeado ou objeto de argumentos)
função addten (num) {num += 10; retorna num;} var count = 20; var resultado = addten (contagem); console.log (contagem); // 20, sem alteração console.log (resultado); // 30【2】 Valor do tipo de referência
Ao passar um valor de tipo de referência para o parâmetro, o endereço desse valor na memória será copiado para uma variável local; portanto, a mudança dessa variável local será refletida fora da função
function setName (obj) {obj.name = 'test';} var pessoa = new Object (); setName (pessoa); console.log (Person.name); // 'teste'Quando os parâmetros formais do tipo de referência são substituídos dentro da função, essa variável refere -se a um objeto local. Este objeto local será destruído imediatamente após a execução da função
function setName (obj) {obj.name = 'test'; console.log (pessoa.name); // 'test'Obj = new Object (); obj.name =' white '; console.log (Person.name); //' test '} var pessoa = new Object (); setName (Person);O exposto acima é o entendimento aprofundado dos parâmetros de função JavaScript introduzidos pelo editor (recomendado). Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!