Điều này có an toàn để sử dụng require("path").joinđể nối các URL, ví dụ:

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

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

Nếu không, bạn sẽ đề xuất cách nào để thực hiện việc này mà không cần viết mã đầy ifs?

Không. path.join()Sẽ trả về giá trị không chính xác khi được sử dụng với URL.

Nghe có vẻ như bạn muốn url.resolve. Từ tài liệu 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'

Chỉnh sửa: Như Andreas đã chỉ ra một cách chính xác trong một nhận xét, url.resolvesẽ chỉ hữu ích nếu vấn đề đơn giản như ví dụ. url.parsecũng áp dụng cho câu hỏi này vì nó trả về các trường được định dạng nhất quán và có thể dự đoán được thông qua URLđối tượng làm giảm nhu cầu về "mã đầy ifs".

Không, bạn không nên sử dụng path.join()để nối các phần tử URL.

Có một gói để làm điều đó ngay bây giờ. Vì vậy, thay vì phát minh lại bánh xe, hãy viết tất cả các bài kiểm tra của riêng bạn, tìm lỗi, sửa chúng, viết thêm bài kiểm tra, tìm một trường hợp cạnh mà nó không hoạt động, v.v., bạn có thể sử dụng gói này.

tham gia url

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

Tải về

npm install url-join

Sử dụng

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

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

console.log(fullUrl);

Bản in:

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

Axios có một chức năng trợ giúp có thể kết hợp các URL.

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

Nguồn: https://github.com/axios/axios/blob/fe7d09bb08fa1c0e414956b7fc760c80459b0a43/lib/helpers/combineURLs.js

Khi tôi thử PATH để nối các phần url, tôi gặp sự cố. PATH.joinsọc '//' xuống '/' và cách này làm mất hiệu lực của một url tuyệt đối (ví dụ: http: // ... -> http: / ...). Đối với tôi, một bản sửa lỗi nhanh chóng là:

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

hoặc với giải pháp được đăng bởi Đại tá Panic:

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

Không! Trên Windows path.joinsẽ kết hợp với dấu gạch chéo ngược. Các url HTTP luôn là dấu gạch chéo về phía trước.

Làm thế nào về

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

Chúng tôi làm như thế này:

var _ = require('lodash');

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

Nếu bạn đang sử dụng lodash , bạn có thể sử dụng oneliner đơn giản này:

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

lấy cảm hứng từ câu trả lời của @Peter Dotchev

Đây là những gì tôi sử dụng:

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

thí dụ:

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

Nếu bạn sử dụng Angular, bạn có thể sử dụng Location :

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

Tuy nhiên, chỉ hoạt động trên 2 đối số, vì vậy bạn phải chuỗi các cuộc gọi hoặc viết một hàm trợ giúp để thực hiện điều đó nếu cần.

Các đối tượng WHATWG URL constructor có một (input, base)phiên bản, và inputcó thể là tương đối sử dụng /, ./, ../. Kết hợp điều này với path.posix.joinvà bạn có thể làm bất cứ điều gì:

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'

Giải pháp tùy chỉnh stylescript:

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

Giải pháp của tôi

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

Chỉnh sửa: nếu bạn muốn hỗ trợ môi trường windows

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

Giải pháp thứ hai sẽ thay thế tất cả các dấu gạch chéo ngược, vì vậy các phần url như chuỗi truy vấn và mã băm cũng có thể bị thay đổi, nhưng chủ đề chỉ tham gia đường dẫn url, vì vậy tôi không coi đó là vấn đề.

Có những câu trả lời làm việc khác, nhưng tôi đã đi với những điều sau đây. Một tổ hợp nhỏ 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

Điều này có thể được thực hiện bằng cách kết hợp đường dẫn và URL của Node :

1. Yêu cầu các gói:

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

2. Bắt đầu bằng cách tạo một đối tượng URL để làm việc với:

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

3. Sử dụng pathname=và path.joinđể xây dựng bất kỳ kết hợp nào có thể có:

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

(bạn có thể thấy sự phóng khoáng như thế nào path.joinvới các lập luận)

4. Tại thời điểm này, URL của bạn phản ánh kết quả mong muốn cuối cùng:

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

Tại sao cách tiếp cận này?

Kỹ thuật này sử dụng các thư viện tích hợp sẵn. Càng ít phụ thuộc của bên thứ ba càng tốt, khi nói đến CVE, bảo trì, v.v.

Tái bút: Đừng bao giờ thao túng URL dưới dạng chuỗi!

Khi tôi xem lại mã, tôi kiên quyết về việc không bao giờ thao tác các URL dưới dạng chuỗi theo cách thủ công . Đối với một, hãy xem thông số kỹ thuật phức tạp như thế nào .

Thứ hai, sự vắng mặt / hiện diện của dấu gạch chéo sau / có tiền tố ( /) sẽ không khiến mọi thứ bị hỏng! Bạn không bao giờ nên làm:

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

và đặc biệt là không:

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

Trong đó tôi vừa gặp phải trong một cơ sở mã.