Definição de função e chamada
Definindo funções. Em JavaScript, a maneira de definir funções é a seguinte:
função abs (x) {if (x> = 0) {return x;} else {return -x;}}A função ABS () acima é definida da seguinte forma:
A função indica que esta é uma definição de função;
ABS é o nome da função;
(x) Liste os parâmetros da função entre colchetes, separados por vários parâmetros;
O código entre {...} é um corpo de função, que pode conter várias instruções, ou mesmo sem nenhuma instrução.
Nota: Quando a instrução dentro do corpo da função é executada, uma vez executado para retornar, a função é executada e o resultado é retornado. Portanto, a determinação interna e o loop podem ser implementados de maneira muito complexa.
Se não houver declaração de retorno, o resultado será retornado após a execução da função, mas o resultado for indefinido.
Como a função do JavaScript também é um objeto, a função ABS () definida acima é na verdade um objeto de função e o nome da função ABS pode ser considerado uma variável apontando para a função.
var abs = function (x) {if (x> = 0) {return x;} else {return -x;}}Dessa maneira, function (x) {...} é uma função anônima que não possui nome de função. No entanto, essa função anônima é atribuída ao ABS variável; portanto, a função pode ser chamada através do ABS variável.
As duas definições são completamente equivalentes. Observe que o segundo método precisa adicionar um no final do corpo da função de acordo com a sintaxe completa, indicando que a instrução de atribuição termina.
Ao chamar uma função, basta passar nos parâmetros em ordem:
ABS (10); // retorna 10
ABS (-9); // retorna para 9
Como o JavaScript permite que qualquer parâmetro seja passado sem ser afetado, não há problema de que haja mais parâmetros passados do que os parâmetros definidos, embora esses parâmetros não sejam necessários dentro da função.
ABS (10, 'BLABLABLA'); // retorna 10
ABS (-9, 'haha', 'hehe', null) // retorna para 9
Não há problema com menos parâmetros do que definidos
abs (); Nan de retorno
No momento, o parâmetro x da função ABS (x) receberá indefinido e o resultado do cálculo é NAN
função abs (x) {if (typeof x! == 'número') {tiro 'não um número':} if (x> = 0) {return x;} else {return -x;}}argumentos
O JavaScript também possui argumentos de palavras -chave gratuitas, que funcionam apenas dentro da função e sempre apontam para todos os parâmetros transmitidos pelo chamador da função atual.
function foo (x) {alert (x); // 10for (var i = 0; i <argumentos.length; ++) {alert (argumentos [i]); // 10,20,30}} Foo (10,20,30)Com os argumentos, você pode passar todos os parâmetros pelo chamador. Ou seja, mesmo que a função não definir nenhum parâmetros, o valor do parâmetro ainda pode ser obtido:
function abs () {if (argumentos.Length === 0) {return 0;} var x = argumentos [0] retornar x> = 0? x: -x;} abs (); // 0ABS (10); // 10ABS (-9) // 9De fato, os argumentos são mais comumente usados para determinar o número de parâmetros recebidos. Você pode ver esta redação:
// foo (a [, b], c)
// Aceite 2 ~ 3 parâmetros, B é um parâmetro opcional. Se apenas dois parâmetros forem inseridos e saídos, B é nulo por padrão
function foo (a, b, c) {if (argumentos.Length ==== 2) {// Os parâmetros reais obtidos são A e BC são indefinidosc = b; b = null; // b se torna o valor padrãoPara alterar o parâmetro do meio B em um parâmetro "opcional", você só pode julgá -lo através de argumentos, reajuste os parâmetros e atribuir valores.
parâmetro de repouso
Como as funções JavaScript permitem receber qualquer parâmetro, precisamos usar argumentos para obter todos os parâmetros ao encontrar problemas:
function foo (a, b) {var i, repouso = []; if (argumentos.Length> 2) {for (i = 2; i <argumentos.length; i ++) {Rest.push (argumentos [i]);}} console.log ('a =' + a) Console.log ('b =' + b);Para obter parâmetros que não sejam os parâmetros definidos A e B, precisamos usar argumentos e o loop começa no índice 2 para excluir os dois primeiros parâmetros. Este método de escrita é estranho, apenas para obter o parâmetro de descanso extra. Existe uma maneira melhor?
O padrão ES6 apresenta o parâmetro restante e a função acima pode ser reescrita como:
function foo (a, b, ... descanso) {console.log ('a =' + a); console.log ('b =' + b); console.log (repousa);} foo (1,2,3,4,5]; // resultado // a = 1 // b = 2 // prisão [3,4,5];O parâmetro restante só pode ser gravado no final e está marcado com ... no resultado da execução. A partir do resultado da operação, podemos ver que os parâmetros passados estão ligados a a, b, e os parâmetros extras são entregues à variável descanso em uma matriz, então,
Obtemos todos os parâmetros sem exigir argumentos.
Se os parâmetros passados não estiverem preenchidos com parâmetros definidos normais, isso não importa, o parâmetro restante receberá uma matriz vazia (observe que não é indefinido).
Declaração de retorno
Mencionamos anteriormente que o mecanismo JavaScript tem um mecanismo para adicionar automaticamente semicolons no final da linha, o que pode fazer com que você caia em um grande poço na declaração de devolução:
function foo () {return {name: 'foo'};} foo (); // {Nome: 'Foo'}Observação:
function foo () {return: // um ponto e vírgula foi adicionado automaticamente, o que é equivalente a retornar indefinido {name: 'foo'}; // Esta linha de instrução não pode mais ser executada. }Portanto, a maneira correta de escrever várias linhas é
function foo () {return {// Um ponto de vírgula não será adicionado automaticamente aqui porque significa que a instrução ainda não terminou. Nome: 'Foo'}}Escopo variável
Em JavaScript, o que é declarado com o VAR é realmente escopo.
Se uma variável for declarada dentro do corpo da função, o escopo da variável é todo o corpo da função e a variável não deve ser referenciada fora do corpo da função.
'Use Strict': function foo () {var x = 1; x = x +1;} x = x +2; // RefrenceError não pode se referir à variável x fora da funçãoSe duas funções diferentes declararem a mesma variável, a variável funcionará apenas dentro do corpo de suas respectivas funções. Em outras palavras, variáveis com o mesmo nome em diferentes funções são independentes uma da outra e não se afetam:
'Use struct': function foo () {var x = 1; x = x +1;} barra de função () {var x = 'a'; x = x + 'b';}Como as funções JavaScript podem ser aninhadas, a função interna pode acessar variáveis definidas por funções externas, e o contrário não é:
'Use Strict'; function foo () {var x = 1; barra de função () {var x = 1; barra de função () {var y = x +1; // barra pode acessar a variável x de foo z = y + 1; // ReferenceError! Foo não pode acessar a variável y de bar! }}E se os nomes variáveis das funções internos e externas forem dobrados?
'Use Strict': function foo () {var x = 1; barra de função () {var x = 'a'; alert ('x em bar () =' + x); // 'a'} alert ('x em foo () =' + x) // 1bar ();}Aprimoramento variável
A definição de função do JavaScript possui um recurso, que primeiro examinará toda a instrução do corpo da função e "atualizar" todas as variáveis declaradas para o topo da função:
'Use Strict'; function foo () {var x = 'hello,'+y; alert (x); var y = 'bob';} foo ();Para a função Foo () acima, o código visto pelo mecanismo JavaScript é equivalente a:
function foo () {var y; // levantar o var x da variável y = 'hello' + y; alerta (x); y = 'bob';}Devido a essa estranha "característica" do JavaScript, quando definimos variáveis dentro de uma função, respeite estritamente a regra "para declarar todas as variáveis primeiro dentro de uma função". A maneira mais comum é usar um VAR para declarar todas as variáveis usadas internamente na função:
function foo () {var x = 1, // x é inicializado em 1y = x +1, // y é inicializado em 2z, i; // z e eu somos indefinidos // Outras declarações para (i = 0; i <100; i ++) {...}}Escopo global
As variáveis não definidas em nenhuma função têm um escopo global. De fato, o JavaScript possui uma variável global escopo por padrão que está realmente vinculado a uma propriedade da janela.
'Use Strict'; var Source = 'Learn JavaScript'; Alert (Curso); // 'Learn javascript'; alert (window.course); // 'Aprenda JavaScript'
Espaço para nome
As variáveis globais estarão vinculadas à janela. Diferentes arquivos JavaScript usam as mesmas variáveis globais ou têm o mesmo nome funções de nível superior, o que causará
Nomear conflitos e é difícil de detectar.
Uma maneira de reduzir o conflito é vincular todas as suas variáveis e funções em uma variável global.
// a única variável quju myAppvar myApp = {}; // outras variáveis: myapp.name = 'myApp'; myApp.version = 1.0; // Outras funções myApp.foo = function () {return 'foo';};Colocar todo o seu código no espaço de nome exclusivo MyApp reduzirá bastante a possibilidade de conflitos variáveis globais.
Escopo local
Como o escopo variável do JavaScript está realmente dentro de uma função, não podemos definir variáveis que não podem ser definidas em blocos de instrução, como para loops.
function foo () {for (var i = 0; i <100; i ++) {//} i+= 100; // As variáveis ainda podem ser referenciadas;}Para resolver o escopo no nível do bloco, o ES6 introduziu uma nova palavra-chave LET e, em vez de VAR, você pode declarar uma variável de escopo em nível de bloco:
function foo () {var sum = 0; para (vamos i = 0; i <100; i ++) {sum += i;} i += 1;}constante
Como o VAR e deixe declarar variáveis, se você deseja declarar uma constante, ele não funcionará antes do ES6. Geralmente usamos todas as variáveis de capital para indicar que isso é uma constante
Não modifique seu valor.
var pi = 3,14;
O padrão ES6 apresenta uma nova palavra-chave const para definir constantes, ambos const e deixar o escopo no nível do bloco;
const pi = 3,14;
Pi = 3; // Alguns navegadores não relatam erros, mas não têm efeito.
Pi; // 3.14
As análises básicas do JavaScript acima de variáveis e escopo são todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.