A experiência do usuário é essencial em software moderno e o desempenho é vital para uma boa experiência. O software moderno tem tudo a ver com desempenho e pode melhorar ou prejudicar sua capacidade de envolver e reter usuários. Aplicativos projetados com desempenho em mente têm uma chance maior de sucesso do que aqueles que não foram.
Um equívoco comum é que um simples trecho de código não pode causar nenhum dano. Pelo contrário, você deve sempre presumir que as consequências de adicionar um trecho de código podem ser piores do que você imagina. O outro lado é que leva apenas algumas linhas de código para melhorar significativamente o desempenho do seu aplicativo.
Neste guia, exploraremos uma das maneiras mais fáceis de melhorar o desempenho em aplicativos modernos: usando notação Big O para medir a complexidade do seu código.
O que é notação Big O ?
A notação Big O é um processo matemático que descreve a complexidade de um algoritmo. É um conceito muito importante no campo da ciência da computação que descreve como a complexidade de um algoritmo aumentará com base no tamanho da entrada.
Imagem de Huyen Pham .
Existem duas maneiras de medir a complexidade de um algoritmo:
A complexidade do espaço mede a quantidade exata de espaço que um algoritmo ocupará de acordo com o tamanho da entrada. É essencialmente medido calculando o espaço ocupado por variáveis em um algoritmo A complexidade de tempo mede a quantidade exata de tempo que um algoritmo levará de acordo com o tamanho da entrada. Depende essencialmente de quantas etapas um algoritmo precisa realizar antes de concluir a execução.
Podemos calcular a complexidade do tempo de um algoritmo medindo quanto tempo levará para executar esse algoritmo. Ao calcular a complexidade de um algoritmo, levamos em consideração três cenários:
Melhor caso -Quando o algoritmo será concluído no menor tempo possível. Esta é sempre a solução ideal Caso médio -Quando o algoritmo será concluído em um tempo médio Pior caso -Quando o algoritmo será concluído no tempo mais lento possível. Esta é sempre a solução pessimal.
Ao medir a complexidade de um algoritmo usando a notação Big O, você deve sempre considerar o pior cenário. O “O” na notação Big O representa a ordem da função e o “n” representa o número de entradas.
O (1)
A melhor complexidade de tempo para um algoritmo é a constante de tempo, também conhecido como O (1). Algoritmos com tempo constante sempre levarão a mesma quantidade de tempo para serem executados. A execução desse algoritmo é independente do tamanho da entrada.
Imagine que temos uma função que retorna o quadrado de um número:
const returnSquare=(num)=> num * num;
A função returnSquare sempre levará a mesma quantidade de tempo para ser executada. É assim que o tempo constante funciona, um algoritmo que roda na mesma quantidade de tempo, não importa o tamanho da entrada.
Agora, imagine que temos uma função que recebe um array. Queremos sempre retornar o primeiro elemento do array, não importa o tamanho do array.
const getFirstItem=(arr)=> arr [0];
A função getFirstItem tem uma complexidade de tempo constante porque será executada na mesma quantidade de tempo, não importa o quanto a matriz cresça em tamanho.
O (n)
O a complexidade de tempo mais comum é a complexidade de tempo linear, também conhecida como O (n).
Um algoritmo tem uma complexidade de tempo linear quando o tempo que leva para ser executado muda linearmente para o tamanho da entrada.
Imagine que temos um array simples e queremos iterar em todo o array para encontrar um item específico:
const searchItem=(arr, item)=> {for (let i=0; i
Conforme nosso array cresce, a complexidade de tempo desse algoritmo cresce linearmente. Cada vez que vemos um loop em nosso algoritmo, podemos assumir que esse código pode ser um algoritmo de complexidade de tempo linear.
O (log n)
Você pode ter estudado logaritmos na escola. Logaritmos são operações matemáticas que determinam quantas vezes um determinado número precisa ser multiplicado por ele mesmo para chegar a outro número.
Imagine que temos uma matriz de 10 elementos e levamos um segundo para iterar em toda a matriz. Conforme a complexidade de tempo desse algoritmo aumenta, levaríamos dois segundos para iterar em todo o array de 20 elementos, três segundos em um array de 30 elementos e assim por diante.
Um bom exemplo de um O O algoritmo (log n) é uma pesquisa binária. Uma pesquisa binária encontra a posição de um elemento específico em uma matriz classificada, dividindo a matriz pela metade em cada iteração:
Imagem feita usando Excalidraw .
Em cada etapa, o algoritmo reduz o tamanho do problema pela metade. Pegue o algoritmo de pesquisa binária como exemplo: cada iteração divide a matriz até encontrar o item específico.
O (n ^ 2)
Um algoritmo tem uma complexidade de tempo quadrática quando o o tempo de execução é proporcional ao quadrado do tamanho da entrada.
Imagine que temos um array e, para cada item, queremos fazer um loop novamente para comparar o elemento atual:
const findItem=(arr, newArr)=> {for (let i=0; i
O (n!)
O (n!) Representa a pior complexidade de tempo que um algoritmo pode ter. Ao escrever código, você não quer escrever um trecho de código que tenha uma complexidade de tempo O (n!), Também conhecida como complexidade de tempo fatorial.
Um algoritmo com tempo O (n!) a complexidade atinge o infinito muito mais rápido do que você pode imaginar. Em uma complexidade de tempo fatorial, estamos adicionando um loop aninhado para cada entrada que temos.
É bom saber que isso é possível, mas você provavelmente não quer escrever código com essa complexidade de tempo.
Conclusão
Os desenvolvedores gostam de medir a força do código com base na legibilidade. Não há nada de errado em usar a legibilidade como referência, mas não é o único que você deve considerar.
O desempenho desempenha um papel crucial em todos os softwares modernos, mas escrever código de desempenho nem sempre é simples. É importante estar ciente do nível de complexidade em sua base de código e evitar a criação de coisas desnecessárias.
O Big O Notation pode ajudá-lo a escrever código de desempenho medindo a complexidade do seu código. O conceito existe há muitos anos e continua a ajudar os desenvolvedores a escrever software envolvente e de alto desempenho.
