node:buffer

O módulo node:buffer no Azion Runtime: a classe Buffer para dados binários, as APIs suportadas e exemplos de codificação, concatenação e corpo de requisição.

Última atualização

Ver como Markdown Configurar agente

O módulo node:buffer fornece Buffer, a classe do Node.js que armazena dados binários brutos como uma sequência de bytes. Use-o para converter texto entre codificações como hex e base64, para combinar e fatiar dados binários e para ler o corpo de uma requisição ou um stream como bytes. No Azion Runtime, Buffer também é um global: o global e a classe que você importa de node:buffer são o mesmo objeto, e todo buffer é um Uint8Array.

Exemplos

Cada exemplo é uma function completa que importa Buffer de node:buffer. A resposta abaixo de cada exemplo é a que uma function com deploy feito retorna.

Operações básicas com buffer

Esta function cria um buffer a partir de uma string, exibe o buffer em duas codificações e sobrescreve parte dele:

JavaScript
01/**
02 * An example of using the Node.js Buffer API in an Azion Function.
03 * Support:
04 * - Partial support
05 * @module runtime-apis/nodejs/buffer/main
06 * @example
07 * // Build and run with the Azion CLI:
08 * azion build
09 * azion dev
10 */
11import { Buffer } from "node:buffer";
12
13/**
14 * Example of using the Node.js Buffer API
15 * Writes `string` to `buf` at `offset` according to the character encoding in `encoding`. The `length` parameter is the number of bytes to write. If `buf` did
16 * not contain enough space to fit the entire string, only part of `string` will be
17 * written. However, partially encoded characters will not be written.
18 * @param {*} event
19 * @returns {Promise<Response>}
20 */
21const main = async (event) => {
22 const helloBuffer = Buffer.from("Hello Edge!", "utf8");
23 console.log(helloBuffer.toString("hex"));
24 // 48656c6c6f204564676521
25 console.log(helloBuffer.toString("base64"));
26 // SGVsbG8gRWRnZSE=
27
28 helloBuffer.write("World", 6, 5, "utf8");
29 console.log(helloBuffer.toString());
30 // Hello World
31 return new Response(helloBuffer.toString(), { status: 200 });
32};
33export default main;

A function responde com o texto sobrescrito:

Hello World

Conversões de codificação de buffer

Esta function converte uma string para três codificações de transmissão de dados e depois decodifica a forma base64 de volta para texto:

JavaScript
01import { Buffer } from "node:buffer";
02
03const main = async (event) => {
04 // Create buffer from string
05 const textBuffer = Buffer.from("Azion Runtime", "utf8");
06
07 // Convert to different encodings
08 const hexEncoded = textBuffer.toString("hex");
09 const base64Encoded = textBuffer.toString("base64");
10 const base64urlEncoded = textBuffer.toString("base64url");
11
12 console.log("Hex:", hexEncoded);
13 console.log("Base64:", base64Encoded);
14 console.log("Base64URL:", base64urlEncoded);
15
16 // Decode back from base64
17 const decoded = Buffer.from(base64Encoded, "base64").toString("utf8");
18 console.log("Decoded:", decoded);
19
20 // Create JSON response with all encodings
21 return new Response(JSON.stringify({
22 original: "Azion Runtime",
23 hex: hexEncoded,
24 base64: base64Encoded,
25 base64url: base64urlEncoded,
26 decoded: decoded
27 }), {
28 headers: { "Content-Type": "application/json" }
29 });
30};
31
32export default main;

A function responde com cada codificação da string:

{"original":"Azion Runtime","hex":"417a696f6e2052756e74696d65","base64":"QXppb24gUnVudGltZQ==","base64url":"QXppb24gUnVudGltZQ==","decoded":"Azion Runtime"}

No Azion Runtime, a saída base64url mantém o preenchimento =, como mostra o valor base64url, e Buffer.isEncoding("base64url") retorna false.

Concatenação e fatiamento de buffer

Esta function combina três buffers em um só e depois extrai e copia uma parte do resultado:

JavaScript
01import { Buffer } from "node:buffer";
02
03const main = async (event) => {
04 // Create multiple buffers
05 const header = Buffer.from("HEADER:", "utf8");
06 const content = Buffer.from("Hello World", "utf8");
07 const footer = Buffer.from(":END", "utf8");
08
09 // Concatenate buffers
10 const combined = Buffer.concat([header, content, footer]);
11 console.log("Combined:", combined.toString());
12 // Combined: HEADER:Hello World:END
13
14 // Use subarray() to extract content (preferred over deprecated slice())
15 const contentOnly = combined.subarray(7, 18);
16 console.log("Extracted:", contentOnly.toString());
17 // Extracted: Hello World
18
19 // Get buffer length
20 console.log("Total length:", combined.length);
21 // Total length: 22
22
23 // Copy portion to another buffer
24 const copy = Buffer.alloc(11);
25 combined.copy(copy, 0, 7, 18);
26 console.log("Copied:", copy.toString());
27 // Copied: Hello World
28
29 return new Response(JSON.stringify({
30 combined: combined.toString(),
31 extracted: contentOnly.toString(),
32 copied: copy.toString()
33 }), {
34 headers: { "Content-Type": "application/json" }
35 });
36};
37
38export default main;

A function responde com o buffer combinado e as duas partes extraídas:

{"combined":"HEADER:Hello World:END","extracted":"Hello World","copied":"Hello World"}

Processamento de dados binários

Esta function lê o corpo da requisição como um buffer, procura nele uma sequência de bytes e, em seguida, compara e aloca buffers:

JavaScript
01import { Buffer } from "node:buffer";
02
03const main = async (event) => {
04 // Get request body
05 const request = event.request;
06 const arrayBuffer = await request.arrayBuffer();
07
08 // Handle empty request body
09 if (!arrayBuffer.byteLength) {
10 return new Response(JSON.stringify({
11 error: "Empty request body",
12 length: 0
13 }), {
14 status: 400,
15 headers: { "Content-Type": "application/json" }
16 });
17 }
18
19 const dataBuffer = Buffer.from(arrayBuffer);
20
21 // Check buffer properties
22 console.log("Buffer length:", dataBuffer.length);
23 console.log("First byte:", dataBuffer[0]);
24
25 // Find byte sequence
26 const searchBuffer = Buffer.from("Azion", "utf8");
27 const index = dataBuffer.indexOf(searchBuffer);
28 console.log("Found 'Azion' at index:", index);
29
30 // Compare buffers
31 const buf1 = Buffer.from("test");
32 const buf2 = Buffer.from("test");
33 console.log("Buffers equal:", buf1.equals(buf2));
34
35 // Create buffer with specific size
36 const allocated = Buffer.alloc(256);
37 allocated.write("Allocated buffer example", 0, "utf8");
38 console.log("Allocated:", allocated.toString("utf8", 0, 24));
39
40 return new Response(JSON.stringify({
41 length: dataBuffer.length,
42 firstByte: dataBuffer[0],
43 foundAtIndex: index
44 }), {
45 headers: { "Content-Type": "application/json" }
46 });
47};
48
49export default main;

Para uma requisição POST cujo corpo é Hello Azion Runtime, a function responde com o tamanho do corpo, o primeiro byte dele e a posição de Azion:

{"length":19,"firstByte":72,"foundAtIndex":6}

Serialização JSON com buffers

Esta function converte um objeto em um buffer JSON, usa o tamanho do buffer na resposta e define Content-Length a partir dele:

JavaScript
01import { Buffer } from "node:buffer";
02
03const main = async (event) => {
04 // Create object with data
05 const data = {
06 id: 12345,
07 name: "Azion Function",
08 timestamp: Date.now()
09 };
10
11 // Convert to JSON string and then to buffer
12 const jsonString = JSON.stringify(data);
13 const jsonBuffer = Buffer.from(jsonString, "utf8");
14
15 // Calculate size for headers
16 const contentLength = jsonBuffer.length;
17
18 // Convert back to object
19 const parsed = JSON.parse(jsonBuffer.toString("utf8"));
20
21 console.log("JSON buffer size:", contentLength, "bytes");
22 console.log("Parsed object:", parsed);
23
24 // Create response buffer with metadata
25 const responseData = {
26 ...parsed,
27 bufferSize: contentLength
28 };
29 const responseBuffer = Buffer.from(JSON.stringify(responseData), "utf8");
30
31 return new Response(responseBuffer, {
32 headers: {
33 "Content-Type": "application/json",
34 "Content-Length": responseBuffer.length.toString()
35 }
36 });
37};
38
39export default main;

A function responde com o objeto e o tamanho do buffer, com Content-Length definido como 78:

{"id":12345,"name":"Azion Function","timestamp":1767268800000,"bufferSize":62}

APIs suportadas

A tabela lista o status de cada API de node:buffer no Azion Runtime:

APIStatus
Buffer.alloc()🟢 Com suporte
Buffer.allocUnsafe()🟢 Com suporte
Buffer.byteLength()🟢 Com suporte
Buffer.compare()🟢 Com suporte
Buffer.concat()🟢 Com suporte
Buffer.from()🟢 Com suporte
Buffer.isBuffer()🟢 Com suporte
Buffer.isEncoding()🟢 Com suporte
buf.compare()🟢 Com suporte
buf.copy()🟢 Com suporte
buf.equals()🟢 Com suporte
buf.fill()🟢 Com suporte
buf.indexOf()🟢 Com suporte
buf.includes()🟢 Com suporte
buf.lastIndexOf()🟢 Com suporte
buf.length🟢 Com suporte
buf.readInt*()🟡 Suporte parcial
buf.subarray()🟢 Com suporte
buf.slice()🟡 Com suporte (obsoleta, use subarray())
buf.toString()🟢 Com suporte
buf.write()🟢 Com suporte
buf.writeInt*()🟡 Suporte parcial
buffer.isAscii()🔴 Sem suporte
buffer.isUtf8()🔴 Sem suporte
buffer.resolveObjectURL()🔴 Sem suporte
buffer.transcode()🔴 Sem suporte

As APIs marcadas como 🟡 Suporte parcial têm funcionalidade limitada em comparação com a implementação completa do Node.js. Entre elas, writeUInt32BE(), readUInt32BE(), writeInt16LE() e readInt16LE() retornam os valores gravados, e readBigUInt64BE() está disponível. As funções de nível de módulo buffer.isAscii(), buffer.isUtf8(), buffer.resolveObjectURL() e buffer.transcode() não têm suporte. O Node.js marca buf.slice() como obsoleta a partir da v17.5.0; use buf.subarray() em vez dela.

Recursos relacionados

APIs do Node.js

O status de cada módulo do Node.js no Azion Runtime, incluindo buffer.

Use APIs do Node.js com polyfills

Como o build transforma imports node: em código que é executado no Azion Runtime.

Encoding

A alternativa da Web API para converter entre texto e bytes.

Documentação de buffer do Node.js

A referência completa do Node.js para cada API de node:buffer da tabela.