node:path

O módulo node:path no Azion Runtime: funções que unem, analisam e normalizam strings de caminho, exemplos de roteamento e análise e as APIs suportadas.

Última atualização

Ver como Markdown Configurar agente

O módulo node:path fornece os utilitários do Node.js para trabalhar com caminhos de arquivos e diretórios. Suas funções unem, dividem, normalizam e analisam caminhos, e uma function as usa para construir caminhos quando roteia requisições ou compõe referências a assets. O Azion Runtime não dá a uma function acesso a um sistema de arquivos real, então toda função de path opera apenas em strings de caminho. Por exemplo, path.resolve() retorna uma string sem ler um diretório.

Exemplos

As functions abaixo são executadas de forma independente: cada uma importa path de node:path, e cada saída é a que uma function com deploy feito retorna.

Operações básicas com path

Esta function une três segmentos em um caminho, registra o caminho no log e o retorna no corpo da resposta:

JavaScript
01/**
02 * An example of using the Node.js Path API in an Azion Function.
03 * Support:
04 * - Partially supported (Extended by library `path-browserify`)
05 * @module runtime-apis/nodejs/path/main
06 * @example
07 * // Build and run with the Azion CLI:
08 * azion build
09 * azion dev
10 */
11import path from "node:path";
12
13/**
14 * An example of using the Node.js Path API in an Azion Function.
15 * @param {*} event
16 * @returns {Promise<Response>}
17 */
18const main = async (event) => {
19 const pathName = path.join("/", "images", "image.jpg");
20 console.log("Path", pathName);
21 return new Response(`Path: ${pathName}`);
22};
23
24export default main;

A function registra Path /images/image.jpg no log e responde com este corpo:

Path: /images/image.jpg

Roteamento de URL com path

Esta function divide o caminho da requisição em diretório, nome do arquivo e extensão. Depois, constrói um caminho de API e um caminho absoluto a partir dessas partes:

JavaScript
01import path from "node:path";
02
03const main = async (event) => {
04 const requestUrl = new URL(event.request.url);
05 const pathname = requestUrl.pathname;
06
07 // Extract path components
08 const dirname = path.dirname(pathname);
09 const basename = path.basename(pathname);
10 const extname = path.extname(pathname);
11
12 console.log("Directory:", dirname);
13 console.log("Filename:", basename);
14 console.log("Extension:", extname);
15
16 // Build a new path for routing
17 const apiPath = path.join("/api", "v1", "users", basename);
18 console.log("API path:", apiPath);
19
20 // In Azion Runtime, path.resolve() manipulates path strings only;
21 // it does not read a filesystem
22 const absolutePath = path.resolve("/app", "public", "images", "logo.png");
23 console.log("Absolute path:", absolutePath);
24
25 return new Response(JSON.stringify({
26 original: pathname,
27 dirname,
28 basename,
29 extname,
30 apiPath,
31 absolutePath
32 }), {
33 headers: { "Content-Type": "application/json" }
34 });
35};
36
37export default main;

Para uma requisição a /docs/getting-started, um caminho sem extensão de arquivo, a function responde com cada parte do caminho e os dois caminhos que construiu:

{"original":"/docs/getting-started","dirname":"/docs","basename":"getting-started","extname":"","apiPath":"/api/v1/users/getting-started","absolutePath":"/app/public/images/logo.png"}

Normalização e análise de caminhos

Esta function normaliza um caminho que contém .., . e uma barra dupla. Depois, analisa um caminho em suas partes, constrói um caminho a partir de um objeto e verifica se dois caminhos são absolutos:

JavaScript
01import path from "node:path";
02
03const main = async (event) => {
04 // Normalize messy paths
05 const messyPath = "/users/../public/./images//photo.jpg";
06 const normalizedPath = path.normalize(messyPath);
07 console.log("Normalized:", normalizedPath);
08 // /public/images/photo.jpg
09
10 // Parse path into components
11 const filePath = "/assets/css/styles.css";
12 const parsed = path.parse(filePath);
13 console.log("Parsed:", parsed);
14 // { root: '/', dir: '/assets/css', base: 'styles.css', ext: '.css', name: 'styles' }
15
16 // Format path from object
17 const formatted = path.format({
18 root: "/",
19 dir: "/data/documents",
20 base: "report.pdf"
21 });
22 console.log("Formatted:", formatted);
23
24 // Check if path is absolute
25 const isAbs1 = path.isAbsolute("/assets/app.js");
26 const isAbs2 = path.isAbsolute("../relative/path");
27 console.log("Is absolute:", isAbs1, isAbs2);
28
29 return new Response(JSON.stringify({
30 normalizedPath,
31 parsed,
32 formatted,
33 isAbsolute: { absolute: isAbs1, relative: isAbs2 }
34 }), {
35 headers: { "Content-Type": "application/json" }
36 });
37};
38
39export default main;

A function responde com o caminho normalizado, as partes analisadas, o caminho formatado e as duas verificações:

{"normalizedPath":"/public/images/photo.jpg","parsed":{"root":"/","dir":"/assets/css","base":"styles.css","ext":".css","name":"styles"},"formatted":"/data/documents/report.pdf","isAbsolute":{"absolute":true,"relative":false}}

Separadores de caminho e variantes de plataforma

Esta function une os mesmos segmentos com as variantes padrão, POSIX e Windows do módulo e lê cada separador e o delimitador:

JavaScript
01import path from "node:path";
02
03const main = async (event) => {
04 // Default path methods (POSIX rules in Azion Runtime)
05 const defaultJoin = path.join("folder", "subfolder", "file.txt");
06 const defaultSep = path.sep;
07
08 // POSIX-style paths (forward slashes)
09 // path.posix and path.win32 are properties of the main module
10 const posixJoin = path.posix.join("folder", "subfolder", "file.txt");
11 const posixSep = path.posix.sep;
12
13 // Windows-style methods: in Azion Runtime, they also use forward slashes
14 const win32Join = path.win32.join("folder", "subfolder", "file.txt");
15 const win32Sep = path.win32.sep;
16
17 console.log("Default join:", defaultJoin);
18 console.log("POSIX join:", posixJoin);
19 console.log("Windows join:", win32Join);
20
21 // Get delimiter for PATH environment variable
22 const delimiter = path.delimiter;
23 console.log("Path delimiter:", delimiter);
24
25 return new Response(JSON.stringify({
26 default: { join: defaultJoin, sep: defaultSep },
27 posix: { join: posixJoin, sep: posixSep },
28 win32: { join: win32Join, sep: win32Sep },
29 delimiter
30 }), {
31 headers: { "Content-Type": "application/json" }
32 });
33};
34
35export default main;

A function responde com o mesmo caminho unido e o separador / nas três variantes, e com : como delimitador:

{"default":{"join":"folder/subfolder/file.txt","sep":"/"},"posix":{"join":"folder/subfolder/file.txt","sep":"/"},"win32":{"join":"folder/subfolder/file.txt","sep":"/"},"delimiter":":"}

APIs suportadas

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

APIStatus
path.basename()🟢 Com suporte
path.dirname()🟢 Com suporte
path.extname()🟢 Com suporte
path.format()🟢 Com suporte
path.isAbsolute()🟢 Com suporte
path.join()🟢 Com suporte
path.normalize()🟢 Com suporte
path.parse()🟢 Com suporte
path.relative()🟢 Com suporte
path.resolve()🟢 Com suporte
path.sep🟢 Com suporte
path.delimiter🟢 Com suporte
path.posix🟢 Com suporte
path.win32🟡 Suporte parcial

path.win32.join() une segmentos com /, então path.win32.join("C:\\a", "b") retorna C:/a/b, e path.win32.sep é /.

Toda função de path opera em strings de caminho, sem acesso ao sistema de arquivos. path.resolve() resolve segmentos relativos a partir de /, então path.resolve("a", "b") retorna /a/b. Para trabalhar com o caminho de uma requisição, leia-o com a API Web URL, como em new URL(event.request.url).pathname, e passe-o para as funções de node:path.

Recursos relacionados

APIs do Node.js

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

Use APIs do Node.js com polyfills

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

node:url

O módulo do Node.js que analisa e formata as URLs cujos caminhos node:path manipula.

Documentação de path do Node.js

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