क्या मैं आवश्यकता ("पथ") का उपयोग कर सकता हूँ।

Question

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'

यदि नहीं, तो इफ़्स से भरा कोड लिखे बिना ऐसा करने के लिए आप क्या सुझाव देंगे?

Comments

यह भी देखें github.com/joyent/node/issues/2216

— कर्नल पैनिक

: मामले में किसी को भी विंडोज पर path.join, लेकिन से बचने के मुद्दों का उपयोग करना चाहता path.posix.join('/one/two/three', 'four') // '/one/two/three/four, path.posix.join('/one/two/three/', 'four') // '/one/two/three/four,path.posix.join('/one/two/three/', '/four') // '/one/two/three/four

— टिमोथी Zorn

@TimothyZorn समस्या यह है कि यदि आप ऐसा कुछ करते हैं path.posix.join('http://localhost:9887/one/two/three/', '/four'), तो जुड़ने पर एक डबल स्लैश से छुटकारा मिल जाता हैhttp://

— मैक्स अलेक्जेंडर

आह, हाँ - अच्छा बिंदु। उन परिदृश्यों में, आप कुछ करना चाहते हैं 'http://localhost:9887/one/two/three/'.replace(/^\/+|\/+$/, '') + '/' + '/four'.replace(/^\/+|\/+$/, '')और यदि आप नियमित अभिव्यक्ति को बार-बार लिखना चाहते हैं तो आप ऐसा कर सकते हैं String.prototype.trimSlashes = function() { return this.replace(/^\/+|\/+$/, ''); }। stackoverflow.com/a/22387870/2537258

— टिमोथी जोर्न

या['http://localhost:9887/one/two/three/', '/four'].map((part) => part. replace(/^\/+|\/+$/, '')).join('/')

— टिमोथी ज़ोर्न

Answer 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 से भरा कोड" की आवश्यकता को कम करता है।

Comments

हालांकि वास्तव में मैं इसके लिए जो देख रहा था वह भी मेरी समस्या का समाधान करता है। मदद के लिए धन्यवाद!

— रेनाटो गामा

@AndreasHultgren पहली टिप्पणी सही है। यदि उदाहरण था url.resolve('/one/two/three/', 'four')तो आउटपुट होगा 'one/two/three/four'।

— तवानब

: मामले में किसी को भी विंडोज पर path.join, लेकिन से बचने के मुद्दों का उपयोग करना चाहता path.posix.join('/one/two/three', 'four') // '/one/two/three/four, path.posix.join('/one/two/three/', 'four') // '/one/two/three/four,path.posix.join('/one/two/three/', '/four') // '/one/two/three/four

— टिमोथी Zorn

टिप्पणी गलत है, url.resolve('/one/two/three', 'four') // '/one/two/four'जवाब में सही है

— जोनाथन।

साथ ही जागरूक रहें url.resolve()केवल 2 तर्क, जहां path.join()किसी भी संख्या को लेता है। इसलिए आप जो कर रहे हैं, उसके आधार पर आपको घोंसले कॉल करने की आवश्यकता हो सकती है, जैसे ..url.resolve(url.resolve(SERVER_URL, pagePath), queryString)

— मोलोमबी

Answer 2

नहीं, आपको path.join()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 '

Comments

यह। यह शानदार है। धन्यवाद।

— दुवेवाद

Answer 3

Axios में एक सहायक कार्य होता है जो URLs को संयोजित कर सकता है।

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

स्रोत: https://github.com/axios/axios/blob/fe7d09bb08fa1c0e414956b7fc760c80459b0a43/lib/helpers-combineurLs.js

Comments

बहुत प्यारा समाधान, कॉपी + पेस्ट :)

— गिल्ड पेलेग

Answer 4

जब मैंने url भागों को समाप्‍त करने के लिए PATH की कोशिश की तो मैं समस्याओं में चला गया। PATH.joinधारियां '//' से 'नीचे' और इस तरह से एक पूर्ण यूआरएल अमान्य है (जैसे। http: // ... -> http: / ...)। मेरे लिए एक त्वरित सुधार था:

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

या कर्नल पैनिक द्वारा पोस्ट किए गए समाधान के साथ:

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

Comments

क्या होगा अगर मैं इस तरह से रूट-रिलेटिव URL बनाने की कोशिश कर रहा हूँ /assets/foo:? यह वर्तमान-पथ-सापेक्ष URL में परिणत होगा assets/foo।

— एंड्री मिखायलोव - lolmaus

Answer 5

नहीं! विंडोज पर path.joinबैकस्लैश के साथ जुड़ेंगे। HTTP url हमेशा आगे की ओर स्लैश होते हैं।

कैसा रहेगा

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

Comments

अच्छा विचार है, लेकिन क्या होगा अगर पहले तर्क में पहले से ही एक स्लैश है? उदा .: ["posts/", "2013"].join("/")?

— रेनाटो गामा

@RenatoGama, posts//2013अभी भी एक मान्य URL है।

— गुडविन

^ जो सभी डोमेन पर काम नहीं करेगा, भले ही यह वैध यूआरआई हो।

— बिंगबॉय नोव

विशेष रूप से, नोड्स एक्सप्रेस रूटिंग के लिए बाहरी स्लैश को अनदेखा नहीं करता है।

— पेर्सीड्स

: मामले में किसी को भी विंडोज पर path.join, लेकिन से बचने के मुद्दों का उपयोग करना चाहता path.posix.join('/one/two/three', 'four') // '/one/two/three/four, path.posix.join('/one/two/three/', 'four') // '/one/two/three/four,path.posix.join('/one/two/three/', '/four') // '/one/two/three/four

— टिमोथी Zorn

Answer 6

हम इसे इस तरह करते हैं:

var _ = require('lodash');

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

Answer 7

यदि आप लॉश का उपयोग कर रहे हैं , तो आप इस सरल ऑन्लाइनर का उपयोग कर सकते हैं:

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

@Peter Dotchev के जवाब से प्रेरित

Answer 8

यही है वह जो मेरे द्वारा उपयोग किया जाता है:

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

Comments

क्या होगा अगर मैं इस तरह से रूट-रिलेटिव URL बनाने की कोशिश कर रहा हूँ /assets/foo:? यह वर्तमान-पथ-सापेक्ष URL में परिणत होगा assets/foo।

— एंड्री मिखायलोव - lolmaus

एक स्लैश शुरू करें? मेरा मतलब है, यह एक साधारण जांच है; आप इसे स्वयं जोड़ सकते हैं।

— चेसो

यह यह है कि यह कैसे शुरू होता है ... अगली बात जब आप जानते हैं कि आपने 8 से 8 घंटे बिताए हैं तो ऐसे किनारे मामले ढूंढे जाएँ जो काम न करें और उन्हें आपके प्रोजेक्ट के दौरान ठीक कर दें।

— पत्थर

Answer 9

यदि आप कोणीय का उपयोग करते हैं, तो आप उपयोग कर सकते हैं स्थान का :

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

हालांकि केवल 2 तर्कों पर काम करता है, इसलिए आपको कॉल करना होगा या जरूरत पड़ने पर एक सहायक फ़ंक्शन लिखना होगा।

Answer 10

WHATWG यूआरएल वस्तु निर्माता एक है (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'

Answer 11

टाइपस्क्रिप्ट कस्टम समाधान:

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

Answer 12

मेरा समाधान

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

संपादित करें: यदि आप खिड़कियों के वातावरण का समर्थन करना चाहते हैं

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

दूसरा समाधान सभी बैकस्लैश की जगह लेगा, इसलिए क्वरलिस्ट्रिंग और हैश जैसे यूआरएल भागों को भी बदला जा सकता है, लेकिन विषय सिर्फ यूआरएल पथ में शामिल हो रहा है, इसलिए मैं इसे एक मुद्दा नहीं मानता।

Answer 13

अन्य कामकाजी उत्तर हैं, लेकिन मैं निम्नलिखित के साथ गया। एक छोटा सा रास्ता। जॉइन / 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

Answer 14

इसे नोड के पथ और 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/'

यह दृष्टिकोण क्यों?

यह तकनीक अंतर्निहित पुस्तकालयों का उपयोग करती है। कम तीसरे पक्ष की निर्भरता बेहतर है, जब यह सीवीई, रखरखाव, आदि की बात आती है।

पुनश्च: कभी भी स्ट्रिंग के रूप में URL में हेरफेर न करें!

जब मैं कोड की समीक्षा करता हूं, तो मैं स्वयं को स्ट्रिंग के रूप में यूआरएल में हेरफेर करने के बारे में नहीं मानता हूं । एक के लिए, यह देखें कि युक्ति कितनी जटिल है ।

दूसरे, अनुगामी / उपसर्ग स्लेश ( /) की अनुपस्थिति / उपस्थिति से सब कुछ टूटने का कारण नहीं होना चाहिए! आपको कभी ऐसा नहीं करना चाहिए:

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

और विशेष रूप से नहीं:

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

जिनमें से मुझे सिर्फ एक कोड बेस में सामना करना पड़ा।