Чи безпечно це використовувати require("path").joinдля об'єднання URL-адрес, наприклад:

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

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

Якщо ні, то як би ви запропонували це зробити без написання коду, повного ifs?

Ні. path.join()Поверне неправильні значення при використанні з URL-адресами.

Це звучить так, як ти хочеш url.resolve. З Документів Документа :

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'

Редагувати: Як правильно вказує у коментарі Андреас, url.resolveце допоможе лише в тому випадку, якщо проблема настільки проста, як приклад. url.parseтакож стосується цього питання, оскільки воно повертає послідовно та передбачувано відформатовані поля через URLоб’єкт, що зменшує потребу в "коді, повному ifs".

Ні, ви не повинні використовувати path.join()для приєднання елементів URL.

Зараз є пакет для цього. Отже, замість того, щоб винаходити колесо, писати всі власні тести, знаходити помилки, виправляти їх, писати більше тестів, знаходити кращий регістр, де воно не працює тощо. Ви можете використовувати цей пакет.

URL-приєднання

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

Встановити

npm install url-join

Використання

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

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

console.log(fullUrl);

Друкує:

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

Axios має функцію помічника, яка може комбінувати URL-адреси.

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

Джерело: https://github.com/axios/axios/blob/fe7d09bb08fa1c0e414956b7fc760c80459b0a43/lib/helpers/combineURLs.js

Коли я спробував PATH для об'єднання частин URL, у мене виникли проблеми. PATH.joinсмужки '//' вниз до '/', і цей спосіб приводить до недійсності абсолютну URL-адресу (наприклад, http: // ... -> http: / ...). Для мене швидке виправлення було:

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

або з рішенням, опублікованим полковником Панікою:

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

Немає! У Windows path.joinприєднаються з косою рисою. URL-адреси HTTP - це завжди косої лінії вперед.

Як щодо

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

Ми робимо це так:

var _ = require('lodash');

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

Якщо ви використовуєте lodash , ви можете використовувати цей простий oneliner:

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

натхненний @Peter Dotchev в відповідь

Це те, що я використовую:

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

приклад:

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

Якщо ви використовуєте Angular, ви можете використовувати Location :

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

Працює лише на два аргументи, тому вам доведеться ланцюжок дзвінків або написання функції помічника, щоб це зробити за потреби.

Об'єкт WHATWG URL - конструктор має (input, base)версію, і inputможе бути відносним використанням /, ./, ../. Поєднайте це, path.posix.joinі ви можете зробити що завгодно:

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'

Спеціальне рішення 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');

Моє рішення

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

Редагувати: якщо ви хочете підтримувати середовище Windows

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

Друге рішення замінить всі косої риски, тому частини URL-адреси, такі як запит і хеш, також можуть бути змінені, але тема приєднується лише до URL-адреси, тому я не вважаю це проблемою.

Є й інші робочі відповіді, але я пішов із наступним. Трохи комбінації 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

Це можна досягти за допомогою комбінації шляху та URL-адреси вузла :

1. Потрібні пакети:

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

2. Почніть з створення об’єкта URL для роботи з:

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

3. Використовуйте pathname=та path.joinбудуйте будь-яку можливу комбінацію:

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

(ви можете бачити, наскільки ліберальний path.joinз аргументами)

4. У цей момент ваша URL-адреса відображає кінцевий бажаний результат:

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

Чому такий підхід?

Ця методика використовує вбудовані бібліотеки. Чим менше сторонніх залежностей, тим краще, якщо мова йде про CVE, технічне обслуговування тощо.

PS: Ніколи не маніпулюйте URL-адресами як рядками!

Переглядаючи код, я переконаний, що ніколи не вручну маніпулювати URL-адресами як рядками . Для початку подивіться, наскільки складна специфікація .

По-друге, відсутність / наявність кінцевої / префіксованої косої риски ( /) не повинна спричиняти все, щоб зламатись! Ніколи не слід робити:

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

і особливо не:

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

З яким я щойно стикався в кодовій базі.