Ordenação de Arrays

const numeros = [0,1,2,3,4,5,6];

// Ordena os dados em ordem decrescente com base em uma propriedade específica
const ordenado = JSON.parse(JSON.stringify(numeros)).sort(this.compararDecrescente(propriedade));

// Função de comparação para ordenação descendente
compararDecrescente(nomePropriedade) {
  return function (objA, objB) {
    const valorA = objA[nomePropriedade];
    const valorB = objB[nomePropriedade];
    return valorB - valorA;
  };
}

Verificação Condicional em Arrrays

// some(): retorna true se algum elemento atender à condição
// every(): retorna true apenas se todos os elementos atenderem à condição

const valores = [0,10,12,13,14,15];
valores.some(item => item > 10);  // true
valores.every(item => item > 10); // false

Cálculo de Diferança Temporal

function calcularDiferenca(inicio, fim) {
  const dataInicio = new Date(inicio);
  const dataFim = new Date(fim);
  const diffMs = dataFim.getTime() - dataInicio.getTime();
  
  const dias = Math.floor(diffMs / (24 * 3600 * 1000));
  const restoHoras = diffMs % (24 * 3600 * 1000);
  const horas = Math.floor(restoHoras / (3600 * 1000));
  
  const restoMinutos = restoHoras % (3600 * 1000);
  const minutos = Math.floor(restoMinutos / (60 * 1000));
  
  const restoSegundos = restoMinutos % (60 * 1000);
  const segundos = Math.round(restoSegundos / 1000);
  
  return { dias, horas, minutos, segundos };
}

Data Anterior ao Dia Atual

function obterDataAnterior(diasAntes) {
  let dataRef = new Date();
  let ano = dataRef.getFullYear();
  let mes = dataRef.getMonth() + 1;
  let dia = dataRef.getDate();
  
  if(dia <= diasAntes) {
    if(mes > 1) {
      mes = mes - 1;
    } else {
      ano = ano - 1;
      mes = 12;
    }
  }
  
  dataRef.setDate(dataRef.getDate() - diasAntes);
  ano = dataRef.getFullYear();
  mes = dataRef.getMonth() + 1;
  dia = dataRef.getDate();
  
  const formatoMes = mes < 10 ? '0' + mes : mes;
  const formatoDia = dia < 10 ? '0' + dia : dia;
  
  return `${ano}-${formatoMes}-${formatoDia}`;
}

Truncagem de Texto com Reticências

function truncarTexto(texto, limite = 5) {
  if (!texto) return '';
  
  if (texto.length > limite) {
    return texto.substring(0, limite) + '...';
  }
  
  return texto;
}

Formatação Numérica

function formatarNumero(valor) {
  if (valor !== undefined) {
    return parseFloat(valor)
      .toFixed(0)
      .replace(/(\d)(?=(?:\d{3})+$)/g, '$1,');
  }
  
  return '';
}

Pesquisa em Estruturas Hierárquicas

this.filtrarArvore(termoBusca, dadosArvore);

filtrarArvore(busca, lista) {
  const resultado = [];
  
  lista.forEach(item => {
    if (item.label.includes(busca)) {
      resultado.push(item);
    } else {
      if (item.children && item.children.length > 0) {
        const filhosFiltrados = this.filtrarArvore(busca, item.children);
        
        if (filhosFiltrados && filhosFiltrados.length > 0) {
          const novoItem = {
            ...item,
            children: filhosFiltrados
          };
          resultado.push(novoItem);
        }
      }
    }
  });
  
  return resultado;
}