Sintaxis de JavaScript

JavaScript distingue entre mayúsculas y minúsculas . Es común que el nombre de un constructor comience con una letra mayúscula y el de una función o variable con una letra minúscula.

Ejemplo:

var a = 5 ; console.log ( a ) ; // 5 console.log ( A ) ; // lanza un ReferenceError : A no está definido

A diferencia de C , los espacios en blanco en el código fuente de JavaScript pueden afectar directamente la semántica . Los puntos y coma finalizan las sentencias en JavaScript. Debido a la inserción automática de punto y coma (ASI), algunas sentencias que están bien formadas cuando se analiza un salto de línea se considerarán completas, como si se hubiera insertado un punto y coma justo antes del salto de línea. Algunos expertos recomiendan proporcionar explícitamente los puntos y coma que finalizan las sentencias, ya que esto puede reducir los efectos no deseados de la inserción automática de punto y coma. ^{[ 3 ]}

Hay dos problemas: cinco tokens pueden iniciar una declaración o ser la extensión de una declaración completa; y cinco producciones restringidas, donde no se permiten saltos de línea en ciertas posiciones, lo que podría generar un análisis sintáctico incorrecto.

Los cinco tokens problemáticos son el paréntesis de apertura " (", el corchete de apertura " [", la barra inclinada " /", el signo más " +" y el signo menos " -". De estos, el paréntesis de apertura es común en el patrón de expresión de función invocada inmediatamente , el corchete de apertura aparece a veces, mientras que los demás son bastante raros. Un ejemplo:

a = b + c ( d + e ). foo ()// Se trata como: // a = b + c(d + e).foo();

con la sugerencia de que la declaración anterior termine con un punto y coma.

Algunos sugieren, en cambio, el uso de punto y coma al principio de las líneas que comienzan con ' (' o ' [', para evitar que la línea se una accidentalmente con la anterior. Esto se conoce como punto y coma defensivo y se emplea porque, de lo contrario, el código podría volverse ambiguo al reorganizarse. Por ejemplo:

a = b + c ( d + e ). foo ()// Se trata como: // a = b + c; // (d + e).foo();

En ocasiones, también se utilizan puntos y comas al inicio de las bibliotecas de JavaScript, por si se añaden a otra biblioteca que omita el punto y coma final, ya que esto puede generar ambigüedad en la instrucción inicial. En estos casos, donde la colocación del punto y coma puede ser inusual, quizás sea mejor colocarlo manualmente al final de las instrucciones.

Las cinco producciones restringidas son return, throw, break, continue, y post-incremento/decremento. En todos los casos, insertar puntos y comas no soluciona el problema, pero aclara la sintaxis analizada, facilitando la detección del error. returny throwtoman un valor opcional, mientras que breaky continuetoman una etiqueta opcional. En todos los casos, se recomienda mantener el valor o la etiqueta en la misma línea que la instrucción. Esto suele aparecer en la instrucción return, donde se podría devolver un literal de objeto grande, que podría colocarse accidentalmente comenzando en una nueva línea. Para post-incremento/decremento, existe una posible ambigüedad con pre-incremento/decremento, y nuevamente se recomienda simplemente mantenerlos en la misma línea.

devolver a + b ;// Devuelve indefinido. Se trata como: // return; // a + b; // Debería escribirse como: // return a + b;

La sintaxis de los comentarios es la misma que en C++ , Swift y otros lenguajes de programación.

Los comentarios de una sola línea comienzan con //y continúan hasta el final de la línea. También se puede hacer un segundo tipo de comentarios; estos comienzan con /*y terminan con */y se pueden usar para comentarios de varias líneas.

Un tercer tipo de comentario, el comentario hashbang, comienza con #!y continúa hasta el final de la línea. Solo son válidos al inicio de los archivos y están pensados ​​para su uso en entornos CLI . ^{[ 4 ]}

# ! Comentario de Hashbang// Comentario de una sola línea/* Comentario de varias líneas  */

Las variables declaradas con vartienen un alcance léxico a nivel de función , mientras que las que tienen leto consttienen un alcance a nivel de bloque . Dado que las declaraciones se procesan antes de que se ejecute cualquier código, una variable puede asignarse a y usarse antes de ser declarada en el código. ^{[ 7 ]} Esto se conoce comoel hoisting , y es equivalente a que las variables sedeclaren anticipadamenteen la parte superior de la función o bloque. ^{[ 8 ]}

Con las declaraciones var, let, y const, solo se eleva la declaración; las asignaciones no se elevan. Por lo tanto, una declaración en medio de la función es equivalente a una declaración al principio de la función y una asignación en ese punto en medio de la función. Esto significa que no se puede acceder a los valores antes de que se declaren; no es posible la referencia anticipada . Con , el valor de una variable es hasta que se inicializa. Las variables declaradas con o no se pueden acceder hasta que se hayan inicializado, por lo que hacer referencia a dichas variables antes provocará un error.varx=1varxx=1varundefinedletconst

Las declaraciones de funciones, que declaran una variable y le asignan una función , son similares a las sentencias de variables, pero además de elevar la declaración, también elevan la asignación (como si toda la sentencia apareciera al principio de la función contenedora), y por lo tanto, también es posible la referencia hacia adelante: la ubicación de una sentencia de función dentro de una función contenedora es irrelevante. Esto es diferente de la asignación de una expresión de función a una variable en una sentencia var, let, o .const

Entonces, por ejemplo,

var func = function () { .. } // solo se eleva la declaración function func () { .. } // se elevan tanto la declaración como la asignación

El ámbito de bloque se puede producir envolviendo todo el bloque en una función y luego ejecutándola (esto se conoce como el patrón de expresión de función invocada inmediatamente ) o declarando la variable usando la letpalabra clave.

Las variables declaradas fuera de un ámbito son globales . Si una variable se declara en un ámbito superior, los ámbitos secundarios pueden acceder a ella.

Cuando JavaScript intenta resolver un identificador, lo busca en el ámbito local. Si no lo encuentra, lo busca en el siguiente ámbito externo, y así sucesivamente a lo largo de la cadena de ámbitos hasta llegar al ámbito global , donde residen las variables globales. Si aún no lo encuentra, JavaScript generará una ReferenceErrorexcepción.

Al asignar un identificador, JavaScript sigue exactamente el mismo proceso para recuperarlo, excepto que si no se encuentra en el ámbito global , creará la "variable" en el ámbito donde se creó. ^{[ 9 ]} Como consecuencia, una variable nunca declarada será global si se le asigna. Declarar una variable (con la palabra clave var) en el ámbito global (es decir, fuera de cualquier cuerpo de función (o bloque en el caso de let/const)), asignar un identificador nunca declarado o agregar una propiedad al objeto global (normalmente window ) también creará una nueva variable global.

Cabe destacar que el modo estricto de JavaScript prohíbe la asignación de una variable no declarada, lo que evita la contaminación del espacio de nombres global.

Aquí hay algunos ejemplos de declaraciones de variables y ámbito:

var x1 = 0 ; // Una variable global, porque no está en ninguna función let x2 = 0 ; // También global, esta vez porque no está en ningún bloquefunción f () { var z = 'zorros' , r = 'pájaros' ; // 2 variables locales m = 'pez' ; // global, porque no se declaró en ningún lugar antesfunction child () { var r = 'monos' ; // Esta variable es local y no afecta a la variable "pájaros" r de la función padre. z = 'pingüinos' ; // Cierre: La función hija puede acceder a las variables de la función padre. }veinte = 20 ; // Esta variable se declara en la siguiente línea, pero se puede usar en cualquier parte de la función, incluso antes, como aquí var veinte ;hijo (); return x1 + x2 ; // Podemos usar x1 y x2 aquí, porque son globales }f ();console.log ( z ) ; // Esta línea generará una excepción ReferenceError, porque el valor de z ya no está disponible .

for ( let i = 0 ; i < 10 ; i ++ ) console . log ( i ); console . log ( i ); // lanza un ReferenceError: i no está definido

for ( const i = 0 ; i < 10 ; i ++ ) console . log ( i ); // lanza un TypeError: Assignment to constant variablefor ( const i of [ 1 , 2 , 3 ]) console . log ( i ); //no generará una excepción. i no se reasigna sino que se recrea en cada iteración.const pi ; // genera un SyntaxError: Falta el inicializador en la declaración const

El valor "undefined" se asigna a todas las variables no inicializadas y también se devuelve al comprobar propiedades de objetos que no existen. En un contexto booleano, el valor "undefined" se considera falso.

Nota: `undefined` se considera un tipo primitivo genuino. A menos que se convierta explícitamente, el valor `undefined` puede comportarse de forma inesperada en comparación con otros tipos que se evalúan como falsos en un contexto lógico.

let test ; // variable declarada, pero no definida, ... // ... se establece al valor de undefined const testObj = {}; console.log ( test ); // la variable test existe, pero el valor no ... // ... está definido, muestra undefined console.log ( testObj.myProp ); // testObj existe, la propiedad no, ... // ... muestra undefined console.log ( undefined == null ); // tipo no aplicado durante la comprobación, muestra true console.log ( undefined === null ); // tipo aplicado durante la comprobación, muestra false

Nota: No existe un literal de lenguaje incorporado para `undefined`. Por lo tanto, no es una forma infalible de comprobar si una variable es `undefined`, porque en versiones anteriores a ECMAScript 5, es válido que alguien escriba ` . Un enfoque más robusto es comparar usando `.(x===undefined)varundefined="I'm defined now";(typeofx==='undefined')

Funciones como esta no funcionarán como se espera:

función isUndefined ( x ) { let u ; return x === u ; } // así... función isUndefined ( x ) { return x === void 0 ; } // ... o esa segunda función isUndefined ( x ) { return ( typeof x ) === "undefined" ; } // ... o esa tercera

Aquí, llamar isUndefined(my_var)genera un ReferenceError si my_var es un identificador desconocido, mientras que no.typeofmy_var==='undefined'

Los números se representan en binario como números de coma flotante de doble precisión IEEE 754. Si bien este formato ofrece una precisión de casi 16 dígitos significativos , no siempre puede representar con exactitud los números reales, incluidas las fracciones.

Esto se convierte en un problema al comparar o formatear números. Por ejemplo:

console.log ( 0.2 + 0.1 === 0.3 ); // muestra false console.log ( 0.94 - 0.01 ) ; // muestra 0.9299999999999999

Como resultado, se debe utilizar una rutina como el método toFixed() para redondear los números siempre que se formateen para su salida .

Los números pueden especificarse en cualquiera de estas notaciones:

345 ; // un "entero", aunque solo hay un tipo numérico en JavaScript 34.5 ; // un número de punto flotante 3.45e2 ; // otro número de punto flotante, equivalente a 345 0b1011 ; // un entero binario igual a 11 0o377 ; // un entero octal igual a 255 0xFF ; // un entero hexadecimal igual a 255, cuyos dígitos están representados por las ... // ... letras AF pueden ser mayúsculas o minúsculas

También existe un separador numérico, _ (el guion bajo), introducido en ES2021:

// Nota: La sintaxis de Wikipedia aún no admite separadores numéricos 1 _000_000_000 ; // Se usa con números grandes 1 _000_000 .5 ; // Admite decimales 1 _000e1_000 ; // Admite exponentes// Soporte con binario, octal y hexadecimal 0b0000 _0000_0101_1011 ; 0o0001 _3520_0237_1327 ; 0xFFFF _FFFF_FFFF_FFFE ;// Pero los usuarios no pueden usarlos junto a una parte numérica que no sea un dígito, ni al principio ni al final _12 ; // La variable no está definida (el guion bajo la convierte en un identificador de variable) 12 _ ; // Error de sintaxis (no puede estar al final de los números) 12 _ .0 ; // Error de sintaxis (no tiene sentido poner un separador junto al punto decimal) 12. _0 ; // Error de sintaxis 12 e_6 ; // Error de sintaxis (junto a "e", un no dígito. No tiene sentido poner un separador al principio) 1000 ____0000 ; // Error de sintaxis (junto a "_", un no dígito. Solo se permite 1 separador a la vez)

Los rangos +∞ , −∞ y NaN (Not a Number) del tipo numérico se pueden obtener mediante dos expresiones de programa :

Infinito ; // infinito positivo (negativo se obtiene con -Infinito, por ejemplo) NaN ; // El valor Not-A-Number, también devuelto como un error en ... // ... conversiones de cadena a número

Infinito y NaN son números:

typeof Infinity ; // devuelve "número" typeof NaN ; // devuelve "número"

Estos tres valores especiales se corresponden y se comportan como los describe la norma IEEE-754 .

El constructor Number (utilizado como función), o un operador unario + o -, pueden utilizarse para realizar conversiones numéricas explícitas:

const myString = "123.456" ; const myNumber1 = Number ( myString ); const myNumber2 = + myString ;

Cuando se utiliza como constructor, se crea un objeto contenedor numérico (aunque es de poca utilidad):

const myNumericWrapper = new Number ( 123.456 );

Sin embargo, NaN no es igual a sí mismo:

constante nan = NaN ; consola . iniciar sesión ( NaN == NaN ); // consola falsa . iniciar sesión ( NaN === NaN ); // consola falsa . iniciar sesión ( NaN ! == NaN ); // verdadera consola . iniciar sesión ( nan !== nan ); // verdadero// Los usuarios pueden usar los métodos isNaN para comprobar si hay NaN console.log ( isNaN ( " convertido a NaN" ) ); // verdadero console.log ( isNaN ( NaN ) ); // verdadero console.log ( Number.isNaN ( " no convertido" ) ); // falso console.log ( Number.isNaN ( NaN ) ) ; // verdadero

En JavaScript, los números regulares se representan con el tipo de punto flotante IEEE 754, lo que significa que los enteros solo se pueden almacenar de forma segura si el valor se encuentra entre Number.MIN_SAFE_INTEGERy Number.MAX_SAFE_INTEGER. ^{[ 10 ]} En cambio, BigInts representa enteros de cualquier tamaño, lo que permite a los programadores almacenar enteros demasiado grandes o pequeños para ser representados con el formato IEEE 754. ^{[ 11 ]}

Hay dos maneras de declarar un valor BigInt. Se npuede agregar un entero o BigIntse puede usar la función: ^{[ 11 ]}

const a = 12345n ; // Crea una variable y almacena un valor BigInt de 12345 const b = BigInt ( 12345 );

En JavaScript, una cadena" es una secuencia de caracteres. Las cadenas se pueden crear directamente (como literales) colocando la serie de caracteres entre comillas dobles ( ) o simples ( '). Dichas cadenas deben escribirse en una sola línea, pero pueden incluir caracteres de salto de línea escapados (como \n). El estándar de JavaScript permite el carácter de comilla invertida` ( , también conocido como acento grave o acento grave) para entrecomillar cadenas literales multilínea, así como expresiones incrustadas que utilizan la sintaxis . ^{[ 12 ]}${expression}

const greeting = "¡Hola, mundo!" ; const anotherGreeting = 'Saludos, gente de la Tierra.' ; const aMultilineGreeting = `Saludos cordiales, John Doe.`// Los literales de plantilla convierten a tipo las expresiones evaluadas y las interpolan en la cadena. const templateLiteral = `Esto es lo que se almacena en anotherGreeting: ${ anotherGreeting } .` ; console . log ( templateLiteral ); // 'Esto es lo que se almacena en anotherGreeting: 'Saludos, gente de la Tierra.'' console . log ( `Tienes ${ Math . floor ( age )=> 18 ? "permitido" : "no permitido" } para ver esta página web` );

Se puede acceder a caracteres individuales dentro de una cadena utilizando el método charAt (proporcionado por String.prototype ). Esta es la forma preferida de acceder a caracteres individuales dentro de una cadena, ya que también funciona en navegadores antiguos:

const h = greeting.charAt ( 0 ) ;​

En los navegadores modernos, se puede acceder a los caracteres individuales dentro de una cadena (como cadenas con un solo carácter) mediante la misma notación que se utiliza para las matrices:

const h = saludo [ 0 ];

Sin embargo, las cadenas de JavaScript son inmutables :

saludo [ 0 ] = "H" ; // Falla.

Al aplicar el operador de igualdad ("==") a dos cadenas, el resultado es verdadero si las cadenas tienen el mismo contenido, es decir: la misma longitud y la misma secuencia de caracteres (las mayúsculas y minúsculas son importantes para los alfabetos). Por lo tanto:

const x = "World" ; const compare1 = ( "Hello, " + x == "Hello, World" ); // Aquí compare1 contiene true. const compare2 = ( "Hello, " + x == "hello, World" ); // Aquí compare2 contiene ... // ... false ya que los ... // ... primeros caracteres ... // ... de ambos operandos ... // ... no son de la misma mayúscula/minúscula.

Las citas del mismo tipo no se pueden anidar a menos que se escapen .

let x = '"¡Hola, mundo!" dijo.' ; // Bien. x = "" ¡Hola , mundo ! " dijo." ; // No está bien. x = "\"¡Hola, mundo!\" dijo." ; // Funciona escapando " con \"

El constructor String crea un objeto string (un objeto que encapsula una cadena):

const greeting = new String ( "Hola, mundo!" );

Estos objetos tienen un método valueOf que devuelve la cadena primitiva encapsulada en ellos :

const s = new String ( "Hello !" ); typeof s ; // Es 'object'. typeof s . valueOf (); // Es 'string'.

La igualdad entre dos objetos String no se comporta como con los tipos de datos primitivos de cadena:

const s1 = new String ( "Hello !" ); const s2 = new String ( "Hello !" ); s1 == s2 ; // Es falso, porque son dos objetos distintos. s1 . valueOf () == s2 . valueOf (); // Es verdadero.

JavaScript proporciona un tipo de dato booleano con literales verdadero y falso . El operador `typeof` devuelve la cadena "boolean" para estos tipos primitivos . Cuando se utiliza en un contexto lógico, 0 , -0 , null , NaN , undefined y la cadena vacía ( "" ) se evalúan como falsos debido a la conversión automática de tipos . Todos los demás valores (el complemento de la lista anterior) se evalúan como verdaderos , incluidas las cadenas "0" , "false" y cualquier objeto.

La coerción automática de tipos por parte de los operadores de comparación de igualdad ( ==y !=) se puede evitar utilizando los operadores de comparación con comprobación de tipos ( ===y !==).

Cuando se requiere conversión de tipo, JavaScript convierte los operandos Boolean , Number , String u Object de la siguiente manera: ^{[ 13 ]}

Número y cadena

La cadena se convierte en un valor numérico. JavaScript intenta convertir el literal numérico de la cadena a un valor de tipo Número. Primero, se obtiene un valor matemático a partir del literal numérico de la cadena. Luego, este valor se redondea al número entero más cercano.

Booleano

Si uno de los operandos es un valor booleano, el operando booleano se convierte en 1 si es verdadero o en 0 si es falso .

Objeto

Si se compara un objeto con un número o una cadena, JavaScript intenta devolver el valor predeterminado del objeto. Para ello, el objeto se convierte a un valor primitivo de tipo cadena o número mediante los métodos ` .valueOf()` o `.toString()` . Si esto falla, se genera un error en tiempo de ejecución.

// Conversión automática de tipos console.log(true == 2); // false... true → 1 !== 2 ← 2 console.log(false == 2 ) ; // false ... false → 0 !== 2 ← 2 console.log(true == 1 ) ; // true .... true → 1 === 1 ← 1 console.log( false == 0 ) ; // true .... false → 0 === 0 ← 0 console.log ( true == " 2 " ) ; // false ... true → 1 !== 2 ← "2" console.log ( false == " 2" ); // false ... false → 0 !== 2 ← "2" console.log ( true == "1" ) ; // verdadero.... verdadero → 1 === 1 ← "1" consola . iniciar sesión ( falso == "0" ); // verdadero.... falso → 0 === 0 ← "0" consola . iniciar sesión ( falso == "" ); // verdadero.... falso → 0 === 0 ← "" consola . iniciar sesión ( falso == NaN ); // falso... falso → 0 !== NaNconsole.log ( NaN == NaN ); // falso...... NaN no es equivalente a nada, incluido NaN .// Comparación con comprobación de tipos (sin conversión de tipos y valores) console.log ( true === 1 ); // false ...... los tipos de datos no coinciden// Coerción de tipo explícita console.log ( true === !! 2 ); // verdadero... los tipos de datos y los valores coinciden console.log (true === !! 0); // falso... los tipos de datos coinciden, pero los valores difieren console.log( 1 ? verdadero : falso ) ; // verdadero... solo ±0 y NaN son números "falsos" console.log( " 0 " ? verdadero : falso ) ; // verdadero ... solo la cadena vacía es " falsa " console.log ( Booleano ( { })); // verdadero... todos los objetos son "verdaderos "

const b = new Boolean ( false ); // Objeto false {} const t = Boolean ( b ); // Booleano true const f = Boolean ( b.valueOf ( )); // Booleano false let n = new Boolean ( b ); // No recomendado n = new Boolean ( b.valueOf ( ) ); // Preferidoif ( 0 || - 0 || "" || null || undefined || b . valueOf () || ! new Boolean () || ! t ) { console . log ( "Nunca esto" ); } else if ([] && {} && b && typeof b === "object" && b . toString () === "false" ) { console . log ( "Siempre esto" ); }

Los símbolos son una característica introducida en ES6 . Se garantiza que cada símbolo es un valor único y se pueden usar para la encapsulación . ^{[ 15 ]}

Ejemplo:

let x = Symbol ( 1 ); const y = Symbol ( 1 ); x === y ; // => falseconst symbolObject = {}; const normalObject = {};// dado que x e y son únicos, // pueden usarse como claves únicas en un objeto symbolObject [ x ] = 1 ; symbolObject [ y ] = 2 ;symbolObject [ x ]; // => 1 symbolObject [ y ]; // => 2// en comparación con las teclas numéricas normales normalObject [ 1 ] = 1 ; normalObject [ 1 ] = 2 ; // sobrescribe el valor de 1normalObject [ 1 ]; // => 2// cambiar el valor de x no cambia la clave almacenada en el objeto x = Symbol ( 3 ); symbolObject [ x ]; // => indefinido// Cambiar x de nuevo solo crea otro símbolo único x = Symbol ( 1 ); symbolObject [ x ]; // => indefinido

También existen símbolos muy conocidos .

Una de ellas es Symbol.iterator; si algo implementa Symbol.iterator, es iterable:

const x = [ 1 , 2 , 3 , 4 ]; // x es un Array x [ Symbol . iterator ] === Array . prototype [ Symbol . iterator ]; // y los Arrays son iterablesconst xIterator = x [ Symbol.iterator ](); // La función [ Symbol.iterator ] debe proporcionar un iterador para x xIterator.next ( ) ; // { value: 1, done: false } xIterator.next ( ) ; // { value: 2, done: false } xIterator.next ( ); // { value: 3, done: false } xIterator.next ( ) ; // { value : 4, done: false } xIterator.next ( ); // { value: undefined, done: true } xIterator.next (); // { value: undefined, done: true }// Los bucles for..of iteran automáticamente los valores for ( const value of x ) { console . log ( value ); // 1 2 3 4 }// Los conjuntos también son iterables: [ Symbol . iterator ] in Set . prototype ; // truefor ( const value of new Set ([ 'apple' , 'orange' ])) { console . log ( value ); // "apple" "orange" }

Un Array es un objeto JavaScript prototipado desde el Arrayconstructor diseñado específicamente para almacenar valores de datos indexados por claves enteras. Los Arrays, a diferencia del tipo Object básico, se prototipan con métodos y propiedades para ayudar al programador en tareas rutinarias (por ejemplo, join, slice, y push).

Al igual que en la familia C , los arreglos utilizan un esquema de indexación basado en cero: un valor que se inserta en un arreglo vacío mediante el pushmétodo ocupa el índice 0 del arreglo.

const myArray = []; // Apunta la variable myArray a un Array vacío recién creado . myArray.push ( "hello World" ); // Rellena el siguiente índice vacío, en este caso 0. console.log(myArray [ 0 ] ) ; // Equivalente a console.log("hello World");

Los arreglos tienen una lengthpropiedad que siempre será mayor que el índice entero más grande utilizado en el arreglo. Esta propiedad se actualiza automáticamente si se crea una propiedad con un índice aún mayor. Al escribir un número menor en la lengthpropiedad, se eliminarán los índices mayores.

ArraySe puede acceder a los elementos de s utilizando la notación normal de acceso a las propiedades de los objetos:

myArray [ 1 ]; // el segundo elemento en myArray myArray [ "1" ];

Las dos opciones anteriores son equivalentes. No es posible utilizar la notación de "punto" ni cadenas con representaciones alternativas del número:

myArray .1 ; // error de sintaxis myArray [ "01" ]; // no es lo mismo que myArray[1]

La declaración de un array puede realizarse mediante un Arrayliteral o mediante el Arrayconstructor:

sea ​​miArray ;// Literales de matriz myArray = [ 1 , 2 ]; // longitud de 2 myArray = [ 1 , 2 ,]; // misma matriz - Los usuarios también pueden tener una coma adicional al final// También es posible no rellenar partes del array myArray = [ 0 , 1 , /* hueco */ , /* hueco */ , 4 , 5 ]; // longitud de 6 myArray = [ 0 , 1 , /* hueco */ , /* hueco */ , 4 , 5 ,]; // mismo array myArray = [ 0 , 1 , /* hueco */ , /* hueco */ , 4 , 5 , /* hueco */ ,]; // longitud de 7// Con el constructor myArray = new Array ( 0 , 1 , 2 , 3 , 4 , 5 ); // longitud de 6 myArray = new Array ( 365 ); // un array vacío con longitud 365

Los arreglos se implementan de manera que solo los elementos definidos usan memoria; son " arreglos dispersos ". Configurar y solo usa espacio para estos dos elementos, al igual que cualquier otro objeto. El del arreglo seguirá siendo reportado como 58. La longitud máxima de un arreglo es 4,294,967,295 que corresponde al número binario de 32 bits (11111111111111111111111111111111) ₂ .myArray[10]='someThing'myArray[57]='somethingOther'length

Se puede utilizar la declaración literal de objeto para crear objetos que se comportan de forma muy similar a los arreglos asociativos en otros lenguajes:

const perro = { color : "marrón" , tamaño : "grande" }; perro [ "color" ]; // da como resultado "marrón" perro . color ; // también da como resultado "marrón"

Se pueden usar las declaraciones literales de objetos y matrices para crear rápidamente matrices asociativas, multidimensionales o ambas. (Técnicamente, JavaScript no admite matrices multidimensionales, pero se pueden simular con matrices de matrices).

const cats = [{ color : "brown" , size : "large" }, { color : "black" , size : "small" }]; cats [ 0 ][ "size" ]; // da como resultado "large"const dogs = { rover : { color : "brown" , size : "large" }, spot : { color : "black" , size : "small" }}; dogs [ "spot" ][ "size" ]; // da como resultado "small" dogs . rover . color ; // da como resultado "brown"

Un Dateobjeto almacena un contador de milisegundos con signo, donde cero representa el 1 de enero de 1970 a las 00:00:00 UT y un rango de ±10⁸ ^días . Existen varias formas de proporcionar argumentos al Dateconstructor. Tenga en cuenta que los meses comienzan en cero.

new Date (); // crea una nueva instancia de Date que representa la hora/fecha actual. new Date ( 2010 , 2 , 1 ); // crea una nueva instancia de Date que representa 2010-Mar-01 00:00:00 new Date ( 2010 , 2 , 1 , 14 , 25 , 30 ); // crea una nueva instancia de Date que representa 2010-Mar-01 14:25:30 new Date ( "2010-3-1 14:25:30" ); // crea una nueva instancia de Date a partir de una String.

Se proporcionan métodos para extraer campos, así como una herramienta útil toString:

const d = new Date ( 2010 , 2 , 1 , 14 , 25 , 30 ); // 2010-Mar-01 14:25:30;// Muestra '2010-3-1 14:25:30': console . log ( d . getFullYear () + '-' + ( d . getMonth () + 1 ) + '-' + d . getDate () + ' ' + d . getHours () + ':' + d . getMinutes () + ':' + d . getSeconds ());// El método toString integrado devuelve algo como 'Mon 1 March, 2010 14:25:30 GMT-0500 (EST)': console . log ( d );

Se pueden crear mensajes de error personalizados utilizando la Errorclase:

lanzar nuevo Error ( "Algo salió mal." );

Estas excepciones pueden ser capturadas por bloques try...catch...finally como se describe en la sección sobre manejo de excepciones .

El objeto Math contiene varias constantes relacionadas con las matemáticas (por ejemplo, π ) y funciones (por ejemplo, coseno). (Tenga en cuenta que el objeto Math no tiene constructor, a diferencia de Array o Date . Todos sus métodos son "estáticos", es decir, métodos de "clase"). Todas las funciones trigonométricas utilizan ángulos expresados ​​en radianes , no en grados ni en grados centesimales .

Cada función en JavaScript es una instancia del Functionconstructor :

// x, y es el argumento. 'return x + y' es el cuerpo de la función, que es el último en la lista de argumentos. const add = new Function ( 'x' , 'y' , 'return x + y' ); add ( 1 , 2 ); // => 3

La función de suma anterior también se puede definir mediante una expresión de función:

const add = function ( x , y ) { return x + y ; }; add ( 1 , 2 ); // => 3

En ES6, se agregó la sintaxis de función flecha, lo que permite que las funciones que devuelven un valor sean más concisas. También conservan el thisdel objeto global en lugar de heredarlo del lugar donde se llamó o sobre qué se llamó, a diferencia de la function() {}expresión.

const add = ( x , y ) => { return x + y ;}; // Los valores también se pueden devolver implícitamente (es decir, no se necesita una instrucción return) const addImplicit = ( x , y ) => x + y ;agregar ( 1 , 2 ); // => 3 agregarImplícito ( 1 , 2 ) // => 3

Para las funciones que necesitan ser elevadas, existe una expresión separada:

función agregar ( x , y ) { return x + y ; } agregar ( 1 , 2 ); // => 3

El sistema de elevación permite a los usuarios utilizar la función antes de que sea "declarada":

add ( 1 , 2 ); // => 3, no es una función ReferenceError add ( x , y ) { return x + y ; }

Una instancia de función tiene propiedades y métodos.

función restar ( x , y ) { return x - y ; }console.log ( subtract.length ); // = > 2 , aridad de la función (número de argumentos ) console.log ( subtract.toString ( ) ) ;/* "función restar(x, y) {  return x - y; }" */

JavaScript admite los siguientes operadores aritméticos binarios :

JavaScript admite los siguientes operadores aritméticos unarios :

let x = 1 ; console.log ( ++ x ); // x se convierte en 2; muestra 2 console.log(x++); // muestra 2; x se convierte en 3 console.log( x ) ; // x es 3 ; muestra 3 console.log( x-- ) ; // muestra 3 ; x se convierte en 2 console.log ( x ) ; // muestra 2 ; x es 2 console.log ( -- x ) ; // x se convierte en 1; muestra 1

El operador módulo muestra el resto de la división por el módulo. Si intervienen números negativos, el valor devuelto depende del operando.

const x = 17 ; console.log ( x % 5 ) ; // muestra 2 console.log ( x % 6 ) ; // muestra 5 console.log ( -x % 5 ); // muestra -2 console.log ( -x % -5 ) ; // muestra -2 console.log ( x % -5 ) ; // muestra 2

Para que siempre se obtenga un número no negativo, los usuarios pueden volver a sumar el módulo y aplicar de nuevo el operador módulo:

const x = 17 ; console.log (( - x % 5 + 5 ) % 5 ); // muestra 3

Los usuarios también podrían hacer lo siguiente:

const x = 17 ; console.log ( Math.abs ( -x % 5 ) ) ; // también 3​

Asignación de tipos primitivos

let x = 9 ; x += 1 ; console.log ( x ); // muestra: 10 x *= 30 ; console.log ( x ); // muestra : 300 x /= 6 ; console.log ( x ); // muestra: 50 x - = 3 ; console.log ( x ) ; // muestra: 47 x % = 7 ; console.log ( x ) ; // muestra : 5

Asignación de tipos de objetos

/** * Para aprender sobre objetos JavaScript... */ const object_1 = { a : 1 }; // asigna la referencia del objeto recién creado a object_1 let object_2 = { a : 0 }; let object_3 = object_2 ; // object_3 hace referencia al mismo objeto que object_2 object_3 . a = 2 ; message (); // muestra 1 2 2 object_2 = object_1 ; // object_2 ahora hace referencia al mismo objeto que object_1 // object_3 todavía hace referencia a lo que object_2 hacía referencia antes message (); // muestra 1 1 2 object_2 . a = 7 ; // modifica object_1 message (); // muestra 7 7 2objeto_3.a = 5 ; // objeto_3 no cambia objeto_2 mensaje ( ); // muestra 7 7 5objeto_3 = objeto_2 ; objeto_3.a = 4 ; // objeto_3 cambia objeto_1 y objeto_2 mensaje ( ); // muestra 4 4 4/** * Imprime el mensaje en la consola */ function message () { console . log ( object_1 . a + " " + object_2 . a + " " + object_3 . a ); }

let a , b , c , d , e ; [ a , b , c ] = [ 3 , 4 , 5 ]; console . log ( ` ${ a } , ${ b } , ${ c } ` ); // muestra: 3,4,5 e = { foo : 5 , bar : 6 , baz : [ 'Baz' , 'Content' ]}; const arr = []; ({ baz : [ arr [ 0 ], arr [ 3 ]], foo : a , bar : b } = e ); console . log ( ` ${ a } , ${ b } , ${ arr } ` ); // muestra: 5,6,Baz,,,Content [ a , b ] = [ b , a ]; // intercambia el contenido de a y b console . log ( a + ',' + b ); // muestra: 6,5[ a , b , c ] = [ 3 , 4 , 5 ]; // permutaciones [ a , b , c ] = [ b , c , a ]; console . log ( ` ${ a } , ${ b } , ${ c } ` ); // muestra: 4,5,3

const a = [ 1 , 2 , 3 , 4 ];// Se puede usar varias veces en la misma expresión.const b = [... a , ... a ]; // b = [1, 2, 3, 4, 1, 2, 3, 4];// Se puede combinar con artículos que no se extienden.const c = [ 5 , 6 , ... a , 7 , 9 ]; // c = [5, 6, 1, 2, 3, 4, 7, 9];// Para comparar, haciendo esto sin el operador de propagación// crea un array anidado.const d = [ a , a ]; // d = [[1, 2, 3, 4], [1, 2, 3, 4]]// Funciona igual con las llamadas a funcionesfunción foo ( arg1 , arg2 , arg3 ) {console.log ( ` ${ arg1 } : ${ arg2 } : $ { arg3 } ` ) ;}// Los usuarios pueden usarlo incluso si pasa más parámetros de los que la función utilizará.foo (... un ); // "1:2:3" → foo(a[0], a[1], a[2], a[3]);// Los usuarios pueden combinarlo con parámetros que no sean de propagación.foo ( 5 , ... a , 6 ); // "5:1:2" → foo(5, a[0], a[1], a[2], a[3], 6);// Para comparar, haciendo esto sin el operador de propagación// Asigna el array a arg1 y nada a los demás parámetros.foo ( a ); // "1,2,3,4:undefined:undefined"const barra = { a : 1 , b : 2 , c : 3 };// Esto copiaría el objetoconst copy = { ... bar }; // copy = { a: 1, b: 2, c: 3 };// Aquí se sobrescribiría la "b".const override = { ... bar , b : 4 }; // override = { a: 1, c: 3, b: 4 }

función foo ( a , b , ... c ) { console . log ( c . length ); }foo ( 1 , 2 , 3 , 4 , 5 ); // "3" → c = [3, 4, 5] foo ( 'a' , 'b' ); // "0" → c = []