Czy jest to bezpieczne do require("path").joinłączenia adresów URL, na przykład:

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

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

Jeśli nie, w jaki sposób możesz to zrobić bez pisania pełnego kodu ifs?

Nie path.join()zwróci nieprawidłowe wartości w przypadku użycia z adresami URL.

Brzmi tak, jak chcesz url.resolve. Z dokumentacji 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'

Edycja: Jak słusznie wskazuje Andreas w komentarzu, url.resolvepomogłoby to tylko wtedy, gdy problem jest tak prosty, jak na przykładzie. url.parsedotyczy również tego pytania, ponieważ zwraca ono spójnie i przewidywalnie sformatowane pola za pośrednictwem URLobiektu, co zmniejsza potrzebę stosowania „kodu pełnego if”.

Nie, nie powinieneś używać path.join()do łączenia elementów URL.

Jest pakiet do tego teraz. Więc zamiast wymyślać koło na nowo, pisz własne testy, znajduj błędy, naprawiaj je, pisz więcej testów, znajdź skrajny przypadek, w którym to nie działa itp., Możesz użyć tego pakietu.

dołączenie url

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

zainstalować

npm install url-join

Stosowanie

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

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

console.log(fullUrl);

Wydruki:

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

Axios ma funkcję pomocniczą, która może łączyć adresy URL.

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

Źródło: https://github.com/axios/axios/blob/fe7d09bb08fa1c0e414956b7fc760c80459b0a43/lib/helpers/combineURLs.js

Kiedy próbowałem PATH do łączenia części adresów URL, napotykam problemy. PATH.joinstripes '//' aż do '/' iw ten sposób unieważnia bezwzględny adres URL (np. http: // ... -> http: / ...). Dla mnie szybkim rozwiązaniem było:

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

lub z rozwiązaniem opublikowanym przez Colonel Panic:

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

Nie! W systemie Windows path.joindołączy z ukośnikiem odwrotnym. Adresy URL HTTP są zawsze ukośnikami.

Co powiesz na

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

Robimy to tak:

var _ = require('lodash');

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

Jeśli używasz lodash , możesz użyć tego prostego onelinera:

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

zainspirowany @Peter Dotchev za odpowiedź

Jeśli używasz Angular, możesz użyć lokalizacji :

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

Działa jednak tylko na 2 argumentach, więc w razie potrzeby musisz łączyć wywołania lub napisać funkcję pomocniczą, aby to zrobić.

Oto czego używam:

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

przykład:

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

Obiekt WHATWG URL konstruktor ma (input, base)wersję, a inputmoże być względna użyciu /, ./, ../. Połącz to z path.posix.joini możesz zrobić wszystko:

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'

Niestandardowe rozwiązanie dla maszynopisu:

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

Moje rozwiązanie

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

Edycja: jeśli chcesz obsługiwać środowiska Windows

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

Drugie rozwiązanie zastąpi wszystkie odwrotne ukośniki, więc części adresu URL, takie jak querystring i hash, mogą również zostać zmienione, ale temat łączy się tylko ze ścieżką adresu URL, więc nie uważam tego za problem.

Istnieją inne działające odpowiedzi, ale poszedłem z następującymi. Mała kombinacja 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

Można to osiągnąć za pomocą kombinacji ścieżki i adresu URL węzła :

1. Wymagaj pakietów:

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

2. Zacznij od utworzenia obiektu URL do pracy z:

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

3. Użyj pathname=i path.joindo skonstruowania dowolnej możliwej kombinacji:

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

(możesz zobaczyć, jak liberalny path.joinjest z argumentami)

4. W tym momencie Twój adres URL odzwierciedla ostateczny pożądany wynik:

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

Dlaczego takie podejście?

Ta technika wykorzystuje wbudowane biblioteki. Im mniej zależności zewnętrznych, tym lepiej, jeśli chodzi o CVE, konserwację itp.

PS: Nigdy nie manipuluj adresami URL jako ciągami!

Kiedy przeglądam kod, zdecydowanie nie chcę ręcznie manipulować adresami URL jako ciągami . Po pierwsze, spójrz, jak skomplikowana jest specyfikacja .

Po drugie, brak / obecność końcowego / poprzedzonego ukośnika ( /) nie powinno powodować zepsucia wszystkiego! Nigdy nie powinieneś robić:

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

a zwłaszcza nie:

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

Z których właśnie spotkałem się w bazie kodu.