recursal/MDN huggingface dataset:
Math.asin()
===========

La Funcion **`Math.asin()`** retorna El arco seno (en radianes) de un número, eso es.



∀
x
∊
[

-
1

;
1
]
,

Math.asin
(
x
)

=
arcsin
(
x
)
=
 the unique 

y
∊

[

-

π
2

;

π
2

]

such that

sin
(
y
)
=
x

\forall x \in [{-1};1],;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } ; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] , \text{such that} ; \sin(y) = x

Syntax
------
```

Math.asin(x)
```

### Parametros

`x`

Un Numero.

### Return value

The arcsine (in radians) of the given number if it's between **-1** and **1**; otherwise, `NaN`.

Descripcion
-----------

The `Math.asin()` method returns a numeric value between 


-

π
2

-\frac{\pi}{2}

 and 


π
2

\frac{\pi}{2}

 radians for `x` between -1 and 1. If the value of `x` is outside this range, it returns `NaN`.

Because `asin()` is a static method of `Math`, you always use it as `Math.asin()`, rather than as a method of a `Math` object you created (`Math` is not a constructor).

Ejemplos
--------

### Usando `Math.asin()`


```js
Math.asin(-2); // NaN
Math.asin(-1); // -1.5707963267948966 (-pi/2)
Math.asin(0); // 0
Math.asin(0.5); // 0.5235987755982989
Math.asin(1); // 1.5707963267948966 (pi/2)
Math.asin(2); // NaN
```


For values less than -1 or greater than 1, `Math.asin()` returns `NaN`.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.asin |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver Mas
-------

* `Math.acos()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.trunc()
============

La función **`Math.trunc()`** devuelve la parte entera de un numero removiendo cualquier dígito decimal (dígitos situados después de la coma).

Sintaxis
--------
```

Math.trunc(x)
```

### Parámetros

`x`

Un número.

### Valor de retorno

La parte entera del número dado.

Descripción
-----------

A diferencia de los otros tres métodos de `Math`: `Math.floor()`, `Math.ceil()` y `Math.round()`, la forma en que `Math.trunc()` funciona es muy simple. *trunca* (corta) el punto y los dígitos a la derecha de él, sin importar si el argumento es un número positivo o negativo.

Si el argumento es un número positivo, `Math.trunc()` es equivalente a `Math.floor();` de otra forma `Math.trunc()` es equivalente a `Math.ceil()`.

El argumento pasado a este método será convertido a un tipo numérico entero.

Debido a que `trunc()` es un método estático de `Math`, siempre úsalo como `Math.trunc()`, en lugar de como un método de un objeto `Math` que hayas creado (`Math` no es un constructor).

Ejemplos
--------

### Usando `Math.trunc()`


```js
Math.trunc(13.37); // 13
Math.trunc(42.84); // 42
Math.trunc(0.123); // 0
Math.trunc(-0.123); // -0
Math.trunc("-1.123"); // -1
Math.trunc(NaN); // NaN
Math.trunc("foo"); // NaN
Math.trunc(); // NaN
```

Polyfill
--------


```js
Math.trunc =
  Math.trunc ||
  function (x) {
    return x < 0 ? Math.ceil(x) : Math.floor(x);
  };
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.trunc |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
Math.floor()
============

Sumario
-------

Devuelve el máximo entero menor o igual a un número.

Sintaxis
--------
```

Math.floor(x)
```

### Parámetros

`x`

Es número.

Descripción
-----------

Como `floor` es un método estático de `Math`, siempre debe usarse como `Math.floor()`, en lugar de usarlo como un método de un objeto `Math` creado.

Ejemplos
--------

### Ejemplo: Usando `Math.floor`

La siguiente función devuelve el valor entero redondeado más bajo de la variable `x`:


```js
function getFloor(x) {
  return Math.floor(x);
}
```


Si se pasa `45.95` a `getFloor`, éste devuelve `45`; si se le pasa `-45.95`, devuelve `-46`.

### Ejemplo: Ajuste decimal


```js
// Cierre
(function () {
  /\*\*
 \* Ajuste decimal de un número.
 \*
 \* @param {String} type El tipo de ajuste.
 \* @param {Number} value El número.
 \* @param {Integer} exp El exponente(el logaritmo en base 10 del ajuste).
 \* @returns {Number} El valor ajustado.
 \*/
  function decimalAdjust(type, value, exp) {
    // Si el exp es indefinido o cero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // Si el valor no es un número o el exp no es un entero...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Cambio
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Volver a cambiar
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Redondeo decimal
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Redondeo hacia abajo
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Redondeo hacia arriba
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Redondeo
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Piso
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Techo
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

Ven También
-----------

* El `Math` objeto.
* `Math.abs`
* `Math.ceil()`
* `Math.round()`
Math.atan()
===========

La función **`Math.atan()`** retorna el arcotangente (en radianes) de un number, esto es



Math.atan
(
x
)

=
arctan
(
x
)
=
 el único 

y
∊

[

-

π
2

;

π
2

]

 tal que

tan
(
y
)
=
x

\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } ; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] , \text{such that} ; \tan(y) = x

Pruébalo
--------

La fuente para este ejemplo interactivo se encuentra almacenado en un repositorio de GitHub. Si quieres contribuir al proyecto de ejemplos interactivos, por favor clona el repositorio que hay en este link: https://github.com/mdn/interactive-examples ; y envíanos una *pull request*.

Sintaxis
--------
```

Math.atan(x)
```

### Parámetros

`x`

Un número.

### Valor de retorno

El arcotangente (en radianes) de el número dado.

Descripción
-----------

El método `Math.atan()` retorna un valor numérico entre 


-

π
2

-\frac{\pi}{2}

 y 


π
2

\frac{\pi}{2}

 radianes.

Dado que `atan()` es un método estático de `Math`, siempre debes usarlo como `Math.atan()`, y no como un método de un objeto `Math` que hayas creado (`Math` no es un constructor).

Ejemplos
--------

### Usando `Math.atan()`


```js
Math.atan(1); // 0.7853981633974483
Math.atan(0); // 0
Math.atan(-0); // -0

Math.atan(Infinity); // 1.5707963267948966
Math.atan(-Infinity); // -1.5707963267948966

// El ángulo que la línea [(0,0);(x,y)] forma con el eje-x en un sistema de coordenadas Cartesianas.
Math.atan(y / x);
```


Nota que podrías querer evitar usar **±**`Infinity` por razones de estilo. En este caso, `Math.atan2()` con `0` como segundo argumento puede ser una mejor solución.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atan |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Math.acos()`
* `Math.asin()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.sqrt()
===========

La función **`Math.sqrt()`** retorna la raíz cuadrada de un número, que es


x
≥
0
,

M
a
t
h
.
s
q
r
t
(
x
)

=

x

=
the unique

y
≥
0

such that

y
2

=
x

\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} ; y \geq 0 ; \text{such that} ; y^2 = x

Sintaxis
--------
```

Math.sqrt(x)
```

### Parámetros

`x`

Un numero

### Valor de Retorno

La raíz cuadrada del número proporcionado. Si los números son negativos, `NaN` es devuelto.

Descripción
-----------

Si el valor de `x` es negativo `Math.sqrt()` retorna `NaN`.

Debido a que `sqrt()` es un método estático de `Math`, siempre úsalo como `Math.sqrt()`, en lugar de un método del objeto `Math` que hayas creado (`Math` no es un constructor).

Ejemplos
--------

### Usando `Math.sqrt()`


```js
Math.sqrt(9); // 3
Math.sqrt(2); // 1.414213562373095

Math.sqrt(1); // 1
Math.sqrt(0); // 0
Math.sqrt(-1); // NaN
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Math.cbrt()`
* `Math.exp()`
* `Math.log()`
* `Math.pow()`
TypedArray.prototype.buffer
===========================

La propiedad de acceso **`buffer`** representa el `ArrayBuffer` referenciada por un *TypedArray* en tiempo de construcción.

Sintaxis
--------
```

typedArray.buffer
```

Descripción
-----------

La propiedad `buffer` es una propiedad de acceso cuya función *set accessor* es `undefined`, significa que tu sólo puedes leer esta propiedad. El valor es establecido cuando *TypedArray* se construye y no puede ser cambiado. *TypedArray* es uno de los TypedArray objects.

Ejemplos
--------

### Usando la propiedad `buffer`


```js
var buffer = new ArrayBuffer(8);
var uint16 = new Uint16Array(buffer);
uint16.buffer; // ArrayBuffer { byteLength: 8 }
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-%typedarray%.prototype.buffer |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* JavaScript typed arrays
* `TypedArray`
EvalError() constructor
=======================

El constructor **`EvalError`** crea un nuevo error relacionado con la función global `eval()`. Esta excepción ya no es lanzada por JavaScript, sin embargo el objeto `EvalError` permanece por compatibilidad.

Sintaxis
--------


```js
new EvalError();
new EvalError(message);
new EvalError(message, fileName);
new EvalError(message, fileName, lineNumber);
```

### Parámetros

`message` Opcional

Descripción del error humanamente legible

`fileName` Opcional

El nombre del archivo que contiene el código que causó la excepción

`lineNumber` Opcional

El número de línea del código que causó la excepción

Ejemplos
--------

El objeto `EvalError` no se utiliza en la especificación actual de ECMAScript y por lo tanto no será lanzado por el tiempo de ejecución. Sin embargo, el objeto en sí se mantiene para la compatibilidad con versiones anteriores de la especificación.

### Creación de un EvalError


```js
try {
  throw new EvalError("Hello", "someFile.js", 10);
} catch (e) {
  console.log(e instanceof EvalError); // true
  console.log(e.message); // "Hello"
  console.log(e.name); // "EvalError"
  console.log(e.fileName); // "someFile.js"
  console.log(e.lineNumber); // 10
  console.log(e.columnNumber); // 0
  console.log(e.stack); // "@Scratchpad/2:2:9\n"
}
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-nativeerror-constructors |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* `Error`
* `eval()`
WeakMap.prototype.set()
=======================

El método **`set()`** añade un nuevo elemento con su `key` y `value` específicos al objeto `WeakMap`.

Pruébalo
--------

Sintaxis
--------
```

wm.set(key, value);
```

### Parámetros

indentificador (key)

Requerido. El identificador (objeto) del elemento a añadir al objeto `WeakMap`.

valor (value)

Requerido. El valor del elemento a añadir al objeto `WeakMap`.

### Valor devuelto

El objeto `WeakMap`.

Ejemplos
--------

### Utilización del método `set`


```js
var wm = new WeakMap();
var obj = {};

// Agregando nuevos elementos a WeakMap
wm.set(obj, "foo").set(window, "bar"); // encadenamiento
// Actualiza el un elemento en el objeto WeakMap
wm.set(obj, "baz");
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.set |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `WeakMap`
* `WeakMap.prototype.get()`
* `WeakMap.prototype.has()`
WeakMap.prototype.delete()
==========================

El método **`delete()`** elimina un elemento específico del objeto `WeakMap` .

Sintaxis
--------
```

wm.delete(key);
```

### Parámetros

identificador (key)

Requerido. El identificador del elemento a eliminar en el objeto `WeakMap`.

### Valor de retorno

`true` si el elemento del objeto `WeakMap` ha sido eliminado correctamente. Y `false` si la llave a eliminar no fue encontrada en el objeto `WeakMap` o bien, si la llave no es un objeto.

Ejemplos
--------

### Utilización del método `delete`
```

var wm = new WeakMap();
wm.set(window, "foo");

wm.delete(window); // Devuelve true. Eliminado correctamente.

wm.has(window);    // Devuelve false. El elemento window ya no es parte de WeakMap.
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.delete |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `WeakMap`
WeakMap.prototype.get()
=======================

El método **`get()`** devuelve un elemento específico del objeto `WeakMap`.

Pruébalo
--------

Sintaxis
--------
```

wm.get(key);
```

### Parámetros

key

Requerido. Es la llave del elemento a retornar desde el objeto WeakMap.

### Valores devueltos

El elemento asociado con la llave específica en el objeto WeakMap. Si la llave no está presente, devolverá `undefined`.

Ejemplos
--------

### Usando el método `get`


```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.get(window); // Devuelve "foo".
wm.get("baz"); // Devuelve undefined.
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.get |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `WeakMap`
* `WeakMap.set()`
* `WeakMap.has()`
WeakMap.prototype.has()
=======================

El método **`has()`** devuelve un boleano indicando ya sea, si el elemento con la llave específica existe o no en el objeto `WeakMap`.

Pruébalo
--------

Sintaxis
--------
```

wm.has(key);
```

### Parámetros

identificador (key)

Requerido. La llave del elemento a comprobar en el objeto `WeakMap`.

### Valor devuelto

Boolean

Devuelve `true` si el elemento con la llave específica existe en el objeto `WeakMap`; de no encontrarse, devolverá `false`.

Ejemplos
--------

### Utilización del método `has`


```js
var wm = new WeakMap();
wm.set(window, "foo");

wm.has(window); // Devuelve true
wm.has("baz"); // Devuelve false
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-weakmap.prototype.has |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `WeakMap`
* `WeakMap.prototype.set()`
* `WeakMap.prototype.get()`
Function.caller
===============

**No estándar:** Esta característica no es parte de los estándares. No la uses en sitios Web en producción: no funcionará para todos los usuarios. Podrían haber también incompatibilidades considerables entre distintas implementaciones y el comportamiento podría cambiar en el futuro.

Resumen
-------

La propiedad **`function.caller`** retorna la función que llamó a la función especificada.

Descripción
-----------

Si la función `f` fue llamada por desde nivel raiz (top level code), el valor de `f.caller` es `null`, de lo contrario se retorna la función que llamó a `f`.

Esta propiedad reemplaza a la propiedad obsoleta `arguments.caller` del objeto `arguments`.

la propiedad especial `__caller__`, la cual retornaba el objeto de activación del llamador y permitía reconstruir la pila de llamadas, ha sido removida por motivos de seguridad.

### Notas

En caso de recursión se puede reconstruir la pila de llamada utilizando esta propiedad, tal como se muestra a continuación:


```js
function f(n) {
  g(n - 1);
}
function g(n) {
  if (n > 0) {
    f(n);
  } else {
    stop();
  }
}
f(2);
```


Al momento de ejecutar `stop()` este se llama con la siguiente pila de llamadas:
```

f(2) -> g(1) -> f(1) -> g(0) -> stop()
```


Siendo verdadero la siguiente consideración:
```

stop.caller === g && f.caller === g && g.caller === f
```


Por lo tanto si se intenta obtener el rastro de llamadas (stack trace) de la función `stop()` como se muestra a continuación:


```js
var f = stop;
var stack = "Stack trace:";
while (f) {
  stack += "\n" + f.name;
  f = f.caller;
}
```


se provocará una bucle que nunca termina.

Ejemplos
--------

### Ejemplo: Verificar el valor de la propiedad `caller` de una función

El siguiente código verifica el valor de la propiedad `caller` de una función.


```js
function myFunc() {
  if (myFunc.caller == null) {
    return "The function was called from the top!";
  } else {
    return "This function's caller was " + myFunc.caller;
  }
}
```

Especificación
--------------

No es parte de ninguna especificación.

Compatiblilidad de Navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* Problema de implementación para SpiderMonkey Error 65683 en Firefox
Function.length
===============

Sumario
-------

La propiedad **`length`** especifica el número de argumentos esperados por la función.

| Atributos de la propiedad `Function.length` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | Sí |

Descripción
-----------

`length` es la propiedad de una función objeto, e indica el número de argumentos que una función requiere, por ejemplo, el número de parámetros formales. Este número no incluye rest parameter (en-US). En cambio, `arguments.length` (en-US) es local a una función y aporta el número de argumentos actuales pasados a una función.

### Propiedades de la `Función` constructora

El `Function` constructor en sí mismo es `Function` un objeto. Sú `propiedad length` tiene el valor 1. Los atributos son: Grabable: `false`, Enumerable: `false`, Configurable: `true`.

### Propiedad de la `Función` prototype object

La propiedad length del `Function` objeto prototype tiene el valor 0.

Ejemplos
--------


```js
console.log(Function.length); /\* 1 \*/

console.log(function () {}.length); /\* 0 \*/
console.log(function (a) {}.length); /\* 1 \*/
console.log(function (a, b) {}.length); /\* 2 etc. \*/
console.log(
  function (...args) {}.length,
); /\* 0, resto de parámetros no se contemplan \*/
console.log(
  function (a, b = 1, c) {}.length,
); /\* 1, solo parámetros antes del primero con un valor por defecto son contados \*/
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-instances-length |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Función`
Function.name
=============

La propiedad **`function.name`** retorna el nombre de la función o retorna `"anonymous"` por funciones creadas anónimamente.

| Atributos de la propiedad `Function.name` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | Sí |

Nótese que en implementaciones no estándar previas a ES2015 el atributo `configurable` también era `false`.

Descripción
-----------

### Nombre de una declaración de función

La propiedad `name` retorna el nombre de una declaración de función.


```js
function doSomething() {}

console.log(doSomething.name); // imprime en pantalla "doSomething"
```

### Nombre de constructor de función

Las funciones creadas con la sintaxis `new Function(...)` o simplemente `Function(...)` tienen como propiedad `name` una cadena vacía. En los ejemplos a continuación se crean funciones anónimas, tales que su `name` retorna una cadena vacía:


```js
var f = function () {};
var object = {
  someMethod: function () {},
};

console.log(f.name == ""); // true
console.log(object.someMethod.name == ""); // también true
```

### Nombres de función inferidos

Los navegadores que implementan funciones ES2015 pueden inferir el nombre de una función anónima de su posición sintáctica. Por ejemplo:


```js
var f = function () {};
console.log(f.name); // "f"
```


Se puede definir una función con un nombre en un function expression:


```js
var object = {
  someMethod: function object\_someMethod() {},
};
console.log(object.someMethod.name); // imprime "object\_someMethod"

try {
  object_someMethod;
} catch (e) {
  console.log(e);
}
// ReferenceError: object\_someMethod is not defined
```


No se puede cambiar el nombre de una función, esta propiedad es de solo lectura:


```js
var object = {
  // anonymous
  someMethod: function () {},
};

object.someMethod.name = "someMethod";
console.log(object.someMethod.name); // cadena vacía, someMethod es anónimo
```


Sin embargo, se puede usar `Object.defineProperty()` para cambiarlo.

### Nombres de métodos


```js
var o = {
  foo() {},
};
o.foo.name; // "foo";
```

### Nombres de funciones atadas (creadas con .bind())

`Function.bind()` produce una función cuyo nombre es igual a "bound " seguido del nombre de la función original.


```js
function foo() {}
foo.bind({}).name; // "bound foo"
```

### Nombres de funciones getters y setters

Cuando se usan `get` y `set,`"get" y "set" aparecerán en el nombre de la función.


```js
var o = {
  get foo() {},
  set foo(x) {},
};

var descriptor = Object.getOwnPropertyDescriptor(o, "foo");
descriptor.get.name; // "get foo"
descriptor.set.name; // "set foo";
```

Ejemplos
--------

Se puede usar `obj.constructor.name` para saber cuál es la "clase" de un objeto:


```js
function a() {}

var b = new a();

console.log(b.constructor.name); // imprime "a"
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-instances-name |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.