Este articulo necesita una revisión editorial. Cómo puedes ayudar.

Traducción en curso

Las funciones son uno de los pilares fundamentales en JavaScript. Una función es un procedimiento JavaScript—un conjunto de sentencias 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 o sentencia 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 sentecias 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 sí 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. 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 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 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 declaracion de la función anterior es sintácticamente una sentencia, las funciones pueden tambien 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ón 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 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 expresiónes de función 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 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. 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 sentencia anterior llama a la a función con el argumento 5. La función ejecuta sus sentencias y retorna el valor 25.

Las funciones deben de estar dentro de ámbito cuando  son llamadas, pero la declaración de la función puede ser izada (aparece 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 todo el programa si esta declarada en el nivel superior.  

Nota: Esto solo funciona cuando se define la función utilizando la sintaxis anterior (p.ej. 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.

 Ámbito de una Función

Las variables definidas dentro de una función no pueden ser accedidas desde ningun lugar desde fuera 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 define. 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 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 para una función de referirse a sí misma:

  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() {
   // las sentencias van aqui
};
 
 
 

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

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

Una función que se llama a si misma es denomina una función recursiva. En cierto modo, la recursividad es análoga a un bucle. Ambos ejecutar 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, conseguir todos los nodos de una estructura de árbol (p. ej. el DOM) se hace más fácilmente 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 a la función loop (definida anteriomente), aqui (en el ejemplo walkTree)  cada llamada recursiva, de por si, 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í 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

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 ambito de la función externa.

En resumen:

  • La función interna sólo se puede acceder a partir de sentencias en 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

Observe cómo x se conserva cuando inside es retornada. Un cierre debe preservar los argumentos y variables dentro de todos los ámbitos que referencia. Dado que cada llamada proporciona potencialmente diferentes argumentos, se crea un nuevo cierre para cada llamada a outside. La memoria puede ser liberada sólo cuando la (función) devuelta inside 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 que puede acceder A, C puede también acceder A. En consecuencia, los cierres pueden contener varios á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 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, el cierre de C incluye a A, 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 solo para B.

Conflictos de nombres

Cuando dos argumentos o variables en los ámbitos de un cierre tienen el mismo nombre, allí  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 á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 parametro x de inside y la variable x de outside. Aquí la cadena de ámbito es {inside, outside, objeto global}. Luego x de inside toma precedencia sobre x de outside, y 20 se devuelve en lugar de 10.

Clausuras (o cierres)

Las clausuras (informamente llamadas cierres) son una de las caracteristicas mas poderosas de JavaScript. JavaScript permite el anidamiento de funciones otorganto a la función interna el acceso completo 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,si la función interna se las arregla para sobrevivir más allá de la vida de la función externa, las variables  y funciones definidas en la función externa viviran más tiempo que la función externa en sí misma, dado que la función interna tiene acceso al ambito de la función externa. Una clausura se crea cuando la función interna es, de alguna manera, hecha disponible en algun  á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"

La cosa puede ser mucho más compleja 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 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 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 obstaculos 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 ambito  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), dado que a lo que this se refiere depende completamente de dónde la función fue llamada, en lugar de dónde 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 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 "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.

Parametros de funcion

Comenzando con ECMAScript 6, hay dos nuevos tipos de parametros: Parametros por defecto y parametros en ristra.

Parametro por defecto

En JavaScript, los parametros de funciones estan establecidos por defecto a undefined. Sin embargo, En ciertas situaciones puede ser util establecerlos a un valor por defecto diferente.  Es entonces cuando los parametros por defecto pueden ayudar.

En el pasado, la estrategia general para establecer los parametros por defecto era comprobar los valores de estos en el cuerpo de la funcion  y asignar un valor si estos eran undefined. Si en el siguiente ejemplo , no se suministra ninngun valor de llamada, Su valor seria undefined  cuando se evalue a*bmultiply haria tener retornado NaN. Sin embargo, esto se captura con la linea segunda en este ejemplo:

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

  return a*b;
}

multiply(5); // 5

Con los parametros por defecto,  la comprobacion ya no es necesaria. Ahora, puedes 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 mas detalles, mirar parametros por defecto en la referencia.

Parametros en ristra

La syntaxis de parametros rest (en ingles)  o en ristra nos permite respresentar un numero infito de argumentos como un array. En el ejemplo, usamos  los parametros en ristra para recolectar los argumentos desde el segundo hasta el final. Entonces los multiplicamos por el primero. Este ejemplo esta usando una funcion flecha, la cual es introducida en la siguiente seccion.

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 expresion de funcion flecha (tambien conocida como funcion flecha gordafat arrow function en ingles) tiene una sintaxis  más corta comparada con las expresiones de función y lexicamente ata el valor  de this. Las funciones flecha son siempre funciones anonimas. Vease tambien esta entrada en el blog hacks.mozilla.org : "ES6 In Depth: Arrow functions" (en ingles).

Dos factores influenciaron la introdución de las funciones flecha: funciones más cortas y this lexico (que feo suena eso ;) ).

Funciones más cortas

En algunos patrones funcionales, funciones mas 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 );

this lexico

Hasta las funciones flecha, cada nueva función definia su propio valor  this ( un nuevo objecto en caso de un constructor, indefinido en llamada a funciones en modo estricto, el objeto de contexto si la funcion es llamada como un "metodo de objeto", etc.). Esto probo ser molesto con 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, este asunto era arreglado asignado el valor contenido por this a  una variable sobre la que se podia 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  podria ser creada tal que el valor apropiado de  this sería pasado a la función growUp().

Las funciones flecha capturan el valor de this del contexto circundante, así que el siguiente codigo 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.

Funcion eval

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 a ser evaluada.

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 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 isFinite

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

isFinite(number);

donde number es el número 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 hexadeciman 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

 Colaboradores en esta página: yozen, gersonfa, HeberRojo, GabrielaMcr93, yakashiro, Cleon, fscholz, Glaucius, teoli, chebit, epcode
 Última actualización por: yozen,