# data[].attributes.body
Number: Los valores representan números de punto flotante como 37o -9.25.

El Numberconstructor contiene constantes y métodos para trabajar con números. Los valores de otros tipos se pueden convertir a números mediante la Number()función.

Los números se expresan más comúnmente en formas literales como 255o 3.14159. La gramática léxica contiene una referencia más detallada.

Cuando se usa como función, Number(value)convierte una cadena u otro valor al tipo numérico. Si el valor no se puede convertir, devuelve NaN.

Sintaxis: Number("123"); // returns the number 123 Number("123") === 123; // true Number("unicorn"); // NaN Number(undefined); // NaN

# data[].attributes.body
(Números)

# data[].attributes.body
Incluye enteros y decimales. En JavaScript no hay diferencia entre int y float. Ejemplos: 5, 3.14, -100.

# data[].attributes.body
let te permite declarar variables limitando su alcance (scope) al bloque, declaración, o expresión donde se está usando.a diferencia de la palabra clave var la cual define una variable global o local en una función sin importar el ámbito del bloque. La otra diferencia entre var y let es que este último se inicializa a un valor sólo cuando un analizador lo evalúa (ver abajo).

Al igual que const, let no crea propiedades del objeto se declara globalmente (en el alcance más alto).

Sintaxis: let var1 [= valor1] [, var2 [= valor2]] [, ..., varN [= valorN]];

# data[].attributes.body
(cadenas de texto)

# data[].attributes.body
Representa texto, como palabras, frases o cualquier secuencia de caracteres. Ejemplos: "Hola", "123", "usuario".

# data[].attributes.body
Los valores booleanos suelen generarse mediante operadores relacionales , operadores de igualdad y NOT ( !) lógicos . También pueden generarse mediante funciones que representan condiciones, como [ Array.isArray()]. Tenga en cuenta que los operadores lógicos binarios , como [ ] &&y [ ] ||, devuelven los valores de los operandos, que pueden ser booleanos o no.

Los valores booleanos se utilizan normalmente en pruebas condicionales, como la condición para las declaraciones if...elsey while, el operador condicional ( ? :) o el valor de retorno del predicado de Array.prototype.filter().

Sintaxis: const good = Boolean(expression);

const good2 = !!expression;

# data[].attributes.body
(booleanos)

# data[].attributes.body
Tienen solo dos valores posibles: true o false. Son especialmente útiles en estructuras de control como if, para evaluar condiciones lógicas.

# data[].attributes.body
En JavaScript, las matrices no son primitivas sino Arrayobjetos con las siguientes características principales:

Las matrices de JavaScript son redimensionables y pueden contener una combinación de diferentes tipos de datos . (Cuando estas características no sean deseables, utilice matrices tipificadas ).

Las matrices de JavaScript no son matrices asociativas y, por lo tanto, no se puede acceder a los elementos de la matriz utilizando cadenas arbitrarias como índices, sino que se debe acceder a ellos utilizando números enteros no negativos (o su respectiva forma de cadena) como índices.

Sintaxis: console.log(years["2"] !== years["02"]);

# data[].attributes.body
(arreglos)

# data[].attributes.body
Son listas ordenadas de elementos, que pueden ser de cualquier tipo, incluso combinados. Por ejemplo: ["rojo", "verde", "azul"] o [1, 2, true, "texto"]. Los arrays permiten agrupar datos relacionados.

# data[].attributes.body
Casi todos los objetos en JavaScript son instancias de Object; un objeto típico hereda propiedades (incluidos los métodos) de Object.prototype, aunque estas propiedades pueden estar ocultas (es decir, sobreescritas). Los únicos objetos que no heredan de Object.prototypeson aquellos con nullprototipo o que descienden de otros nullobjetos prototipo.

Los cambios en el Object.prototypeobjeto son visibles para todos los objetos mediante el encadenamiento de prototipos, a menos que las propiedades y métodos sujetos a dichos cambios se sobrescriban posteriormente en la cadena de prototipos.

Sintaxis:const obj = Object.create(null);

const obj2 = { proto: null };

# data[].attributes.body
(objetos)

# data[].attributes.body
Son colecciones de pares clave: valor, que representan entidades más complejas. Por ejemplo, un objeto persona puede tener nombre, edad y ocupación. Ejemplo:
{ nombre: "Ana", edad: 30 }.

# data[].attributes.body
Undefined es una propiedad del objeto global. Es decir, es una variable de alcance global.

En todos los navegadores que no son heredados, undefined es una propiedad no configurable ni modificable. Incluso si no es así, evite sobrescribirla.

Una variable a la que no se le ha asignado un valor es de tipo undefined. Un método o una sentencia también devuelve undefined si la variable que se evalúa no tiene un valor asignado. Una función devuelve undefined si no se devolvió un valor.

Sintaxis: let x;

if (x === undefined) {

// these statements execute

} else {

// these statements do not execute

}

# data[].attributes.body
Es el valor por defecto que tiene una variable cuando ha sido declarada pero no se le ha asignado ningún valor. También se usa para indicar la ausencia de valor intencional o por error.

# data[].attributes.body
El valor nulo se escribe con un literal: nulo. Nulo no es un identificador de una propiedad del objeto global, como puede ser undefined. En cambio, nulo expresa falta de identificación, lo que indica que una variable no apunta a ningún objeto. En las API, nulo se recupera a menudo donde se espera un objeto, pero ningún objeto es relevante.

Sintaxis:typeof null; // "object" (not "null" for legacy reasons)

typeof undefined; // "undefined"

null === undefined; // false

null == undefined; // true

null === null; // true

null == null; // true

!null; // true

Number.isNaN(1 + null); // false

Number.isNaN(1 + undefined); // true

# data[].attributes.body
Valores nulos

# data[].attributes.body
Es un valor especial que representa la "ausencia intencionada de cualquier valor". A diferencia de undefined, null es asignado explícitamente por el programador para indicar que una variable está vacía a propósito.

# data[].attributes.body
Un valor BigInt, a veces también llamado solamente BigInt, es un primitivo bigint, creado al anexar una n al final de un literal entero o llamando a la función BigInt() (sin el operador new) y dándole un valor ded entero o un valor de cadena.

Sintaxis: const previouslyMaxSafeInteger = 9007199254740991n;

const alsoHuge = BigInt(9007199254740991);

// 9007199254740991n

const hugeString = BigInt("9007199254740991");

// 9007199254740991n

const hugeHex = BigInt("0x1fffffffffffff");

// 9007199254740991n

const hugeOctal = BigInt("0o377777777777777777");

// 9007199254740991n

const hugeBin = BigInt(

"0b11111111111111111111111111111111111111111111111111111",

);

// 9007199254740991n

# data[].attributes.body
Permite representar números enteros muy grandes que superan el límite del tipo Number. Se define agregando una n al final: 12345678901234567890n.

# data[].attributes.body
Symboles un objeto incorporado cuyo constructor devuelve un symbol primitivo — también llamado Symbol value o simplemente Symbol — que está garantizado que sea único. Los Símbolos se utilizan a menudo para añadir claves de propiedades únicas a un objeto que no sean iguales a las claves que cualquier otro código pueda añadir al objeto, y que están ocultas de cualquier mecanismo que otro código utilice normalmente para acceder al objeto. Esto permite una forma de encapsulación débil, o una forma débil de ocultación de información.

Sintaxis:let sym1 = Symbol();

let sym2 = Symbol("foo");

let sym3 = Symbol("foo");

# data[].attributes.body
Representa un valor único e inmutable. Se usa comúnmente como identificador único para propiedades de objetos.

# data[].attributes.body
Las funciones son uno de los componentes fundamentales de JavaScript. Una función en JavaScript es similar a un procedimiento: un conjunto de sentencias que realiza una tarea o calcula un valor. Sin embargo, para que un procedimiento se considere una función, debe recibir una entrada y devolver una salida donde exista una relación obvia entre ambas. Para usar una función, debe definirla en algún lugar del ámbito desde el que desea llamarla.

Sintaxis:function square(number) {

return number * number;

}

# data[].attributes.body
Aunque técnicamente es un tipo especial de objeto, se considera un tipo estructurado importante. Una función puede ser almacenada en una variable, pasada como argumento y ejecutada más tarde. Ejemplo:
function saludar() { console.log("Hola"); }

# data[].attributes.body
Cada tipo de dato tiene comportamientos y usos distintos. Por ejemplo, comparar un Number con un String puede generar resultados inesperados si no se manejan adecuadamente. Usar el tipo correcto permite que el código sea más claro y confiable.

# data[].attributes.body
A diferencia de otros lenguajes con tipado estricto, en JavaScript una misma variable puede contener un número, luego una cadena, y después un objeto. Esto da flexibilidad, pero también requiere cuidado para evitar confusión y errores lógicos.

# data[].attributes.body
Tipos como Array, Object y Function no solo almacenan datos, sino que permiten construir estructuras y comportamientos más complejos. Dominar su uso es fundamental para construir aplicaciones reales.

# data[].attributes.body
https://developer.mozilla.org/en-US/docs/Web/JavaScript

# data[].attributes.attachment_link.readable_text
JavaScript ( JS) is a lightweight interpreted (or just-in-time compiled) programming language with first-class functions. While it is most well-known as the scripting language for Web pages, many non-browser environments also use it, such as Node.js, Apache CouchDB and Adobe Acrobat. JavaScript is a prototype-based, multi-paradigm, single-threaded, dynamic language, supporting object-oriented, imperative, and declarative (e.g. functional programming) styles.

JavaScript's dynamic capabilities include runtime object construction, variable parameter lists, function variables, dynamic script creation (via ), object introspection (via and Object utilities), and source-code recovery (JavaScript functions store their source text and can be retrieved through ).

This section is dedicated to the JavaScript language itself, and not the parts that are specific to Web pages or other host environments. For information about APIs that are specific to Web pages, please see Web APIs and DOM.

The standards for JavaScript are the ECMAScript Language Specification (ECMA-262) and the ECMAScript Internationalization API specification (ECMA-402). As soon as one browser implements a feature, we try to document it. This means that cases where some proposals for new ECMAScript features have already been implemented in browsers, documentation and examples in MDN articles may use some of those new features. Most of the time, this happens between the stages 3 and 4, and is usually before the spec is officially published.

Do not confuse JavaScript with the Java programming language - JavaScript is not "Interpreted Java". Both "Java" and "JavaScript" are trademarks or registered trademarks of Oracle in the U.S. and other countries. However, the two programming languages have very different syntax, semantics, and use.

JavaScript documentation of core language features (pure ECMAScript, for the most part) includes the following:

For more information about JavaScript specifications and related technologies, see JavaScript technologies overview.
Looking to become a front-end web developer?
We have put together a course that includes all the essential information you need to work towards your goal.

# data[].attributes.attachment_link.description
JavaScript (JS) is a lightweight interpreted (or just-in-time compiled) programming language with first-class functions. While it is most well-known as the scripting language for Web pages, many non-browser environments also use it, such as Node.js, Apache CouchDB and Adobe Acrobat. JavaScript is a prototype-based, multi-paradigm, single-threaded, dynamic language, supporting object-oriented, imperative, and declarative (e.g.