Apakah ini aman digunakan require("path").joinuntuk menggabungkan URL, misalnya:

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

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

Jika tidak, cara apa yang Anda sarankan untuk melakukan ini tanpa menulis kode penuh jika?

Tidak. path.join()Akan mengembalikan nilai yang salah saat digunakan dengan URL.

Kedengarannya seperti yang Anda inginkan url.resolve. Dari dokumen 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'

Sunting: Seperti yang ditunjukkan Andreas dengan benar dalam komentar, url.resolvehanya akan membantu jika masalahnya sesederhana contoh. url.parsejuga berlaku untuk pertanyaan ini karena ia mengembalikan bidang yang diformat secara konsisten dan dapat diprediksi melalui URLobjek yang mengurangi kebutuhan akan "kode penuh jika".

Tidak, Anda tidak boleh menggunakan path.join()untuk menggabungkan elemen URL.

Ada paket untuk melakukan itu sekarang. Jadi, daripada menemukan kembali roda, tulis semua pengujian Anda sendiri, temukan bug, perbaiki, tulis lebih banyak pengujian, temukan casing edge yang tidak berfungsi, dll., Anda dapat menggunakan paket ini.

url-join

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

Install

npm install url-join

Pemakaian

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

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

console.log(fullUrl);

Cetakan:

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

Axios memiliki fungsi pembantu yang dapat menggabungkan URL.

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

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

Ketika saya mencoba PATH untuk menggabungkan bagian url saya mengalami masalah. PATH.joingaris '//' down to '/' dan cara ini membuat url absolut tidak valid (mis. http: // ... -> http: / ...). Bagi saya, perbaikan cepatnya adalah:

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

atau dengan solusi yang diposting oleh Kolonel Panic:

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

Tidak! Di Windows path.joinakan bergabung dengan garis miring terbalik. URL HTTP selalu berupa garis miring ke depan.

Bagaimana tentang

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

Kami melakukannya seperti ini:

var _ = require('lodash');

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

Jika Anda menggunakan lodash , Anda dapat menggunakan oneliner sederhana ini:

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

terinspirasi oleh jawaban @Peter Dotchev

Jika Anda menggunakan Angular, Anda dapat menggunakan Lokasi :

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

Bekerja hanya pada 2 argumen, jadi Anda harus melakukan panggilan berantai atau menulis fungsi pembantu untuk melakukannya jika diperlukan.

Ini yang saya gunakan:

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

contoh:

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

The WHATWG URL objek konstruktor memiliki (input, base)versi, dan inputbisa relatif menggunakan /, ./, ../. Gabungkan ini dengan path.posix.joindan Anda dapat melakukan apa saja:

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'

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

Solusi saya

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

Edit: jika Anda ingin mendukung lingkungan windows

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

Solusi kedua akan menggantikan semua garis miring terbalik, jadi bagian url seperti querystring dan hash juga dapat diubah, tetapi topiknya hanya bergabung dengan jalur url, jadi saya tidak menganggapnya sebagai masalah.

Ada jawaban kerja lainnya, tetapi saya pergi dengan yang berikut ini. Sebuah combo path.join / URL kecil.

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

Ini dapat dilakukan dengan kombinasi jalur Node dan URL :

1. Membutuhkan paket:

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

2. Mulailah dengan membuat objek URL untuk digunakan:

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

3. Gunakan pathname=dan path.joinuntuk membuat kombinasi yang mungkin:

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

(Anda dapat melihat betapa liberal path.joindengan argumen)

4. Pada titik ini, URL Anda mencerminkan hasil akhir yang diinginkan:

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

Mengapa pendekatan ini?

Teknik ini menggunakan pustaka bawaan. Semakin sedikit ketergantungan pihak ketiga semakin baik, dalam hal CVE, pemeliharaan, dll.

PS: Jangan pernah memanipulasi URL sebagai string!

Ketika saya meninjau kode, saya bersikeras tidak pernah memanipulasi URL sebagai string secara manual . Pertama, lihat betapa rumitnya speknya .

Kedua, tidak adanya / adanya garis miring ( /) di belakang / diawali tidak akan menyebabkan semuanya rusak! Anda tidak boleh melakukan:

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

dan terutama tidak:

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

Yang baru saja saya temui di basis kode.