É seguro usar require("path").joinpara concatenar URLs, por exemplo:

require("path").join("http://example.com", "ok"); 
//returns 'http://example.com/ok'

require("path").join("http://example.com/", "ok"); 
//returns 'http://example.com/ok'

Caso contrário, de que maneira você sugeriria isso sem escrever um código cheio de ifs?

No. path.join()retornará valores incorretos quando usado com URLs.

Parece que você quer url.resolve. Nos documentos do Node :

url.resolve('/one/two/three', 'four')         // '/one/two/four'
url.resolve('http://example.com/', '/one')    // 'http://example.com/one'
url.resolve('http://example.com/one', '/two') // 'http://example.com/two'

Editar: como Andreas corretamente indica em um comentário, url.resolvesó ajudaria se o problema fosse tão simples quanto o exemplo. url.parsetambém se aplica a essa pergunta porque retorna campos formatados de forma consistente e previsível por meio do URLobjeto que reduz a necessidade de "código cheio de ifs".

Não, você não deve usar path.join()para associar elementos de URL.

Há um pacote para fazer isso agora. Então, em vez de reinventar a roda, escreva todos os seus próprios testes, encontre bugs, corrija-os, escreva mais testes, encontre um caso de borda onde não funcione etc., você pode usar este pacote.

junção de URL

https://github.com/jfromaniello/url-join

Instalar

npm install url-join

Uso

var urljoin = require('url-join');

var fullUrl = urljoin('http://www.google.com', 'a', '/b/cd', '?foo=123');

console.log(fullUrl);

Impressões:

' http://www.google.com/a/b/cd?foo=123 '

O Axios possui uma função auxiliar que pode combinar URLs.

function combineURLs(baseURL, relativeURL) {
  return relativeURL
    ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
    : baseURL;
}

Fonte: https://github.com/axios/axios/blob/fe7d09bb08fa1c0e414956b7fc760c80459b0a43/lib/helpers/combineURLs.js

Quando tentei o PATH para concatenar partes de URL, me deparei com problemas. PATH.joinlistras '//' até '/' e, dessa forma, invalida um URL absoluto (por exemplo, http: // ... -> http: / ...). Para mim, uma solução rápida foi:

baseurl.replace(/\/$/,"") + '/' + path.replace(/^\//,"") )

ou com a solução postada pelo coronel Panic:

[pathA.replace(/^\/|\/$/g,""),pathB.replace(/^\/|\/$/g,"")].join("/")

Não! No Windows path.joinse juntará às barras invertidas. URLs HTTP sempre são barras.

E se

> ["posts", "2013"].join("/")
'posts/2013'

Fazemos assim:

var _ = require('lodash');

function urlJoin(a, b) {
  return _.trimEnd(a, '/') + '/' + _.trimStart(b, '/');
}

Se você estiver usando o lodash , poderá usar este oneliner simples:

// returns part1/part2/part3
['part1/', '/part2', '/part3/'].map((s) => _.trim(s, '/')).join('/')

inspirado na resposta de @Peter Dotchev

Isto é o que eu uso:

function joinUrlElements() {
  var re1 = new RegExp('^\\/|\\/$','g'),
      elts = Array.prototype.slice.call(arguments);
  return elts.map(function(element){return element.replace(re1,""); }).join('/');
}

exemplo:

url = joinUrlElements(config.mgmtServer, '/v1/o/', config.org, '/apps');

Se você usa Angular, pode usar Local :

import { Location } from '@angular/common';
// ...
Location.joinWithSlash('beginning', 'end');

Funciona apenas com 2 argumentos, portanto, você deve encadear chamadas ou escrever uma função auxiliar para fazer isso, se necessário.

O objeto WHATWG URL construtor tem uma (input, base)versão eo inputpode ser relativo usando /, ./, ../. Combine isso com path.posix.joine você pode fazer qualquer coisa:

const {posix} = require ("path");
const withSlash = new URL("https://example.com:8443/something/");
new URL(posix.join("a", "b", "c"), withSlash).toString(); // 'https://example.com:8443/something/a/b/c'
new URL(posix.join("./a", "b", "c"), withSlash).toString(); // 'https://example.com:8443/something/a/b/c'
new URL(posix.join("/a", "b", "c"), withSlash).toString(); // 'https://example.com:8443/a/b/c'
new URL(posix.join("../a", "b", "c"), withSlash).toString(); // 'https://example.com:8443/a/b/c'
const noSlash = new URL("https://example.com:8443/something");
new URL(posix.join("./a", "b", "c"), noSlash).toString(); // 'https://example.com:8443/a/b/c'

Solução personalizada datilografada:

export function pathJoin(parts: string[], sep: string) {
  return parts
    .map(part => {
      const part2 = part.endsWith(sep) ? part.substring(0, part.length - 1) : part;
      return part2.startsWith(sep) ? part2.substr(1) : part2;
    })
    .join(sep);
}

expect(pathJoin(['a', 'b', 'c', 'd'], '/')).toEqual('a/b/c/d');
expect(pathJoin(['a/', '/b/', 'c/', 'd'], '/')).toEqual('a/b/c/d');
expect(pathJoin(['http://abc.de', 'users/login'], '/')).toEqual('http://abc.de/users/login');

Minha solução

path.join(SERVER_URL, imageAbsolutePath).replace(':/','://');

Editar: se você deseja oferecer suporte ao ambiente do Windows

path.join(SERVER_URL, imageAbsolutePath).replace(/\\/g,'/').replace(':/','://');

A segunda solução substituirá todas as barras invertidas; portanto, partes de URL, como querystring e hash, também podem ser alteradas, mas o tópico está se unindo apenas ao caminho da URL, por isso não considero um problema.

Existem outras respostas úteis, mas eu fui com o seguinte. Uma pequena combinação path.join / URL.

const path = require('path');
//
const baseUrl = 'http://ejemplo.mx';
// making odd shaped path pieces to see how they're handled.
const pieces = ['way//', '//over/', 'there/'];
//
console.log(new URL(path.join(...pieces), baseUrl).href);
// http://ejemplo.mx/way/over/there/

// path.join expects strings. Just an example how to ensure your pieces are Strings.
const allString = ['down', 'yonder', 20000].map(String);
console.log(new URL(path.join(...allString), baseUrl).href);
// http://ejemplo.mx/down/yonder/20000

Isso pode ser realizado por uma combinação do caminho e da URL do nó :

1. Exija os pacotes:

const nodeUrl = require('url')
const nodePath = require('path')

2. Comece criando um objeto de URL para trabalhar:

> const myUrl = new nodeUrl.URL('https://example.com')

3. Use pathname=e path.joinpara construir qualquer combinação possível:

> myUrl.pathname = nodePath.join('/search', 'for', '/something/')
'/search/for/something/'

(você pode ver o quão liberal path.joiné com argumentos)

4. Nesse ponto, seu URL reflete o resultado final desejado:

> myUrl.toString()
'https://example.com/search/for/something/'

Por que essa abordagem?

Essa técnica usa bibliotecas internas. Quanto menos dependências de terceiros, melhor, quando se trata de CVEs, manutenção etc.

PS: nunca manipule URLs como strings!

Ao revisar o código, sou inflexível sobre nunca manipular URLs como sequências manualmente . Por um lado, veja como a especificação é complicada .

Em segundo lugar, a ausência / presença de uma barra final / prefixada ( /) não deve fazer com que tudo quebre! Você nunca deve fazer:

const url = `${baseUrl}/${somePath}`

e especialmente não:

uri: host + '/' + SAT_SERVICE + '/' + CONSTELLATION + '/',

Dos quais eu acabei de encontrar em uma base de código.