MDN’s new design is in Beta! A sneak peek: https://blog.mozilla.org/opendesign/mdns-new-design-beta/

Esta traducción está incompleta. Por favor, ayuda a traducir este artículo del inglés.

Las funciones son uno de los pilares fundamentales en JavaScript. Una función es un procedimiento JavaScript—un conjunto de sentencias que realizan una tarea o calculan un valor. Para usar una función, debe definirla en algún lugar del ámbito desde el cual desea llamarla.

Definición de funciones

Declaraciones de función

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

  • El nombre de la función (opcional).
  • Una lista de argumentos para la función, encerrados entre paréntesis y separados por comas (,).
  • Las sentencias 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 expresa el retorno del argumento de la función (el cual es, number) multiplicado por sí mismo. La sentencia return especifica el valor retornado por la función.

return number * number;

Los parámetros primitivos (como puede ser 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 pasa un objecto (p. ej. un 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 afuera 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 toma el valor "Honda"

myFunc(mycar);
y = mycar.make;     // y toma el valor "Toyota"
                    // (la propiedad make fue cambida por la funcion)

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 la declaración de la función anterior es sintácticamente una sentencia, las funciones pueden también ser creadas por una expresión de función. Tal función puede ser anónima; no debe tener un nombre. Por ejemplo, la función square podría haber sido definida como:

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

Sin embargo, se puede proporcionar un nombre a una expresión de función, y éste puede ser utilizado dentro de la función para referirse a sí misma, o en un depurador para identificar la función en el trazado de pila:

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

print(factorial(3));

Las expresiones de función son convenientes cuando se pasa una función como argumento a otra función. El siguiente ejemplo muestra una función map siendo definida y luego llamada con una expresión de función 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 myFunc es definida 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í, se puede utilizar el constructor Function para crear funciones desde una cadena en tiempo de ejecución, muy al estilo de eval().

Un método, es una función que es propiedad de un objeto. Puede leer 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 es lo que realmente realiza las acciones especificadas con los parámetros indicados. Por ejemplo, si define la función  square, podría llamarla como sigue:

square(5);

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

Las funciones deben de estar dentro del ámbito cuando son llamadas, pero la declaración de la función puede ser izada (aparecer por debajo de la llamada en el codigo), como muestra el siguiente ejemplo:

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

El ámbito de la función es la función en la que es declarada o el programa entero si ésta es declarada en el nivel superior.  

Nota: Esto sólo funciona cuando se define la función utilizando la sintaxis anterior (p.ej. function funcName(){}). El siguiente código no funcionará. Esto quiere decir que el izado de funciones sólo funciona con una declaración de función y no con una expresión de función

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

Los argumentos de una función no están limitados a cadenas y números. Pueden enviarse 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));
}

Entonces, podría calcular los factoriales desde uno hasta 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 donde una función necesita ser llamada de forma dinámica, o en donde el número de argumentos de la misma varía; o en la cual, el contexto de la llamada de la función necesita ser ajustada para un objeto específico determinado en el tiempo de ejecución. Resulta que las funciones en sí mismas son objetos, y estos objetos a su vez tienen métodos (ver el objeto Function). Uno de éstos, el método apply(), se puede utilizar para lograr este objetivo.

 Ámbito de una Función

Las variables definidas dentro de una función no pueden ser accedidas desde ningún lugar fuera de la función, ya que la variable está definida sólo en el ámbito de la función. Sin embargo, una función puede acceder a todas las variables y funciones definidas dentro del ámbito en el cual está definida. 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 su función padre y a cualquier otra variable a la que la función padre 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 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í misma:

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

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

var foo = function bar() {
   // las sentencias van aqui
};
 
 
 

Dentro del cuerpo de la función, todo lo siguiente es equivalente:

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

Una función que se llama a sí misma se denomina una función recursiva. En cierto modo, la recursividad es análoga a un bucle. Ambos ejecutan el mismo código varias veces, y ambos 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" es la condicion del bucle
   // hacer cosas
   x++;
}
 
 
 
 
 

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

function loop(x) {
  if (x >= 10) // "x >= 10" es la condicion de salida (equivalente a "!(x < 10)")
    return;
  // hacer cosas
  loop(x + 1); // la llamada recursiva
}
loop(0);
 
 
 
 
 
 
 

Sin embargo, algunos algoritmos no pueden ser bucles iterativos simples. Por ejemplo, obtener todos los nodos de una estructura de árbol (p. ej. el DOM) es más fácil utilizando recursividad:

function walkTree(node) {
  if (node == null) // 
    return;
  // hacer alguna cosa con el nodo
  for (var i = 0; i < node.childNodes.length; i++) {
    walkTree(node.childNodes[i]);
  }
}
 
 
 
 
 
 
 
 

En comparación con la función loop (definida anteriomente), aquí (en el ejemplo walkTree) cada llamada recursiva a sí misma, hace muchas llamadas recursivas.

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

El comportamiento tipo-pila puede ser visto en el siguiente ejemplo:

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

// Salida:

// begin:3
// begin:2
// begin:1
// begin:0
// end:0
// end:1
// end:2
// end:3

Funciones anidadas y cierres

Se puede anidar una función dentro de una función. La función anidada (interna) es privada a su función contenedora (externa). 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 ata esas variables (que "cierra" la expresión).

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

En resumen:

  • La función interna sólo se puede acceder a partir de sentencias dentro 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); // retorna 13
b = addSquares(3,4); // retorna 25
c = addSquares(4,5); // retorna 41
 
 
 
 
 
 
 
 
 

Dado que la función interna forma un cierre, se puede llamar a la función externa y especificar argumentos para ambas, tanto para la función externa como para la interna:

function outside(x) {
  function inside(y) {
    return x + y;
  }
  return inside;
}
fn_inside = outside(3); // Pensar en esto como: dar una funcion que suma 3 a lo que sea que des
result = fn_inside(5); // retorna 8

result1 = outside(3)(5); // retorna 8
 
 
 
 
 
 
 
 
 
 

Preservación de variables

Observa cómo x se conserva cuando inside es retornada. Un cierre debe preservar los argumentos y variables dentro de todos los ámbitos que referencía. Dado que cada llamada proporciona potencialmente diferentes argumentos, un nuevo cierre es creado para cada llamada a outside. La memoria puede ser liberada sólo cuando la (función)  inside retornada ya no es accesible.

Esto no es diferente de almacenar referencias en otros objetos, pero a menudo es menos evidente porque uno no establece las referencias directamente y no puede inspeccionarlas.

Funciones Multi-anidadas

Las funciones pueden ser multi-anidadas, p. ej una función (A) que contiene una función (B) que contiene una función (C). Aqui ambas funciones B y C forman cierres, así que B puede acceder A, y C puede acceder B. Además, dado que C puede acceder B, la cual puede acceder A, entonces C puede también acceder A. En consecuencia, los cierres pueden contener múltiples ámbitos; que contienen de forma recursiva el ámbito de las funciones que los contienen. Esto se conoce como encadenamiento de ámbito. (¿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); // registra 6 (1 + 2 + 3)
 
 
 
 
 
 
 
 
 
 

En este ejemplo, C accede a y de B y a x de A. 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 A, y el cierre de C incluye a A, esto permite que C puede acceder a los  argumentos y variables de B y A . En otras palabras, C encadena 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 ningun argumento o variable de B, del que C es una variable. Así, que C permance privado sólo para B.

Conflictos de nombres

Cuando dos argumentos o variables en los ámbitos de un cierre tienen el mismo nombre, ocurre un conflicto de nombre. Los ámbitos más internos toman precedencia, asi que el ambito más interno de todos toma la precedencia más alta, mientras que el ámbito más externo toma la más baja. Esta es la cadena de ámbito. El primero en la cadena es el ámbito más interno de todos, y el último, es el ámbito más externo. Considere lo siguiente:

function outside() {
  var x = 10;
  function inside(x) {
    return x;
  }
  return inside;
}
result = outside()(20); // retorna 20 en lugar de 10
 
 
 
 
 
 
 
 

El conflicto de nombres sucede en la sentencia return x y es entre el parámetro x de inside y la variable x de outside. Aquí la cadena de ámbito es {inside, outside, objeto global}. Por lo tanto, x de inside toma precedencia sobre x de outside, y 20 (la x de inside) se devuelve en lugar de 10 (la x de outside).

Clausuras (o cierres)

Las clausuras (informalmente llamadas cierres) son una de las características más poderosas de JavaScript. JavaScript permite debido al anidamiento de funciones y concesiones a la función interna, el acceso total a todas las variables y funciones definidas dentro de la función externa (y a todas las variables y funciones a las cuales la función externa tiene acceso). Sin embargo, la función externa no tiene acceso a las variables y funciones definidas dentro de la función interna. Esto provee una especie de seguridad a las variables de la función interna. Además, ya que la función interna tiene acceso al ámbito de la función externa, las variables y funciones definidas en la función externa vivirán más tiempo que la función externa en sí misma si la función interna las administra para sobrevivir más allá del ciclo de vida de la función externa. Una clausura es creada cuando la función interna es, de alguna manera, hecha disponible a cualquier  ámbito fuera de la función externa.

var pet = function(name) {          // La funtion externa define una variable llamada "name"
      var getName = function() {
        return name;                // La funtion interna tiene aceso a la variable "name" de la funcion externa
      }

      return getName;               // Devolver la funtion interna, por lo tanto exponiendola a un ambito exterior
    },
    myPet = pet("Vivie");
    
myPet();                            // Devuelve "Vivie"

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

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 funciones internas. Las variables internas de las funciones internas actúan como almacenamientos seguros para las variables y argumentos externos. Mantienen "persistente", y aún segura, la información con la que necesitan trabajar las funciones internas. Las funciones incluso no tienen por que ser asignadas a una variable, o tener un nombre.

var getCode = (function(){
  var secureCode = "0]Eal(eh&2";    // Un code que no querimos que los externos sean capaces de modificar...
  
  return function () {
    return secureCode;
  };
})();

getCode();    // Retorna el codigo secreto

Hay, sin embargo, una serie obstáculos a vigilar cuando se usan clausuras. Si una función encerrada define una variable con el mismo nombre que una variable dentro del ámbito exterior, no hay forma referirse de nuevo a la variable del ámbito exterior.

var createPet = function(name) {  // la funcion externa define una variable llamada "name"
  return {
    setName: function(name) {    // la funcion encerrada tambien define una variable llamada "name"
      name = name;               // ¿¿¿ Como accedemos la "name" definida por la funcion externa ???
    }
  }
}

La variable mágica this es muy tramposa en las clausuras. Deben de ser usadas cuidadosamente (las clausuras que usan this), el modo en que this se refiere depende completamente de en donde la función fue llamada, en lugar de en donde fue definida.

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 direccionados de la siguiente forma:

arguments[i]

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

Usando el objeto arguments, se puede llamar una función con más argumentos de los que formalmente fueron declarados que puede aceptar. 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 realmente pasados a la función, y luego acceder a cada argumento usando el objeto arguments.

Por ejemplo, consideremos una función que concatena varias cadenas de caracteres (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 en una "lista" de strings:

// 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");

Nota: La variable arguments es de "estilo array", 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.

Parámetros de funcion

A partir de ECMAScript 6, hay dos nuevos tipos de parámetros: Parámetros por defecto y  los parámetros REST.

Parámetro por defecto

En JavaScript, los parámetros de funciones están establecidos por defecto a undefined. Sin embargo, en ciertas situaciones puede ser útil establecerlos a un valor suministrado por defecto diferente.  Es entonces cuando los parámetros por defecto pueden ayudar.

En el pasado, la estrategia general para establecer los parámetros por defecto era comprobar los valores de éstos en el cuerpo de la función y asignar un valor si estos eran undefined. Si en el siguiente ejemplo ningún valor es suministrado para b durante el llamado, su valor sería undefined cuando se evalúe a*b; y la llamda de  multiply  retornaría NaN. Sin embargo, esto se evita con la segunda línea en este ejemplo:

function multiply(a, b) {
  b = typeof b !== 'undefined' ?  b : 1;
  
  return a*b;
}

multiply(5); // 5

Con los parámetros por defecto, la comprobación en el cuerpo de la función ya no es necesaria. Ahora, puede simplemente poner 1 como valor por defecto para b en la cabeza de la función.

function multiply(a, b = 1) {
  return a*b;
}

multiply(5); // 5

Para más detalles, puede consultar parámetros por defecto en la referencia.

Parámetros rest

La syntaxis de parámetros rest (en inglés) nos permite respresentar un número indefinido de argumentos en forma de array. En el ejemplo, usamos los parámetros rest para recolectar los argumentos a partir del segundo y hasta el final. Entonces los multiplicamos por el primero. Este ejemplo está usando una función flecha, la cual es introducida en la siguiente sección.

function multiply(multiplier, ...theArgs) {
  return theArgs.map(x => multiplier * x);
}

var arr = multiply(2, 1, 2, 3);
console.log(arr); // [2, 4, 6]

Funciones flecha

Una expresión de función flecha (también conocida como función flecha gruesa o fat arrow function en inglés) tiene una sintaxis más corta comparada con las expresiones de función y léxicamente ata el valor de this. Las funciones flecha son siempre funciones anónimas. Véase también esta entrada en el blog hacks.mozilla.org : "ES6 In Depth: Arrow functions" (en inglés).

Dos factores influenciaron la introdución de las funciones flecha: funciones más cortas y el léxico this.

Funciones más cortas

En algunos patrones funcionales, las funciones más cortas son bienvenidas. Compare:

var a = [
  "Hydrogen",
  "Helium",
  "Lithium",
  "Beryl­lium"
];

var a2 = a.map(function(s){ return s.length });

var a3 = a.map( s => s.length );

El léxico this

Hasta antes de las funciones flecha, cada nueva función definía su propio valor this (un nuevo objecto en el caso de un constructor, no definido en llamada a funciones en modo estricto, el objeto de contexto si la funcion es llamada como un "metodo de objeto", etc.). Esto probó ser molesto en un estilo de programación orientada a objetos.

function Person() {
  // El constructor Person() define `this` como el mismo.
  this.age = 0;

  setInterval(function growUp() {
    // En modo no estricto, la funcion growUp() define `this` 
    // como el objeto global, el cual es diferente de el `this`
    // definido por el constructor Person().
    this.age++;
  }, 1000);
}

var p = new Person();

En ECMAScript 3/5, esto fue solucionado asignado el valor contenido por this a  una variable sobre la que se podía cerrar (o clausurar).

function Person() {
  var self = this; // Algunos eligen `that` en lugar de `self`. 
                   // Elija uno y sea consistente.
  self.age = 0;

  setInterval(function growUp() {
    // La retrollamada se refiere a la variable `self` de la cual
    // el valor es el objeto esperado.
    self.age++;
  }, 1000);
}

Alternativamente, una función ligada podría ser creada de modo que el propio valor de  this sería pasado a la función growUp().

Las funciones flecha capturan el valor de this del contexto circundante, por lo que el siguiente código funciona como se espera.

function Person(){
  this.age = 0;

  setInterval(() => {
    this.age++; // |this| se refiere apropiadamente al objeto instancia de Person.
  }, 1000);
}

var p = new Person();

Funciones predefinidas

JavaScript tiene varias funciones predefinidas de nivel superior:

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

Método eval

El método eval() evalúa el código JavaScript representado como una cadena de caracteres (string). La sintaxis de eval es:

eval(cadena de caracteres o string);

donde string es la cadena de caracteres a ser evaluada. que puede representar una expresión, sentencia o secuencia de sentencias de JavaScript. La expresión puede incluir variables y propiedades de un objeto existente.

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

Funcion global isFinite

La función global isFinite determina si el valor pasado es un número finito, si se necesita el parámetro primero es convertido a número. La sintaxis de isFinite es:

isFinite(number);

donde number es el valor a evaluar.

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

El siguiente Codigo de control  deternima si la entrada del cliente se trata de un número finito.

if(isFinite(ClientInput)){
   /* tomar pasos espeficos */
}

Funcion isNaN

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();
}

Funciones parseInt and parseFloat

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 carácter 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, indicada 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),de  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 carácteres 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 a valores enteros.

Funciones Number y String

Las funciones Number y String  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. Number utiliza el método valueOf () del objeto; String utiliza el método toString () del objeto.

El ejemplo siguiente convierte el objeto Date  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 el objeto String a un objeto Number.

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);

Funciones escape y unescape (Obsoletas. En versiones antes de JavaScript 1.5)

Las funciones escape y unescape no funcionan apropiadamente para caracteres no ASCII  y se encuentra en desuso. En versiones de JavaScript 1.5 y posteriores, use encodeURI, decodeURI, encodeURIComponent, y decodeURIComponent.

Las funciones escape y unescape  te permiten codificar y decodificar cadenas. La función escape retorna la codificación hexadecimal de un argumento que se encuentra en los caracteres ISO Latin. La función unescape retorna el string ASCII para la codificación especifica hexadecimal de un valor.

  1. La sintaxis es la siguiente:
escape(string);
unescape(string);

Estas funciones son usadas principalmente en javascript del  lado del servidor para codificar y decodificar pares nombres/valores en URLs.

Etiquetas y colaboradores del documento

 Última actualización por: sergio_p_d,