Învață JavaScript: comenzi explicate cu exemple

Toate funcțiile

Lista completă a celor 768 funcții și metode JavaScript incluse aici: metodele obiectelor predefinite ale limbajului (citite direct din Node.js) și cele mai folosite API-uri ale browserului, cu semnătura lor (parametrii între [ ] sunt opționali). Funcțiile cu link au o pagină cu explicații și exemple. Cele marcate „Învechită” încă merg, dar nu le mai folosi în cod nou.

Șiruri de caractere și expresii regulate (60)

Funcție	Ce face
RegExp	Creează o expresie regulată dintr-un model și indicatori (g, i, m, u, s, d, v, y). RegExp(pattern[, flags])
RegExp.escape	Escapează caracterele speciale ca textul să fie căutat exact într-o expresie regulată. RegExp.escape(string)
RegExp.prototype.compile	Învechită: recompilează expresia cu alt model; creează un RegExp nou. regex.compile(pattern[, flags])
RegExp.prototype.exec	Următoarea potrivire, cu grupuri, index și groups, ori null. regex.exec(str)
RegExp.prototype.test	Verifică dacă textul se potrivește cu expresia: true sau false. regex.test(str)
RegExp.prototype.toString	Expresia ca text, cu bare oblice și indicatori (de ex. „/\d+/g”). regex.toString()
String	Transformă orice valoare în șir de caractere (inclusiv null și undefined). String(value)
String.fromCharCode	Construiește un text din coduri UTF-16 (până la 65535). String.fromCharCode(num1, ..., numN)
String.fromCodePoint	Construiește un text din coduri Unicode complete, inclusiv emoji. String.fromCodePoint(num1, ..., numN)
String.prototype.anchor	Învechită: înconjoară textul cu eticheta HTML <a name>; construiește elementele cu DOM și CSS. str.anchor(name)
String.prototype.at	Caracterul de la o poziție; indicii negativi numără de la sfârșit. str.at(index)
String.prototype.big	Învechită: înconjoară textul cu eticheta HTML <big>; construiește elementele cu DOM și CSS. str.big()
String.prototype.blink	Învechită: înconjoară textul cu eticheta HTML <blink>; construiește elementele cu DOM și CSS. str.blink()
String.prototype.bold	Învechită: înconjoară textul cu eticheta HTML <b>; construiește elementele cu DOM și CSS. str.bold()
String.prototype.charAt	Caracterul de la o poziție sau „” dacă poziția nu există. str.charAt(index)
String.prototype.charCodeAt	Codul UTF-16 (0–65535) al caracterului de la o poziție. str.charCodeAt(index)
String.prototype.codePointAt	Codul Unicode complet al caracterului de la o poziție (corect și pentru emoji). str.codePointAt(index)
String.prototype.concat	Lipește alte texte la sfârșitul șirului și returnează rezultatul. str.concat(str1, ..., strN)
String.prototype.endsWith	Verifică dacă textul se termină cu un anumit text. str.endsWith(searchString[, endPosition])
String.prototype.fixed	Învechită: înconjoară textul cu eticheta HTML <tt>; construiește elementele cu DOM și CSS. str.fixed()
String.prototype.fontcolor	Învechită: înconjoară textul cu eticheta HTML <font color>; construiește elementele cu DOM și CSS. str.fontcolor(color)
String.prototype.fontsize	Învechită: înconjoară textul cu eticheta HTML <font size>; construiește elementele cu DOM și CSS. str.fontsize(size)
String.prototype.includes	Verifică dacă textul conține alt text (ține cont de majuscule). str.includes(searchString[, position])
String.prototype.indexOf	Poziția primei apariții a unui text sau -1. str.indexOf(searchString[, position])
String.prototype.isWellFormed	Verifică dacă textul nu are perechi surogat rupte (Unicode valid). str.isWellFormed()
String.prototype.italics	Învechită: înconjoară textul cu eticheta HTML <i>; construiește elementele cu DOM și CSS. str.italics()
String.prototype.lastIndexOf	Poziția ultimei apariții a unui text sau -1. str.lastIndexOf(searchString[, position])
String.prototype.link	Învechită: înconjoară textul cu eticheta HTML <a href>; construiește elementele cu DOM și CSS. str.link(url)
String.prototype.localeCompare	Compară două texte după alfabetul unei limbi; util la sortare cu diacritice. str.localeCompare(compareString[, locales[, options]])
String.prototype.match	Potrivirile unei expresii regulate (prima, cu grupuri, sau toate cu g) ori null. str.match(regexp)
String.prototype.matchAll	Iterator cu toate potrivirile unei expresii cu g, fiecare cu grupuri și poziție. str.matchAll(regexp)
String.prototype.normalize	Aduce textul la o formă Unicode standard (NFC, NFD, NFKC, NFKD). str.normalize([form])
String.prototype.padEnd	Completează textul la dreapta până la lungimea dorită. str.padEnd(targetLength[, padString])
String.prototype.padStart	Completează textul la stânga până la lungimea dorită (de ex. zerouri în față). str.padStart(targetLength[, padString])
String.prototype.repeat	Returnează textul repetat de un număr de ori. str.repeat(count)
String.prototype.replace	Înlocuiește prima apariție (sau toate, cu o expresie cu g) a unui text. str.replace(pattern, replacement)
String.prototype.replaceAll	Înlocuiește toate aparițiile unui text sau ale unei expresii regulate. str.replaceAll(pattern, replacement)
String.prototype.search	Poziția primei potriviri a unei expresii regulate sau -1. str.search(regexp)
String.prototype.slice	Bucata de text dintre două poziții; acceptă indici negativi. str.slice(indexStart[, indexEnd])
String.prototype.small	Învechită: înconjoară textul cu eticheta HTML <small>; construiește elementele cu DOM și CSS. str.small()
String.prototype.split	Împarte textul într-un tablou după un separator. str.split([separator[, limit]])
String.prototype.startsWith	Verifică dacă textul începe cu un anumit text. str.startsWith(searchString[, position])
String.prototype.strike	Învechită: înconjoară textul cu eticheta HTML <strike>; construiește elementele cu DOM și CSS. str.strike()
String.prototype.sub	Învechită: înconjoară textul cu eticheta HTML <sub>; construiește elementele cu DOM și CSS. str.sub()
String.prototype.substr	Învechită: bucata de text de la o poziție, cu o lungime dată; folosește slice. str.substr(start[, length])
String.prototype.substring	Bucata de text dintre două poziții; negativele devin 0. str.substring(indexStart[, indexEnd])
String.prototype.sup	Învechită: înconjoară textul cu eticheta HTML <sup>; construiește elementele cu DOM și CSS. str.sup()
String.prototype.toLocaleLowerCase	Litere mici după regulile unei limbi (de ex. turca). str.toLocaleLowerCase([locales])
String.prototype.toLocaleUpperCase	Litere mari după regulile unei limbi (de ex. turca). str.toLocaleUpperCase([locales])
String.prototype.toLowerCase	Transformă textul în litere mici. str.toLowerCase()
String.prototype.toString	Returnează textul însuși (pentru un obiect String, valoarea simplă). str.toString()
String.prototype.toUpperCase	Transformă textul în litere mari. str.toUpperCase()
String.prototype.toWellFormed	Copie a textului în care perechile surogat rupte devin caracterul �. str.toWellFormed()
String.prototype.trim	Elimină spațiile albe de la ambele capete. str.trim()
String.prototype.trimEnd	Elimină spațiile albe de la sfârșitul textului. str.trimEnd()
String.prototype.trimLeft	Alias vechi pentru trimStart. str.trimLeft()
String.prototype.trimRight	Alias vechi pentru trimEnd. str.trimRight()
String.prototype.trimStart	Elimină spațiile albe de la începutul textului. str.trimStart()
String.prototype.valueOf	Valoarea simplă de tip string a unui obiect String. str.valueOf()
String.raw	Template literal în care backslash-urile rămân text, fără secvențe speciale. String.raw(strings, ...substitutions)

Tablouri, typed arrays, ArrayBuffer și iteratori (142)

Funcție	Ce face
Array	Creează un tablou; cu un singur număr creează un tablou gol de acea lungime. Array([element1, ..., elementN | arrayLength])
Array.from	Tablou nou din orice iterabil sau obiect cu length, cu transformare opțională. Array.from(items[, mapFn[, thisArg]])
Array.fromAsync	Tablou nou din valori asincrone (iterator asincron, promisiuni). Array.fromAsync(items[, mapFn[, thisArg]])
Array.isArray	Verifică dacă o valoare este un tablou. Array.isArray(value)
Array.of	Tablou nou din valorile primite (fără capcana constructorului Array). Array.of(element1, ..., elementN)
Array.prototype.at	Elementul de la o poziție; indicii negativi numără de la sfârșit. arr.at(index)
Array.prototype.concat	Tablou nou format din tablou urmat de alte tablouri sau valori. arr.concat(value1, ..., valueN)
Array.prototype.copyWithin	Copiază o bucată din tablou peste altă poziție din același tablou. arr.copyWithin(target, start[, end])
Array.prototype.entries	Iterator cu perechi [indice, element]. arr.entries()
Array.prototype.every	Verifică dacă toate elementele îndeplinesc o condiție. arr.every(callbackFn[, thisArg])
Array.prototype.fill	Umple tabloul (sau o zonă) cu aceeași valoare. arr.fill(value[, start[, end]])
Array.prototype.filter	Tablou nou doar cu elementele care îndeplinesc o condiție. arr.filter(callbackFn[, thisArg])
Array.prototype.find	Primul element care îndeplinește o condiție sau undefined. arr.find(callbackFn[, thisArg])
Array.prototype.findIndex	Poziția primului element care îndeplinește o condiție sau -1. arr.findIndex(callbackFn[, thisArg])
Array.prototype.findLast	Ultimul element care îndeplinește o condiție sau undefined. arr.findLast(callbackFn[, thisArg])
Array.prototype.findLastIndex	Poziția ultimului element care îndeplinește o condiție sau -1. arr.findLastIndex(callbackFn[, thisArg])
Array.prototype.flat	Tablou nou aplatizat până la adâncimea dată. arr.flat([depth])
Array.prototype.flatMap	map urmat de aplatizare cu un nivel. arr.flatMap(callbackFn[, thisArg])
Array.prototype.forEach	Rulează o funcție pentru fiecare element. arr.forEach(callbackFn[, thisArg])
Array.prototype.includes	Verifică dacă tabloul conține o valoare (găsește și NaN). arr.includes(searchElement[, fromIndex])
Array.prototype.indexOf	Poziția primei apariții a unei valori sau -1. arr.indexOf(searchElement[, fromIndex])
Array.prototype.join	Lipește elementele într-un text, cu un separator. arr.join([separator])
Array.prototype.keys	Iterator cu indicii tabloului. arr.keys()
Array.prototype.lastIndexOf	Poziția ultimei apariții a unei valori sau -1. arr.lastIndexOf(searchElement[, fromIndex])
Array.prototype.map	Tablou nou cu rezultatul funcției pentru fiecare element. arr.map(callbackFn[, thisArg])
Array.prototype.pop	Scoate și returnează ultimul element. arr.pop()
Array.prototype.push	Adaugă elemente la sfârșit și returnează noua lungime. arr.push(element1, ..., elementN)
Array.prototype.reduce	Combină elementele într-o singură valoare, de la stânga la dreapta. arr.reduce(callbackFn[, initialValue])
Array.prototype.reduceRight	Combină elementele într-o singură valoare, de la dreapta la stânga. arr.reduceRight(callbackFn[, initialValue])
Array.prototype.reverse	Inversează ordinea elementelor, modificând tabloul. arr.reverse()
Array.prototype.shift	Scoate și returnează primul element. arr.shift()
Array.prototype.slice	Copie a unei bucăți dintre două poziții (acceptă indici negativi). arr.slice([start[, end]])
Array.prototype.some	Verifică dacă cel puțin un element îndeplinește o condiție. arr.some(callbackFn[, thisArg])
Array.prototype.sort	Sortează tabloul pe loc (implicit ca texte; dă o funcție pentru numere). arr.sort([compareFn])
Array.prototype.splice	Șterge, înlocuiește sau inserează elemente, modificând tabloul. arr.splice(start[, deleteCount[, item1, ..., itemN]])
Array.prototype.toLocaleString	Text cu elementele formatate după limbă, separate prin virgulă. arr.toLocaleString([locales[, options]])
Array.prototype.toReversed	Copie inversată, fără a modifica originalul. arr.toReversed()
Array.prototype.toSorted	Copie sortată, fără a modifica originalul. arr.toSorted([compareFn])
Array.prototype.toSpliced	Copie cu elemente șterse sau inserate, fără a modifica originalul. arr.toSpliced(start[, skipCount[, item1, ..., itemN]])
Array.prototype.toString	Text cu elementele separate prin virgulă. arr.toString()
Array.prototype.unshift	Adaugă elemente la început și returnează noua lungime. arr.unshift(element1, ..., elementN)
Array.prototype.values	Iterator cu elementele tabloului. arr.values()
Array.prototype.with	Copie în care elementul de la o poziție este înlocuit. arr.with(index, value)
ArrayBuffer	Bloc de memorie brută de lungime dată, citit prin typed arrays sau DataView. new ArrayBuffer(length[, options])
ArrayBuffer.isView	Verifică dacă o valoare este o vedere (typed array sau DataView). ArrayBuffer.isView(value)
ArrayBuffer.prototype.resize	Schimbă mărimea unui buffer redimensionabil. buffer.resize(newLength)
ArrayBuffer.prototype.slice	Copie a unei bucăți într-un ArrayBuffer nou. buffer.slice([start[, end]])
ArrayBuffer.prototype.transfer	Mută conținutul într-un buffer nou și îl detașează pe cel vechi. buffer.transfer([newByteLength])
ArrayBuffer.prototype.transferToFixedLength	Ca transfer, dar bufferul nou are lungime fixă. buffer.transferToFixedLength([newByteLength])
Atomics.add	Adună atomic o valoare și returnează valoarea veche. Atomics.add(typedArray, index, value)
Atomics.and	ȘI pe biți atomic; returnează valoarea veche. Atomics.and(typedArray, index, value)
Atomics.compareExchange	Înlocuiește valoarea doar dacă este cea așteptată; returnează valoarea veche. Atomics.compareExchange(typedArray, index, expectedValue, replacementValue)
Atomics.exchange	Înlocuiește atomic valoarea și o returnează pe cea veche. Atomics.exchange(typedArray, index, value)
Atomics.isLockFree	Verifică dacă operațiile pe o anumită mărime sunt fără blocare. Atomics.isLockFree(size)
Atomics.load	Citește atomic valoarea de la o poziție. Atomics.load(typedArray, index)
Atomics.notify	Trezește firele care așteaptă pe o poziție. Atomics.notify(typedArray, index[, count])
Atomics.or	SAU pe biți atomic; returnează valoarea veche. Atomics.or(typedArray, index, value)
Atomics.pause	Pauză foarte scurtă, pentru buclele de așteptare activă. Atomics.pause([durationHint])
Atomics.store	Scrie atomic o valoare la o poziție. Atomics.store(typedArray, index, value)
Atomics.sub	Scade atomic o valoare și returnează valoarea veche. Atomics.sub(typedArray, index, value)
Atomics.wait	Oprește firul până la un notify pe aceeași poziție (nu pe firul principal). Atomics.wait(typedArray, index, value[, timeout])
Atomics.waitAsync	Ca wait, dar returnează o promisiune în loc să blocheze. Atomics.waitAsync(typedArray, index, value[, timeout])
Atomics.xor	SAU exclusiv pe biți atomic; returnează valoarea veche. Atomics.xor(typedArray, index, value)
DataView	Vedere care citește și scrie numere de orice tip la orice poziție dintr-un buffer. new DataView(buffer[, byteOffset[, byteLength]])
DataView.prototype.getBigInt64	Citește un BigInt cu semn pe 64 de biți de la o poziție în octeți. view.getBigInt64(byteOffset[, littleEndian])
DataView.prototype.getBigUint64	Citește un BigInt fără semn pe 64 de biți de la o poziție în octeți. view.getBigUint64(byteOffset[, littleEndian])
DataView.prototype.getFloat16	Citește un număr cu zecimale pe 16 biți de la o poziție în octeți. view.getFloat16(byteOffset[, littleEndian])
DataView.prototype.getFloat32	Citește un număr cu zecimale pe 32 de biți de la o poziție în octeți. view.getFloat32(byteOffset[, littleEndian])
DataView.prototype.getFloat64	Citește un număr cu zecimale pe 64 de biți de la o poziție în octeți. view.getFloat64(byteOffset[, littleEndian])
DataView.prototype.getInt16	Citește un întreg cu semn pe 16 biți de la o poziție în octeți. view.getInt16(byteOffset[, littleEndian])
DataView.prototype.getInt32	Citește un întreg cu semn pe 32 de biți de la o poziție în octeți. view.getInt32(byteOffset[, littleEndian])
DataView.prototype.getInt8	Citește un întreg cu semn pe 8 biți de la o poziție în octeți. view.getInt8(byteOffset)
DataView.prototype.getUint16	Citește un întreg fără semn pe 16 biți de la o poziție în octeți. view.getUint16(byteOffset[, littleEndian])
DataView.prototype.getUint32	Citește un întreg fără semn pe 32 de biți de la o poziție în octeți. view.getUint32(byteOffset[, littleEndian])
DataView.prototype.getUint8	Citește un întreg fără semn pe 8 biți de la o poziție în octeți. view.getUint8(byteOffset)
DataView.prototype.setBigInt64	Scrie un BigInt cu semn pe 64 de biți la o poziție în octeți. view.setBigInt64(byteOffset, value[, littleEndian])
DataView.prototype.setBigUint64	Scrie un BigInt fără semn pe 64 de biți la o poziție în octeți. view.setBigUint64(byteOffset, value[, littleEndian])
DataView.prototype.setFloat16	Scrie un număr cu zecimale pe 16 biți la o poziție în octeți. view.setFloat16(byteOffset, value[, littleEndian])
DataView.prototype.setFloat32	Scrie un număr cu zecimale pe 32 de biți la o poziție în octeți. view.setFloat32(byteOffset, value[, littleEndian])
DataView.prototype.setFloat64	Scrie un număr cu zecimale pe 64 de biți la o poziție în octeți. view.setFloat64(byteOffset, value[, littleEndian])
DataView.prototype.setInt16	Scrie un întreg cu semn pe 16 biți la o poziție în octeți. view.setInt16(byteOffset, value[, littleEndian])
DataView.prototype.setInt32	Scrie un întreg cu semn pe 32 de biți la o poziție în octeți. view.setInt32(byteOffset, value[, littleEndian])
DataView.prototype.setInt8	Scrie un întreg cu semn pe 8 biți la o poziție în octeți. view.setInt8(byteOffset, value)
DataView.prototype.setUint16	Scrie un întreg fără semn pe 16 biți la o poziție în octeți. view.setUint16(byteOffset, value[, littleEndian])
DataView.prototype.setUint32	Scrie un întreg fără semn pe 32 de biți la o poziție în octeți. view.setUint32(byteOffset, value[, littleEndian])
DataView.prototype.setUint8	Scrie un întreg fără semn pe 8 biți la o poziție în octeți. view.setUint8(byteOffset, value)
Iterator.concat	Un singur iterator care parcurge pe rând mai multe iterabile. Iterator.concat(...items)
Iterator.from	Iterator cu metode ajutătoare din orice iterabil sau obiect cu next(). Iterator.from(object)
Iterator.prototype.drop	Iterator leneș care sare primele n valori. iterator.drop(limit)
Iterator.prototype.every	Verifică dacă toate valorile îndeplinesc o condiție. iterator.every(callbackFn)
Iterator.prototype.filter	Iterator leneș doar cu valorile care îndeplinesc o condiție. iterator.filter(callbackFn)
Iterator.prototype.find	Prima valoare care îndeplinește o condiție sau undefined. iterator.find(callbackFn)
Iterator.prototype.flatMap	Iterator leneș care desface iterabilele returnate de funcție. iterator.flatMap(callbackFn)
Iterator.prototype.forEach	Rulează o funcție pentru fiecare valoare a iteratorului. iterator.forEach(callbackFn)
Iterator.prototype.map	Iterator leneș cu valorile transformate. iterator.map(callbackFn)
Iterator.prototype.reduce	Combină valorile iteratorului într-una singură. iterator.reduce(callbackFn[, initialValue])
Iterator.prototype.some	Verifică dacă cel puțin o valoare îndeplinește o condiție. iterator.some(callbackFn)
Iterator.prototype.take	Iterator leneș cu primele n valori. iterator.take(limit)
Iterator.prototype.toArray	Adună valorile iteratorului într-un tablou. iterator.toArray()
SharedArrayBuffer	Memorie brută partajată între workers. new SharedArrayBuffer(length[, options])
SharedArrayBuffer.prototype.grow	Mărește un SharedArrayBuffer creat cu maxByteLength. sab.grow(newLength)
SharedArrayBuffer.prototype.slice	Copie a unei bucăți într-un SharedArrayBuffer nou. sab.slice([start[, end]])
TypedArray	Părintele comun al tablourilor numerice (Uint8Array, Float64Array etc.). new TypedArray([length | typedArray | object | buffer[, byteOffset[, length]]])
TypedArray.from	Typed array nou din orice iterabil, cu transformare opțională. TypedArray.from(arrayLike[, mapFn[, thisArg]])
TypedArray.of	Typed array nou din valorile primite. TypedArray.of(element1, ..., elementN)
TypedArray.prototype.at	Elementul de la o poziție; indicii negativi numără de la sfârșit. typedArray.at(index)
TypedArray.prototype.copyWithin	Copiază o bucată din tablou peste altă poziție din același tablou. typedArray.copyWithin(target, start[, end])
TypedArray.prototype.entries	Iterator cu perechi [indice, element]. typedArray.entries()
TypedArray.prototype.every	Verifică dacă toate elementele îndeplinesc o condiție. typedArray.every(callbackFn[, thisArg])
TypedArray.prototype.fill	Umple typed array-ul (sau o zonă) cu aceeași valoare. typedArray.fill(value[, start[, end]])
TypedArray.prototype.filter	Typed array nou doar cu elementele care îndeplinesc o condiție. typedArray.filter(callbackFn[, thisArg])
TypedArray.prototype.find	Primul element care îndeplinește o condiție sau undefined. typedArray.find(callbackFn[, thisArg])
TypedArray.prototype.findIndex	Poziția primului element care îndeplinește o condiție sau -1. typedArray.findIndex(callbackFn[, thisArg])
TypedArray.prototype.findLast	Ultimul element care îndeplinește o condiție sau undefined. typedArray.findLast(callbackFn[, thisArg])
TypedArray.prototype.findLastIndex	Poziția ultimului element care îndeplinește o condiție sau -1. typedArray.findLastIndex(callbackFn[, thisArg])
TypedArray.prototype.forEach	Rulează o funcție pentru fiecare element. typedArray.forEach(callbackFn[, thisArg])
TypedArray.prototype.includes	Verifică dacă typed array-ul conține o valoare (găsește și NaN). typedArray.includes(searchElement[, fromIndex])
TypedArray.prototype.indexOf	Poziția primei apariții a unei valori sau -1. typedArray.indexOf(searchElement[, fromIndex])
TypedArray.prototype.join	Lipește elementele într-un text, cu un separator. typedArray.join([separator])
TypedArray.prototype.keys	Iterator cu indicii typed array-ului. typedArray.keys()
TypedArray.prototype.lastIndexOf	Poziția ultimei apariții a unei valori sau -1. typedArray.lastIndexOf(searchElement[, fromIndex])
TypedArray.prototype.map	Typed array nou, de același tip, cu rezultatul funcției pentru fiecare element. typedArray.map(callbackFn[, thisArg])
TypedArray.prototype.reduce	Combină elementele într-o singură valoare, de la stânga la dreapta. typedArray.reduce(callbackFn[, initialValue])
TypedArray.prototype.reduceRight	Combină elementele într-o singură valoare, de la dreapta la stânga. typedArray.reduceRight(callbackFn[, initialValue])
TypedArray.prototype.reverse	Inversează ordinea elementelor, modificând typed array-ul. typedArray.reverse()
TypedArray.prototype.set	Copiază valori dintr-un tablou într-un typed array, de la o poziție. typedArray.set(array[, targetOffset])
TypedArray.prototype.slice	Copie a unei bucăți dintre două poziții (acceptă indici negativi). typedArray.slice([start[, end]])
TypedArray.prototype.some	Verifică dacă cel puțin un element îndeplinește o condiție. typedArray.some(callbackFn[, thisArg])
TypedArray.prototype.sort	Sortează typed array-ul pe loc, numeric. typedArray.sort([compareFn])
TypedArray.prototype.subarray	Vedere asupra unei bucăți, cu aceeași memorie (fără copiere). typedArray.subarray([begin[, end]])
TypedArray.prototype.toLocaleString	Text cu elementele formatate după limbă, separate prin virgulă. typedArray.toLocaleString([locales[, options]])
TypedArray.prototype.toReversed	Copie inversată, fără a modifica originalul. typedArray.toReversed()
TypedArray.prototype.toSorted	Copie sortată numeric, fără a modifica originalul. typedArray.toSorted([compareFn])
TypedArray.prototype.toString	Text cu elementele separate prin virgulă. typedArray.toString()
TypedArray.prototype.values	Iterator cu elementele typed array-ului. typedArray.values()
TypedArray.prototype.with	Copie în care elementul de la o poziție este înlocuit. typedArray.with(index, value)
Uint8Array.fromBase64	Octeți decodați dintr-un text Base64 sau Base64URL. Uint8Array.fromBase64(string[, options])
Uint8Array.fromHex	Octeți decodați dintr-un text hexazecimal. Uint8Array.fromHex(string)
Uint8Array.prototype.setFromBase64	Scrie într-un tablou existent octeții decodați din Base64. bytes.setFromBase64(string[, options])
Uint8Array.prototype.setFromHex	Scrie într-un tablou existent octeții decodați din hexazecimal. bytes.setFromHex(string)
Uint8Array.prototype.toBase64	Codifică octeții ca text Base64 (sau Base64URL). bytes.toBase64([options])
Uint8Array.prototype.toHex	Codifică octeții ca text hexazecimal. bytes.toHex()

Obiecte, funcții, erori, Map și Set, Reflect, Proxy, JSON (117)

Funcție	Ce face
Boolean	Transformă orice valoare în true sau false. Boolean(value)
Boolean.prototype.toString	„true” sau „false”. bool.toString()
Boolean.prototype.valueOf	Valoarea logică simplă a unui obiect Boolean. bool.valueOf()
Error	Creează un obiect de eroare cu mesaj, nume, stivă și cauză opțională. Error([message[, options]])
Error.captureStackTrace	Adaugă proprietatea stack unui obiect (V8, nestandard). Error.captureStackTrace(targetObject[, constructorOpt])
Error.isError	Verifică dacă o valoare este o eroare adevărată, din orice context. Error.isError(value)
Error.prototype.toString	Text de forma „Nume: mesaj”. err.toString()
eval	Rulează un text ca și cod JavaScript; periculos și lent, evită-l. eval(script)
FinalizationRegistry	Rulează o funcție după ce obiectele înregistrate au fost eliberate din memorie. new FinalizationRegistry(callbackFn)
FinalizationRegistry.prototype.register	Înregistrează un obiect pentru notificare după eliberare. registry.register(target, heldValue[, unregisterToken])
FinalizationRegistry.prototype.unregister	Anulează înregistrările făcute cu un token. registry.unregister(unregisterToken)
Function	Creează o funcție din texte (parametri și corp); ca eval, de evitat. Function(arg1, ..., argN, functionBody)
Function.prototype.apply	Apelează funcția cu this ales și argumentele dintr-un tablou. func.apply(thisArg[, argsArray])
Function.prototype.bind	Funcție nouă cu this fixat și argumente completate dinainte. func.bind(thisArg[, arg1, ..., argN])
Function.prototype.call	Apelează funcția cu this ales și argumentele date separat. func.call(thisArg[, arg1, ..., argN])
Function.prototype.toString	Codul sursă al funcției, ca text. func.toString()
JSON.isRawJSON	Verifică dacă o valoare a fost creată cu JSON.rawJSON. JSON.isRawJSON(value)
JSON.parse	Transformă un text JSON în valoare JavaScript. JSON.parse(text[, reviver])
JSON.rawJSON	Valoare scrisă exact în JSON, de ex. un număr mare dintr-un BigInt. JSON.rawJSON(string)
JSON.stringify	Transformă o valoare în text JSON, opțional indentat. JSON.stringify(value[, replacer[, space]])
Map	Colecție cheie–valoare cu chei de orice tip, în ordinea inserării. new Map([iterable])
Map.groupBy	Grupează elementele unei liste după o cheie calculată, într-un Map. Map.groupBy(items, callbackFn)
Map.prototype.clear	Șterge toate perechile. map.clear()
Map.prototype.delete	Șterge o cheie; true dacă a existat. map.delete(key)
Map.prototype.entries	Iterator cu perechile [cheie, valoare]. map.entries()
Map.prototype.forEach	Rulează o funcție (valoare, cheie) pentru fiecare pereche. map.forEach(callbackFn[, thisArg])
Map.prototype.get	Valoarea unei chei sau undefined. map.get(key)
Map.prototype.getOrInsert	Valoarea cheii; dacă lipsește, o adaugă întâi cu valoarea implicită. map.getOrInsert(key, defaultValue)
Map.prototype.getOrInsertComputed	Valoarea cheii; dacă lipsește, o calculează cu o funcție și o adaugă. map.getOrInsertComputed(key, callbackFn)
Map.prototype.has	Verifică dacă există o cheie. map.has(key)
Map.prototype.keys	Iterator cu cheile. map.keys()
Map.prototype.set	Adaugă sau înlocuiește valoarea unei chei; returnează Map-ul. map.set(key, value)
Map.prototype.values	Iterator cu valorile. map.values()
Object	Transformă o valoare simplă în obiect; obiectele rămân neschimbate. Object([value])
Object.assign	Copiază proprietățile surselor într-un obiect țintă (copie superficială). Object.assign(target, ...sources)
Object.create	Obiect nou cu prototipul dat (sau fără prototip, cu null). Object.create(proto[, propertiesObject])
Object.defineProperties	Definește mai multe proprietăți cu descriptori. Object.defineProperties(obj, props)
Object.defineProperty	Definește o proprietate cu control total (writable, enumerable, get/set). Object.defineProperty(obj, prop, descriptor)
Object.entries	Tablou cu perechile [cheie, valoare] proprii. Object.entries(obj)
Object.freeze	Îngheață obiectul: nicio proprietate nu mai poate fi schimbată. Object.freeze(obj)
Object.fromEntries	Obiect nou din perechi [cheie, valoare] (tablou, Map, URLSearchParams). Object.fromEntries(iterable)
Object.getOwnPropertyDescriptor	Descriptorul unei proprietăți proprii (valoare, writable, get, set…). Object.getOwnPropertyDescriptor(obj, prop)
Object.getOwnPropertyDescriptors	Descriptorii tuturor proprietăților proprii. Object.getOwnPropertyDescriptors(obj)
Object.getOwnPropertyNames	Toate cheile text proprii, inclusiv cele neenumerabile. Object.getOwnPropertyNames(obj)
Object.getOwnPropertySymbols	Toate cheile Symbol proprii. Object.getOwnPropertySymbols(obj)
Object.getPrototypeOf	Prototipul obiectului (de la care moștenește). Object.getPrototypeOf(obj)
Object.groupBy	Grupează elementele unei liste după o cheie calculată, într-un obiect. Object.groupBy(items, callbackFn)
Object.hasOwn	Verifică dacă obiectul are o proprietate proprie cu numele dat. Object.hasOwn(obj, prop)
Object.is	Compară ca ===, dar NaN este egal cu NaN, iar 0 diferit de -0. Object.is(value1, value2)
Object.isExtensible	Verifică dacă se mai pot adăuga proprietăți. Object.isExtensible(obj)
Object.isFrozen	Verifică dacă obiectul este înghețat. Object.isFrozen(obj)
Object.isSealed	Verifică dacă obiectul este sigilat. Object.isSealed(obj)
Object.keys	Tablou cu cheile enumerabile proprii. Object.keys(obj)
Object.preventExtensions	Interzice adăugarea de proprietăți noi. Object.preventExtensions(obj)
Object.prototype.__defineGetter__	Învechită: definește un getter; folosește Object.defineProperty sau get. obj.__defineGetter__(prop, func)
Object.prototype.__defineSetter__	Învechită: definește un setter; folosește Object.defineProperty sau set. obj.__defineSetter__(prop, func)
Object.prototype.__lookupGetter__	Învechită: returnează getter-ul unei proprietăți; folosește getOwnPropertyDescriptor. obj.__lookupGetter__(prop)
Object.prototype.__lookupSetter__	Învechită: returnează setter-ul unei proprietăți; folosește getOwnPropertyDescriptor. obj.__lookupSetter__(prop)
Object.prototype.hasOwnProperty	Verifică o proprietate proprie (preferă Object.hasOwn). obj.hasOwnProperty(prop)
Object.prototype.isPrototypeOf	Verifică dacă obiectul apare în lanțul de prototipuri al altuia. obj.isPrototypeOf(object)
Object.prototype.propertyIsEnumerable	Verifică dacă o proprietate proprie este enumerabilă. obj.propertyIsEnumerable(prop)
Object.prototype.toLocaleString	Ca toString, dar poate fi adaptat limbii (implicit apelează toString). obj.toLocaleString()
Object.prototype.toString	Text care descrie obiectul (implicit „[object Object]”). obj.toString()
Object.prototype.valueOf	Valoarea simplă a obiectului (implicit obiectul însuși). obj.valueOf()
Object.seal	Interzice adăugarea și ștergerea proprietăților; valorile se pot schimba. Object.seal(obj)
Object.setPrototypeOf	Schimbă prototipul unui obiect existent (lent; preferă Object.create). Object.setPrototypeOf(obj, prototype)
Object.values	Tablou cu valorile proprietăților enumerabile proprii. Object.values(obj)
Proxy	Învelește un obiect și interceptează operațiile pe el (get, set, delete etc.). new Proxy(target, handler)
Proxy.revocable	Proxy care poate fi dezactivat ulterior cu revoke(). Proxy.revocable(target, handler)
Reflect.apply	Apelează o funcție cu this și tablou de argumente. Reflect.apply(target, thisArgument, argumentsList)
Reflect.construct	Ca new Clasa(…argumente). Reflect.construct(target, argumentsList[, newTarget])
Reflect.defineProperty	Ca Object.defineProperty, dar returnează true/false. Reflect.defineProperty(target, propertyKey, attributes)
Reflect.deleteProperty	Ca delete obiect[cheie]; returnează true/false. Reflect.deleteProperty(target, propertyKey)
Reflect.get	Ca obiect[cheie], cu receptor opțional pentru getter-e. Reflect.get(target, propertyKey[, receiver])
Reflect.getOwnPropertyDescriptor	Ca Object.getOwnPropertyDescriptor (doar pentru obiecte). Reflect.getOwnPropertyDescriptor(target, propertyKey)
Reflect.getPrototypeOf	Ca Object.getPrototypeOf (doar pentru obiecte). Reflect.getPrototypeOf(target)
Reflect.has	Ca operatorul in. Reflect.has(target, propertyKey)
Reflect.isExtensible	Ca Object.isExtensible (doar pentru obiecte). Reflect.isExtensible(target)
Reflect.ownKeys	Toate cheile proprii, text și Symbol. Reflect.ownKeys(target)
Reflect.preventExtensions	Ca Object.preventExtensions, dar returnează true/false. Reflect.preventExtensions(target)
Reflect.set	Ca obiect[cheie] = valoare; returnează true/false. Reflect.set(target, propertyKey, value[, receiver])
Reflect.setPrototypeOf	Ca Object.setPrototypeOf, dar returnează true/false. Reflect.setPrototypeOf(target, prototype)
Set	Colecție de valori unice, în ordinea inserării. new Set([iterable])
Set.prototype.add	Adaugă o valoare (dacă nu există); returnează Set-ul. set.add(value)
Set.prototype.clear	Șterge toate valorile. set.clear()
Set.prototype.delete	Șterge o valoare; true dacă a existat. set.delete(value)
Set.prototype.difference	Set nou cu valorile care nu sunt în celălalt Set. set.difference(other)
Set.prototype.entries	Iterator cu perechi [valoare, valoare]. set.entries()
Set.prototype.forEach	Rulează o funcție pentru fiecare valoare. set.forEach(callbackFn[, thisArg])
Set.prototype.has	Verifică dacă o valoare există în Set. set.has(value)
Set.prototype.intersection	Set nou cu valorile comune. set.intersection(other)
Set.prototype.isDisjointFrom	Verifică dacă cele două Set-uri nu au valori comune. set.isDisjointFrom(other)
Set.prototype.isSubsetOf	Verifică dacă toate valorile se găsesc în celălalt Set. set.isSubsetOf(other)
Set.prototype.isSupersetOf	Verifică dacă Set-ul conține toate valorile celuilalt. set.isSupersetOf(other)
Set.prototype.keys	Același iterator ca values (un Set nu are chei separate). set.keys()
Set.prototype.symmetricDifference	Set nou cu valorile aflate doar într-unul dintre cele două. set.symmetricDifference(other)
Set.prototype.union	Set nou cu toate valorile din ambele. set.union(other)
Set.prototype.values	Iterator cu valorile. set.values()
structuredClone	Copie completă (în adâncime) a unei valori, cu Date, Map, Set și referințe circulare. structuredClone(value[, options])
Symbol	Creează o valoare unică, folosită ca cheie de proprietate. Symbol([description])
Symbol.for	Simbolul din registrul global pentru o cheie (îl creează dacă lipsește). Symbol.for(key)
Symbol.keyFor	Cheia unui simbol din registrul global sau undefined. Symbol.keyFor(sym)
Symbol.prototype.toString	Text de forma „Symbol(descriere)”. sym.toString()
Symbol.prototype.valueOf	Simbolul însuși. sym.valueOf()
WeakMap	Map cu chei obiecte, care nu împiedică eliberarea lor din memorie. new WeakMap([iterable])
WeakMap.prototype.delete	Șterge o cheie obiect. weakMap.delete(key)
WeakMap.prototype.get	Valoarea asociată unui obiect sau undefined. weakMap.get(key)
WeakMap.prototype.getOrInsert	Valoarea cheii; dacă lipsește, o adaugă întâi cu valoarea implicită. weakMap.getOrInsert(key, defaultValue)
WeakMap.prototype.getOrInsertComputed	Valoarea cheii; dacă lipsește, o calculează și o adaugă. weakMap.getOrInsertComputed(key, callbackFn)
WeakMap.prototype.has	Verifică dacă un obiect are o valoare asociată. weakMap.has(key)
WeakMap.prototype.set	Asociază o valoare unui obiect. weakMap.set(key, value)
WeakRef	Referință slabă la un obiect, citită cu deref(). new WeakRef(target)
WeakRef.prototype.deref	Obiectul referit sau undefined dacă a fost eliberat. ref.deref()
WeakSet	Set de obiecte, care nu împiedică eliberarea lor din memorie. new WeakSet([iterable])
WeakSet.prototype.add	Adaugă un obiect. weakSet.add(value)
WeakSet.prototype.delete	Scoate un obiect din WeakSet. weakSet.delete(value)
WeakSet.prototype.has	Verifică dacă un obiect a fost adăugat. weakSet.has(value)

Numere, Math și BigInt (59)

Funcție	Ce face
BigInt	Creează un întreg de orice mărime (tipul bigint) dintr-un număr sau text. BigInt(value)
BigInt.asIntN	Păstrează ultimii N biți ai unui BigInt, ca întreg cu semn. BigInt.asIntN(bits, bigint)
BigInt.asUintN	Păstrează ultimii N biți ai unui BigInt, ca întreg fără semn. BigInt.asUintN(bits, bigint)
BigInt.prototype.toLocaleString	Formatează un BigInt după limbă (separatori de mii). big.toLocaleString([locales[, options]])
BigInt.prototype.toString	Scrie un BigInt ca text, opțional în altă bază. big.toString([radix])
BigInt.prototype.valueOf	Valoarea simplă de tip bigint a unui obiect BigInt. big.valueOf()
isFinite	Verifică dacă valoarea, după transformarea în număr, este finită. isFinite(value)
isNaN	Verifică dacă valoarea, după transformarea în număr, este NaN (preferă Number.isNaN). isNaN(value)
Math.abs	Valoarea absolută a unui număr. Math.abs(x)
Math.acos	Arccosinusul, în radiani. Math.acos(x)
Math.acosh	Arccosinusul hiperbolic. Math.acosh(x)
Math.asin	Arcsinusul, în radiani. Math.asin(x)
Math.asinh	Arcsinusul hiperbolic. Math.asinh(x)
Math.atan	Arctangenta, în radiani. Math.atan(x)
Math.atan2	Unghiul punctului (x, y) față de axa orizontală, între −π și π. Math.atan2(y, x)
Math.atanh	Arctangenta hiperbolică. Math.atanh(x)
Math.cbrt	Rădăcina cubică. Math.cbrt(x)
Math.ceil	Rotunjește în sus, la cel mai apropiat întreg mai mare sau egal. Math.ceil(x)
Math.clz32	Numărul de zerouri din stânga în scrierea pe 32 de biți. Math.clz32(x)
Math.cos	Cosinusul unui unghi în radiani. Math.cos(x)
Math.cosh	Cosinusul hiperbolic. Math.cosh(x)
Math.exp	e la puterea x. Math.exp(x)
Math.expm1	e la puterea x, minus 1 (precis pentru x aproape de 0). Math.expm1(x)
Math.f16round	Cea mai apropiată valoare reprezentabilă pe 16 biți (half float). Math.f16round(doubleFloat)
Math.floor	Rotunjește în jos, la cel mai apropiat întreg mai mic sau egal. Math.floor(x)
Math.fround	Cea mai apropiată valoare reprezentabilă pe 32 de biți (float). Math.fround(doubleFloat)
Math.hypot	Rădăcina pătrată a sumei pătratelor (ipotenuza, distanța). Math.hypot(value1, ..., valueN)
Math.imul	Înmulțire ca întregi pe 32 de biți, cu depășire. Math.imul(a, b)
Math.log	Logaritmul natural (baza e). Math.log(x)
Math.log10	Logaritmul în baza 10. Math.log10(x)
Math.log1p	Logaritmul natural din 1 + x (precis pentru x aproape de 0). Math.log1p(x)
Math.log2	Logaritmul în baza 2. Math.log2(x)
Math.max	Cel mai mare dintre numerele primite. Math.max(value1, ..., valueN)
Math.min	Cel mai mic dintre numerele primite. Math.min(value1, ..., valueN)
Math.pow	Ridică un număr la o putere (la fel ca operatorul **). Math.pow(base, exponent)
Math.random	Un număr aleatoriu între 0 (inclusiv) și 1 (exclusiv). Math.random()
Math.round	Rotunjește la cel mai apropiat întreg (.5 în sus). Math.round(x)
Math.sign	Semnul unui număr: 1, -1 sau 0. Math.sign(x)
Math.sin	Sinusul unui unghi în radiani. Math.sin(x)
Math.sinh	Sinusul hiperbolic. Math.sinh(x)
Math.sqrt	Rădăcina pătrată. Math.sqrt(x)
Math.tan	Tangenta unui unghi în radiani. Math.tan(x)
Math.tanh	Tangenta hiperbolică (valori între -1 și 1). Math.tanh(x)
Math.trunc	Taie zecimalele și păstrează partea întreagă. Math.trunc(x)
Number	Transformă o valoare în număr; un text care nu este un număr valid dă NaN. Number(value)
Number.isFinite	Verifică dacă valoarea este un număr finit (fără conversie). Number.isFinite(value)
Number.isInteger	Verifică dacă valoarea este un număr întreg. Number.isInteger(value)
Number.isNaN	Verifică dacă valoarea este exact NaN (fără conversie). Number.isNaN(value)
Number.isSafeInteger	Verifică dacă valoarea este un întreg reprezentat exact (până la 2^53 − 1). Number.isSafeInteger(value)
Number.parseFloat	Același lucru ca funcția globală parseFloat. Number.parseFloat(string)
Number.parseInt	Același lucru ca funcția globală parseInt. Number.parseInt(string[, radix])
Number.prototype.toExponential	Scrie numărul în notație exponențială (de ex. 1.5e+6). num.toExponential([fractionDigits])
Number.prototype.toFixed	Scrie numărul ca text, cu un număr fix de zecimale (rotunjit). num.toFixed([digits])
Number.prototype.toLocaleString	Formatează numărul după limbă: separatori, monedă, procente, unități. num.toLocaleString([locales[, options]])
Number.prototype.toPrecision	Scrie numărul ca text, cu un număr dat de cifre semnificative. num.toPrecision([precision])
Number.prototype.toString	Scrie numărul ca text, opțional în altă bază (2–36). num.toString([radix])
Number.prototype.valueOf	Valoarea numerică simplă a unui obiect Number. num.valueOf()
parseFloat	Citește un număr cu zecimale de la începutul unui text. parseFloat(string)
parseInt	Citește un număr întreg de la începutul unui text, opțional într-o bază dată. parseInt(string[, radix])

Dată și oră (Date) și formatare regională (Intl) (109)

Funcție	Ce face
Date	Creează o dată: acum, din milisecunde, dintr-un text ISO sau din componente (luna de la 0). Date([value | year, monthIndex[, day[, hours[, minutes[, seconds[, ms]]]]]])
Date.now	Momentul curent, în milisecunde de la 1 ianuarie 1970 UTC. Date.now()
Date.parse	Citește o dată dintr-un text și returnează milisecundele sau NaN. Date.parse(dateString)
Date.prototype.getDate	Returnează ziua lunii (1–31), în ora locală. date.getDate()
Date.prototype.getDay	Returnează ziua săptămânii (0 = duminică), în ora locală. date.getDay()
Date.prototype.getFullYear	Returnează anul (4 cifre), în ora locală. date.getFullYear()
Date.prototype.getHours	Returnează ora (0–23), în ora locală. date.getHours()
Date.prototype.getMilliseconds	Returnează milisecundele, în ora locală. date.getMilliseconds()
Date.prototype.getMinutes	Returnează minutele, în ora locală. date.getMinutes()
Date.prototype.getMonth	Returnează luna (0–11), în ora locală. date.getMonth()
Date.prototype.getSeconds	Returnează secundele, în ora locală. date.getSeconds()
Date.prototype.getTime	Milisecundele de la 1 ianuarie 1970 UTC. date.getTime()
Date.prototype.getTimezoneOffset	Diferența în minute dintre UTC și ora locală (-180 pentru UTC+3). date.getTimezoneOffset()
Date.prototype.getUTCDate	Returnează ziua lunii (1–31), în UTC. date.getUTCDate()
Date.prototype.getUTCDay	Returnează ziua săptămânii (0 = duminică), în UTC. date.getUTCDay()
Date.prototype.getUTCFullYear	Returnează anul (4 cifre), în UTC. date.getUTCFullYear()
Date.prototype.getUTCHours	Returnează ora (0–23), în UTC. date.getUTCHours()
Date.prototype.getUTCMilliseconds	Returnează milisecundele, în UTC. date.getUTCMilliseconds()
Date.prototype.getUTCMinutes	Returnează minutele, în UTC. date.getUTCMinutes()
Date.prototype.getUTCMonth	Returnează luna (0–11), în UTC. date.getUTCMonth()
Date.prototype.getUTCSeconds	Returnează secundele, în UTC. date.getUTCSeconds()
Date.prototype.getYear	Învechită: anul minus 1900; folosește getFullYear. date.getYear()
Date.prototype.setDate	Setează ziua lunii (1–31), în ora locală; valorile prea mari trec mai departe. date.setDate(dateValue)
Date.prototype.setFullYear	Setează anul (4 cifre), în ora locală; valorile prea mari trec mai departe. date.setFullYear(yearValue[, monthValue[, dateValue]])
Date.prototype.setHours	Setează ora (0–23), în ora locală; valorile prea mari trec mai departe. date.setHours(hoursValue[, minutesValue[, secondsValue[, msValue]]])
Date.prototype.setMilliseconds	Setează milisecundele, în ora locală; valorile prea mari trec mai departe. date.setMilliseconds(millisecondsValue)
Date.prototype.setMinutes	Setează minutele, în ora locală; valorile prea mari trec mai departe. date.setMinutes(minutesValue[, secondsValue[, msValue]])
Date.prototype.setMonth	Setează luna (0–11), în ora locală; valorile prea mari trec mai departe. date.setMonth(monthValue[, dateValue])
Date.prototype.setSeconds	Setează secundele, în ora locală; valorile prea mari trec mai departe. date.setSeconds(secondsValue[, msValue])
Date.prototype.setTime	Mută data la un alt timestamp (milisecunde). date.setTime(timeValue)
Date.prototype.setUTCDate	Setează ziua lunii (1–31), în UTC. date.setUTCDate(dateValue)
Date.prototype.setUTCFullYear	Setează anul (4 cifre), în UTC. date.setUTCFullYear(yearValue[, monthValue[, dateValue]])
Date.prototype.setUTCHours	Setează ora (0–23), în UTC. date.setUTCHours(hoursValue[, minutesValue[, secondsValue[, msValue]]])
Date.prototype.setUTCMilliseconds	Setează milisecundele, în UTC. date.setUTCMilliseconds(millisecondsValue)
Date.prototype.setUTCMinutes	Setează minutele, în UTC. date.setUTCMinutes(minutesValue[, secondsValue[, msValue]])
Date.prototype.setUTCMonth	Setează luna (0–11), în UTC. date.setUTCMonth(monthValue[, dateValue])
Date.prototype.setUTCSeconds	Setează secundele, în UTC. date.setUTCSeconds(secondsValue[, msValue])
Date.prototype.setYear	Învechită: setează anul; folosește setFullYear. date.setYear(yearValue)
Date.prototype.toDateString	Doar partea cu data, în engleză (de ex. „Mon Oct 19 2026”). date.toDateString()
Date.prototype.toGMTString	Învechită: alias pentru toUTCString. date.toGMTString()
Date.prototype.toISOString	Data în format ISO 8601, în UTC (2026-10-19T11:30:00.000Z). date.toISOString()
Date.prototype.toJSON	Același text ca toISOString; folosită de JSON.stringify. date.toJSON()
Date.prototype.toLocaleDateString	Doar data, după regulile unei limbi. date.toLocaleDateString([locales[, options]])
Date.prototype.toLocaleString	Data și ora după regulile unei limbi (de ex. ro-RO). date.toLocaleString([locales[, options]])
Date.prototype.toLocaleTimeString	Doar ora, după regulile unei limbi. date.toLocaleTimeString([locales[, options]])
Date.prototype.toString	Data și ora locală, cu fusul orar, în engleză. date.toString()
Date.prototype.toTimeString	Doar ora locală și fusul orar, ca text. date.toTimeString()
Date.prototype.toUTCString	Data în UTC, în formatul antetelor HTTP. date.toUTCString()
Date.prototype.valueOf	Milisecundele datei; folosită automat la scăderi și comparații. date.valueOf()
Date.UTC	Milisecundele pentru o dată dată în componente UTC. Date.UTC(year[, monthIndex[, day[, hour[, minute[, second[, millisecond]]]]]])
Intl.Collator	Compară texte după alfabetul unei limbi; pentru sortare. new Intl.Collator([locales[, options]])
Intl.Collator.prototype.compare	Compară două texte: negativ, 0 sau pozitiv (bun pentru sort). collator.compare(string1, string2)
Intl.Collator.prototype.resolvedOptions	Opțiunile efective ale formatorului (limbă, stil etc.). collator.resolvedOptions()
Intl.Collator.supportedLocalesOf	Limbile din cele cerute care sunt disponibile pentru acest formator. Intl.Collator.supportedLocalesOf(locales[, options])
Intl.DateTimeFormat	Formator de date și ore după limbă, refolosibil. new Intl.DateTimeFormat([locales[, options]])
Intl.DateTimeFormat.prototype.format	Formatează o dată ca text. dateTimeFormat.format(date)
Intl.DateTimeFormat.prototype.formatRange	Formatează un interval de date fără repetiții. dateTimeFormat.formatRange(startDate, endDate)
Intl.DateTimeFormat.prototype.formatRangeToParts	Intervalul de date formatat, pe bucăți. dateTimeFormat.formatRangeToParts(startDate, endDate)
Intl.DateTimeFormat.prototype.formatToParts	Data formatată, pe bucăți (zi, lună, an…). dateTimeFormat.formatToParts(date)
Intl.DateTimeFormat.prototype.resolvedOptions	Opțiunile efective ale formatorului (limbă, stil etc.). dateTimeFormat.resolvedOptions()
Intl.DateTimeFormat.supportedLocalesOf	Limbile din cele cerute care sunt disponibile pentru acest formator. Intl.DateTimeFormat.supportedLocalesOf(locales[, options])
Intl.DisplayNames	Nume afișabile pentru coduri de țări, limbi, monede. new Intl.DisplayNames(locales, options)
Intl.DisplayNames.prototype.of	Numele afișabil pentru un cod. displayNames.of(code)
Intl.DisplayNames.prototype.resolvedOptions	Opțiunile efective ale formatorului (limbă, stil etc.). displayNames.resolvedOptions()
Intl.DisplayNames.supportedLocalesOf	Limbile din cele cerute care sunt disponibile pentru acest formator. Intl.DisplayNames.supportedLocalesOf(locales[, options])
Intl.DurationFormat	Formatează o durată: „2 ore, 5 minute”. new Intl.DurationFormat([locales[, options]])
Intl.DurationFormat.prototype.format	Formatează o durată ca text. durationFormat.format(duration)
Intl.DurationFormat.prototype.formatToParts	Durata formatată, pe bucăți. durationFormat.formatToParts(duration)
Intl.DurationFormat.prototype.resolvedOptions	Opțiunile efective ale formatorului (limbă, stil etc.). durationFormat.resolvedOptions()
Intl.DurationFormat.supportedLocalesOf	Limbile din cele cerute care sunt disponibile pentru acest formator. Intl.DurationFormat.supportedLocalesOf(locales[, options])
Intl.getCanonicalLocales	Aduce codurile de limbă la forma standard. Intl.getCanonicalLocales(locales)
Intl.ListFormat	Unește o listă într-o propoziție: „a, b și c”. new Intl.ListFormat([locales[, options]])
Intl.ListFormat.prototype.format	Lista unită într-un text. listFormat.format(list)
Intl.ListFormat.prototype.formatToParts	Lista unită, pe bucăți (elemente și separatori). listFormat.formatToParts(list)
Intl.ListFormat.prototype.resolvedOptions	Opțiunile efective ale formatorului (limbă, stil etc.). listFormat.resolvedOptions()
Intl.ListFormat.supportedLocalesOf	Limbile din cele cerute care sunt disponibile pentru acest formator. Intl.ListFormat.supportedLocalesOf(locales[, options])
Intl.Locale	Obiect care descrie o limbă și regiune, cu informații despre ea. new Intl.Locale(tag[, options])
Intl.Locale.prototype.getCalendars	Calendarele folosite în limba/regiunea respectivă. locale.getCalendars()
Intl.Locale.prototype.getCollations	Tipurile de sortare disponibile. locale.getCollations()
Intl.Locale.prototype.getHourCycles	Formatul orei: h23 (24 de ore) sau h12. locale.getHourCycles()
Intl.Locale.prototype.getNumberingSystems	Sistemele de cifre folosite (latn, arab…). locale.getNumberingSystems()
Intl.Locale.prototype.getTextInfo	Direcția scrisului (ltr sau rtl). locale.getTextInfo()
Intl.Locale.prototype.getTimeZones	Fusurile orare ale regiunii. locale.getTimeZones()
Intl.Locale.prototype.getWeekInfo	Prima zi a săptămânii și zilele de weekend. locale.getWeekInfo()
Intl.Locale.prototype.maximize	Completează componentele probabile (ro → ro-Latn-RO). locale.maximize()
Intl.Locale.prototype.minimize	Elimină componentele implicite (ro-Latn-RO → ro). locale.minimize()
Intl.Locale.prototype.toString	Codul complet al limbii (de ex. „ro-RO”). locale.toString()
Intl.NumberFormat	Formator de numere după limbă: monedă, procente, unități, compact. new Intl.NumberFormat([locales[, options]])
Intl.NumberFormat.prototype.format	Formatează un număr (sau BigInt) ca text. numberFormat.format(number)
Intl.NumberFormat.prototype.formatRange	Formatează un interval de numere (100 – 250 RON). numberFormat.formatRange(startRange, endRange)
Intl.NumberFormat.prototype.formatRangeToParts	Intervalul de numere formatat, pe bucăți. numberFormat.formatRangeToParts(startRange, endRange)
Intl.NumberFormat.prototype.formatToParts	Numărul formatat, pe bucăți (întreg, grup, fracție, monedă). numberFormat.formatToParts(number)
Intl.NumberFormat.prototype.resolvedOptions	Opțiunile efective ale formatorului (limbă, stil etc.). numberFormat.resolvedOptions()
Intl.NumberFormat.supportedLocalesOf	Limbile din cele cerute care sunt disponibile pentru acest formator. Intl.NumberFormat.supportedLocalesOf(locales[, options])
Intl.PluralRules	Alege forma de plural potrivită unui număr într-o limbă. new Intl.PluralRules([locales[, options]])
Intl.PluralRules.prototype.resolvedOptions	Opțiunile efective ale formatorului (limbă, stil etc.). pluralRules.resolvedOptions()
Intl.PluralRules.prototype.select	Categoria de plural a unui număr (one, few, other…). pluralRules.select(number)
Intl.PluralRules.prototype.selectRange	Categoria de plural a unui interval. pluralRules.selectRange(startRange, endRange)
Intl.PluralRules.supportedLocalesOf	Limbile din cele cerute care sunt disponibile pentru acest formator. Intl.PluralRules.supportedLocalesOf(locales[, options])
Intl.RelativeTimeFormat	Formatează timp relativ: „acum 3 zile”, „peste 2 ore”. new Intl.RelativeTimeFormat([locales[, options]])
Intl.RelativeTimeFormat.prototype.format	Textul pentru o valoare și o unitate de timp. rtf.format(value, unit)
Intl.RelativeTimeFormat.prototype.formatToParts	Textul de timp relativ, pe bucăți. rtf.formatToParts(value, unit)
Intl.RelativeTimeFormat.prototype.resolvedOptions	Opțiunile efective ale formatorului (limbă, stil etc.). rtf.resolvedOptions()
Intl.RelativeTimeFormat.supportedLocalesOf	Limbile din cele cerute care sunt disponibile pentru acest formator. Intl.RelativeTimeFormat.supportedLocalesOf(locales[, options])
Intl.Segmenter	Împarte un text în caractere vizibile, cuvinte sau propoziții. new Intl.Segmenter([locales[, options]])
Intl.Segmenter.prototype.resolvedOptions	Opțiunile efective ale formatorului (limbă, stil etc.). segmenter.resolvedOptions()
Intl.Segmenter.prototype.segment	Bucățile unui text (caractere, cuvinte sau propoziții). segmenter.segment(input)
Intl.Segmenter.supportedLocalesOf	Limbile din cele cerute care sunt disponibile pentru acest formator. Intl.Segmenter.supportedLocalesOf(locales[, options])
Intl.supportedValuesOf	Valorile suportate: monede, fusuri orare, calendare, unități. Intl.supportedValuesOf(key)

Promisiuni, temporizatoare și cereri HTTP (60)

Funcție	Ce face
AbortController	Controller care oprește operații asincrone prin semnalul lui. new AbortController()
AbortController.abort	Declanșează semnalul și oprește operațiile legate de el. controller.abort([reason])
AbortSignal.abort	Semnal deja declanșat. AbortSignal.abort([reason])
AbortSignal.any	Semnal declanșat de primul dintre mai multe semnale. AbortSignal.any(iterable)
AbortSignal.throwIfAborted	Aruncă motivul opririi dacă semnalul a fost declanșat. signal.throwIfAborted()
AbortSignal.timeout	Semnal care se declanșează singur după un număr de milisecunde. AbortSignal.timeout(time)
BroadcastChannel	Canal de mesaje între filele și workerii aceluiași site. new BroadcastChannel(channelName)
BroadcastChannel.close	Închide canalul. channel.close()
BroadcastChannel.postMessage	Trimite un mesaj tuturor celorlalți abonați ai canalului. channel.postMessage(message)
clearInterval	Oprește un setInterval. clearInterval(intervalID)
clearTimeout	Anulează un setTimeout programat. clearTimeout(timeoutID)
EventSource	Primește un flux de mesaje de la server (Server-Sent Events). new EventSource(url[, options])
EventSource.close	Oprește definitiv fluxul de mesaje. source.close()
fetch	Trimite o cerere HTTP și returnează o promisiune cu răspunsul. fetch(resource[, options])
FormData	Câmpurile unui formular în perechi nume–valoare, gata de trimis. new FormData([form[, submitter]])
FormData.append	Adaugă o valoare (un nume poate avea mai multe). formData.append(name, value[, filename])
FormData.delete	Șterge un câmp. formData.delete(name)
FormData.entries	Iterator cu perechile [nume, valoare]. formData.entries()
FormData.get	Prima valoare a unui câmp sau null. formData.get(name)
FormData.getAll	Toate valorile unui câmp. formData.getAll(name)
FormData.has	Verifică dacă există un câmp. formData.has(name)
FormData.set	Înlocuiește valorile unui câmp. formData.set(name, value[, filename])
Headers	Colecție de antete HTTP, cu nume fără diferența de majuscule. new Headers([init])
Headers.append	Adaugă încă o valoare la un antet. headers.append(name, value)
Headers.delete	Șterge un antet. headers.delete(name)
Headers.get	Valoarea unui antet sau null. headers.get(name)
Headers.has	Verifică dacă există un antet. headers.has(name)
Headers.set	Setează (înlocuiește) un antet. headers.set(name, value)
MessageChannel	Pereche de porturi legate pentru mesaje directe. new MessageChannel()
Promise	Creează o promisiune: un rezultat care va veni mai târziu. new Promise(executor)
Promise.all	Așteaptă toate promisiunile în paralel; eșuează la prima eroare. Promise.all(iterable)
Promise.allSettled	Așteaptă toate promisiunile și returnează starea fiecăreia. Promise.allSettled(iterable)
Promise.any	Prima promisiune reușită; eșuează doar dacă toate eșuează (AggregateError). Promise.any(iterable)
Promise.prototype.catch	Rulează o funcție dacă promisiunea este respinsă. promise.catch(onRejected)
Promise.prototype.finally	Rulează o funcție la final, indiferent de rezultat. promise.finally(onFinally)
Promise.prototype.then	Rulează o funcție cu rezultatul promisiunii; returnează o promisiune nouă. promise.then(onFulfilled[, onRejected])
Promise.race	Se termină ca prima promisiune terminată, cu succes sau eroare. Promise.race(iterable)
Promise.reject	Promisiune deja respinsă cu o eroare. Promise.reject(reason)
Promise.resolve	Promisiune deja împlinită cu o valoare. Promise.resolve(value)
Promise.try	Apelează o funcție și returnează mereu o promisiune, prinzând și erorile sincrone. Promise.try(func[, arg1, ..., argN])
Promise.withResolvers	Promisiune nouă împreună cu funcțiile resolve și reject. Promise.withResolvers()
queueMicrotask	Programează o funcție imediat după codul curent, înaintea oricărui setTimeout. queueMicrotask(callback)
Request	Descrie o cerere HTTP (adresă, metodă, antete, corp) ca obiect. new Request(input[, options])
Response	Creează un răspuns HTTP (în service workers, teste). new Response([body[, options]])
Response.arrayBuffer	Citește corpul răspunsului ca ArrayBuffer (octeți). response.arrayBuffer()
Response.blob	Citește corpul răspunsului ca Blob (fișier, imagine). response.blob()
Response.clone	Copie a răspunsului, ca să poți citi corpul de două ori. response.clone()
Response.error	Răspuns care reprezintă o eroare de rețea. Response.error()
Response.formData	Citește corpul răspunsului ca FormData. response.formData()
Response.json	Citește corpul răspunsului ca JSON. response.json()
Response.redirect	Răspuns de redirecționare către o adresă. Response.redirect(url[, status])
Response.text	Citește corpul răspunsului ca text. response.text()
setInterval	Rulează o funcție în mod repetat, la intervale egale. setInterval(functionRef[, delay[, param1, ..., paramN]])
setTimeout	Rulează o funcție o singură dată, după o pauză în milisecunde. setTimeout(functionRef[, delay[, param1, ..., paramN]])
WebSocket	Conexiune permanentă, în ambele sensuri, cu un server. new WebSocket(url[, protocols])
WebSocket.close	Închide conexiunea WebSocket. socket.close([code[, reason]])
WebSocket.send	Trimite un mesaj prin WebSocket. socket.send(data)
Worker	Rulează un script pe un fir separat (Web Worker). new Worker(url[, options])
Worker.postMessage	Trimite un mesaj (copiat) către worker. worker.postMessage(message[, transfer])
Worker.terminate	Oprește imediat workerul. worker.terminate()

Consola, URL, codificare, fișiere și criptografie (65)

Funcție	Ce face
atob	Decodifică un text Base64. atob(encodedData)
Blob	Bloc de date imuabil, cu tip MIME. new Blob([blobParts[, options]])
Blob.arrayBuffer	Citește conținutul ca ArrayBuffer. blob.arrayBuffer()
Blob.bytes	Citește conținutul ca Uint8Array. blob.bytes()
Blob.slice	Blob nou dintr-o parte (în octeți). blob.slice([start[, end[, contentType]]])
Blob.stream	Flux (ReadableStream) pentru citirea pe bucăți. blob.stream()
Blob.text	Citește conținutul ca text. blob.text()
btoa	Codifică un text în Base64 (doar caractere cu cod până la 255). btoa(stringToEncode)
console.assert	Afișează o eroare doar dacă o condiție este falsă. console.assert(condition, ...data)
console.clear	Golește consola. console.clear()
console.count	Numără apelurile pentru o etichetă și afișează numărul. console.count([label])
console.countReset	Resetează contorul unei etichete. console.countReset([label])
console.debug	Afișează un mesaj de depanare (ascuns implicit în Chrome). console.debug(...data)
console.dir	Afișează proprietățile unui obiect, cu adâncime aleasă în Node.js. console.dir(object[, options])
console.error	Afișează o eroare (roșu în browser, stderr în Node.js). console.error(...data)
console.group	Începe un grup indentat de mesaje. console.group([...label])
console.groupCollapsed	Începe un grup de mesaje strâns (în browser). console.groupCollapsed([...label])
console.groupEnd	Închide grupul curent de mesaje. console.groupEnd()
console.info	Afișează un mesaj informativ. console.info(...data)
console.log	Afișează valori în consolă. console.log(...data)
console.table	Afișează un tablou sau un obiect ca tabel. console.table(data[, columns])
console.time	Pornește un cronometru cu etichetă. console.time([label])
console.timeEnd	Afișează timpul final și oprește cronometrul. console.timeEnd([label])
console.timeLog	Afișează timpul scurs pe un cronometru, fără să-l oprească. console.timeLog([label[, ...data]])
console.trace	Afișează mesajul și stiva de apeluri. console.trace([...data])
console.warn	Afișează un avertisment (galben în browser, stderr în Node.js). console.warn(...data)
crypto.getRandomValues	Umple un typed array cu numere aleatorii sigure criptografic. crypto.getRandomValues(typedArray)
crypto.randomUUID	Identificator unic aleatoriu (UUID v4). crypto.randomUUID()
crypto.subtle.digest	Calculează un hash SHA-1/256/384/512. crypto.subtle.digest(algorithm, data)
decodeURI	Decodifică o adresă codificată cu encodeURI. decodeURI(encodedURI)
decodeURIComponent	Decodifică secvențele %XX dintr-un text. decodeURIComponent(encodedURIComponent)
encodeURI	Codifică o adresă completă, păstrând caracterele de structură (: / ? & = #). encodeURI(uri)
encodeURIComponent	Codifică un text pentru a fi pus sigur într-o bucată de adresă (de ex. un parametru). encodeURIComponent(uriComponent)
escape	Învechită: codificare veche, greșită pentru diacritice; folosește encodeURIComponent. escape(str)
File	Blob cu nume de fișier și dată a modificării. new File(fileBits, fileName[, options])
FileReader.readAsArrayBuffer	Citește un fișier ca ArrayBuffer. reader.readAsArrayBuffer(blob)
FileReader.readAsDataURL	Citește un fișier ca adresă data: în Base64. reader.readAsDataURL(blob)
FileReader.readAsText	Citește un fișier ca text (rezultat în evenimentul load). reader.readAsText(blob[, encoding])
performance.mark	Pune un reper de timp cu nume. performance.mark(markName[, markOptions])
performance.measure	Durata dintre două repere de timp. performance.measure(measureName[, startOrMeasureOptions[, endMark]])
performance.now	Timp de înaltă precizie, în milisecunde, pentru măsurarea duratelor. performance.now()
TextDecoder.decode	Transformă octeți în text (UTF-8 sau altă codificare). decoder.decode([buffer[, options]])
TextEncoder.encode	Octeții UTF-8 ai unui text, ca Uint8Array. encoder.encode([string])
TextEncoder.encodeInto	Scrie octeții UTF-8 ai unui text într-un Uint8Array existent. encoder.encodeInto(string, uint8Array)
unescape	Învechită: decodificare veche; folosește decodeURIComponent. unescape(str)
URL	Desface o adresă în părți (domeniu, cale, parametri) și o construiește la loc. new URL(url[, base])
URL.canParse	Verifică dacă un text este o adresă validă, fără excepție. URL.canParse(url[, base])
URL.createObjectURL	Adresă temporară blob: pentru un Blob sau un fișier din memorie. URL.createObjectURL(object)
URL.parse	Ca new URL, dar returnează null pentru adrese invalide. URL.parse(url[, base])
URL.prototype.toJSON	Adresa completă; folosită de JSON.stringify. url.toJSON()
URL.prototype.toString	Adresa completă, ca text. url.toString()
URL.revokeObjectURL	Eliberează o adresă creată cu createObjectURL. URL.revokeObjectURL(objectURL)
URLSearchParams	Citește și construiește parametrii unei adrese, cu codificare automată. new URLSearchParams([options])
URLSearchParams.append	Adaugă încă o valoare unui parametru. params.append(name, value)
URLSearchParams.delete	Șterge un parametru (sau doar o anumită valoare). params.delete(name[, value])
URLSearchParams.entries	Iterator cu perechile [nume, valoare]. params.entries()
URLSearchParams.forEach	Rulează o funcție (valoare, nume) pentru fiecare parametru. params.forEach(callback)
URLSearchParams.get	Prima valoare a unui parametru sau null. params.get(name)
URLSearchParams.getAll	Toate valorile unui parametru. params.getAll(name)
URLSearchParams.has	Verifică dacă există un parametru (opțional cu o anumită valoare). params.has(name[, value])
URLSearchParams.keys	Iterator cu numele parametrilor. params.keys()
URLSearchParams.set	Setează (înlocuiește) un parametru. params.set(name, value)
URLSearchParams.sort	Ordonează parametrii după nume. params.sort()
URLSearchParams.toString	Parametrii ca text codificat, fără „?”. params.toString()
URLSearchParams.values	Iterator cu valorile parametrilor. params.values()

Pagina web (DOM) și evenimente (109)

Funcție	Ce face
CSSStyleDeclaration.getPropertyValue	Citește un stil scris direct pe element. element.style.getPropertyValue(property)
CSSStyleDeclaration.removeProperty	Șterge un stil scris pe element și îl returnează. element.style.removeProperty(property)
CSSStyleDeclaration.setProperty	Setează un stil sau o variabilă CSS pe element. element.style.setProperty(propertyName, value[, priority])
CustomEvent	Creează un eveniment cu date proprii în detail. new CustomEvent(type[, options])
document.createComment	Creează un comentariu HTML. document.createComment(data)
document.createDocumentFragment	Container invizibil pentru a adăuga multe elemente dintr-o dată. document.createDocumentFragment()
document.createElement	Creează un element HTML nou, încă neadăugat în pagină. document.createElement(tagName[, options])
document.createTextNode	Creează un nod de text. document.createTextNode(data)
document.elementFromPoint	Elementul aflat deasupra la coordonatele date. document.elementFromPoint(x, y)
document.exitFullscreen	Iese din modul ecran complet. document.exitFullscreen()
document.getElementById	Elementul cu un anumit id sau null. document.getElementById(id)
document.getElementsByClassName	Colecție vie cu elementele care au clasele date. document.getElementsByClassName(names)
document.getElementsByName	Elementele cu un anumit atribut name (de ex. butoane radio). document.getElementsByName(name)
document.getElementsByTagName	Colecție vie cu elementele unei etichete. document.getElementsByTagName(name)
document.hasFocus	Verifică dacă pagina este fereastra activă. document.hasFocus()
document.importNode	Copie a unui nod din alt document (de ex. conținutul unui template). document.importNode(externalNode[, deep])
document.querySelector	Primul element care se potrivește cu un selector CSS. document.querySelector(selectors)
document.querySelectorAll	Toate elementele care se potrivesc cu un selector CSS (listă fixă). document.querySelectorAll(selectors)
document.startViewTransition	Animează trecerea între două stări ale paginii. document.startViewTransition([updateCallback])
Element.after	Adaugă noduri sau texte imediat după element. element.after(...nodes)
Element.animate	Animă elementul din JavaScript (Web Animations API). element.animate(keyframes, options)
Element.append	Adaugă noduri sau texte la sfârșitul conținutului. element.append(...nodes)
Element.attachShadow	Atașează un Shadow DOM (zonă izolată cu HTML și CSS proprii). element.attachShadow(options)
Element.before	Adaugă noduri sau texte imediat înaintea elementului. element.before(...nodes)
Element.checkVisibility	Verifică dacă elementul este afișat (nu are display: none). element.checkVisibility([options])
Element.classList.add	Adaugă una sau mai multe clase CSS. element.classList.add(token1, ..., tokenN)
Element.classList.contains	Verifică dacă elementul are o clasă. element.classList.contains(token)
Element.classList.remove	Scoate una sau mai multe clase CSS. element.classList.remove(token1, ..., tokenN)
Element.classList.replace	Înlocuiește o clasă cu alta, dacă există. element.classList.replace(oldToken, newToken)
Element.classList.toggle	Adaugă clasa dacă lipsește, o scoate dacă există. element.classList.toggle(token[, force])
Element.closest	Cel mai apropiat element (el însuși sau un părinte) care se potrivește cu un selector. element.closest(selectors)
Element.getAttribute	Valoarea unui atribut HTML sau null. element.getAttribute(attributeName)
Element.getAttributeNames	Numele tuturor atributelor elementului. element.getAttributeNames()
Element.getBoundingClientRect	Poziția și mărimea elementului față de fereastra vizibilă. element.getBoundingClientRect()
Element.getClientRects	Câte un dreptunghi pentru fiecare rând al unui element de text. element.getClientRects()
Element.getElementsByClassName	Colecție vie cu elementele din interior care au clasele date. element.getElementsByClassName(names)
Element.getElementsByTagName	Colecție vie cu elementele din interior cu o anumită etichetă. element.getElementsByTagName(tagName)
Element.hasAttribute	Verifică dacă elementul are un atribut. element.hasAttribute(name)
Element.insertAdjacentElement	Inserează un element într-una din patru poziții. element.insertAdjacentElement(position, element)
Element.insertAdjacentHTML	Inserează HTML într-una din patru poziții față de element. element.insertAdjacentHTML(position, text)
Element.insertAdjacentText	Inserează text simplu într-una din patru poziții. element.insertAdjacentText(where, data)
Element.matches	Verifică dacă elementul se potrivește cu un selector CSS. element.matches(selectors)
Element.prepend	Adaugă noduri sau texte la începutul conținutului. element.prepend(...nodes)
Element.querySelector	Primul element din interior care se potrivește cu un selector. element.querySelector(selectors)
Element.querySelectorAll	Toate elementele din interior care se potrivesc cu un selector. element.querySelectorAll(selectors)
Element.remove	Scoate elementul din pagină. element.remove()
Element.removeAttribute	Șterge un atribut HTML. element.removeAttribute(attrName)
Element.replaceChildren	Înlocuiește tot conținutul (fără argumente îl golește). element.replaceChildren(...nodes)
Element.replaceWith	Înlocuiește elementul cu alte noduri sau texte. element.replaceWith(...nodes)
Element.requestFullscreen	Afișează elementul pe tot ecranul. element.requestFullscreen([options])
Element.scrollBy	Derulează conținutul elementului cu o anumită distanță. element.scrollBy(x-coord, y-coord | options)
Element.scrollIntoView	Derulează astfel încât elementul să devină vizibil. element.scrollIntoView([alignToTop | scrollIntoViewOptions])
Element.scrollTo	Derulează conținutul elementului la o poziție. element.scrollTo(x-coord, y-coord | options)
Element.setAttribute	Setează un atribut HTML. element.setAttribute(name, value)
Element.setHTMLUnsafe	Ca innerHTML, dar înțelege Shadow DOM declarativ; nu curăță HTML-ul. element.setHTMLUnsafe(input)
Element.toggleAttribute	Adaugă sau scoate un atribut boolean (hidden, disabled). element.toggleAttribute(name[, force])
Event	Creează un eveniment (opțional care urcă și poate fi anulat). new Event(type[, options])
Event.composedPath	Elementele prin care trece evenimentul. event.composedPath()
Event.preventDefault	Anulează acțiunea obișnuită a browserului. event.preventDefault()
Event.stopImmediatePropagation	Oprește și ceilalți ascultători de pe același element. event.stopImmediatePropagation()
Event.stopPropagation	Oprește urcarea evenimentului spre părinți. event.stopPropagation()
EventTarget.addEventListener	Rulează o funcție când are loc un eveniment. target.addEventListener(type, listener[, options])
EventTarget.dispatchEvent	Declanșează un eveniment pe un element sau obiect. target.dispatchEvent(event)
EventTarget.removeEventListener	Scoate o funcție adăugată cu addEventListener. target.removeEventListener(type, listener[, options])
HTMLCanvasElement.getContext	Contextul de desen al canvas-ului (2d, webgl2…). canvas.getContext(contextType[, contextAttributes])
HTMLCanvasElement.toBlob	Desenul ca Blob (imagine), prin callback. canvas.toBlob(callback[, type[, quality]])
HTMLCanvasElement.toDataURL	Desenul ca adresă data: în Base64. canvas.toDataURL([type[, encoderOptions]])
HTMLDialogElement.close	Închide dialogul, cu o valoare returnată opțională. dialog.close([returnValue])
HTMLDialogElement.show	Deschide un dialog fără să blocheze pagina. dialog.show()
HTMLDialogElement.showModal	Deschide un dialog modal, cu fundalul blocat. dialog.showModal()
HTMLElement.blur	Scoate focusul de pe element. element.blur()
HTMLElement.click	Simulează un clic pe element. element.click()
HTMLElement.focus	Mută focusul tastaturii pe element. element.focus([options])
HTMLElement.hidePopover	Ascunde un popover. element.hidePopover()
HTMLElement.showPopover	Afișează un element cu atributul popover. element.showPopover()
HTMLElement.togglePopover	Afișează sau ascunde un popover. element.togglePopover([force])
HTMLFormElement.checkValidity	Verifică regulile de validare, fără mesaje. form.checkValidity()
HTMLFormElement.reportValidity	Verifică regulile de validare și afișează mesajele. form.reportValidity()
HTMLFormElement.requestSubmit	Trimite formularul ca un clic pe buton (cu validare și submit). form.requestSubmit([submitter])
HTMLFormElement.reset	Readuce câmpurile la valorile inițiale. form.reset()
HTMLFormElement.submit	Trimite formularul fără validare și fără evenimentul submit. form.submit()
HTMLInputElement.select	Selectează tot textul din câmp. input.select()
HTMLInputElement.setCustomValidity	Marchează câmpul invalid cu un mesaj propriu („” = valid). input.setCustomValidity(message)
HTMLInputElement.setSelectionRange	Selectează o parte din textul câmpului. input.setSelectionRange(selectionStart, selectionEnd[, selectionDirection])
HTMLInputElement.showPicker	Deschide selectorul câmpului (dată, culoare, fișier). input.showPicker()
HTMLMediaElement.load	Reîncarcă elementul media de la început. video.load()
HTMLMediaElement.pause	Oprește redarea. video.pause()
HTMLMediaElement.play	Pornește redarea video/audio (returnează o promisiune). video.play()
IntersectionObserver	Anunță când elementele intră sau ies din zona vizibilă. new IntersectionObserver(callback[, options])
IntersectionObserver.disconnect	Oprește urmărirea tuturor elementelor. observer.disconnect()
IntersectionObserver.observe	Începe urmărirea unui element. observer.observe(targetElement)
IntersectionObserver.unobserve	Oprește urmărirea unui element. observer.unobserve(target)
MutationObserver	Anunță modificările din DOM. new MutationObserver(callback)
MutationObserver.disconnect	Oprește urmărirea. observer.disconnect()
MutationObserver.observe	Începe urmărirea modificărilor unui element. observer.observe(target[, options])
MutationObserver.takeRecords	Modificările încă nelivrate funcției. observer.takeRecords()
Node.appendChild	Adaugă un nod la sfârșitul copiilor și îl returnează. node.appendChild(aChild)
Node.cloneNode	Copie a nodului, opțional cu tot conținutul. node.cloneNode([deep])
Node.contains	Verifică dacă un nod se află în interiorul altuia. node.contains(otherNode)
Node.hasChildNodes	Verifică dacă nodul are copii (inclusiv text). node.hasChildNodes()
Node.insertBefore	Inserează un nod înaintea unui copil existent. node.insertBefore(newNode, referenceNode)
Node.isEqualNode	Verifică dacă două noduri sunt identice ca structură. node.isEqualNode(otherNode)
Node.normalize	Unește nodurile de text alăturate și le șterge pe cele goale. node.normalize()
Node.removeChild	Șterge un copil și îl returnează. node.removeChild(child)
Node.replaceChild	Înlocuiește un copil cu alt nod. node.replaceChild(newChild, oldChild)
ResizeObserver	Anunță când elementele își schimbă mărimea. new ResizeObserver(callback)
ResizeObserver.disconnect	Oprește urmărirea tuturor elementelor. observer.disconnect()
ResizeObserver.observe	Începe urmărirea mărimii unui element. observer.observe(target[, options])
ResizeObserver.unobserve	Oprește urmărirea unui element. observer.unobserve(target)

Fereastra browserului, navigare și stocare (47)

Funcție	Ce face
caches.open	Deschide un cache cu nume pentru cereri și răspunsuri. caches.open(cacheName)
history.back	Înapoi în istoric (ca butonul browserului). history.back()
history.forward	Înainte în istoric. history.forward()
history.go	Sare un număr de pași în istoric. history.go([delta])
history.pushState	Schimbă adresa fără reîncărcare, adăugând o intrare în istoric. history.pushState(state, unused[, url])
history.replaceState	Schimbă adresa fără reîncărcare, înlocuind intrarea curentă. history.replaceState(state, unused[, url])
indexedDB.open	Deschide (sau creează) o bază de date IndexedDB. indexedDB.open(name[, version])
localStorage.clear	Șterge toate valorile salvate de site. localStorage.clear()
localStorage.getItem	Citește o valoare salvată sau null. localStorage.getItem(keyName)
localStorage.key	Numele cheii de pe o poziție. localStorage.key(index)
localStorage.removeItem	Șterge o valoare salvată. localStorage.removeItem(keyName)
localStorage.setItem	Salvează o valoare (text) permanent, pentru site. localStorage.setItem(keyName, keyValue)
location.assign	Navighează la o adresă (păstrează pagina curentă în istoric). location.assign(url)
location.reload	Reîncarcă pagina. location.reload()
location.replace	Navighează la o adresă, înlocuind pagina curentă în istoric. location.replace(url)
navigator.canShare	Verifică dacă datele pot fi partajate. navigator.canShare([data])
navigator.clipboard.readText	Citește textul din clipboard (cu permisiune). navigator.clipboard.readText()
navigator.clipboard.writeText	Copiază un text în clipboard. navigator.clipboard.writeText(newClipText)
navigator.geolocation.clearWatch	Oprește urmărirea poziției. navigator.geolocation.clearWatch(id)
navigator.geolocation.getCurrentPosition	Poziția utilizatorului, o singură dată (cu permisiune). navigator.geolocation.getCurrentPosition(success[, error[, options]])
navigator.geolocation.watchPosition	Urmărește poziția utilizatorului la fiecare schimbare. navigator.geolocation.watchPosition(success[, error[, options]])
navigator.sendBeacon	Trimite date mici la server, chiar la închiderea paginii. navigator.sendBeacon(url[, data])
navigator.serviceWorker.register	Instalează un service worker (offline, notificări push). navigator.serviceWorker.register(scriptURL[, options])
navigator.share	Deschide meniul de partajare al sistemului. navigator.share([data])
navigator.vibrate	Face telefonul să vibreze (Android). navigator.vibrate(pattern)
Notification	Afișează o notificare a sistemului de operare. new Notification(title[, options])
Notification.requestPermission	Cere permisiunea pentru notificări. Notification.requestPermission([callback])
sessionStorage.clear	Șterge toate valorile filei curente. sessionStorage.clear()
sessionStorage.getItem	Citește o valoare salvată în filă sau null. sessionStorage.getItem(keyName)
sessionStorage.removeItem	Șterge o valoare din fila curentă. sessionStorage.removeItem(keyName)
sessionStorage.setItem	Salvează o valoare doar pentru fila curentă. sessionStorage.setItem(keyName, keyValue)
window.alert	Fereastră cu un mesaj și butonul OK; oprește pagina până la închidere. window.alert([message])
window.cancelAnimationFrame	Anulează un requestAnimationFrame. window.cancelAnimationFrame(requestID)
window.cancelIdleCallback	Anulează un requestIdleCallback. window.cancelIdleCallback(handle)
window.close	Închide o fereastră deschisă din cod. window.close()
window.confirm	Întrebare cu OK și Anulează; returnează true sau false. window.confirm([message])
window.getComputedStyle	Stilurile finale, calculate, ale unui element. window.getComputedStyle(element[, pseudoElt])
window.getSelection	Textul selectat de utilizator în pagină. window.getSelection()
window.matchMedia	Verifică o interogare media CSS (ecran mic, temă întunecată). window.matchMedia(mediaQueryString)
window.open	Deschide o adresă într-o filă sau fereastră nouă. window.open([url[, target[, windowFeatures]]])
window.postMessage	Trimite mesaje sigure între ferestre și iframe-uri de pe domenii diferite. window.postMessage(message, targetOrigin[, transfer])
window.print	Deschide fereastra de tipărire. window.print()
window.prompt	Cere un text utilizatorului; returnează textul sau null. window.prompt([message[, defaultValue]])
window.requestAnimationFrame	Rulează o funcție înainte de următoarea redesenare (animații). window.requestAnimationFrame(callback)
window.requestIdleCallback	Rulează o funcție când browserul este liber. window.requestIdleCallback(callback[, options])
window.scrollBy	Derulează pagina cu o anumită distanță. window.scrollBy(x-coord, y-coord | options)
window.scrollTo	Derulează pagina la o poziție. window.scrollTo(x-coord, y-coord | options)