Un singur pas, indiferent de dimensiune
O(1) înseamnă timp constant: operația face același număr de pași fie că intrarea are 5 elemente, fie că are un milion. Munca nu crește deloc.
Aceasta este cea mai bună complexitate care există. Operații tipice O(1) în TypeScript sunt: citirea unui element de tablou după index, citirea unei valori dintr-un Map după cheie, .length, adăugarea unui element la final și calculele simple.
Observă ce nu înseamnă O(1): nu înseamnă „rapid”, ci înseamnă „nu devine mai lent atunci când intrarea crește”. Un pas constant poate fi totuși un pas lent — dar rămâne un singur pas.
Căutări în tablou și în Map
Un element de tablou se află la o poziție cunoscută în memorie, așa că words[2] este un singur salt — calculatorul nu parcurge elementele dinaintea lui. Aceeași citire costă la fel într-un tablou cu un milion de elemente.
O căutare într-un Map precum ages.get("Ben") are de asemenea timp constant în medie: cheia îi spune direct map-ului unde este stocată valoarea. Nu există o a doua valoare returnată pentru „a existat sau nu” — get() are tipul number | undefined și întoarce undefined atunci când cheia lipsește. ages.has("Ben") răspunde la aceeași întrebare printr-un boolean, iar ?? 0 transformă o valoare lipsă într-una implicită. Toate trei au timp constant.
Citirea unui element după index
Programul citește un element dintr-un tablou cu 5 elemente și unul dintr-un tablou cu un milion de elemente. Ambele citiri sunt un singur pas — lungimea tabloului nu joacă niciun rol.
Ieșire: program TypeScript și rezultatul capturat
const words = ["one", "two", "three", "four", "five"]
const big: number[] = new Array(1000000)
for (let i = 0; i < big.length; i++) {
big[i] = i * 2
}
// Câte un singur pas, indiferent cât de lung este tabloul.
console.log(words[2])
console.log(big[999999])
Citirea unei valori după cheie
ages.get("Ben") găsește direct 25. Cheia lipsă "Dan" dă undefined, iar ages.has("Dan") este false — tot în timp constant. ages.get("Dan") ?? 0 afișează în schimb 0.
Ieșire: program TypeScript și rezultatul capturat
const ages = new Map<string, number>([
["Ana", 30],
["Ben", 25],
["Cleo", 41],
])
const ben: number | undefined = ages.get("Ben")
console.log(ben, ages.has("Ben"))
const dan: number | undefined = ages.get("Dan")
console.log(dan, ages.has("Dan"))
console.log("valoare implicită pentru o cheie lipsă:", ages.get("Dan") ?? 0)
Adăugarea la final și calculele simple
push() adaugă un element la finalul unui tablou. De cele mai multe ori acesta este un singur pas. (Din când în când tabloul trebuie să crească și este copiat, dar, în medie, costul per push rămâne constant.)
Toate operațiile mărunte — atribuiri, adunări, comparații, interschimbarea a două valori — sunt și ele O(1). Ele sunt „pașii” în care sunt numărate toate celelalte clase de complexitate.
Adăugarea unui element la final
colors.push("galben") pune "galben" la final. Costul nu depinde de câte culori se află deja în tablou.
Ieșire: program TypeScript și rezultatul capturat
const colors = ["roșu", "verde", "albastru"]
console.log("înainte:", colors, "lungime:", colors.length)
colors.push("galben")
console.log("după: ", colors, "lungime:", colors.length)
Interschimbarea a două valori
[a, b] = [b, a] interschimbă cele două valori într-un singur pas de timp constant — nu este nevoie de o variabilă ajutătoare. Linia începe cu punct și virgulă pentru a fi citită ca o instrucțiune de sine stătătoare, nu ca un index pe linia de deasupra.
Ieșire: program TypeScript și rezultatul capturat
let a = 1
let b = 2
console.log("înainte:", a, b)
// Punctul și virgula de la început ține această linie separată de cea de deasupra.
;[a, b] = [b, a]
console.log("după: ", a, b)