Diferença entre a chamada path.resolve e path.join?

Existe alguma diferença entre as seguintes invocações?

path.join(__dirname, 'app')

vs.

path.resolve(__dirname, 'app')

Qual deles deve ser preferido?

As duas funções lidam com segmentos começando de /maneiras muito diferentes; joinapenas o concatenará com o argumento anterior, no entanto resolve, tratará isso como o diretório raiz e ignorará todos os caminhos anteriores - pense nisso como o resultado da execução cdcom cada argumento:

path.join('/a', '/b') // Outputs '/a/b'

path.resolve('/a', '/b') // Outputs '/b'

Outro aspecto a ser observado é que path.resolvesempre resultará em uma URL absoluta e usará seu diretório de trabalho como base para resolver esse caminho. Mas, como __dirnameé um caminho absoluto, isso não importa no seu caso.

Quanto a qual você deve usar, a resposta é: depende de como você deseja que os segmentos que começam /a se comportar - eles devem ser unidos ou devem atuar como a nova raiz?

Se os outros argumentos são codificados, isso realmente não importa; nesse caso, você provavelmente deve considerar (a) como essa linha pode mudar no futuro e (b) quão consistente é com outros lugares no código.

As operações padrão do caminho do sistema de arquivos variam de acordo com o sistema operacional. Precisamos de algo que o abstraia. O pathmódulo fornece utilitários ou API para trabalhar com caminhos de arquivos e diretórios. você pode incluí-lo em seu projeto usando

const path = require('path');

O path.joinepath.resolve são dois métodos diferentes do módulo de caminho.

Ambos os métodos aceitam uma sequência de caminhos ou segmentos de caminho.

O path.resolve()método resolve uma sequência de caminhos ou segmentos de caminho em um caminho absoluto .

O path.join()método une todos os segmentos de caminho fornecidos usando o separador específico da plataforma como um delimitador e normaliza o caminho resultante.

Para entender melhor e diferenciar comportamentos, deixe-me explicá-lo com diferentes cenários.

1. Se não fornecermos nenhum argumento ou string vazia

no meu caso, meu nome de arquivo é index.jse o diretório de trabalho atual éE:\MyFolder\Pjtz\node

const path = require('path');

console.log("path.join() : ", path.join());
// outputs .
console.log("path.resolve() : ", path.resolve());
// outputs current directory or equalent to __dirname of the node process

e em execução resultado é como abaixo

λ node index.js
path.join() :  .
path.resolve() :  E:\MyFolder\Pjtz\node

A inferência do experimento acima é que o path.resolve()método produzirá o caminho absoluto onde os path.join()retornos. representando o diretório de trabalho atual ou o caminho relativo se nada for fornecido

2. Adicionando um / caminho como qualquer um dos argumentos.

const path=require('path');

console.log("path.join() : " ,path.join('abc','/bcd'));
console.log("path.resolve() : ",path.resolve('abc','/bcd'));

e o resultado é

λ node index.js
path.join() :  abc\bcd
path.resolve() :  E:\bcd

A inferência que podemos encontrar com este experimento é que path.join() apenas concatena a lista de entradas com o separador específico da plataforma enquanto path.resolve()processa a sequência de caminhos da direita para a esquerda, com cada caminho subsequente precedido até que um caminho absoluto seja construído.

path.join()concatena cada argumento com separadores específicos do SO, enquanto path.resolve()resolve cada argumento com raiz e produz saída.

1) path.resolve cria o caminho absoluto.

O método cria um caminho ausente da direita para a esquerda até que um caminho absoluto seja construído.

Por exemplo:

path.resolve('/a', 'b', 'c');     //    C:\a\b\c
path.resolve('/a', '/b', 'c');    //    C:\b\c
path.resolve('/a', '/b', '/c');   //    C:\c

Se o caminho absoluto não for gerado, o método usando o diretório de trabalho atual:

Por exemplo:

path.resolve('a', 'b', 'c');     //    C:\{current_working_directory}\a\b\c

2) path.join junta todos os caminhos e normaliza o resultado

Por exemplo:

path.join('/a', '/b', '/c');   //   \a\b\c
path.join('/a', '/b', 'c');    //   \a\b\c
path.join('/a', 'b', 'c');     //   \a\b\c
path.join('a', 'b', 'c');      //   \a\b\c