O Blob no Node.js representa uma sequência imutável de bytes com tamanho e tipo MIME. A API segue o padrão da Web e integra com fetch, FormData, Response, File, MessagePort e Web Streams, facilitando o compartilhamento de código entre navegador e backend.
Blobs são úteis para montar arquivos em memória, encapsular texto e dados binários, enviar uploads, criar respostas e transferir conteúdo entre threads. Porém, armazenar objetos grandes inteiramente em memória pode aumentar RSS e provocar pausas de garbage collection.
Neste guia, você aprenderá a criar Blob a partir de strings, Buffer e TypedArray, ler bytes e texto, usar slice, stream, FormData, Worker Threads, controlar memória, validar tipos e escolher entre Blob, Buffer e streams.
O que é Blob?
Blob significa Binary Large Object e representa dados binários imutáveis. A documentação oficial de Blob no Node.js descreve construtor, propriedades e métodos. A documentação de Blob na MDN explica o padrão compartilhado com navegadores.
Para buffers, consulte Buffer no Node.js. Para uploads, veja FormData no Node.js. O artigo Web Streams API no Node.js apresenta consumo incremental.
Criando um Blob de texto
const blob = new Blob(
['Olá, Node.js!'],
{ type: 'text/plain;charset=utf-8' }
);O conteúdo é convertido em bytes. O tipo MIME é metadado e não valida o conteúdo real.
Propriedades
console.log(blob.size);
console.log(blob.type);size retorna o tamanho em bytes. type retorna o MIME normalizado ou string vazia.
Criando a partir de Buffer
const data = Buffer.from([1, 2, 3, 4]);
const blob = new Blob([data], {
type: 'application/octet-stream'
});Blob pode receber Buffer, ArrayBuffer, TypedArray, DataView, string e outros Blobs.
Imutabilidade
Depois de criado, o conteúdo lógico do Blob não muda. Alterar o Buffer original não deve ser usado como forma de editar o Blob. Para produzir outro conteúdo, crie um novo objeto.
Lendo como texto
const text = await blob.text();text() decodifica o conteúdo como UTF-8 e carrega tudo em memória. Não use para arquivos gigantes.
Lendo como ArrayBuffer
const arrayBuffer = await blob.arrayBuffer();
const bytes = new Uint8Array(arrayBuffer);Esse método também materializa todo o conteúdo. Use stream quando o volume for grande.
bytes()
Versões modernas podem oferecer bytes() para retornar Uint8Array:
const bytes = await blob.bytes();Confirme suporte na versão mínima do Node.js.
Stream do Blob
const readable = blob.stream();
for await (const chunk of readable) {
await processChunk(chunk);
}stream() retorna uma ReadableStream. Ele evita uma única grande alocação no consumidor, embora o Blob já represente dados mantidos pela aplicação.
Convertendo para stream tradicional
const { Readable } = require('node:stream');
const nodeStream = Readable.fromWeb(blob.stream());Isso facilita integração com pipeline, filesystem e bibliotecas antigas.
Salvando no filesystem
const fs = require('node:fs');
const { pipeline } = require('node:stream/promises');
const { Readable } = require('node:stream');
await pipeline(
Readable.fromWeb(blob.stream()),
fs.createWriteStream(destination)
);Use caminho controlado e permissões mínimas. Consulte File System no Node.js.
slice()
const firstKilobyte = blob.slice(
0,
1024,
'application/octet-stream'
);slice() cria uma visão lógica de parte dos dados. Índices negativos contam a partir do final.
Dividindo em partes
function splitBlob(blob, chunkSize) {
const parts = [];
for (let start = 0; start < blob.size; start += chunkSize) {
parts.push(blob.slice(start, start + chunkSize));
}
return parts;
}Esse padrão ajuda em uploads por partes, mas precisa de limite de concorrência e retomada.
Blob em FormData
const form = new FormData();
form.set('document', blob, 'document.txt');
const response = await fetch(url, {
method: 'POST',
body: form
});Deixe o fetch definir o boundary multipart.
Blob como corpo de fetch
const response = await fetch(url, {
method: 'PUT',
headers: {
'content-type': blob.type || 'application/octet-stream'
},
body: blob
});Defina timeout e verifique status. Veja Fetch Nativo no Node.js.
Response com Blob
const response = new Response(blob, {
headers: {
'content-type': blob.type
}
});Isso é útil em APIs que trabalham com interfaces Web Request e Response.
Criando Blob de JSON
const blob = new Blob(
[JSON.stringify(data)],
{ type: 'application/json' }
);Valide o objeto e evite serializar estruturas gigantes ou circulares.
Unicode
Strings são codificadas em UTF-8. O tamanho em bytes pode ser maior que o comprimento em caracteres:
const blob = new Blob(['ação']);
console.log(blob.size);Line endings
O construtor pode aceitar opções relacionadas a finais de linha em implementações compatíveis. Para formatos de protocolo, gere bytes explicitamente em vez de depender da plataforma.
Blob e File
File estende a ideia de Blob com nome e data de modificação:
const file = new File(
[blob],
'report.txt',
{
type: blob.type,
lastModified: Date.now()
}
);O nome é metadado e não deve ser usado diretamente como caminho.
Transferência para Worker Threads
Blob pode ser enviado por MessagePort em versões compatíveis:
port.postMessage({ blob });O conteúdo pode ser compartilhado sem materialização imediata. Cada receptor pode chamar arrayBuffer() ou text().
Consulte Worker Threads no Node.js.
Blob versus Buffer
- Blob: imutável, API Web, possui type, slice e stream.
- Buffer: API tradicional do Node.js, mutável, eficiente para protocolos e I/O nativo.
Use Blob quando interoperabilidade Web e imutabilidade forem úteis. Use Buffer quando APIs do Node.js exigem esse tipo.
Blob versus stream
Blob representa um conjunto finito de bytes. Stream representa produção incremental que pode não estar completamente em memória.
Para arquivos muito grandes, prefira ler o filesystem em stream em vez de criar um Blob gigante.
Consumo de memória
A soma de vários Blobs pode ultrapassar o heap ou a memória externa. Monitore:
- RSS;
- heap usado;
- external;
- arrayBuffers;
- quantidade e tamanho de objetos ativos.
Limite antes da criação
if (buffer.byteLength > MAX_BYTES) {
throw new Error('Arquivo excede o limite');
}
const blob = new Blob([buffer]);Não espere criar o objeto para só depois verificar.
Validação de MIME
blob.type não prova o formato. Para imagens e documentos, verifique assinatura e faça parsing seguro.
URLs de objeto
Versões modernas do Node.js podem oferecer URLs de objeto para Blobs:
const url = URL.createObjectURL(blob);
try {
// usar a URL dentro do processo
} finally {
URL.revokeObjectURL(url);
}Essas URLs são locais ao processo e precisam ser revogadas para liberar referências.
resolveObjectURL()
O módulo Buffer pode oferecer função para recuperar o Blob associado a uma URL de objeto. Consulte a versão e não exponha identificadores como mecanismo de autorização.
Segurança
Dados binários podem conter conteúdo malicioso. Não execute, descompacte ou interprete sem limites. Arquivos comprimidos podem expandir para volumes enormes.
Criptografia
Para criptografar um Blob, processe bytes com Web Crypto ou streams apropriados. Veja Web Crypto API no Node.js.
Hash
const bytes = await blob.arrayBuffer();
const digest = await crypto.subtle.digest('SHA-256', bytes);Para conteúdo grande, uma API de hash em stream do módulo Crypto pode usar menos memória.
Testes
Cubra:
- Blob vazio;
- texto Unicode;
- Buffer;
- slice;
- stream;
- tipo MIME;
- limite de tamanho;
- transferência para worker;
- URL de objeto;
- cancelamento do consumidor.
Erros comuns
- Criar Blob gigante: memória do processo cresce.
- Confiar no type: formato real pode ser diferente.
- Usar text() em binário: dados são interpretados incorretamente.
- Não revogar URL: referências permanecem.
- Usar nome de File como caminho: path traversal se torna possível.
- Confundir Blob com stream: todo o conteúdo já precisa existir.
- Copiar bytes repetidamente: RSS aumenta.
Boas práticas
- Defina limites antes de criar.
- Use MIME como metadado, não validação.
- Prefira stream para arquivos grandes.
- Use slice para partes.
- Revogue URLs de objeto.
- Controle concorrência.
- Monitore memória externa.
- Valide conteúdo.
- Evite nomes externos como caminho.
- Teste a versão mínima do runtime.
Conclusão
O Blob no Node.js oferece uma representação imutável e compatível com a Web para texto e dados binários. Ele integra com fetch, FormData, Response, File e Worker Threads.
O principal cuidado é a memória. Blobs são convenientes para conteúdo finito e moderado, enquanto streams são melhores para arquivos grandes ou produção incremental. Com limites, validação e escolha correta entre Blob, Buffer e streams, aplicações conseguem manipular binários com segurança e interoperabilidade.
