Funções Utilitárias para Funções 1.0.0

Funções utilitárias para funções oferecem uma variedade de métodos para gerenciar e aprimorar a execução de funções. Essas utilidades auxiliam em tarefas como debouncing, throttling, composição de funções e gerenciamento de comportamento assíncrono, facilitando o controle do fluxo de funções e otimizando o desempenho.

Instalação

Para instalar as funções utilitárias para funções, use um dos seguintes comandos, dependendo do seu gerenciador de pacotes:

npm

npm install @utilify/function

yarn

yarn add @utilify/function

pnpm

pnpm add @utilify/function

Após a instalação, você pode importar as funções no seu projeto, usando ESM ou CJS.

Uso

Esta biblioteca oferece suporte tanto para os sistemas de módulos ESM quanto CJS.

esm

import { debounce } from '@utilify/function';

cjs

const { debounce } = require('@utilify/function');

Overview

benchmark

async function benchmark(callback: () => void | Promise<void>, iterations: number = 1): Promise<number>;

Mede o tempo médio de execução (em milissegundos) de uma determinada função síncrona ou assíncrona em um número especificado de iterações.

compose

function compose<T>(...callbacks: ((value: T) => T)[]): (value: T) => T;

Componente para compor funções, aplicando-as da direita para a esquerda em um valor.

debounce

function debounce(callback: (...args: any[]) => void, delay: number = 300): (...args: any[]) => void;

Adia a execução de uma função até que um período de inatividade tenha ocorrido após a última invocação.

defer

function defer(callback: () => void): void;

Enfileira a execução de uma função para ser executada após o ciclo de eventos atual.

fallback

function fallback<T>(callback: () => T, fallback: () => T): T;

Executa a função callback e, em caso de erro, executa a função fallback.

guard

function guard<T, U = T>(validator: (value: T) => boolean, callback: (value: T) => U, fallback: (value: T) => U): (value: T) => U;

Executa uma função de callback se um valor passar por uma validação, caso contrário, executa uma função de fallback.

identity

function identity<T>(value: T): T;

Retorna o valor fornecido, útil como função de identidade.

lock

function lock(callback: (...args: any[]) => Promise<void>): (...args: any[]) => void;

Impedir a execução simultânea de uma função, garantindo que uma execução termine antes de permitir outra.

memo

function memo(callback: (...args: any[]) => any, cacheTimeout?: number): (...args: any[]) => any;

Armazena em cache os resultados de uma função com base em seus argumentos e os retorna imediatamente se a função for chamada novamente com os mesmos argumentos.

noop

function noop(): void;

Uma função que não faz nada, usada como um placeholder.

once

function once<T>(callback: (...args: any[]) => T): (...args: any[]) => T;

Executa uma função apenas uma vez, independentemente de quantas vezes for chamada.

parallel

function parallel(...callbacks: (() => Promise<any>)[]): Promise<any[]>;

Executa várias funções assíncronas em paralelo e aguarda todas as promessas serem resolvidas.

partialLeft

function partialLeft<T>(callback: (...args: any[]) => T, ...partial: any[]): (...args: any[]) => T;

Cria uma versão da função fornecida com os argumentos iniciais pré-definidos.

partialRight

function partialRight<T>(callback: (...args: any[]) => T, ...partial: any[]): (...args: any[]) => T;

Cria uma versão da função fornecida com os argumentos finais pré-definidos.

pipe

function pipe<T>(...callbacks: ((value: T) => T)[]): (value: T) => T;

Componente para compor funções, aplicando-as da esquerda para a direita em um valor.

rate

function rate(callback: (...args: any[]) => void, limit: number, interval: number): (...args: any[]) => boolean;

Limita a quantidade de vezes que uma função pode ser executada em um intervalo de tempo.

sleep

function sleep(timeout: number): Promise<void>;

Pausa a execução de uma função por um tempo específico, útil em funções assíncronas.

throttle

function throttle(callback: (...args: any[]) => void, wait: number = 300): (...args: any[]) => void;

Limita a frequência com que uma função pode ser chamada, permitindo que seja executada no máximo uma vez a cada wait milissegundos.