Uživatelská zkušenost je v moderním softwaru zásadní a výkon je pro dobrý zážitek zásadní. Moderní software je především o výkonu a může způsobit nebo narušit vaši schopnost zaujmout a udržet uživatele. Aplikace navržené s ohledem na výkon mají větší šanci na úspěch oproti těm, které nebyly.
Obvyklá mylná představa je, že jednoduchý kus kódu nemůže způsobit žádnou škodu. Naopak byste měli vždy předpokládat, že důsledky přidání části kódu mohou být horší, než si představujete. Druhou stranou je, že k výraznému zlepšení výkonu vaší aplikace stačí jen několik řádků kódu.
V této příručce prozkoumáme jeden z nejjednodušších způsobů, jak zlepšit výkon v moderních aplikacích:použití notace Big O k měření složitosti vašeho kódu.
Co je notace velkého O?
Velký O zápis je matematický proces, který popisuje složitost algoritmu. Je to velmi důležitý koncept v oblasti počítačových věd, který popisuje, jak bude narůstat složitost algoritmu na základě velikosti vstupu.
Existují dva způsoby měření složitosti algoritmu:
- Složitost prostoru měří přesné množství prostoru, který algoritmus zabere podle velikosti vstupu. V podstatě se měří výpočtem prostoru obsazeného proměnnými v algoritmu
- Časová složitost měří přesné množství času, který algoritmus zabere podle velikosti vstupu. V podstatě záleží na tom, kolik kroků musí algoritmus provést, než dokončí provádění
Můžeme vypočítat časovou složitost algoritmu měřením, jak dlouho bude trvat spuštění tohoto algoritmu. Při výpočtu složitosti algoritmu bereme v úvahu tři scénáře:
- Nejlepší případ — Když se algoritmus dokončí v nejrychlejším možném čase. Toto je vždy optimální řešení
- Průměrný případ — Kdy bude algoritmus dokončen v průměrném čase
- V nejhorším případě — Když se algoritmus dokončí v nejpomalejším možném čase. Toto je vždy pesimální řešení
Při měření složitosti algoritmu pomocí notace Big O byste měli vždy zvážit nejhorší možný scénář. „O“ v zápisu velkého O znamená pořadí funkce a „n“ znamená počet vstupů.
O(1)
Nejlepší časovou složitostí pro algoritmus je konstantní čas, také známý jako O(1). Provedení algoritmů s konstantním časem bude vždy trvat stejně dlouho. Provedení tohoto algoritmu je nezávislé na velikosti vstupu.
Představte si, že máme funkci, která vrací druhou mocninu čísla:
const returnSquare = (num) => num * num;
returnSquare spuštění funkce bude vždy trvat stejně dlouho. Takto funguje konstantní čas, algoritmus, který běží ve stejnou dobu, bez ohledu na velikost vstupu.
Nyní si představte, že máme funkci, která přijímá pole. Chceme vždy vrátit první prvek pole bez ohledu na velikost pole.
const getFirstItem = (arr) => arr[0];
getFirstItem funkce má konstantní časovou složitost, protože poběží za stejnou dobu bez ohledu na to, jak moc pole naroste.
O(n)
Nejběžnější časovou složitostí je lineární složitost času, známá také jako O(n).
Algoritmus má lineární časovou složitost, když se doba potřebná ke spuštění lineárně mění s velikostí vstupu.
Představte si, že máme jednoduché pole a chceme iterovat celé pole, abychom našli konkrétní položku:
const searchItem = (arr, item) => {
for (let i = 0; i < arr.length; i++) {
if (arr[i] === item) {
return item;
}
}
}
V nejlepším případě je položka, na kterou se díváme, první položkou a nemusíme mapovat celé pole. V nejhorším případě může být položka poslední a budeme muset iterovat celé pole.
Jak naše pole roste, časová složitost tohoto algoritmu roste lineárně. Pokaždé, když v našem algoritmu vidíme smyčku, můžeme předpokládat, že tento kód může být algoritmem lineární časové složitosti.
Další skvělé články od LogRocket:
- Nenechte si ujít ani okamžik s The Replay, kurátorským zpravodajem společnosti LogRocket
- Použijte useEffect React k optimalizaci výkonu vaší aplikace
- Přepínání mezi více verzemi Node
- Naučte se animovat aplikaci React pomocí AnimXYZ
- Prozkoumejte Tauri, nový rámec pro vytváření binárních souborů
- Porovnejte NestJS vs. Express.js
- Objevte oblíbené ORM používané v prostředí TypeScript
O(log n)
Možná jste se ve škole učili logaritmy. Logaritmy jsou matematické operace, které určují, kolikrát musí být určité číslo vynásobeno samo sebou, aby se dosáhlo jiného čísla.
Představte si, že máme pole 10 prvků a trvá nám jednu sekundu, než celé pole iterujeme. Jak roste časová složitost tohoto algoritmu, iterování celého pole 20 prvků by trvalo dvě sekundy, pole 30 prvků tři sekundy a tak dále.
Dobrým příkladem algoritmu O(log n) je binární vyhledávání. Binární vyhledávání najde pozici konkrétního prvku v seřazeném poli rozdělením pole na polovinu v každé iteraci:
V každém kroku algoritmus zmenší velikost problému na polovinu. Vezměte si binární vyhledávací algoritmus jako příklad:každá iterace rozděluje pole, dokud nenajde konkrétní položku.
O(n ^ 2)
Algoritmus má kvadratickou časovou složitost, když je doba běhu úměrná druhé mocnině velikosti vstupu.
Představte si, že máme pole a pro každou položku chceme opakovat smyčku, abychom porovnali aktuální prvek:
const findItem = (arr, newArr) => {
for (let i = 0; i < arr.length; i++) {
for (let j = 0; j < newArr.length; j++) {
if (arr[i] === newArr[j]) {
console.log('hello!');
}
}
}
}
Toto je příklad algoritmu kvadratické časové složitosti. Vnořené smyčky způsobují zdvojnásobení časové složitosti. Pokaždé, když se velikost našich polí zvětší, komplexita se zvýší kvadraticky.
O(n!)
O(n!) představuje nejhorší časovou složitost, jakou může algoritmus mít. Při psaní kódu nechcete psát část kódu, který má časovou složitost O(n!), také známou jako faktoriální časová složitost.
Algoritmus s časovou složitostí O(n!) dosahuje nekonečna mnohem rychleji, než si dokážete představit. Při faktoriální časové složitosti přidáváme vnořenou smyčku pro každý vstup, který máme.
Je dobré vědět, že je to možné, ale pravděpodobně nebudete chtít psát kód s touto časovou složitostí.
Závěr
Vývojáři rádi měří sílu kódu na základě čitelnosti. Na použití čitelnosti jako měřítka není nic špatného, ale není to jediné, o čem byste měli uvažovat.
Výkon hraje zásadní roli ve všech moderních softwarech, ale psaní výkonného kódu není vždy jednoduché. Je důležité si uvědomit úroveň složitosti vaší kódové základny a vyhnout se vytváření věcí, které jsou zbytečné.
Big O Notation vám může pomoci napsat výkonný kód měřením složitosti vašeho kódu. Tento koncept existuje již mnoho let a nadále pomáhá vývojářům psát poutavý a výkonný software.