Могу ли я использовать require ( "путь" ). Присоединиться, чтобы безопасно объединить URL-адреса?

Безопасно ли использовать 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?

Ответ 1

Нет. 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".

Ответ 2

Нет, вы не должны использовать 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 "

Ответ 3

Когда я попробовал PATH для конкатенирования частей URL, я столкнулся с проблемами. PATH.join stripes '//' down to '/' и таким образом делает недействительным абсолютный URL (например, http://... → http:/...). Для меня быстро исправить было:

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

или с решением, посланным полковником Паникой:

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

Ответ 4

Нет! В Windows path.join будут объединены обратные косые черты. URL-адреса HTTP всегда являются косой чертой.

Как насчет

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

Ответ 5

Мы делаем это так:

var _ = require('lodash');

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

Ответ 6

Это то, что я использую:

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

Ответ 7

Axios имеет вспомогательную функцию, которая может объединять URL-адреса.

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

Источник: https://github.com/axios/axios/blob/fe7d09bb08fa1c0e414956b7fc760c80459b0a43/lib/helpers/combineURLs.js

Ответ 8

Если вы используете lodash, вы можете использовать этот простой oneliner:

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

вдохновленный ответом @Peter Dotchev

Ответ 9

Если вы используете Angular, вы можете использовать Location:

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

Работает только с 2 аргументами, так что вам нужно объединить вызовы или написать вспомогательную функцию, чтобы сделать это при необходимости.

Ответ 10

Индивидуальное решение 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');

Ответ 11

Мне нужна была утилита, которая разрешала бы URL так же, как браузер. Вот решение:

import {
  URL
} from 'url';
import path from 'path';
import test from 'ava';

const resolveUrl = (baseUrl, nextUrl) => {
  if (nextUrl.startsWith('http://') || nextUrl.startsWith('https://')) {
    return nextUrl;
  }

  const baseUrlTokens = new URL(baseUrl);

  if (nextUrl.startsWith('//')) {
    return baseUrlTokens.protocol + nextUrl;
  }

  let nextPath = path.resolve(baseUrlTokens.pathname, nextUrl);

  if (!baseUrlTokens.pathname.endsWith('/')) {
    nextPath = nextPath.replace('/?', '?');
  }

  return (new URL(nextPath, baseUrl)).toString();
};

test('extends base URL using second URL fragment just like browser would', (t) => {
  t.is(resolveUrl('http://foo.com', '/bar'), 'http://foo.com/bar');
  t.is(resolveUrl('http://foo.com/bar', './baz'), 'http://foo.com/bar/baz');
  t.is(resolveUrl('http://foo.com/bar', '/baz'), 'http://foo.com/baz');
  t.is(resolveUrl('http://foo.com/bar/baz', '../qux'), 'http://foo.com/bar/qux');
  t.is(resolveUrl('http://foo.com', '?foo=bar'), 'http://foo.com/?foo=bar');
  t.is(resolveUrl('http://foo.com/', '?foo=bar'), 'http://foo.com/?foo=bar');
  t.is(resolveUrl('http://foo.com/bar', '?foo=bar'), 'http://foo.com/bar?foo=bar');
  t.is(resolveUrl('http://foo.com/bar/', '?foo=bar'), 'http://foo.com/bar/?foo=bar');
  t.is(resolveUrl('http://foo.com/?baz=qux', '?foo=bar'), 'http://foo.com/?foo=bar');
  t.is(resolveUrl('http://foo.com/?baz=qux', 'http://bar.baz/?qux=quux'), 'http://bar.baz/?qux=quux');
  t.is(resolveUrl('http://foo.com/?baz=qux', 'https://bar.baz/?qux=quux'), 'https://bar.baz/?qux=quux');
  t.is(resolveUrl('http://foo.com/?baz=qux', '//bar.baz/?qux=quux'), 'http://bar.baz/?qux=quux');
  t.is(resolveUrl('https://foo.com/?baz=qux', '//bar.baz/?qux=quux'), 'https://bar.baz/?qux=quux');
});

Это отличается от url.resolve в этих двух сценариях:

|--------------------------------------|------------------------|----------------------|
| subject                              | resolveUrl             | url.resolve          |
|--------------------------------------|------------------------|----------------------|
|('http://foo.com/bar', './baz')       |http://foo.com/bar/baz  | http://foo.com/baz   |
|('http://foo.com/bar/baz', '../qux')  |http://foo.com/bar/qux  | http://foo.com/qux   |
|--------------------------------------|------------------------|----------------------|