mozilla
Los resultados de tu búsqueda

    Funciones

    This translation is in progress.

    Las funciones son uno de los pilares fundamentales en JavaScript. Una función es un procedimiento JavaScript—un conjunto de declaraciones que realiza una tarea o calcula un valor. Para usar una función, debes definirla en algún lugar del ámbito desde el cual deseas llamarla.

    Definición de funciones

    Declaraciones de función

    La definición de una función (también llamada declaración de función) consiste en la palabra clave (reservada)  function, seguida por:

    • El nombre de la función (opcional).
    • Una lista de argumentos para la función, encerrados por paréntesis y separados por comas (,).
    • Las declaraciones JavaScript que definen la función, encerradas por llaves, { }.

    Por ejemplo, el siguiente código define una función simple llamada  square:

    function square(number) {
      return number * number;
    }
    

    La función square toma un argumento, llamado number. La función consiste de una sentencia que dice "retorna el argumento de la función (que es, number) multiplicado por si mismo. La sentencia return especifica el valor retornado por la función.

    return number * number;
    

    Los parámetros primitivos (como un número) son pasados a las funciones por valor; el valor es pasado a la función, pero si la función cambia el valor del parámetro, este cambio no es reflejado globalmente o en otra llamada a la función.

    Si le pasas un objecto (p. ej. um valor no primitivo, como un Array o un objeto definido por el usuario) como parámetro, y la función cambia las propiedades del objeto, este cambio es visible desde fuera de la función, como se  ve en el siguiente ejemplo:

    function myFunc(theObject) {
      theObject.make = "Toyota";
    }
    
    var mycar = {make: "Honda", model: "Accord", year: 1998},
        x,
        y;
    
    x = mycar.make;     // x gets the value "Honda"
    
    myFunc(mycar);
    y = mycar.make;     // y gets the value "Toyota"
                        // (the make property was changed by the function)
    

    Nota: Tenga en cuenta que asignar un nuevo objeto al parámetro no tendrá ningún efecto fuera de la función, porque esto está cambiando el valor del parámetro en lugar de una de las propiedades del objeto:

    function myFunc(theObject) {
      theObject = {make: "Ford", model: "Focus", year: 2006};
    }
    
    var mycar = {make: "Honda", model: "Accord", year: 1998},
        x,
        y;
    
    x = mycar.make;     // x gets the value "Honda"
    
    myFunc(mycar);
    y = mycar.make;     // y still gets the value "Honda" 
    

    Expresiones de función

    Si bien las declaraciones de la función anterior son sintácticamente una declaración, las funciones puede tambier ser creadas por una expresión de función. Tal función puede ser anónima; no tiene que tener un nombre. Por ejemplo, la función0 square podría haberse definido:

    var square = function(number) {return number * number};
    var x = square(4) //x gets the value 16

    Sin embargo, se puede proporcionar un nombre con una expresión de función, y puede ser usado dentro de la función para referirse a sí misma, o en un debugger para identificar la función en el seguimiento de la pila:

    var factorial = function fac(n) {return n<2 ? 1 : n*fac(n-1)};
    
    print(factorial(3));
    

    La expresión de funciones son convenientes cuando se le pasa una función como argumento a otra función. El siguiente ejemplo muestra una función map que se define a continuación y luego se la llama con una función anónima como primer parámetro:

    function map(f,a) {
      var result = [], // Create a new Array
          i;
      for (i = 0; i != a.length; i++)
        result[i] = f(a[i]);
      return result;
    }
    

    El siguiente código:

    map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]);
    

    retorna [0, 1, 8, 125, 1000].

    En JavaScript, una función puede ser definida en base a una condición. Por ejemplo, la siguiente definición de función define (redundancia) myFunc sólo si num es igual a 0:

    var myFunc;
    if (num == 0){
      myFunc = function(theObject) {
        theObject.make = "Toyota"
      }
    }

    Además de definir funciones como se describe aquí, puedes usar el constructor Function para crear funciones de una cadena en tiempo de ejecución, igual a eval().

    Un método es una función que es propiedad de un objeto. Lea más acerca de objetos y métodos en Trabajando con objetos.

    Llamando funciones

    Definir una función no la ejecuta. Definir una función simplemente la nombra y especifica que hacer cuando la función es llamada. Llamar la función realiza las acciones especificadas con los parámetros indicados. Por ejemplo, si defines la función  square, podrías llamarla como sigue:

    square(5);
    

    La declaración anterior llama a la a función con el argumento 5. La función ejecuta sus declaraciones y retorna el valor 25.

    Las funciones deben estar en el ámbito (scope) cuando ellas son llamadas, pero la declaración de la función puede estar por debajo de la llamada, como muestra el siguiente ejemplo:

    console.log(square(5));
    /* ... */
    function square(n) { return n*n } 
    

    El ámbito (scope) de la función es la función que es declarada o todo el programa si esta declarada en el nivel superior.  

    Nota: Esto solo funciona cuando se define la función utilizando la sintaxis anterior (i.e. function funcName(){}). El siguiente código no funciona:

    console.log(square(5));
    square = function (n) {
      return n * n;
    } 

     

    Los argumentos de una función no estan limitados a cadenas y números. Puedes enviar objetos enteros a una función. La función show_props (definida en Trabajando con objetos) es un ejemplo de una función que toma un objeto como argumento.

    Una función puede ser recursiva; es decir que puede llamarse a sí misma. Por ejemplo, a continuación tenemos una función que calcula el factorial de forma recursiva:

    function factorial(n){
      if ((n == 0) || (n == 1))
        return 1;
      else
        return (n * factorial(n - 1));
    }
    

    A continuación, se puede calcular los factoriales de uno a cinco de la siguiente manera:

    var a, b, c, d, e;
    a = factorial(1); // a gets the value 1
    b = factorial(2); // b gets the value 2
    c = factorial(3); // c gets the value 6
    d = factorial(4); // d gets the value 24
    e = factorial(5); // e gets the value 120
    

    Hay otras formas de llamar a las funciones. A menudo hay casos en los tenemos que llamar a una función de forma dinámica, o variar el número de argumentos de la misma, o en los que se debe establecer el contexto de la llamada a la función para un objeto específico determinado en el tiempo de ejecución. Resulta que las funciones son, en mismos, objetos, y estos objetos a su vez tienen métodos (ver El objeto Function). Uno de estos, el método apply(), se puede utilizar para lograr este objetivo.

    Alcance o ámbito de una Función

    Las variables definidas dentro de una función no pueden ser accedidas desde cualquier lugar desde afuera de la función, ya que la variable se define sólo en el ámbito de la función. Sin embargo, una función puede tener acceso a todas las variables y funciones definidas dentro del ámbito en el que se definen. En otras palabras, una función definida en el ámbito global puede acceder a todas las variables definidas en el ámbito global. Una función definida dentro de otra función también puede acceder a todas las variables definidas en la función principal y cualquier otra variable a la que la función principal tenga acceso.

    // Las siguientes variables están  definidas en el ámbito global
    var num1 = 20,
        num2 = 3,
        nombre = "Messi";
    
    // Esta función se define en el ámbito global
    function multiplicar() {
      return num1 * num2;
    }
    
    multiplicar(); // Retorna 60
    
    // Un ejemplo de función anidada
    function obtenerPuntaje () {
      var num1 = 2,
          num2 = 3;
      
      function agregar() {
        return nombre + " puntaje " + (num1 + num2);
      }
      
      return agregar();
    }
    
    obtenerPuntaje(); // Retorna "Messi puntaje 5"
    

    Ámbito de aplicación y la pila de la función

    La recursividad

    Una función puede referirse y llamarse a sí misma. Hay tres formas de una función para referirse a sí mismo:

    1. El nombre de la función
    2. arguments.callee
    3. una variable en el ámbito que se refiere a la función

    Por ejemplo, considere la siguiente definición de función:

    var foo = function bar() {
       // statements go here
    };
     
     
     

    Dentro del cuerpo de la función, los siguientes son todas equivalentes:

    1. bar()
    2. arguments.callee()
    3. foo()

    Una función que se llama se llama una función recursiva. En cierto modo, la recursividad es análogo a un bucle. Tanto ejecutar el mismo código varias veces, y ambas requieren una condición (para evitar un bucle infinito, o más bien, la recursividad infinita en este caso). Por ejemplo, el siguiente bucle:

    var x = 0;
    while (x < 10) { // "x < 10" is the loop condition
       // do stuff
       x++;
    }
     
     
     
     
     

    se puede convertir en una función recursiva y una llamada a la función:

    function loop(x) {
      if (x >= 10) // "x >= 10" is the exit condition (equivalent to "!(x < 10)")
        return;
      // do stuff
      loop(x + 1); // the recursive call
    }
    loop(0);
     
     
     
     
     
     
     

    Sin embargo, algunos algoritmos no pueden ser bucles iterativos simples. Por ejemplo, conseguir todos los nodos de una estructura de árbol (e.g. the DOM) se hace más fácilmente utilizando recursividad:

    function walkTree(node) {
      if (node == null) // 
        return;
      // do something with node
      for (var i = 0; i < node.childNodes.length; i++) {
        walkTree(node.childNodes[i]);
      }
    }
     
     
     
     
     
     
     
     

    En comparación con el bucle de la función, cada uno en sí llamada recursiva hace muchas llamadas recursivas aquí.

    Es posible convertir cualquier algoritmo recursivo para una no-recursivo, pero a menudo la lógica es mucho más complejo y hacerlo requiere el uso de una pila. De hecho, la recursividad en sí utiliza una pila: la pila de la función.

    El comportamiento-pila como se puede ver en el siguiente ejemplo:

    function foo(i) {
      if (i < 0)
        return;
      console.log('begin:' + i);
      foo(i - 1);
      console.log('end:' + i);
    }
    foo(3);
    
    // Output:
    
    // begin:3
    // begin:2
    // begin:1
    // begin:0
    // end:0
    // end:1
    // end:2
    // end:3

    Funciones anidadas y cierres

    Puede anidar una función dentro de una función. La función anidada (interior) es privado para su función que contiene (exterior). También forma un cierre. Un cierre es una expresión (típicamente una función) que puede tener variables libres junto con un entorno que une esas variables (que "cierra" la expresión).

    Desde una función anidada es un cierre, esto significa que una función anidada puede "heredar" los argumentos y variables de su función de contención. En otras palabras, la función interna contiene el alcance de la función externa.

    En resumen:

    La función interna sólo se puede acceder a partir de las declaraciones de la función externa.
    La función interna forma un cierre: la función interna puede utilizar los argumentos y variables de la función externa, mientras que la función externa no puede utilizar los argumentos y las variables de la función interna.

    El siguiente ejemplo muestra funciones anidadas:

    function addSquares(a,b) {
      function square(x) {
        return x * x;
      }
      return square(a) + square(b);
    }
    a = addSquares(2,3); // returns 13
    b = addSquares(3,4); // returns 25
    c = addSquares(4,5); // returns 41
     
     
     
     
     
     
     
     
     

    Dado que la función interna forma un cierre, se puede llamar a la función externa y especificar argumentos para la función exterior e interior:

    function outside(x) {
      function inside(y) {
        return x + y;
      }
      return inside;
    }
    fn_inside = outside(3); // Think of it like: give me a function that adds 3 to whatever you give it
    result = fn_inside(5); // returns 8
    
    result1 = outside(3)(5); // returns 8
     
     
     
     
     
     
     
     
     
     

    Preservación de variables

    Observe cómo x se conserva cuando se devuelve dentro. Un cierre debe preservar los argumentos y variables en todos los ámbitos que hace referencia. Desde cada llamada proporciona potencialmente diferentes argumentos, se crea un nuevo cierre para cada llamada al exterior. La memoria puede ser liberado sólo cuando el devuelto dentro ya no es accesible.

    Esto no es diferente de almacenar referencias en otros objetos, pero a menudo es menos evidente porque no se establecen las referencias directamente y no puede inspeccionarlos.

    Multiplicar funciones anidadas

    Las funciones pueden ser anidados-multiplican, es decir, una función (A) que contiene una función (B) que contiene una función (C). Ambas funciones B y C forman cierres aquí, así que B puede acceder A y C puede acceder B. Además, dado que C puede acceder B que puede acceder A, C puede también acceder A. Por lo tanto, el cierre puede contener varios ámbitos; que contienen de forma recursiva el alcance de las funciones que lo contienen. Esto se conoce el alcance de encadenamiento. (¿Por qué se le llama "encadenamiento" se explicará más adelante.)

    Considere el siguiente ejemplo:

    function A(x) {
      function B(y) {
        function C(z) {
          console.log(x + y + z);
        }
        C(3);
      }
      B(2);
    }
    A(1); // logs 6 (1 + 2 + 3)
     
     
     
     
     
     
     
     
     
     

    En este ejemplo, C accede y de B y de A x. Esto se puede hacer porque:

    1. B forma un cierre que incluye A, es decir B puede acceder a los argumentos y variables de A.
    2. C forma un cierre que incluye B.
    3. Debido a que el cierre de B incluye A, el cierre de C incluye A, C puede acceder tanto B como argumentos y variables de A. En otras palabras, las cadenas de C los ámbitos de B y A en ese orden.

    Lo contrario, sin embargo, no es cierto. A no puede acceder a C, ya que A no puede acceder a cualquier argumento o variable de B, que C es una variable de. Por lo tanto, C sigue siendo privado a solamente B.

    Conflictos de nombres

    Cuando dos argumentos o variables en los ámbitos de un cierre tienen el mismo nombre, allí es aname conflicto. Más ámbitos internos tienen prioridad, por lo que el centro de la mayor alcance toma la precedencia más alta, mientras que el más exterior alcance tiene el más bajo. Esta es la cadena de ámbito. El primero en la cadena es el centro de la más alcance, y el último es el más exterior alcance. Considere lo siguiente:

    function outside() {
      var x = 10;
      function inside(x) {
        return x;
      }
      return inside;
    }
    result = outside()(20); // returns 20 instead of 10
     
     
     
     
     
     
     
     

    El conflicto de nombres que sucede en el retorno declaración xy está entre parameterx de dentro y de fuera de la variable x. La cadena de ámbito que aquí es {interior, exterior, objeto global}. Por lo tanto en el interior es x toma precedencia sobre de fuera de x, y 20 (de interior x) se devuelve en lugar de 10 (de fuera x).

    Closures

    Los cierres hijo Una de las Características Más Poderosas de JavaScript. JavaScript permite el anidamiento de Funciones y,: Además, otorga a la Función interior acceso acceso completo a por todas las variables de y Funciones definidas Dentro de la Función externa (y Todas Las Otras variables de y Funciones a la cual sea la Función externa Tiene acceso acceso). Sin embargo, exterior Función la No Tiene Acceso a las variables de y Funciones definidas Dentro de la Función interior. ESTO proporciona Un tipo de piso, a las variables de de la Función interna. : Además, dado Que la Función interna Tiene Acceso al Ámbito de la Función Externa, las variables de y Funciones definidas en la Función externa viviran Más Tiempo Que la Función externa en Misma si, si la Función interna se las arregla párrafo Sobrevivir Más allá de la vida de la Función externa. El Cierre (cierre) se crea CUANDO la Función interna de Alguna Manera ESTA una Disposición de CUALQUIER Ámbito Fuera de la Función externa.

    var pet = function(name) {          // The outer function defines a variable called "name"
          var getName = function() {
            return name;                // The inner function has access to the "name" variable of the outer function
          }
    
          return getName;               // Return the inner function, thereby exposing it to outer scopes
        },
        myPet = pet("Vivie");
        
    myPet();                            // Returns "Vivie"
    

    Puede ser mucho más complejo que el código anterior. Un objeto que contiene métodos para manipular las variables internas de la función externa puede ser retornado.

    var createPet = function(name) {
      var sex;
      
      return {
        setName: function(newName) {
          name = newName;
        },
        
        getName: function() {
          return name;
        },
        
        getSex: function() {
          return sex;
        },
        
        setSex: function(newSex) {
          if(typeof newSex == "string" && (newSex.toLowerCase() == "male" || newSex.toLowerCase() == "female")) {
            sex = newSex;
          }
        }
      }
    }
    
    var pet = createPet("Vivie");
    pet.getName();                  // Vivie
    
    pet.setName("Oliver");
    pet.setSex("male");
    pet.getSex();                   // male
    pet.getName();                  // Oliver
    

    En el código anterior, la variable name de la función externa es accesible desde las funciones internas, y no hay otra forma de acceder a las variables internas excepto a través de las funcines internas. Las variables internas de la función interna actúan como almacenes seguros para las funciones internas. Mantienen "persistente", pero segura, la información con la que necesitan trabajar las funciones internas. Las funciones incluso no tienen que ser asignadas a una variable, o tener un nombre.

    var getCode = (function(){
      var secureCode = "0]Eal(eh&2";    // A code we do not want outsiders to be able to modify...
      
      return function () {
        return secureCode;
      };
    })();
    
    getCode();    // Returns the secret code
    

    Hay, sin embargo, una serie de peligros a tener en cuenta al usar closures. Si una función de cierre define una variable con el mismo nombre que una variable del ámbito exterior, no hay forma de hacer referencia al ámbito de la variable exterior.

    var createPet = function(name) {  // Outer function defines a variable called "name"
      return {
        setName: function(name) {    // Enclosed function also defines a variable called "name"
          name = name;               // ??? How do we access the "name" defined by the outer function ???
        }
      }
    }
    

    La variable mágica this es muy tramposa en los closures. Debe ser usada cuidadosamente, la referencia a this depende completamente de dónde se llama la función, en lugar de dónde se define. Un excelente y elaborado artículo sobre closures puede encontrarse aqui.

    Usando el objeto arguments

    Los argumentos de una función son mantenidos en un objeto similar a un array. Dentro de una función, los argumentos pasados a la misma pueden ser referenciados de la siguiente forma:

    arguments[i]
    

    donde i es el número ordinal del argumento, con base cero. Entonces, el primer argumento pasado a una función sería arguments[0]. El número total de argumentos es retornado por arguments.length.

    Usando el objeto arguments, podemos llamar una función com más argumentos de los que estén formalmente declarados. Esto es a menudo muy útil cuando no se sabe con antelación cuantos argumentos serán pasados a la función. Se puede usar arguments.length para determinar el número de argumentos pasados a la función, y luego acceder a cada argumento usando el objeto arguments.

    Por ejemplo, consideremos una función que concatene varias strings. El único argumento formal para la función es una string que especifica los caracteres que separan los elementos a concatenar. La función es definida de la siguiente forma:

    function myConcat(separator) {
       var result = "", // initialize list
           i;
       // iterate through arguments
       for (i = 1; i < arguments.length; i++) {
          result += arguments[i] + separator;
       }
       return result;
    }
    

    Se pueden pasar cualquier número de argumentos a esta función, y la misma concatenará cada argumento usando como separador el primer argumento:

    // returns "red, orange, blue, "
    myConcat(", ", "red", "orange", "blue");
    
    // returns "elephant; giraffe; lion; cheetah; "
    myConcat("; ", "elephant", "giraffe", "lion", "cheetah");
    
    // returns "sage. basil. oregano. pepper. parsley. "
    myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
    

    Tengamos en cuenta que la variable arguments es "array-símil", pero no es un array. Es similar a un array por poseer un índice numérico (index) y una propiedad length. Sin embargo, no posee todos los métodos de manipulación propios de un array.

    Véase el objeto Function en la referencia JavaScript para más información.

    Funciones predefinidas

    JavaScript tiene varias funciones predefinidas de nivel superior:

    Las siguientes secciones presentan estas funciones. Vea el JavaScript Reference para obtener información detallada sobre todas estas funciones.

    eval Function

    La función eval evalúa una cadena de código JavaScript sin hacer referencia a un objeto en particular. La sintaxis de eval es:

    eval(expr);
    

    donde expr es una cadena para ser evaluados.

    Si la cadena representa una expresión, eval evalúa la expresión. Si el argumento representa una o más sentencias de JavaScript, eval ejecuta las declaraciones. El ámbito de aplicación de código eval es idéntico al alcance de la código de llamada. No llame a eval para evaluar una expresión aritmética; JavaScript evalúa las expresiones aritméticas automáticamente.

    isFinite function

    La función isFinite evalúa un argumento para determinar si es un número finito. La sintaxis de isFinite es:

    isFinite(number);
    

    donde número es el número de evaluar.

    Si el argumento es NaN, el infinito positivo o infinito negativo, este método devuelve false, de lo contrario, devuelve true.

    La siguiente entrada del cliente Código de los controles para determinar si se trata de un número finito.

    if(isFinite(ClientInput)){
       /* take specific steps */
    }
    

    isNaN function

    La función isNaN evalúa un argumento para determinar si es "NaN" (no es un número). La sintaxis de isNaN es:

    isNaN(testValue);
    

    donde TestValue es el valor que desea evaluar.

    Las funciones parseFloat y parseInt regresan "NaN" cuando evalúan un valor que no es un número. isNaN devuelve true si se aprueba "NaN", y false en caso contrario.

    El código siguiente evalúa floatValue para determinar si es un número y luego llama a un procedimiento en consecuencia:

    var floatValue = parseFloat(toFloat);
    
    if (isNaN(floatValue)) {
       notFloat();
    } else {
       isFloat();
    }
    

    parseInt and parseFloat functions

    Las dos funciones "parse", parseInt y parseFloat, devuelven un valor numérico cuando se les da una cadena como argumento.

    La sintaxis de parseFloat es:

    parseFloat(str);
    

    donde parseFloat analiza su argumento, la cadena str, e intenta devolver un número de coma flotante. Si se encuentra un carácter que no sea un signo (+ o -), un número (0-9), un punto decimal o un exponente, a continuación, devuelve el valor hasta ese punto e ignora ese personaje y todos los caracteres siguientes. Si el primer carácter no puede ser convertido a un número, devuelve "NaN" (no un número).

    La sintaxis de parseInt es:

    parseInt(str [, radix]);
    

    parseInt analiza su primer argumento, la cadena str, e intenta devolver un entero de la base especificada (base), indicado por el segundo, el argumento opcional, radix. Por ejemplo, un radix de diez indica a convertir en un número decimal, ocho octal, hexadecimal dieciséis, y así sucesivamente. Para bases superiores a diez, las letras del alfabeto indican numerales mayores de nueve. Por ejemplo, para los números hexadecimales (base 16), A a F se utilizan.

    Si parseInt encuentra un carácter que no es un número en la base especificada, lo ignora y todos los personajes sucesivos y devuelve el valor entero analizado hasta ese momento. Si el primer carácter no puede ser convertido a un número en la base especificada, devuelve "NaN". La función parseInt trunca la cadena de valores enteros.

    Number and String functions

    Las funciones Número y Cuerda le permiten convertir un objeto a un número o una cadena. La sintaxis de estas funciones es:

    var objRef;
    objRef = Number(objRef);
    objRef = String(objRef);
    

    donde objRef es una referencia de objeto. Número utiliza el método valueOf () del objeto; Cadena utiliza el método toString () del objeto.

    El ejemplo siguiente convierte la Date Object a una cadena legible.

    var D = new Date(430054663215),
        x;
    x = String(D); // x equals "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983"
    

    El ejemplo siguiente convierte la String object to Number object.

    var str = "12",
        num;
    num = Number(str);
    

    Puede comprobarlo. Utilice el método DOM write () y el operador typeof JavaScript.

    var str = "12",
        num;
    document.write(typeof str);
    document.write("<br/>");
    num = Number(str);
    document.write(typeof num);
    

    escape and unescape functions(Obsoleted above JavaScript 1.5)

    The escape and unescape functions do not work properly for non-ASCII characters and have been deprecated. In JavaScript 1.5 and later, use encodeURI, decodeURI, encodeURIComponent, and decodeURIComponent.

    The escape and unescape functions let you encode and decode strings. The escape function returns the hexadecimal encoding of an argument in the ISO Latin character set. The unescape function returns the ASCII string for the specified hexadecimal encoding value.

    The syntax of these functions is:

    escape(string);
    unescape(string);
    

    These functions are used primarily with server-side JavaScript to encode and decode name/value pairs in URLs.

    Etiquetas y colaboradores del documento

    Contributors to this page: epcode, fscholz, Cleon, chebit, Glaucius, teoli, yakashiro
    Última actualización por: yakashiro,
    Ocultar la barra lateral