URL पैरामीटर को जावास्क्रिप्ट ऑब्जेक्ट में कैसे बदलें?


223

मेरे पास एक स्ट्रिंग है जैसे:

abc=foo&def=%5Basf%5D&xyz=5

मैं इसे इस तरह जावास्क्रिप्ट ऑब्जेक्ट में कैसे बदल सकता हूं?

{
  abc: 'foo',
  def: '[asf]',
  xyz: 5
}

यह भी देखें stackoverflow.com/questions/901115/…
Bergi

1
यह नहीं है: developer.mozilla.org/en-US/docs/Web/API/URLSearchParams/… developer.mozilla.org/en-US/docs/Web/API/URL/… (हालांकि हमें इंतजार करना होगा थोड़ी देर के लिए सभी ब्राउज़रों ने इसे उठाया है)
आर्थर

जवाबों:


336

संपादित करें

यह संपादन सुधार करता है और टिप्पणियों के आधार पर उत्तर बताता है।

var search = location.search.substring(1);
JSON.parse('{"' + decodeURI(search).replace(/"/g, '\\"').replace(/&/g, '","').replace(/=/g,'":"') + '"}')

उदाहरण

abc=foo&def=%5Basf%5D&xyz=5पाँच चरणों में पारस :

  • decodeURI: abc = foo & def = [asf] & xyz = 5
  • भागने के उद्धरण: वही, जैसा कि कोई उद्धरण नहीं है
  • बदलने के &: abc=foo","def=[asf]","xyz=5
  • प्रतिस्थापित करें: abc":"foo","def":"[asf]","xyz":"5
  • कर्ल और उद्धरण के साथ Suround: {"abc":"foo","def":"[asf]","xyz":"5"}

जो कानूनी JSON है।

एक बेहतर समाधान खोज स्ट्रिंग में अधिक वर्णों के लिए अनुमति देता है। यह यूआरआई डिकोडिंग के लिए एक रिवाइवर फ़ंक्शन का उपयोग करता है:

var search = location.search.substring(1);
JSON.parse('{"' + search.replace(/&/g, '","').replace(/=/g,'":"') + '"}', function(key, value) { return key===""?value:decodeURIComponent(value) })

उदाहरण

search = "abc=foo&def=%5Basf%5D&xyz=5&foo=b%3Dar";

देता है

Object {abc: "foo", def: "[asf]", xyz: "5", foo: "b=ar"}

मूल उत्तर

एक-लाइनर:

JSON.parse('{"' + decodeURI("abc=foo&def=%5Basf%5D&xyz=5".replace(/&/g, "\",\"").replace(/=/g,"\":\"")) + '"}')

4
इसके लिए CoffeeScript में काम करने के लिए, regex में '=' ​​से बच जाएं। .replace (/ \ = / g, "\": \ "")
एयरलोक

175
यह कोई एक लाइनर नहीं है ... यह एक अंतरिक्ष स्टेशन है।
जिग्गी

5
बेहतर है अगर आप उपयोग करते हैंJSON.parse('{"' + decodeURI(location.search.substring(1).replace(/&/g, "\",\"").replace(/=/g, "\":\"")) + '"}')
Daniël Tulp

4
यदि आप url को पार्स करने के लिए समान वर्ण का चिह्न रखते हैं तो यह विफल हो जाता है। EX: "कुकी = dlksdlfj = sodkfjhsdlfj"
jholloman

3
जब आप बिना मान के एक भी पैरामीटर काम नहीं करते हैं।
साइक

113

2020 ईएस 6/7/8 और दृष्टिकोण पर

ईएस 6 शुरू करने और पर, जावास्क्रिप्ट इस मुद्दे के लिए एक प्रदर्शन समाधान बनाने के लिए कई निर्माण प्रदान करता है।

इसमें URLSearchParams और पुनरावृत्तियों का उपयोग करना शामिल है

let params = new URLSearchParams('abc=foo&def=%5Basf%5D&xyz=5');
params.get("abc"); // "foo"

क्या आपके उपयोग के मामले में आपको वास्तव में इसे ऑब्जेक्ट में बदलने की आवश्यकता है, तो आप निम्नलिखित फ़ंक्शन को लागू कर सकते हैं:

function paramsToObject(entries) {
  let result = {}
  for(let entry of entries) { // each 'entry' is a [key, value] tupple
    const [key, value] = entry;
    result[key] = value;
  }
  return result;
}

बेसिक डेमो

const urlParams = new URLSearchParams('abc=foo&def=%5Basf%5D&xyz=5');
const entries = urlParams.entries(); //returns an iterator of decoded [key,value] tuples
const params = paramsToObject(entries); //{abc:"foo",def:"[asf]",xyz:"5"}

Object.fromEntries और स्प्रेड का उपयोग करना

हम Object.fromEntries का उपयोग कर सकते हैं (जो वर्तमान में चरण 4 में है), के paramsToObjectसाथ बदल रहा है Object.fromEntries(entries)

मूल्य जोड़े से अधिक पुनरावृति करने के लिए सूची नाम-मूल्य जोड़े हैं जिनमें कुंजी का नाम और मूल्य का मूल्य है।

चूंकि URLParams, कॉल करने के बजाय प्रसार ऑपरेटर का उपयोग करके, एक पुन: उपयोग करने योग्य वस्तु देता है, इसलिए इसकी कल्पना के अनुसार प्रविष्टियां भी प्राप्त होंगी:.entries

const urlParams = new URLSearchParams('abc=foo&def=%5Basf%5D&xyz=5');
const params = Object.fromEntries(urlParams); // {abc: "foo", def: "[asf]", xyz: "5"}

नोट: सभी मान URLSearchParams कल्पना के अनुसार स्वचालित रूप से तार हैं

एकाधिक कुंजी

जैसा कि @siipe ने बताया, कई समान कुंजी वाले मानों को अंतिम उपलब्ध मान में समाहित किया foo=first_value&foo=second_valueजाएगा : सार रूप में बन जाएगा {foo: "second_value"}:।

इस उत्तर के अनुसार: https://stackoverflow.com/a/1746566/1194694 यह तय करने के लिए कोई युक्ति नहीं है कि इसके साथ क्या करना है और प्रत्येक रूपरेखा अलग-अलग व्यवहार कर सकती है।

एक सामान्य उपयोग का मामला दो समान मानों को एक सरणी में मिलाने के लिए होगा, जिससे आउटपुट ऑब्जेक्ट में होगा:

{foo: ["first_value", "second_value"]}

यह निम्नलिखित कोड के साथ प्राप्त किया जा सकता है:

const groupParamsByKey = (params) => [...params.entries()].reduce((acc, tuple) => {
 // getting the key and value from each tuple
 const [key, val] = tuple;
 if(acc.hasOwnProperty(key)) {
    // if the current key is already an array, we'll add the value to it
    if(Array.isArray(acc[key])) {
      acc[key] = [...acc[key], val]
    } else {
      // if it's not an array, but contains a value, we'll convert it into an array
      // and add the current value to it
      acc[key] = [acc[key], val];
    }
 } else {
  // plain assignment if no special case is present
  acc[key] = val;
 }

return acc;
}, {});

const params = new URLSearchParams('abc=foo&def=%5Basf%5D&xyz=5&def=dude');
const output = groupParamsByKey(params) // {abc: "foo", def: ["[asf]", "dude"], xyz: 5}

2
मैं इस समाधान की सिफारिश नहीं करता हूं। URLSearchParams में अस्वाभाविक ऐनक हैं ( developer.mozilla.org/en-US/docs/Web/API/… )
Seph Reed

1
मुझे खेद है लेकिन तर्क का इससे कोई लेना-देना नहीं है। कोई यह तर्क दे सकता है कि यह एक search stringपार्सर है - जो कि इसे करने के लिए डिज़ाइन किया गया था, इसकी परवाह किए बिना एक URL से जुड़ा हुआ है
सिलिकेट करता है

Object.fromEntriesदोहराया कुंजी के लिए काम नहीं करता है। हम की तरह कुछ करने के लिए प्रयास करते हैं तो ?foo=bar1&foo=bar2, हम केवल मिल जाएगा { foo: 'bar2' }। अनुरोध वस्तु Node.js, उदाहरण के लिए, यह के रूप में पार्स करता है{ foo: ['bar1', 'bar2'] }
Siipe

आप सही हैं, हालांकि इसका कोई
अनुमान

यह मुझे अच्छा लगता है, लेकिन दोहराव की कुंजी के लिए मूल्यों को प्राप्त करने के लिए हम इसका उपयोग कर सकते हैं let temp={};Object.keys(params).map(key=>{temp[key]=urlParams.getAll(key)})
तिरुमलेश्वर केरगड़े

45

ES6 एक लाइनर। साफ और सरल।

Object.fromEntries(new URLSearchParams(location.search));

आपके विशिष्ट मामले के लिए, यह होगा:

console.log(
  Object.fromEntries(new URLSearchParams('abc=foo&def=%5Basf%5D&xyz=5'))
);


यह गोचरों का शिकार हो जाता है। "http://place.com?foo=bar&hello=%40world&showThing"का निर्माण{ hello: "@world", http://place.com?foo: "bar", showThing: "" }
रीड

1
आपको प्रश्न स्ट्रिंग का उपयोग करना चाहिए (स्थान से। खोज से) जैसे "foo = bar & hello =% 40world और showThing" संपूर्ण url नहीं, जैसा कि प्रश्न बताता है।
मुर्गियां

1
यह प्रयोग किया जा सकता है, लेकिन सावधानी के साथ ?someValue=falseहो जाता है{ someValue: "false" }
साइमन

यह दोहराया कुंजी के लिए काम नहीं करता है। हम की तरह कुछ करने के लिए प्रयास करते हैं तो ?foo=bar1&foo=bar2, हम केवल मिल जाएगा { foo: 'bar2' }। Node.js अनुरोध वस्तु के रूप में इसे { foo: ['bar1', 'bar2'] }
पार

@ SephReed, मेरा मानना ​​है कि आपकी टिप्पणी को अद्यतन संस्करण के साथ संबोधित किया गया हैlocation.search
काइलमिट

27

पर विभाजित &नाम / मान युग्म पाने के लिए, तो पर प्रत्येक जोड़ी विभाजित =। यहाँ एक उदाहरण है:

var str = "abc=foo&def=%5Basf%5D&xy%5Bz=5"
var obj = str.split("&").reduce(function(prev, curr, i, arr) {
    var p = curr.split("=");
    prev[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
    return prev;
}, {});

एक और दृष्टिकोण, नियमित अभिव्यक्ति का उपयोग कर:

var obj = {}; 
str.replace(/([^=&]+)=([^&]*)/g, function(m, key, value) {
    obj[decodeURIComponent(key)] = decodeURIComponent(value);
}); 

यह जॉन रेजिग के "सर्च एंड डोंट रिप्ले " से अनुकूलित है ।


tx! आपको बाएं में डिकोड्यूरिकोम्पोन (p [0]) को भी जोड़ना चाहिए
एलेक्स

पहला उदाहरण रिक्त क्वेरी स्ट्रिंग के साथ काम नहीं करता है।
मिचेल पेरोलाकोव्स्की

18

संक्षिप्त समाधान:

location.search
  .slice(1)
  .split('&')
  .map(p => p.split('='))
  .reduce((obj, pair) => {
    const [key, value] = pair.map(decodeURIComponent);
    return ({ ...obj, [key]: value })
  }, {});

यह सरणियों के साथ विफल रहता है अर्थात: x = 1 & x = 2
Sh eldeeb

16

अब तक मुझे मिले प्रस्तावित समाधान अधिक जटिल परिदृश्यों को कवर नहीं करते हैं।

मुझे एक क्वेरी स्ट्रिंग बदलने की आवश्यकता है

https://random.url.com?Target=Offer&Method=findAll&filters%5Bhas_goals_enabled%5D%5BTRUE%5D=1&filters%5Bstatus%5D=active&fields%5B%5D=id&fields%5B%5D=name&fields%5B%5D=default_goal_name

एक वस्तु में जैसे:

{
    "Target": "Offer",
    "Method": "findAll",
    "fields": [
        "id",
        "name",
        "default_goal_name"
    ],
    "filters": {
        "has_goals_enabled": {
            "TRUE": "1"
        },
        "status": "active"
    }
}

या:

https://random.url.com?Target=Report&Method=getStats&fields%5B%5D=Offer.name&fields%5B%5D=Advertiser.company&fields%5B%5D=Stat.clicks&fields%5B%5D=Stat.conversions&fields%5B%5D=Stat.cpa&fields%5B%5D=Stat.payout&fields%5B%5D=Stat.date&fields%5B%5D=Stat.offer_id&fields%5B%5D=Affiliate.company&groups%5B%5D=Stat.offer_id&groups%5B%5D=Stat.date&filters%5BStat.affiliate_id%5D%5Bconditional%5D=EQUAL_TO&filters%5BStat.affiliate_id%5D%5Bvalues%5D=1831&limit=9999

जांच:

{
    "Target": "Report",
    "Method": "getStats",
    "fields": [
        "Offer.name",
        "Advertiser.company",
        "Stat.clicks",
        "Stat.conversions",
        "Stat.cpa",
        "Stat.payout",
        "Stat.date",
        "Stat.offer_id",
        "Affiliate.company"
    ],
    "groups": [
        "Stat.offer_id",
        "Stat.date"
    ],
    "limit": "9999",
    "filters": {
        "Stat.affiliate_id": {
            "conditional": "EQUAL_TO",
            "values": "1831"
        }
    }
}

मैंने कई समाधानों को संकलित और रूपांतरित किया है जो वास्तव में काम करता है:

कोड:

var getParamsAsObject = function (query) {

    query = query.substring(query.indexOf('?') + 1);

    var re = /([^&=]+)=?([^&]*)/g;
    var decodeRE = /\+/g;

    var decode = function (str) {
        return decodeURIComponent(str.replace(decodeRE, " "));
    };

    var params = {}, e;
    while (e = re.exec(query)) {
        var k = decode(e[1]), v = decode(e[2]);
        if (k.substring(k.length - 2) === '[]') {
            k = k.substring(0, k.length - 2);
            (params[k] || (params[k] = [])).push(v);
        }
        else params[k] = v;
    }

    var assign = function (obj, keyPath, value) {
        var lastKeyIndex = keyPath.length - 1;
        for (var i = 0; i < lastKeyIndex; ++i) {
            var key = keyPath[i];
            if (!(key in obj))
                obj[key] = {}
            obj = obj[key];
        }
        obj[keyPath[lastKeyIndex]] = value;
    }

    for (var prop in params) {
        var structure = prop.split('[');
        if (structure.length > 1) {
            var levels = [];
            structure.forEach(function (item, i) {
                var key = item.replace(/[?[\]\\ ]/g, '');
                levels.push(key);
            });
            assign(params, levels, params[prop]);
            delete(params[prop]);
        }
    }
    return params;
};

यह सबसे अच्छा जवाब है, क्योंकि यह वास्तव में जटिल प्रश्नों को ठीक से संभालता है।
जार्ज इवानोव

मुझे लगता है कि यह सिर्फ चीजों को उलझाता है, मैं अभी गुजरता हूं obj=encodeURIComponent(JSON.stringify({what:{ever:','},i:['like']}))
मुर्गियों

15

यह सरल संस्करण है, जाहिर है आप कुछ त्रुटि जाँच जोड़ना चाहेंगे:

var obj = {};
var pairs = queryString.split('&');
for(i in pairs){
    var split = pairs[i].split('=');
    obj[decodeURIComponent(split[0])] = decodeURIComponent(split[1]);
}

1
क्या आप% 5B और% 5D को वर्णों में बदलने के लिए स्ट्रिंग को अनएकोड करना नहीं भूलते?
jfriend00

@ एलेक्स - क्या आपने अपडेटेड कोड या मूल का उपयोग किया है? मूल में एक मुद्दा और एक टाइपो था।
जस्टिन निस्नेर

जब उनके मानों में '=' ​​सम्‍मिलित होता है, तो यह ठीक से संभाल नहीं सकता। यह मूल्यों को पहले '=' तक ले जाता है।
21

JSON.parse('{"' + decodeURIComponent(query.replace(/"/g, '\\"').replace(/&/g, '","').replace(/=/g,'":"') + '"}'));मेरे लिए काम करता है
Danil Gaponov

1
इसके लिए काम नहीं करता है name[]=test1&name[]=test2और यह परिणाम होगाname[]=test2
रफी

10

मुझे $ .String.deparam सबसे पूर्ण पूर्व निर्मित समाधान मिला (नेस्टेड ऑब्जेक्ट्स कर सकता है)। की जाँच करें प्रलेखन


केवल यह इंगित करना कि क्या आपका इनपुट हमेशा क्रमबद्ध क्वेरी स्ट्रिंग होने वाला है, घोंसले के शिकार के बारे में चिंता करने की कोई आवश्यकता नहीं है और अधिक हल्का समाधान शायद बेहतर है
शानदार

ठीक है ... लेकिन यह पहले से ही किया गया है और परीक्षण किया गया है (जस्टिन ईजी प्रारंभिक उत्तर में यूआरआई डिकोड को भूल जाते हैं - जो छोटे मुद्दे हैं जो चीजों को शुरू में लगने की तुलना में बहुत अधिक जटिल बना सकते हैं)।
दफ

9

2019 वन-लाइनर दृष्टिकोण

आपके विशिष्ट मामले के लिए:

Object.fromEntries(new URLSearchParams('abc=foo&def=%5Basf%5D&xyz=5'));

अधिक सामान्य मामले के लिए जहां कोई व्यक्ति किसी वस्तु के लिए क्वेरी पार्स को पार्स करना चाहता है:

Object.fromEntries(new URLSearchParams(location.search));

यदि आप Object.fromEntries का उपयोग करने में असमर्थ हैं, तो यह भी काम करेगा:

Array.from(new URLSearchParams(window.location.search)).reduce((o, i) => ({ ...o, [i[0]]: i[1] }), {});

इसके अलावा[...new URLSearchParams(window.location.search)].reduce((o, i) => ({ ...o, [i[0]]: i[1] }), {});
dman

1
URLSearchParams के पास कुछ गोचर्स हैं जिनके लिए यह टूट जाता है। "http://place.com?foo=bar&hello=%40world&showThingपैदा करता है { hello: "@world", http://place.com?foo: "bar", showThing: "" }। जोड़ने की कोशिश करेंstr.split("?").pop()
रीड

7

URLSearchParams ( https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams ) के नवीनतम मानक पर आधारित एक और समाधान

function getQueryParamsObject() {
  const searchParams = new URLSearchParams(location.search.slice(1));
  return searchParams
    ? _.fromPairs(Array.from(searchParams.entries()))
    : {};
}

कृपया ध्यान दें कि यह समाधान उपयोग कर रहा है

Array.from ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from )

और _.fromPairs ( https://lodash.com/docs#fromPairs ) सादगी के लिए दर्ज करें।

जब से आप searchParams.entries () इट्रेटर तक पहुंच पाते हैं, तब से अधिक संगत समाधान बनाना आसान हो सकता है।


6

मुझे भी यही समस्या थी, यहाँ समाधान की कोशिश की, लेकिन उनमें से कोई भी वास्तव में काम नहीं करता था, क्योंकि मेरे पास URL पैरामीटर में सरणियाँ थीं, जैसे:

?param[]=5&param[]=8&othr_param=abc&param[]=string

इसलिए मैंने अपना JS फ़ंक्शन लिखना शुरू किया, जो URI में परम से एक सरणी बनाता है:

/**
 * Creates an object from URL encoded data
 */
var createObjFromURI = function() {
    var uri = decodeURI(location.search.substr(1));
    var chunks = uri.split('&');
    var params = Object();

    for (var i=0; i < chunks.length ; i++) {
        var chunk = chunks[i].split('=');
        if(chunk[0].search("\\[\\]") !== -1) {
            if( typeof params[chunk[0]] === 'undefined' ) {
                params[chunk[0]] = [chunk[1]];

            } else {
                params[chunk[0]].push(chunk[1]);
            }


        } else {
            params[chunk[0]] = chunk[1];
        }
    }

    return params;
}

2
यह वास्तव में मददगार था और मैंने जैसा चाहा लगभग वैसा ही किया। मुझे पसंद नहीं था, हालांकि, कैसे "[]" को ऑब्जेक्ट में चातुर्य में रखा जाता है यदि URL पैरामीटर जैसे हैं: बेकन [] = अंडे और बेकन [] = टोस्ट। तो मैं एक लाइन में जोड़ा के बाद if(chunk[0].search("\\[\\]") !== -1) {कि हैchunk[0]=chunk[0].replace(/\[\]$/,'');
rgbflawed

@rgbflawed आपको भविष्य के पाठक और सुगमता के लिए जवाब को संपादित करना चाहिए
Webwoman

constइसके बजाय उपयोग करें varक्योंकि कोई ऐसा कर सकता है createObjFromURI = 'some text'और फिर वे कोड को गड़बड़ कर देंगे। यदि आप उपयोग करते हैं constतो कोई चलने createObjFromURI = 'some text'वाला त्रुटि बना देगा निरंतर चर के लिए मान प्रदान नहीं कर सकता है।
जस्टिन लियू

5

ES6, URL API और URLSearchParams API का उपयोग करना।

function objectifyQueryString(url) {
  let _url = new URL(url);
  let _params = new URLSearchParams(_url.search);
  let query = Array.from(_params.keys()).reduce((sum, value)=>{
    return Object.assign({[value]: _params.get(value)}, sum);
  }, {});
  return query;
}

5

ES6 एक लाइनर (यदि हम इसे उस तरह से लंबी लाइन को देख सकते हैं)

[...new URLSearchParams(location.search).entries()].reduce((prev, [key,val]) => {prev[key] = val; return prev}, {})


2
आप curकुछ अतिरिक्त स्पष्टता के लिए भी विनाश कर सकते हैं । .reduce((prev, [key, val]) => {prev[key] = val})
एलन लेई

मुझे आपका सुझाव एलन लेई पसंद है। मैं अपना जवाब अपडेट करता हूं
fadomire

3

URLSearchParamsजावास्क्रिप्ट वेब एपीआई का उपयोग करना बहुत आसान है,

var paramsString = "q=forum&topic=api";

//returns an iterator object
var searchParams = new URLSearchParams(paramsString);

//Usage
for (let p of searchParams) {
  console.log(p);
}

//Get the query strings
console.log(searchParams.toString());

//You can also pass in objects

var paramsObject = {q:"forum",topic:"api"}

//returns an iterator object
var searchParams = new URLSearchParams(paramsObject);

//Usage
for (let p of searchParams) {
  console.log(p);
}

//Get the query strings
console.log(searchParams.toString());

उपयोगी कड़ियाँ

नोट : IE में समर्थित नहीं है


3

नोड जेएस के लिए, आप नोड जेएस एपीआई का उपयोग कर सकते हैं querystring:

const querystring = require('querystring');

querystring.parse('abc=foo&def=%5Basf%5D&xyz=5&foo=b%3Dar');
// returns the object

प्रलेखन: https://nodejs.org/api/querystring.html


2

कोई ऐसा देशी हल नहीं है जिससे मैं अवगत हूं। यदि आप संयोग से उस ढांचे का उपयोग करते हैं तो Dojo में एक अंतर्निहित गैर-मानकीकरण पद्धति है।

अन्यथा आप इसे स्वयं लागू कर सकते हैं बल्कि सरलता से:

function unserialize(str) {
  str = decodeURIComponent(str);
  var chunks = str.split('&'),
      obj = {};
  for(var c=0; c < chunks.length; c++) {
    var split = chunks[c].split('=', 2);
    obj[split[0]] = split[1];
  }
  return obj;
}

संपादित करें: जोड़ा गया decodeURIComponent ()


2

YouAreI.js नामक एक हल्की लाइब्रेरी है जिसका परीक्षण किया गया है और यह वास्तव में आसान है।

YouAreI = require('YouAreI')
uri = new YouAreI('http://user:pass@www.example.com:3000/a/b/c?d=dad&e=1&f=12.3#fragment');

uri.query_get() => { d: 'dad', e: '1', f: '12.3' }

2

URLSearchParam इंटरफ़ेस का उपयोग करके ऐसा करने का सबसे सरल तरीका है।

नीचे काम कोड स्निपेट है:

let paramObj={},
    querystring=window.location.search,
    searchParams = new URLSearchParams(querystring);    

  //*** :loop to add key and values to the param object.
 searchParams.forEach(function(value, key) {
      paramObj[key] = value;
   });

1

यह सबसे अच्छा समाधान लगता है क्योंकि यह एक ही नाम के कई मापदंडों को ध्यान में रखता है।

    function paramsToJSON(str) {
        var pairs = str.split('&');
        var result = {};
        pairs.forEach(function(pair) {
            pair = pair.split('=');
            var name = pair[0]
            var value = pair[1]
            if( name.length )
                if (result[name] !== undefined) {
                    if (!result[name].push) {
                        result[name] = [result[name]];
                    }
                    result[name].push(value || '');
                } else {
                    result[name] = value || '';
                }
        });
        return( result );
    }

<a href="index.html?x=1&x=2&x=3&y=blah">something</a>
paramsToJSON("x=1&x=2&x=3&y=blah"); 

console yields => {x: Array[3], y: "blah"} where x is an array as is proper JSON

मैंने बाद में इसे jQuery प्लगइन में बदलने का फैसला किया ...

$.fn.serializeURLParams = function() {
    var result = {};

    if( !this.is("a") || this.attr("href").indexOf("?") == -1 ) 
        return( result );

    var pairs = this.attr("href").split("?")[1].split('&');
    pairs.forEach(function(pair) {
        pair = pair.split('=');
        var name = decodeURI(pair[0])
        var value = decodeURI(pair[1])
        if( name.length )
            if (result[name] !== undefined) {
                if (!result[name].push) {
                    result[name] = [result[name]];
                }
                result[name].push(value || '');
            } else {
                result[name] = value || '';
            }
    });
    return( result )
}

<a href="index.html?x=1&x=2&x=3&y=blah">something</a>
$("a").serializeURLParams(); 

console yields => {x: Array[3], y: "blah"} where x is an array as is proper JSON

अब, पहले केवल मापदंडों को स्वीकार करेंगे लेकिन jQuery प्लगइन पूरे यूआरएल को ले जाएगा और क्रमबद्ध मापदंडों को वापस कर देगा।


1

यहाँ एक मैं उपयोग कर रहा हूँ:

var params = {};
window.location.search.substring(1).split('&').forEach(function(pair) {
  pair = pair.split('=');
  if (pair[1] !== undefined) {
    var key = decodeURIComponent(pair[0]),
        val = decodeURIComponent(pair[1]),
        val = val ? val.replace(/\++/g,' ').trim() : '';

    if (key.length === 0) {
      return;
    }
    if (params[key] === undefined) {
      params[key] = val;
    }
    else {
      if ("function" !== typeof params[key].push) {
        params[key] = [params[key]];
      }
      params[key].push(val);
    }
  }
});
console.log(params);

बुनियादी उपयोग, उदाहरण के लिए।
?a=aa&b=bb
Object {a: "aa", b: "bb"}

डुप्लिकेट params, उदा।
?a=aa&b=bb&c=cc&c=potato
Object {a: "aa", b: "bb", c: ["cc","potato"]}

मिसिंग कीज़, उदाहरण के लिए।
?a=aa&b=bb&=cc
Object {a: "aa", b: "bb"}

गुम मान, उदा।
?a=aa&b=bb&c
Object {a: "aa", b: "bb"}

उपरोक्त JSON / regex समाधान इस निराला यूआरएल पर एक वाक्यविन्यास त्रुटि को फेंक देते हैं:
?a=aa&b=bb&c=&=dd&e
Object {a: "aa", b: "bb", c: ""}


1

यहां मेरा त्वरित और गंदा संस्करण है, मूल रूप से इसके तत्वों में '&' द्वारा अलग किए गए URL पैरामीटर को विभाजित करते हुए, और फिर उस सरणी पर '=' द्वारा अलग किए गए कुंजी / मान जोड़े को एक ऑब्जेक्ट में जोड़ते हुए पुन: प्रसारित करता है। मैं एन्कोडेड वर्णों को उनके सामान्य स्ट्रिंग समकक्षों में अनुवाद करने के लिए डिकोड्यूरिकम्पोनेंट () का उपयोग कर रहा हूं (इसलिए% 20 एक स्थान बन जाता है,% 26 'और', आदि बन जाता है):

function deparam(paramStr) {
    let paramArr = paramStr.split('&');     
    let paramObj = {};
    paramArr.forEach(e=>{
        let param = e.split('=');
        paramObj[param[0]] = decodeURIComponent(param[1]);
    });
    return paramObj;
}

उदाहरण:

deparam('abc=foo&def=%5Basf%5D&xyz=5')

रिटर्न

{
    abc: "foo"
    def:"[asf]"
    xyz :"5"
}

एकमात्र मुद्दा यह है कि xyz एक स्ट्रिंग है और एक संख्या नहीं है (decodeURIComponent () का उपयोग करने के कारण), लेकिन इससे परे यह एक बुरा शुरुआती बिंदु नहीं है।


1
//under ES6 
const getUrlParamAsObject = (url = window.location.href) => {
    let searchParams = url.split('?')[1];
    const result = {};
    //in case the queryString is empty
    if (searchParams!==undefined) {
        const paramParts = searchParams.split('&');
        for(let part of paramParts) {
            let paramValuePair = part.split('=');
            //exclude the case when the param has no value
            if(paramValuePair.length===2) {
                result[paramValuePair[0]] = decodeURIComponent(paramValuePair[1]);
            }
        }

    }
    return result;
}

मैं वास्तव में इस विधि को पसंद करता हूं (2017 में) कुछ अन्य रेगेक्स-आधारित उत्तरों की तुलना में। यदि पॉलीफ़िल एरो फंक्शन (या एक पारंपरिक फ़ंक्शन के रूप में फिर से लिखना), मुझे लगता है कि यह बहुत अच्छी तरह से क्रॉस-ब्राउज़र पर काम करना चाहिए
स्क्रिबलब्लमर

@ स्क्रिप्‍बलमेकर की Babelमदद से आप इसे अन्य पर्यावरण के तहत अच्छी तरह से कर सकते हैं
XYz Amos

1

Phpjs का उपयोग करना

function parse_str(str, array) {
  //       discuss at: http://phpjs.org/functions/parse_str/
  //      original by: Cagri Ekin
  //      improved by: Michael White (http://getsprink.com)
  //      improved by: Jack
  //      improved by: Brett Zamir (http://brett-zamir.me)
  //      bugfixed by: Onno Marsman
  //      bugfixed by: Brett Zamir (http://brett-zamir.me)
  //      bugfixed by: stag019
  //      bugfixed by: Brett Zamir (http://brett-zamir.me)
  //      bugfixed by: MIO_KODUKI (http://mio-koduki.blogspot.com/)
  // reimplemented by: stag019
  //         input by: Dreamer
  //         input by: Zaide (http://zaidesthings.com/)
  //         input by: David Pesta (http://davidpesta.com/)
  //         input by: jeicquest
  //             note: When no argument is specified, will put variables in global scope.
  //             note: When a particular argument has been passed, and the returned value is different parse_str of PHP. For example, a=b=c&d====c
  //             test: skip
  //        example 1: var arr = {};
  //        example 1: parse_str('first=foo&second=bar', arr);
  //        example 1: $result = arr
  //        returns 1: { first: 'foo', second: 'bar' }
  //        example 2: var arr = {};
  //        example 2: parse_str('str_a=Jack+and+Jill+didn%27t+see+the+well.', arr);
  //        example 2: $result = arr
  //        returns 2: { str_a: "Jack and Jill didn't see the well." }
  //        example 3: var abc = {3:'a'};
  //        example 3: parse_str('abc[a][b]["c"]=def&abc[q]=t+5');
  //        returns 3: {"3":"a","a":{"b":{"c":"def"}},"q":"t 5"}

  var strArr = String(str)
    .replace(/^&/, '')
    .replace(/&$/, '')
    .split('&'),
    sal = strArr.length,
    i, j, ct, p, lastObj, obj, lastIter, undef, chr, tmp, key, value,
    postLeftBracketPos, keys, keysLen,
    fixStr = function(str) {
      return decodeURIComponent(str.replace(/\+/g, '%20'));
    };

  if (!array) {
    array = this.window;
  }

  for (i = 0; i < sal; i++) {
    tmp = strArr[i].split('=');
    key = fixStr(tmp[0]);
    value = (tmp.length < 2) ? '' : fixStr(tmp[1]);

    while (key.charAt(0) === ' ') {
      key = key.slice(1);
    }
    if (key.indexOf('\x00') > -1) {
      key = key.slice(0, key.indexOf('\x00'));
    }
    if (key && key.charAt(0) !== '[') {
      keys = [];
      postLeftBracketPos = 0;
      for (j = 0; j < key.length; j++) {
        if (key.charAt(j) === '[' && !postLeftBracketPos) {
          postLeftBracketPos = j + 1;
        } else if (key.charAt(j) === ']') {
          if (postLeftBracketPos) {
            if (!keys.length) {
              keys.push(key.slice(0, postLeftBracketPos - 1));
            }
            keys.push(key.substr(postLeftBracketPos, j - postLeftBracketPos));
            postLeftBracketPos = 0;
            if (key.charAt(j + 1) !== '[') {
              break;
            }
          }
        }
      }
      if (!keys.length) {
        keys = [key];
      }
      for (j = 0; j < keys[0].length; j++) {
        chr = keys[0].charAt(j);
        if (chr === ' ' || chr === '.' || chr === '[') {
          keys[0] = keys[0].substr(0, j) + '_' + keys[0].substr(j + 1);
        }
        if (chr === '[') {
          break;
        }
      }

      obj = array;
      for (j = 0, keysLen = keys.length; j < keysLen; j++) {
        key = keys[j].replace(/^['"]/, '')
          .replace(/['"]$/, '');
        lastIter = j !== keys.length - 1;
        lastObj = obj;
        if ((key !== '' && key !== ' ') || j === 0) {
          if (obj[key] === undef) {
            obj[key] = {};
          }
          obj = obj[key];
        } else { // To insert new dimension
          ct = -1;
          for (p in obj) {
            if (obj.hasOwnProperty(p)) {
              if (+p > ct && p.match(/^\d+$/g)) {
                ct = +p;
              }
            }
          }
          key = ct + 1;
        }
      }
      lastObj[key] = value;
    }
  }
}

1

माइक कॉसर के जवाब के शीर्ष पर बिल्डिंग मैंने इस फ़ंक्शन को बनाया है जो एक ही कुंजी ( foo=bar&foo=baz) और कॉमा-से-अलग मापदंडों ( foo=bar,baz,bin) के साथ कई पैरामेट्स को ध्यान में रखता है । यह आपको एक निश्चित क्वेरी कुंजी की खोज करने देता है।

function getQueryParams(queryKey) {
    var queryString = window.location.search;
    var query = {};
    var pairs = (queryString[0] === '?' ? queryString.substr(1) : queryString).split('&');
    for (var i = 0; i < pairs.length; i++) {
        var pair = pairs[i].split('=');
        var key = decodeURIComponent(pair[0]);
        var value = decodeURIComponent(pair[1] || '');
        // Se possui uma vírgula no valor, converter em um array
        value = (value.indexOf(',') === -1 ? value : value.split(','));

        // Se a key já existe, tratar ela como um array
        if (query[key]) {
            if (query[key].constructor === Array) {
                // Array.concat() faz merge se o valor inserido for um array
                query[key] = query[key].concat(value);
            } else {
                // Se não for um array, criar um array contendo o valor anterior e o novo valor
                query[key] = [query[key], value];
            }
        } else {
            query[key] = value;
        }
    }

    if (typeof queryKey === 'undefined') {
        return query;
    } else {
        return query[queryKey];
    }
}

उदाहरण इनपुट: foo.html?foo=bar&foo=baz&foo=bez,boz,buz&bar=1,2,3

उदाहरण आउटपुट

{
    foo: ["bar","baz","bez","boz","buz"],
    bar: ["1","2","3"]
}



0

सबसे पहले हमें एक नया वर पाने की जरूरत है:

function getVar()
{
    this.length = 0;
    this.keys = [];
    this.push = function(key, value)
    {
        if(key=="") key = this.length++;
        this[key] = value;
        this.keys.push(key);
        return this[key];
    }
}

बस पढ़ें:

function urlElement()
{
    var thisPrototype = window.location;
    for(var prototypeI in thisPrototype) this[prototypeI] = thisPrototype[prototypeI];
    this.Variables = new getVar();
    if(!this.search) return this;
    var variables = this.search.replace(/\?/g,'').split('&');
    for(var varI=0; varI<variables.length; varI++)
    {
        var nameval = variables[varI].split('=');
        var name = nameval[0].replace(/\]/g,'').split('[');
        var pVariable = this.Variables;
        for(var nameI=0;nameI<name.length;nameI++)
        {
            if(name.length-1==nameI) pVariable.push(name[nameI],nameval[1]);
            else var pVariable = (typeof pVariable[name[nameI]] != 'object')? pVariable.push(name[nameI],new getVar()) : pVariable[name[nameI]];
        }
    }
}

और उपयोग की तरह:

var mlocation = new urlElement();
mlocation = mlocation.Variables;
for(var key=0;key<mlocation.keys.length;key++)
{
    console.log(key);
    console.log(mlocation[mlocation.keys[key]];
}

कृपया अपने उत्तर मिलाएं। दूसरे को संपादित करें , फिर इस एक को हटा दें।
बरगी २

0

मुझे +URL के क्वेरी भाग से भी निपटने की आवश्यकता थी ( डिकोड्यूरिकोम्पोनेंट नहीं है ), इसलिए मैंने बनने के लिए वोल्फगैंग के कोड को अनुकूलित किया:

var search = location.search.substring(1);
search = search?JSON.parse('{"' + search.replace(/\+/g, ' ').replace(/&/g, '","').replace(/=/g,'":"') + '"}',
             function(key, value) { return key===""?value:decodeURIComponent(value)}):{};

मेरे मामले में, मैं URL- तैयार फ़ॉर्म पैरामीटर प्राप्त करने के लिए jQuery का उपयोग कर रहा हूं, फिर इस ऑब्जेक्ट को उसमें से बनाने के लिए ट्रिक और मैं तब आसानी से ऑब्जेक्ट पर पैरामीटर अपडेट कर सकता हूं और क्वेरी URL, जैसे:

var objForm = JSON.parse('{"' + $myForm.serialize().replace(/\+/g, ' ').replace(/&/g, '","').replace(/=/g,'":"') + '"}',
             function(key, value) { return key===""?value:decodeURIComponent(value)});
objForm.anyParam += stringToAddToTheParam;
var serializedForm = $.param(objForm);

0

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

const uri = new URL('https://example.org/?myvar1=longValue&myvar2=value')
const result = {}
for (let p of uri.searchParams) {
  result[p[0]] = p[1]
}

0

यदि आपको पुनरावृत्ति की आवश्यकता है, तो आप छोटे js-extension-ling लाइब्रेरी का उपयोग कर सकते हैं ।

npm i js-extension-ling
const jsx = require("js-extension-ling");

console.log(jsx.queryStringToObject("a=1")); 
console.log(jsx.queryStringToObject("a=1&a=3")); 
console.log(jsx.queryStringToObject("a[]=1")); 
console.log(jsx.queryStringToObject("a[]=1&a[]=pomme")); 
console.log(jsx.queryStringToObject("a[0]=one&a[1]=five"));
console.log(jsx.queryStringToObject("http://blabla?foo=bar&number=1234")); 
console.log(jsx.queryStringToObject("a[fruits][red][]=strawberry"));
console.log(jsx.queryStringToObject("a[fruits][red][]=strawberry&a[1]=five&a[fruits][red][]=cherry&a[fruits][yellow][]=lemon&a[fruits][yellow][688]=banana"));

यह कुछ इस तरह से उत्पादन करेगा:

{ a: '1' }
{ a: '3' }
{ a: { '0': '1' } }
{ a: { '0': '1', '1': 'pomme' } }
{ a: { '0': 'one', '1': 'five' } }
{ foo: 'bar', number: '1234' }
{
  a: { fruits: { red: { '0': 'strawberry' } } }
}
{
  a: {
    '1': 'five',
    fruits: {
      red: { '0': 'strawberry', '1': 'cherry' },
      yellow: { '0': 'lemon', '688': 'banana' }
    }
  }
}

नोट: यह locutus parse_str function ( https://locutus.io/php/strings/parse_str/ ) पर आधारित है ।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.