1. ¿Qué es JavaScript?
 (abreviado comúnmente JS) es un lenguaje de programación interpretado, dialecto del estándar ECMAScript. Se define como orientado a objetos,3​ basado en prototipos, imperativo, débilmente tipado y dinámico.

Se utiliza principalmente en su forma del lado del cliente (client-side), implementado como parte de un navegador web permitiendo mejoras en la interfaz de usuario y páginas web dinámicas4​ aunque existe una forma de JavaScript del lado del servidor (Server-side JavaScript o SSJS). Su uso en aplicaciones externas a la web, por ejemplo en documentos PDF, aplicaciones de escritorio (mayoritariamente widgets) es también significativo.




2. Características de JavaScript
Las siguientes características son comunes a todas las implementaciones que se ajustan al estándar ECMAScript, a menos que especifique explícitamente en caso contrario.

Imperativo y estructurado

JavaScript es compatible con gran parte de la estructura de programación de C (por ejemplo, sentencias if, bucles for, sentencias switch, etc.). Con una salvedad, en parte: en C, el ámbito de las variablesalcanza al bloque en el cual fueron definidas; sin embargo JavaScript no es compatible con esto, puesto que el ámbito de las variables es el de la función en la cual fueron declaradas. Esto cambia con la versión de ECMAScript 2015, ya que añade compatibilidad con block scoping por medio de la palabra clave let. Como en C, JavaScript hace distinción entre expresiones y sentencias. Una diferencia sintáctica con respecto a C es la inserción automática de punto y coma, es decir, en JavaScript los puntos y coma que finalizan una sentencia pueden ser omitidos.25​

Dinámico

Tipado dinámico
Como en la mayoría de lenguajes de scripting, el tipo está asociado al valor, no a la variable. Por ejemplo, una variable x en un momento dado puede estar ligada a un número y más adelante, religada a una cadena. JavaScript es compatible con varias formas de comprobar el tipo de un objeto, incluyendo duck typing.26​ Una forma de saberlo es por medio de la palabra clave typeof.
Objetual
JavaScript está formado casi en su totalidad por objetos. Los objetos en JavaScript son arrays asociativos, mejorados con la inclusión de prototipos (ver más adelante). Los nombres de las propiedades de los objetos son claves de tipo cadena: obj.x = 10 y obj['x'] = 10 son equivalentes, siendo azúcar sintáctico la notación con punto. Las propiedades y sus valores pueden ser creados, cambiados o eliminados en tiempo de ejecución. La mayoría de propiedades de un objeto (y aquellas que son incluidas por la cadena de la herencia prototípica) pueden ser enumeradas a por medio de la instrucción de bucle for... in. JavaScript tiene un pequeño número de objetos predefinidos como son Function y Date.
Evaluación en tiempo de ejecución
JavaScript incluye la función eval que permite evaluar expresiones expresadas como cadenas en tiempo de ejecución. Por ello se recomienda que eval sea utilizado con precaución y que se opte por utilizar la función JSON.parse() en la medida de lo posible, pues resulta mucho más segura.

Funcional

Funciones de primera clase
A las funciones se les suele llamar ciudadanos de primera clase; son objetos en sí mismos. Como tal, poseen propiedades y métodos, como .call() y .bind().27​ Una función anidada es una función definida dentro de otra. Esta es creada cada vez que la función externa es invocada. Además, cada función creada forma una clausura; es el resultado de evaluar un ámbito conteniendo en una o más variables dependientes de otro ámbito externo, incluyendo constantes, variables locales y argumentos de la función externa llamante. El resultado de la evaluación de dicha clausura forma parte del estado interno de cada objeto función, incluso después de que la función exterior concluya su evaluación.28​

Prototípico

Prototipos
JavaScript usa prototipos en vez de clases para el uso de herencia.29​ Es posible llegar a emular muchas de las características que proporcionan las clases en lenguajes orientados a objetos tradicionales por medio de prototipos en JavaScript.30​
Funciones como constructores de objetos
Las funciones también se comportan como constructores. Prefijar una llamada a la función con la palabra clave new crear una nueva instancia de un prototipo, que heredan propiedades y métodos del constructor (incluidas las propiedades del prototipo de Object).31​ ECMAScript 5 ofrece el método Object.create, permitiendo la creación explícita de una instancia sin tener que heredar automáticamente del prototipo de Object (en entornos antiguos puede aparecer el prototipo del objeto creado como null).32​ La propiedad prototype del constructor determina el objeto usado para el prototipo interno de los nuevos objetos creados. Se pueden añadir nuevos métodos modificando el prototipo del objeto usado como constructor. Constructores predefinidos en JavaScript, como Array u Object, también tienen prototipos que pueden ser modificados. Aunque esto sea posible se considera una mala práctica modificar el prototipo de Object ya que la mayoría de los objetos en Javascript heredan los métodos y propiedades del objeto prototype, objetos los cuales pueden esperar que estos no hayan sido modificados.33​

Otras características

Entorno de ejecución
JavaScript normalmente depende del entorno en el que se ejecute (por ejemplo, en un navegador web) para ofrecer objetos y métodos por los que los scripts pueden interactuar con el "mundo exterior". De hecho, depende del entorno para ser capaz de proporcionar la capacidad de incluir o importar scripts (por ejemplo, en HTML por medio del tag <script>). (Esto no es una característica del lenguaje, pero es común en la mayoría de las implementaciones de JavaScript.)
Funciones variádicas
Un número indefinido de parámetros pueden ser pasados a la función. La función puede acceder a ellos a través de los parámetros o también a través del objeto local arguments. Las funciones variádicastambién pueden ser creadas usando el método .apply().
Funciones como métodos
A diferencia de muchos lenguajes orientados a objetos, no hay distinción entre la definición de función y la definición de método. Más bien, la distinción se produce durante la llamada a la función; una función puede ser llamada como un método. Cuando una función es llamada como un método de un objeto, la palabra clave this, que es una variable local a la función, representa al objeto que invocó dicha función.
Arrays y la definición literal de objetos
Al igual que muchos lenguajes de script, arrays y objetos (arrays asociativos en otros idiomas) pueden ser creados con una sintaxis abreviada. De hecho, estos literales forman la base del formato de datos JSON.
Expresiones regulares
JavaScript también es compatible con expresiones regulares de una manera similar a Perl, que proporcionan una sintaxis concisa y poderosa para la manipulación de texto que es más sofisticado que las funciones incorporadas a los objetos de tipo string.34​

Extensiones específicas del fabricante

JavaScript se encuentra oficialmente bajo la organización de Mozilla Foundation, y periódicamente se añaden nuevas características del lenguaje. Sin embargo, sólo algunos motores JavaScript son compatibles con estas características:

  • Las propiedades get y set (también compatibles con WebKit, Opera,35​ ActionScript y Rhino).36​
  • Cláusulas catch condicionales.
  • Protocolo iterador adoptado de Python.
  • Corrutinas también adoptadas de Python.
  • Generación de listas y expresiones por comprensión también adoptado de Python.
  • Establecer el ámbito a bloque a través de la palabra clave let.
  • Desestructuración de arrays y objetos (forma limita de emparejamiento de patrones).
  • Expresiones concretas en funciones (function(args) expr).
  • ECMAScript para XML (E4X), una extensión que añade compatibilidad nativa XML a ECMAScript.





3. Diferencia entre Java y JavaScript
Dada la similitud de nombre suelen considerarse como sinónimos o muy similares cuando existen diferencias apreciables entre las que cabe destacar: * Java es un lenguaje de programación y JavaScript no, aunque ambos comparten la misma sintaxis.


  • JavaScript no es un lenguaje compilado. JavaScript se integra directamente en las páginas HTML y es interpretado (sin estar compilado) por el cliente (navegador). Es decir, el programa fuente (página web) se ejecuta directamente.
  • JavaScript está basado en objetos, mientras que Java es un lenguaje de programación orientado a objetos (OOP). JavaScript no utiliza clases, herencias o técnicas habituales en la OOP.
  • No existe la declaración de tipos de variables a utilizar. JavaScript se encarga de ello automáticamente.
  • Las referencias a los objetos se comprueban en tiempo real durante la ejecución. En los lenguajes compilados como Java esa comprobación se efectúa al compilarse.
  • JavaScript no puede (no sabe) escribir en el disco duro (excepto cookies). Por ello puede considerarse como un lenguaje seguro en Internet, en el sentido que desde las páginas web, con JavaScript, no se pueden “gastar bromas”.



4. Formas de incluir JavaScript
El código JavaScript se encierra entre etiquetas <script> y se incluye en cualquier parte del documento. Aunque es correcto incluir cualquier bloque de código en cualquier zona de la página, se recomienda definir el código JavaScript dentro de la cabecera del documento (dentro de la etiqueta <head>):


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">



<html xmlns="http://www.w3.org/1999/xhtml">



<head>



<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />



<title>Ejemplo de código JavaScript en el propio documento</title>



<script type="text/javascript">



alert("Un mensaje de prueba");



</script>



</head>




<body>



<p>Un párrafo de texto.</p>



</body>



</html>


Para que la página XHTML resultante sea válida, es necesario añadir el atributo type a la etiqueta <script>. Los valores que se incluyen en el atributo type están estandarizados y para el caso de JavaScript, el valor correcto es text/javascript.

Este método se emplea cuando se define un bloque pequeño de código o cuando se quieren incluir instrucciones específicas en un determinado documento HTML que completen las instrucciones y funciones que se incluyen por defecto en todos los documentos del sitio web.



El principal inconveniente es que si se quiere hacer una modificación en el bloque de código, es necesario modificar todas las páginas que incluyen ese mismo bloque de código JavaScript.





5. Estructura básica de JavaScript
  • Aunque JavaScript se puede incluir directamente en un documento (X)HTML, ocurre como las hojas de estilo: suele ser más útil como un archivo independiente vinculado a cada documento que necesite de los comportamientos definidos en él; así sólo hay que mantener unos pocos archivos .js para actualizar los comportamiento de todo un sitio1. Para ello habría que incluir en el head del documento una línea como ésta:
    
    <script type="text/javascript" src="URL_de_archivo.js"></script>
  • JavaScript es un lenguaje interpretado, no compilado. Significa que sólo se necesita el bloc de notas para programar un archivo .js, y vincularlo a una página para ver los resultados en un navegador.






6. Como colocar comentarios en JavaScript

Comentarios JavaScript de una línea

Pon dos barras // al comienzo de la línea o justo delante del código a comentar. Todo lo que haya a la derecha de las dos barras será ignorado hasta la siguiente línea. Ideal para pequeñas notas.

Ejemplo


<script>
  // Este un comentario de una única línea
  alert("Escibiendo comentarios en javascript!"); //Aquí puedo poner una nota de lo que hace esta línea
  // alert("Esto no se ejecuta");
</script>

7. Tipos de datos
Nota: En los códigos siguientes vamos a utilizar console.assert(). Este método está disponible en la gran mayoría de los navegadores modernos y en Node. Ejecuta una expresión y si es verdadera continua sin hacer nada y si es falsa lanza una excepción. La utilizaremos para comprobar los tipos de datos de forma sencilla, rápida y sin necesidad de librerías externas.

typeof

La primera aproximación que podemos hacer es utilizar typeof, una instrucción pensada de forma específica para conocer el tipo del valor de una variable. Funciona perfectamente con los tipos primitivos y con las funciones, pero en el caso de los objetos ofrece muy poca información, ya que para todos ellos devuelve object sin mayor detalle.
Uso de typeof
1
2
3
console.assert( typeof true === 'boolean' );
console.assert( typeof [] === 'object' );
console.assert( typeof new Date() === 'object' );

instanceof

Para los objetos existe una instrucción bastante práctica que permite conocer si un objeto determinado es una instancia de una clase superior. De esta forma podemos comprobar si un determinado dato es de tipo Date, Array, etc.
Uso de instanceof
1
2
console.assert( new Date() instanceof Date === true );
console.assert( [] instanceof Array === true );
Como todos los objetos heredan de Object, cualquier objeto es una instancia de Object y de esta forma podemos diferenciar un objeto de los tipos de datos primitivos:
Uso de instanceof Object
1
2
console.assert( new Date() instanceof Object === true );
console.assert( 10 instanceof Object === false );

Object.prototype.toString

Una forma indirecta, pero bastante interesante, de conocer el tipo de un objeto es utilizar el método toString() del prototipo de Object pasando como parámetro el valor que queremos comprobar. Este método devuelve una cadena de texto que indicará que es un objeto y de qué tipo es enmarcado entre corchetes.
Uso de Object.prototype.toString.call
1
2
console.assert( Object.prototype.toString.call([]) === '[object Array]' );
console.assert( Object.prototype.toString.call(new Date()) === '[object Date]' );

myObject.constructor.name

Todas las instancias de los objetos tienen un método myVar.constructor y este método, como todas las funciones en la mayoría de las implementaciones, tiene una propiedad name que contiene el nombre de la función. Lamentablemente no todos los navegadores facilitan esta propiedad name y en esas ocasiones deberemos utilizar un método alternativo para obtener el nombre de la función (o de la clase) que ha servido como constructor del objeto por medio del método toString() del prototipo de Function que nos devuelve el código fuente del constructor y del cual podemos extraer el nombre.
Uso de myObject.constructor
1
2
3
4
console.assert( [].constructor.name === 'Array' );
console.assert( new Date().constructor.name === 'Date' );
console.assert( Function.prototype.toString.call(new Date().constructor)
        .match(/^\n?(function|class)\s*(\w*)/)[2] === 'Date' );

Tipos de datos y las estrategias de consulta

Vamos a analizar cada una de estas estrategias con los diferentes tipos de datos de los que disponemos en Javascript y como se comportan en cada caso a fin de determinar la mejor estrategia en cada caso.

Tipos primitivos

Javascript tiene seis tipos primitivos:
  • Sin definir (undefined)
  • Nulo (null)
  • Lógicos (boolean)
  • Numérico (number)
  • Cadena (string)
  • Símbolo (symbol)
Todos los demás tipos son objetos (Object): Array, Date, Promise y todos los demás tipos son objetos.

undefined

undefined y las diferentes estrategias
1
2
3
4
5
console.assert( typeof undefined === 'undefined' );
console.assert( undefined instanceof Object === false );
console.assert( Object.prototype.toString.call(undefined) === '[object Undefined]' );
// TypeError: Cannot read property "constructor" of undefined
// console.assert( undefined.constructor.name );
Cualquier variable no definida tiene como valor un tipo undefined. Este valor no es un objeto y la mejor estrategia para identificarlo es utilizar typeof o simplemente myVar === undefined ya que existe una variable global con el nombre undefined.

null

null y las diferentes estrategias
1
2
3
4
5
6
var testNull = null;
console.assert( typeof testNull === 'object' );
console.assert( testNull instanceof Object === false );
console.assert( Object.prototype.toString.call(testNull) === '[object Null]' );
// TypeError: Cannot read property "constructor" of null
console.assert( testNull.constructor.name );
Como se puede comprobar null es un objeto según typeof, pero por otra parte no es una instancia de Object. Esta es una circunstancia peculiar que nos obliga a un tratamiento específico de null, ya que la única forma de comprobar si un valor es nulo, es compararlo con el literal null:
Comprobar si un valor es null
1
2
var testNull = null;
console.assert( (testNull === null) );

symbol

symbol y las diferentes estrategias
1
2
3
4
5
var mySymbol = Symbol();
console.assert( typeof mySymbol === 'symbol' );
console.assert( mySymbol instanceof Object === false );
console.assert( Object.prototype.toString.call(mySymbol) === '[object Symbol]' );
console.assert( mySymbol.constructor.name === 'Symbol' );
En ES6 disponemos de un nuevo tipo primitivo, los símbolos (symbol). Estos tipos de datos son utilizados como claves en objetos y mapas de datos sin que puedan ser convertidos a otros tipos, por lo que para poder acceder a estos elementos tendremos que tener una referencia al símbolo con el que se creó.
Cada vez que creamos un símbolo obtenemos un valor único, por lo que son de mucha utilidad a la hora de crear constantes con valores únicos y asegurarnos que no se va a producir confusiones por valores duplicados.
Existen algunos símbolos conocidos y que se utilizan para acceder a algunas características avanzadas del lenguaje como Symbol.iterator que nos permite acceder al método interno que devuelve un objeto iterador de un objeto Array, String, Map o Set.
En todos los casos, la mejor forma de saber si un valor es de tipo symbol es utilizar typeof.

Lógico (boolean), Numérico (number) y cadena (string)

En estos tres casos hay que diferenciar los tipos primitivos (normalmente descritos en minúsculas) que se crean por medio de las expresiones literales para estos tipos, y los objetos de igual nombre (normalmente escritos con la primera letra en mayúscula) que se crean llamando a los constructores con new seguido del constructor. Estos objetos son wrappers de los tipos primitivos y ofrece propiedades y métodos para el manejo de este tipo de valores.
Es importante comprender que Javascript realiza una conversión implícita cuando utilizamos un valor primitivo con propiedades o métodos, por ejemplo, cuando consultamos el tamaño de una cadena "text".length. En estos casos el objeto wrapper es creado internamente para realizar la invocación al método o propiedad y posteriormente eliminado.
Como podemos ver las diferentes estrategias funcionan de forma diferente en el caso de los tipos primitivos y en el caso de los objetos wrapper.
Tipos primitivos, objetos wrapper y las diferentes estrategias
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// Primitive boolean
var testBoolean = true;
console.assert( typeof testBoolean === 'boolean' );
console.assert( testBoolean instanceof Object === false );
console.assert( testBoolean instanceof Boolean === false );
console.assert( Object.prototype.toString.call(testBoolean) === '[object Boolean]' );
console.assert( testBoolean.constructor.name === 'Boolean' );
 
// Object Boolean
var testBooleanObject = new Boolean(true);
console.assert( typeof testBooleanObject === 'object' );
console.assert( testBooleanObject instanceof Object === true );
console.assert( testBooleanObject instanceof Boolean === true );
console.assert( Object.prototype.toString.call(testBooleanObject) === '[object Boolean]' );
console.assert( testBooleanObject.constructor.name === 'Boolean' );
 
// Primitive type number
var testNumber = 10;
console.assert( typeof testNumber === 'number' );
console.assert( testNumber instanceof Object === false );
console.assert( testNumber instanceof Number === false );
console.assert( Object.prototype.toString.call(testNumber) === '[object Number]' );
console.assert( testNumber.constructor.name === 'Number' );
 
// Object Number
var testNumberObject = new Number(10);
console.assert( typeof testNumberObject === 'object' );
console.assert( testNumberObject instanceof Object === true );
console.assert( testNumberObject instanceof Number === true );
console.assert( Object.prototype.toString.call(testNumberObject) === '[object Number]' );
console.assert( testNumberObject.constructor.name === 'Number' );
 
// Primitive type string
var testString = 'text';
console.assert( typeof testString === 'string' );
console.assert( testString instanceof Object === false );
console.assert( testString instanceof String === false );
console.assert( Object.prototype.toString.call(testString) === '[object String]' );
console.assert( testString.constructor.name === 'String' );
 
// Object String
var testStringObject = new String('text');
console.assert( typeof testStringObject === 'object' );
console.assert( testStringObject instanceof Object === true );
console.assert( testStringObject instanceof String === true );
console.assert( Object.prototype.toString.call(testStringObject) === '[object String]' );
console.assert( testStringObject.constructor.name === 'String' );
Nos encontramos con un reto, ya que como se puede observar, las llamadas de Object.prototype.toString.call() y .constructor.name sobre los tipos primitivos convierte estos en objetos (aparecen con la primera letra en mayúscula) y por lo tanto nos pueden confundir. En general los tipos de datos primitivos funcionan bien con typeof.






8. Variable, constantes e identificadores
9. Palabras reservadas de JavaScript (insertar una tabla o imagen con las principales)
10. Expresiones y operadores en JavaScript
11. Estructuras de control y manejo de errores
11.1 Selectivas
11.2 Iterativas
11.3 Try/catch/throw
12. ¿Qué es una función en JavaScript?
a 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 toma el valor "Honda"

myFunc(mycar);
y = mycar.make;     // y sigue con el valor "Honda"

13. Cuales son las partes de una función, coloque una imagen donde se explique esto.

 Resultado de imagen para cuales son las partes de una función en javascript


Resultado de imagen para cuales son las partes de una función en javascript




 14. Tipos de funciones en JavaScript.
Declaración de Función
Se le asigna un nombre  a la función. Dicha función se debe cargar en el ámbito de la aplicación antes de la ejecución del código.
Ejemplo:
function Saludar(){
  
  alert("Hola a todos");
}
Expresión de Función
Aquí se crea una función anónima y se le asigna a una variable. Esta función no se encuentra lista hasta que esa línea en particular sea evaluada durante la ejecución del código.
Ejemplo:
var Cantar = function(){
  
  alert("Yo canto muy bien");
}
Llamado de funciones
Para invocar una función desde cualquier parte de nuestro programa, solo es necesario escribir el nombre de la función creada seguido de paréntesis( en caso de tener parámetros indicarlos dentro, separados por comas).
Ejemplo:
Sumar();
Saludar();
Cantar();
Funciones con parámetros
Hasta ahora sólo hemos creado funciones sin parámetros. A continuación los parámetros pueden ser capturados dentro de la función y hacer cualquier tipo de manipulación sobre estas.
Una función puede tener muchos parámetros separados por comas.

15. ¿Qué es un parámetro?
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 bdurante 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.



16. Funciones predeterminadas en JavaScript
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 evalSección

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 isFiniteSección

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 isNaNSección

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 parseFloatSección

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 StringSección

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 equivale a "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 typeofJavaScript.
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)Sección

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.






17. Funciones anidadas en JavaScript
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

Comentarios

Publicar un comentario

Entradas populares