Est-ce sûr à utiliser require("path").joinpour concaténer des URL, par exemple:

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

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

Sinon, que suggéreriez-vous pour faire cela sans écrire de code plein de ifs?

No. path.join()renverra des valeurs incorrectes lorsqu'il est utilisé avec des URL.

On dirait que tu veux url.resolve. À partir de la documentation 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'

Edit: Comme Andreas le souligne correctement dans un commentaire, url.resolvecela n'aiderait que si le problème est aussi simple que l'exemple. url.parses'applique également à cette question car elle renvoie des champs formatés de manière cohérente et prévisible via l' URLobjet, ce qui réduit le besoin de «code plein de if».

Non, vous ne devez pas utiliser path.join()pour joindre des éléments d'URL.

Il y a un paquet pour faire ça maintenant. Donc, plutôt que de réinventer la roue, d'écrire tous vos propres tests, de trouver des bogues, de les corriger, d'écrire plus de tests, de trouver un cas limite où cela ne fonctionne pas, etc., vous pouvez utiliser ce paquet.

jointure d'URL

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

Installer

npm install url-join

Usage

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

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

console.log(fullUrl);

Impressions:

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

Axios a une fonction d'assistance qui peut combiner des URL.

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

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

Quand j'ai essayé PATH pour concaténer des parties d'url, j'ai rencontré des problèmes. PATH.joinstripes '//' jusqu'à '/' et de cette façon invalide une URL absolue (par exemple. http: // ... -> http: / ...). Pour moi, une solution rapide était:

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

ou avec la solution publiée par le colonel Panic:

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

Non! Sur Windows path.joinse joindra avec des barres obliques inverses. Les URL HTTP sont toujours des barres obliques.

Que diriez-vous

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

Nous le faisons comme ceci:

var _ = require('lodash');

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

Si vous utilisez lodash , vous pouvez utiliser ce simple oneliner:

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

inspiré par la réponse de @Peter Dotchev

Si vous utilisez Angular, vous pouvez utiliser Location :

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

Cela ne fonctionne que sur 2 arguments, vous devez donc enchaîner les appels ou écrire une fonction d'assistance pour le faire si nécessaire.

Voici ce que j'utilise:

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

exemple:

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

L' objet URL WHATWG constructeur a une (input, base)version et inputpeut être relatif à l' aide /, ./, ../. Combinez cela avec path.posix.joinet vous pouvez tout faire:

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'

Solution personnalisée 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');

Ma solution

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

Modifier: si vous souhaitez prendre en charge les environnements Windows

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

La deuxième solution remplacera toutes les barres obliques inverses, de sorte que les parties d'URL comme la chaîne de requête et le hachage peuvent également être modifiées, mais le sujet ne rejoint que le chemin de l'url, donc je ne considère pas cela comme un problème.

Il y a d'autres réponses de travail, mais je suis allé avec ce qui suit. Un petit combo 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

Cela peut être accompli par une combinaison du chemin et de l' URL de Node :

1. Exiger les packages:

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

2. Commencez par créer un objet URL avec lequel travailler:

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

3. Utilisez pathname=et path.joinpour construire toute combinaison possible:

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

(vous pouvez voir à quel point les path.joinarguments sont libéraux )

4. À ce stade, votre URL reflète le résultat ultime souhaité:

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

Pourquoi cette approche?

Cette technique utilise des bibliothèques intégrées. Moins il y a de dépendances tierces, mieux c'est, en ce qui concerne les CVE, la maintenance, etc.

PS: ne manipulez jamais les URL comme des chaînes!

Lorsque j'examine le code, je suis catégorique sur le fait de ne jamais manipuler manuellement les URL en tant que chaînes . D'une part, regardez à quel point la spécification est compliquée .

Deuxièmement, l'absence / présence d'une barre oblique de fin / préfixée ( /) ne doit pas tout casser! Vous ne devriez jamais faire:

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

et surtout pas:

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

Dont je viens de rencontrer dans une base de code.