Ist dies sicher zum require("path").joinVerketten von URLs, zum Beispiel:

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

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

Wenn nicht, wie würden Sie dies vorschlagen, ohne Code voller Wenns zu schreiben?

Nein. path.join() Gibt bei Verwendung mit URLs falsche Werte zurück.

Es klingt wie du willst url.resolve. Aus den Knotendokumenten :

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'

Bearbeiten: Wie Andreas in einem Kommentar richtig hervorhebt, url.resolvewürde nur helfen, wenn das Problem so einfach ist wie im Beispiel. url.parseDies gilt auch für diese Frage, da über das URLObjekt konsistent und vorhersehbar formatierte Felder zurückgegeben werden , wodurch der Bedarf an "Code voller Ifs" verringert wird.

Nein, Sie sollten keine path.join()URL-Elemente verknüpfen.

Dafür gibt es jetzt ein Paket. Anstatt das Rad neu zu erfinden, alle Ihre eigenen Tests zu schreiben, Fehler zu finden, sie zu beheben, weitere Tests zu schreiben, einen Randfall zu finden, in dem es nicht funktioniert usw., könnten Sie dieses Paket verwenden.

URL-Join

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

Installieren

npm install url-join

Verwendung

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

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

console.log(fullUrl);

Drucke:

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

Axios verfügt über eine Hilfsfunktion, mit der URLs kombiniert werden können.

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

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

Als ich PATH zum Verketten von URL-Teilen ausprobiert habe, sind Probleme aufgetreten. PATH.joinStreifen '//' bis '/' und auf diese Weise wird eine absolute URL ungültig (z. B. http: // ... -> http: / ...). Für mich war eine schnelle Lösung:

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

oder mit der von Colonel Panic veröffentlichten Lösung:

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

Nein! Unter Windows path.joinwerden Backslashes hinzugefügt. HTTP-URLs sind immer Schrägstriche.

Wie wäre es mit

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

Wir machen es so:

var _ = require('lodash');

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

Wenn Sie lodash verwenden , können Sie diesen einfachen Oneliner verwenden:

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

inspiriert von @Peter Dotchevs Antwort

Das benutze ich:

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

Beispiel:

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

Wenn Sie Angular verwenden, können Sie Location verwenden :

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

Funktioniert jedoch nur mit 2 Argumenten, sodass Sie bei Bedarf Aufrufe verketten oder eine Hilfsfunktion schreiben müssen, um dies zu tun.

Das WHATWG URL - Objekt Konstruktor hat eine (input, base)Version, und das inputkann mit relativ sein /, ./, ../. Kombinieren Sie dies mit path.posix.joinund Sie können alles tun:

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'

Benutzerdefinierte Typoskript-Lösung:

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

Meine Lösung

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

Bearbeiten: Wenn Sie Windows-Umgebungen unterstützen möchten

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

Die zweite Lösung ersetzt alle Backslashes, sodass URL-Teile wie Querystring und Hash ebenfalls geändert werden können, das Thema jedoch nur den URL-Pfad verbindet, sodass ich es nicht als Problem betrachte.

Es gibt andere funktionierende Antworten, aber ich ging mit den folgenden. Eine kleine Kombination aus path.join und 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

Dies kann durch eine Kombination von Knoten des erreicht werden Pfad und URL :

1. Benötigen Sie die Pakete:

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

2. Erstellen Sie zunächst ein URL-Objekt, mit dem Sie arbeiten können:

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

3. Verwenden pathname=und path.joinkonstruieren Sie eine mögliche Kombination:

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

(Sie können sehen, wie liberal path.joinmit Argumenten ist)

4. Zu diesem Zeitpunkt spiegelt Ihre URL das letztendlich gewünschte Ergebnis wider:

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

Warum dieser Ansatz?

Diese Technik verwendet integrierte Bibliotheken. Je weniger Abhängigkeiten von Drittanbietern, desto besser, wenn es um CVEs, Wartung usw. geht.

PS: Manipuliere niemals URLs als Strings!

Wenn ich Code überprüfe, bin ich fest davon überzeugt , URLs niemals manuell als Zeichenfolgen zu bearbeiten . Schauen Sie sich zum einen an, wie kompliziert die Spezifikation ist .

Zweitens sollte das Fehlen / Vorhandensein eines abschließenden / vorangestellten Schrägstrichs ( /) nicht dazu führen, dass alles kaputt geht! Sie sollten niemals tun:

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

und vor allem nicht:

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

Davon bin ich gerade in einer Codebasis begegnet.