¿Es seguro usarlo require("path").joinpara concatenar URL, por ejemplo:

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

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

Si no es así, ¿qué manera sugeriría para hacer esto sin escribir un código lleno de if?

No. path.join()devolverá valores incorrectos cuando se use con URL.

Suena como si quisieras url.resolve. De los documentos de 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 señala correctamente en un comentario, url.resolvesolo ayudaría si el problema es tan simple como el ejemplo. url.parsetambién se aplica a esta pregunta porque devuelve campos formateados de manera consistente y predecible a través del URLobjeto que reduce la necesidad de "código lleno de ifs".

No, no debe utilizar path.join()para unir elementos de URL.

Hay un paquete para hacer eso ahora. Entonces, en lugar de reinventar la rueda, escribir todas sus propias pruebas, encontrar errores, corregirlos, escribir más pruebas, encontrar un caso extremo donde no funcione, etc., podría usar este paquete.

url-join

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

Instalar en pc

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);

Huellas dactilares:

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

Axios tiene una función auxiliar que puede combinar URL.

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

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

Cuando probé PATH para concatenar partes de URL, me encontré con problemas. PATH.joinrayas '//' hasta '/' y de esta manera invalida una URL absoluta (por ejemplo, http: // ... -> http: / ...). Para mí, una solución rápida fue:

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

o con la solución publicada por Colonel Panic:

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

¡No! En Windows path.joinse unirá con barras invertidas. Las URL HTTP son siempre barras inclinadas.

Qué tal si

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

Lo hacemos así:

var _ = require('lodash');

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

Si está usando lodash , puede usar este sencillo delineador:

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

inspirado en la respuesta de @Peter Dotchev

Si usa Angular, puede usar Location :

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

Sin embargo, solo funciona con 2 argumentos, por lo que debe encadenar llamadas o escribir una función auxiliar para hacerlo si es necesario.

Esto es lo que uso:

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

ejemplo:

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

El objeto WHATWG URL constructor tiene una (input, base)versión y el inputpuede ser relativa usando /, ./, ../. Combine esto con path.posix.joiny puede hacer cualquier cosa:

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'

Solución personalizada de TypeScript:

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');

Mi solución

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

Editar: si desea admitir entornos de Windows

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

La segunda solución reemplazará todas las barras invertidas, por lo que las partes de la URL como la cadena de consulta y el hash también pueden modificarse, pero el tema se une solo a la ruta de la URL, por lo que no lo considero un problema.

Hay otras respuestas que funcionan, pero fui con lo siguiente. Un pequeño combo 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

Esto se puede lograr mediante una combinación de la ruta y la URL del nodo :

1. Requerir los paquetes:

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

2. Empiece por crear un objeto URL con el que trabajar:

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

3. Utilice pathname=y path.joinpara construir cualquier combinación posible:

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

(puedes ver lo liberal que path.joines con los argumentos)

4. En este punto, su URL refleja el resultado final deseado:

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

¿Por qué este enfoque?

Esta técnica utiliza bibliotecas integradas. Cuantas menos dependencias de terceros, mejor, cuando se trata de CVE, mantenimiento, etc.

PD: ¡Nunca manipules las URL como cadenas!

Cuando reviso el código, soy inflexible sobre nunca manipular las URL como cadenas manualmente . Por un lado, mire lo complicada que es la especificación .

En segundo lugar, la ausencia / presencia de una barra inclinada ( /) al final o prefijada no debería hacer que todo se rompa. Nunca deberías hacer:

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

y especialmente no:

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

De los cuales acabo de encontrar en una base de código.