È sicuro da usare require("path").joinper concatenare gli URL, ad esempio:

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

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

In caso contrario, che modo suggeriresti di farlo senza scrivere codice pieno di se?

No. path.join()restituirà valori errati se utilizzato con gli URL.

Sembra che tu voglia url.resolve. Dai documenti di 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'

Modifica: come sottolinea correttamente Andreas in un commento, url.resolveaiuterebbe solo se il problema fosse semplice come l'esempio. url.parsesi applica anche a questa domanda perché restituisce campi formattati in modo coerente e prevedibile tramite l' URLoggetto che riduce la necessità di "codice pieno di se".

No, non dovresti usare path.join()per unire elementi URL.

C'è un pacchetto per farlo adesso. Quindi, piuttosto che reinventare la ruota, scrivere tutti i tuoi test, trovare bug, risolverli, scrivere più test, trovare un caso limite in cui non funziona, ecc., Potresti usare questo pacchetto.

url-join

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

Installare

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

stampe:

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

Axios ha una funzione di supporto che può combinare gli URL.

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

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

Quando ho provato PATH per concatenare parti URL, ho riscontrato problemi. PATH.joinstrisce "//" fino a "/" e in questo modo invalida un URL assoluto (es. http: // ... -> http: / ...). Per me una soluzione rapida è stata:

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

o con la soluzione pubblicata dal colonnello Panic:

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

No! Su Windows path.joinsi unirà con i backslash. Gli URL HTTP sono sempre barre in avanti.

Che ne dite di

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

Lo facciamo in questo modo:

var _ = require('lodash');

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

Se stai usando lodash , puoi usare questo semplice oneliner:

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

ispirato dalla risposta di @Peter Dotchev

Se usi Angular, puoi usare Location :

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

Funziona solo su 2 argomenti, quindi devi concatenare chiamate o scrivere una funzione di supporto per farlo se necessario.

Questo è quello che uso:

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

esempio:

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

L' oggetto WHATWG URL costruttore ha una (input, base)versione e l' inputpuò essere relativo utilizzo /, ./, ../. Combina questo con path.posix.joine puoi fare qualsiasi 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'

Soluzione personalizzata per dattiloscritto:

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

La mia soluzione

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

Modifica: se vuoi supportare gli ambienti Windows

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

La seconda soluzione sostituirà tutte le barre rovesciate, quindi anche le parti dell'URL come querystring e hash potrebbero essere modificate, ma l'argomento si unisce solo al percorso dell'URL, quindi non lo considero un problema.

Ci sono altre risposte di lavoro, ma sono andato con quanto segue. Una piccola combinazione 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

Ciò può essere ottenuto mediante una combinazione del percorso e dell'URL di Node :

1. Richiedi i pacchetti:

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

2. Inizia creando un oggetto URL con cui lavorare:

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

3. Usa pathname=e path.joinper costruire ogni possibile combinazione:

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

(puoi vedere quanto path.joinè liberale con gli argomenti)

4. A questo punto il tuo URL riflette il risultato finale desiderato:

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

Perché questo approccio?

Questa tecnica utilizza librerie incorporate. Meno dipendenze da terze parti, meglio è, quando si tratta di CVE, manutenzione, ecc.

PS: non manipolare mai gli URL come stringhe!

Quando esamino il codice sono irremovibile nel non manipolare mai manualmente gli URL come stringhe . Per prima cosa, guarda quanto sono complicate le specifiche .

In secondo luogo, l'assenza / presenza di una barra in coda / con prefisso ( /) non dovrebbe causare la rottura di tutto! Non dovresti mai fare:

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

e soprattutto no:

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

Di cui ho appena incontrato in una base di codice.