Definición de función y llamada
Definición de funciones. En JavaScript, la forma de definir funciones es la siguiente:
Función ABS (x) {if (x> = 0) {return x;} else {return -x;}}La función ABS () anterior se define de la siguiente manera:
La función indica que esta es una definición de función;
El ABS es el nombre de la función;
(x) enumere los parámetros de la función en los soportes, separados por múltiples parámetros;
El código entre {...} es un cuerpo de funciones, que puede contener varias declaraciones, o incluso sin ninguna declaración.
Nota: Cuando se ejecuta la declaración dentro del cuerpo de la función, una vez que se ejecuta para devolver, la función se ejecuta y se devuelve el resultado. Por lo tanto, la determinación interna y el bucle se pueden implementar de manera muy compleja.
Si no hay una declaración de retorno, el resultado se devolverá después de ejecutar la función, pero el resultado no está definido.
Dado que la función de JavaScript también es un objeto, la función ABS () definida anteriormente es en realidad un objeto de función, y el nombre de la función ABS puede considerarse como una variable que apunta a la función.
var abs = function (x) {if (x> = 0) {return x;} else {return -x;}}De esta manera, la función (x) {...} es una función anónima que no tiene nombre de función. Sin embargo, esta función anónima se asigna a la variable ABS, por lo que la función puede llamarse a través del ABS variable.
Las dos definiciones son completamente equivalentes. Tenga en cuenta que el segundo método debe agregar uno al final del cuerpo de la función de acuerdo con la sintaxis completa, lo que indica que finaliza la declaración de asignación.
Al llamar a una función, simplemente pase los parámetros en orden:
abdominales (10); // devolver 10
abdominales (-9); // volver a 9
Dado que JavaScript permite que se pase cualquier parámetro sin ser afectado, no hay problema de que hay más parámetros que pasan que los parámetros definidos, aunque estos parámetros no son necesarios dentro de la función.
abdominales (10, 'blablabla'); // devolver 10
abdominales (-9, 'jaja', 'jeje', nulo) // volver a 9
No hay problema con menos parámetros de los definidos
abdominales (); Return Nan
En este momento, el parámetro x de la función ABS (x) recibirá indefinido y el resultado del cálculo es nan
Función ABS (x) {if (typeof x! == 'number') {Throw 'no un número':} if (x> = 0) {return x;} else {return -x;}}argumentos
JavaScript también tiene argumentos de palabras clave gratuitas, que solo funciona dentro de la función y siempre apunta a todos los parámetros pasados por la persona que llama de la función actual.
función foo (x) {alerta (x); // 10for (var i = 0; i <arguments.length; ++) {alert (argumentos [i]); // 10,20,30}} foo (10.20,30)Con los argumentos, puede obtener todos los parámetros pasados por la persona que llama. Es decir, incluso si la función no define ningún parámetro, el valor del parámetro aún se puede obtener:
función abs () {if (arguments.length === 0) {return 0;} var x = argumentos [0] return x> = 0? x: -x;} abs (); // 0abs (10); // 10abs (-9) // 9De hecho, los argumentos se usan más comúnmente para determinar el número de parámetros entrantes. Puede ver este escrito:
// foo (a [, b], c)
// Acepta 2 ~ 3 parámetros, B es un parámetro opcional. Si solo se ingresan y salen dos parámetros, B es nulo de forma predeterminada
función foo (a, b, c) {if (arguments.length === 2) {// Los parámetros reales obtenidos son A y BC están indefinidosc = b; b = nulo; // b se convierte en el valor predeterminadoPara cambiar el parámetro medio B en un parámetro "opcional", solo puede juzgarlo a través de los argumentos, luego reajustar los parámetros y asignar valores.
parámetro de descanso
Dado que las funciones de JavaScript permiten recibir cualquier parámetro, tenemos que usar argumentos para obtener todos los parámetros al encontrar problemas:
función foo (a, b) {var i, REST = []; if (argumentos.length> 2) {for (i = 2; i <arguments.length; i ++) {REST.push (argumentos [i]);}} console.log ('a =' + a); console.log ('b =' + b); console.log (REST);}Para obtener parámetros distintos de los parámetros A y B, tenemos que usar argumentos, y el bucle comienza desde el índice 2 para excluir los dos primeros parámetros. Este método de escritura es incómodo, solo para obtener el parámetro de descanso adicional. ¿Hay una mejor manera?
El estándar ES6 introduce el parámetro REST, y la función anterior se puede reescribir como:
function foo (a, b, ... REST) {Console.log ('a =' + a); console.log ('b =' + b); console.log (REST);} foo (1,2,3,4,5); // resultado // a = 1 // b = 2 // array [3,4,5] foo (1) // resultado // a = 1 // b = ÚltimoEl parámetro REST solo se puede escribir al final y está marcado con ... desde el resultado de la ejecución. Desde el resultado de la operación, podemos ver que los parámetros pasados están unidos a A, B, y los parámetros adicionales se entregan al reposo variable en una matriz, por lo tanto.
Obtenemos todos los parámetros sin requerir argumentos.
Si los parámetros pasados no se llenan con parámetros definidos normales, no importa, el parámetro REST recibirá una matriz vacía (tenga en cuenta que no está indefinido).
declaración de retorno
Mencionamos anteriormente que el motor JavaScript tiene un mecanismo para agregar automáticamente semicolones al final de la línea, lo que puede hacer que caiga en un gran pozo en la declaración de devolución:
function foo () {return {name: 'foo'};} foo (); // {nombre: 'foo'}Nota:
function foo () {return: // Se agregó automáticamente un punto y coma, que es equivalente para devolver {nombre: 'foo'}; // Esta línea de declaración ya no se puede ejecutar. }Entonces, la forma correcta de escribir múltiples líneas es
function foo () {return {// un punto y coma no se agregará automáticamente aquí porque significa que la declaración aún no ha finalizado. Nombre: 'foo'}}Alcance variable
En JavaScript, lo que se declara con VAR en realidad se alcanza.
Si se declara una variable dentro del cuerpo de la función, el alcance de la variable es todo el cuerpo de la función, y la variable no debe referenciarse fuera del cuerpo de la función.
'Use Strict': function foo () {var x = 1; x = x +1;} x = x +2; // RefenceError no puede referirse a la variable x fuera de la funciónSi dos funciones diferentes declaran la misma variable, entonces la variable solo funciona dentro del cuerpo de sus respectivas funciones. En otras palabras, las variables con el mismo nombre dentro de diferentes funciones son independientes entre sí y no se afectan entre sí:
'Use struct': function foo () {var x = 1; x = x +1;} function bar () {var x = 'a'; x = x + 'b';}Dado que las funciones de JavaScript se pueden anidar, la función interna puede acceder a variables definidas por funciones externas, y al revés no es:
'Use Strict'; function foo () {var x = 1; function bar () {var x = 1; function bar () {var y = x +1; // La barra puede acceder a la variable x de foo z = y + 1; // referenceError! ¡No se puede acceder a la variable y de la barra! }}¿Qué pasa si se duplican los nombres variables de las funciones internas y externas?
'Use Strict': function foo () {var x = 1; function bar () {var x = 'a'; alert ('x en bar () =' + x); // 'a'} alert ('x en foo () =' + x) // 1bar ();}Mejora variable
La definición de funciones de JavaScript tiene una función, que primero escaneará toda la instrucción del cuerpo de funciones y "actualizar" todas las variables declaradas en la parte superior de la función:
'use estrict'; function foo () {var x = 'hello,'+y; alert (x); var y = 'bob';} foo ();Para la función foo () anterior, el código visto por el motor JavaScript es equivalente a:
función foo () {var y; // elevar el var x de la variable y = 'hola' + y; alerta (x); y = 'bob';}Debido a esta extraña "característica" de JavaScript, cuando definimos variables dentro de una función, por favor, por favor, respete estrictamente la regla "para declarar todas las variables primero dentro de una función". La forma más común es usar un VAR para declarar todas las variables utilizadas internamente en la función:
función foo () {var x = 1, // x se inicializa a 1y = x +1, // y se inicializa a 2z, i; // z y yo está indefinido // otras declaraciones para (i = 0; i <100; i ++) {...}}Alcance global
Las variables no definidas en ninguna función tienen un alcance global. De hecho, JavaScript tiene una variable de alcance global de forma predeterminada que en realidad está vinculada a una propiedad de la ventana.
'Use Strict'; var fource = 'Learn JavaScript'; Alert (curso); // 'Learn JavaScript'; Alert (Window.Course); // 'Learn JavaScript'
Espacio de nombres
Las variables globales estarán vinculadas a la ventana. Diferentes archivos de JavaScript usan las mismas variables globales, o tienen el mismo nombre de funciones de nivel superior, lo que causará
Nombrar conflictos y son difíciles de detectar.
Una forma de reducir el conflicto es unir todas sus variables y funciones a una variable global.
// La única variable quju myappvar myapp = {}; // otras variables: myapp.name = 'myapp'; myapp.version = 1.0; // otras funciones myapp.foo = function () {return 'foo';};Poner todo su código en el espacio de nombres único MyApp reducirá en gran medida la posibilidad de conflictos variables globales.
Alcance local
Dado que el alcance variable de JavaScript en realidad está dentro de una función, no podemos definir variables que no se puedan definir en bloques de declaración como para bucles.
función foo () {for (var i = 0; i <100; i ++) {//} i+= 100; // Las variables aún se pueden hacer referencia;}Para resolver el alcance de nivel de bloque, ES6 introdujo una nueva palabra clave, y en lugar de VAR, puede declarar una variable de alcance de nivel de bloque:
función foo () {var sum = 0; para (let i = 0; i <100; i ++) {sum += i;} i += 1;}constante
Como var y dejar declarar variables, si desea declarar una constante, no funcionará antes de ES6. Por lo general, usamos todas las variables de capital para indicar que esto es una constante
No modifique su valor.
var pi = 3.14;
El estándar ES6 introduce una nueva palabra clave constante para definir constantes, tanto const como dejar tener un alcance de nivel de bloque;
const pi = 3.14;
Pi = 3; // Algunos navegadores no informan errores, pero no tienen ningún efecto.
PI; // 3.14
El análisis de JavaScript Basic Functions_in de variables y el alcance anteriores es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.