কীভাবে একটি জাভাস্ক্রিপ্ট অবজেক্টে ইউআরএল পরামিতি রূপান্তর করবেন?


223

আমার মতো স্ট্রিং রয়েছে:

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

আমি কীভাবে এটিকে জাভাস্ক্রিপ্ট অবজেক্টে রূপান্তর করতে পারি?

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

এছাড়াও দেখুন
স্ট্যাকওভারফ্লো.

1
এটি নয়: developer.mozilla.org/en-US/docs/Web/API/ URLS SearchParams/… বিকাশকারী.মোজিলা.অর্গ / মার্কিন- ডকস / ওয়েব / এপিআই / ইউআরএল / যদিও (যদিও আমাদের একটি অপেক্ষা করতে হবে সমস্ত ব্রাউজারগুলি এটি তুলতে আরও অল্প সময়ের মধ্যে)
আর্থার

উত্তর:


334

সম্পাদন করা

এই সম্পাদনাটি মন্তব্যের ভিত্তিতে উত্তরটির উন্নতি করে এবং ব্যাখ্যা করে explains

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

উদাহরণ

abc=foo&def=%5Basf%5D&xyz=5পাঁচটি ধাপে পার্স করুন :

  • ডিকোডুরি: abc = foo & def = [asf] এবং xyz = 5
  • এসকেট উদ্ধৃতি: একই, যেমন কোনও উদ্ধৃতি নেই are
  • প্রতিস্থাপন করুন এবং: abc=foo","def=[asf]","xyz=5
  • প্রতিস্থাপন =: abc":"foo","def":"[asf]","xyz":"5
  • কুঁকড়ানো এবং উদ্ধৃতি সহ চমত্কার: {"abc":"foo","def":"[asf]","xyz":"5"}

যা আইনী জেএসওএন।

একটি উন্নত সমাধান অনুসন্ধান স্ট্রিংয়ের আরও অক্ষরের জন্য অনুমতি দেয়। এটি ইউআরআই ডিকোডিংয়ের জন্য একটি রিভিভার ফাংশন ব্যবহার করে:

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
কফিস্ক্রিপ্টে কাজ করার জন্য, রেজেক্সে '=' এড়িয়ে চলুন। .replace (/ \ = / g, "\": \ "")
এয়ারলোক

175
এটি কোনও ওলাইনার নয় ... এটি একটি স্পেস স্টেশন।
জিগি

5
আপনি যদি ব্যবহার করেন তবে আরও ভালJSON.parse('{"' + decodeURI(location.search.substring(1).replace(/&/g, "\",\"").replace(/=/g, "\":\"")) + '"}')
ডানিয়েল তুল্প

4
পার্স হওয়ার জন্য ইউআরএলটিতে যদি সমান চিহ্নের অক্ষর থাকে তবে এটি ব্যর্থ হয়। EX: "কুকি = dlksdlfj = sodkfjhsdlfj"
jholloman

3
মানহীন প্যারামিটারগুলির একটি থাকলেও কাজ করে না।
সিচ

112

2020 ES6 / 7/8 এবং আগমন

ES6 আরম্ভ করে জাভাস্ক্রিপ্ট এই সমস্যার জন্য পারফরম্যান্ট সমাধান তৈরি করতে বেশ কয়েকটি নির্মাণ প্রস্তাব করে।

এর মধ্যে ইউআরএল সার্চপ্যারাম এবং পুনরুক্তি ব্যবহার করে

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"}

অবজেক্ট.ফ্রেম এন্ট্রি ব্যবহার করে এবং ছড়িয়ে দিন

এর সাথে প্রতিস্থাপন করে আমরা অবজেক্ট.ফ্রেম এন্ট্রিগুলি (যা বর্তমানে পর্যায়ে 4 এ রয়েছে) ব্যবহার করতে পারি ।paramsToObjectObject.fromEntries(entries)

পুনরাবৃত্তি করতে মান জোড়গুলি হল নামটির নাম তালিকা এবং মানটি মান হিসাবে মান তালিকা being

যেহেতু URLParams, একটি পুনরাবৃত্তিযোগ্য অবজেক্ট ফেরত দেয় , কল করার পরিবর্তে স্প্রেড অপারেটর ব্যবহার করে .entriesতার প্রতি অনুমান অনুসারে এন্ট্রিও প্রদান করবে:

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

দ্রষ্টব্য: সমস্ত মান স্বয়ংক্রিয়ভাবে ইউআরএল সার্চপ্যারাম অনুসারে স্ট্রিং হয়

একাধিক একই কী

হিসাবে @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
আমি এই সমাধানের প্রস্তাব দিই না। ইউআরএল সার্চপ্যারামগুলির অযৌক্তিক স্পেস রয়েছে ( বিকাশকারী.মোজিলা.আর.ইন- ইউএস / ডকস / ওয়েবে / এপিআই /… )
সেফ রেড

1
আমি দুঃখিত তবে লজিকের এর সাথে কিছু করার নেই। কেউ যুক্তিযুক্ত হতে পারে যে এটি একটি search stringপার্সার - এটি কোনও ইউআরএলের সাথে সম্পর্কিত না করেই এটি করার জন্য ডিজাইন করা হয়েছিল
সিলিক্যাকগুলি

Object.fromEntriesপুনরাবৃত্তি কীগুলির জন্য কাজ করে না। আমরা যদি এমন কিছু করার চেষ্টা করি তবে আমরা ?foo=bar1&foo=bar2কেবল তা পাব { foo: 'bar2' }। নোড.জেএস অনুরোধ অবজেক্ট, উদাহরণস্বরূপ, এটিকে পার্স করে{ foo: ['bar1', 'bar2'] }
সাইপ

তুমি ঠিক আছে, তবে এটি কোন বৈশিষ্ট এবং অনেক ভাষায় কিভাবে তারা এটি বিশ্লেষণ করতে হিসাবে একটি একগুঁয়ে অভিগমন: stackoverflow.com/a/1746566/1194694
silicakes

এটি আমার কাছে ভাল লাগছে, তবে পুনরাবৃত্ত 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 = বার এবং হ্যালো =% 40 ওয়ার্ল্ড ও শোথিং" এর মতো ব্যবহার করা উচিত, পুরো ইউআরএল নয়, যেমন প্রশ্ন থেকেই যায়।
মুরগি

1
এটি ব্যবহার করা যেতে পারে, তবে সাবধানতার সাথে ?someValue=falseহয়ে যায়{ someValue: "false" }
সাইমন

এটি পুনরাবৃত্তি কীগুলির জন্য কাজ করে না। আমরা যদি এমন কিছু করার চেষ্টা করি তবে আমরা ?foo=bar1&foo=bar2কেবল তা পাব { foo: 'bar2' }। নোড.জেএস অনুরোধ অবজেক্ট এটিকে পার্স করে{ foo: ['bar1', 'bar2'] }
সাইপ

@ সেফরিড, আমি বিশ্বাস করি যে আপনার মন্তব্যটি আপডেট হওয়া সংস্করণটির সাথে সম্বোধন করা হয়েছে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! আপনার বাম দিকের ডিকোডেরিউআইআরসি কম্পিউটারোন (পি [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
শে

16

আমি এখনও অবধি প্রস্তাবিত সমাধানগুলি আরও জটিল পরিস্থিতিতে notেকে রাখে না।

আমার মতো একটি কোয়েরি স্ট্রিং রূপান্তর করা দরকার

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']}))
মুরগি 21

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 কে অক্ষরে রূপান্তর করতে স্ট্রিংটি আনইনকোড করতে ভুলে যাননি?
jفر00

@ অ্যালেক্স - আপনি আপডেট কোড বা মূলটি ব্যবহার করেছেন? আসলটির একটি সমস্যা এবং একটি টাইপ ছিল।
জাস্টিন নিসনার

এটি প্যারামগুলিতে সঠিকভাবে পরিচালনা করতে পারে না যখন তাদের মানগুলিতে '=' থাকে। এটি মানটিকে প্রথমে '=' এ ছাঁটাই করে।
গ্র্যাক করুন

JSON.parse('{"' + decodeURIComponent(query.replace(/"/g, '\\"').replace(/&/g, '","').replace(/=/g,'":"') + '"}'));আমার জন্য কাজ করে
ড্যানিল গাপোনভ

1
name[]=test1&name[]=test2এটি এর জন্য কাজ করে না এবং এর ফলাফল হবেname[]=test2
রাফি

10

আমি খুঁজে পেয়েছি ringস্ট্রিং.ডাপারাম সবচেয়ে সম্পূর্ণ প্রাক বিল্ট সলিউশন (নেস্টেড অবজেক্টস ইত্যাদি করতে পারেন)। পরীক্ষা করে দেখুন ডকুমেন্টেশন


শুধু যদি আপনার ইনপুট সবসময় একটি ধারাবাহিকভাবে কোয়েরি স্ট্রিং পাখির এবং একটি আরো লাইটওয়েট সমাধান সম্পর্কে চিন্তা করতে কোন প্রয়োজন নেই হতে যাচ্ছে সম্ভবত ভাল আউট নির্দেশ করা হয়
mattacular

অবশ্যই ঠিক আছে ... তবে এটি ইতিমধ্যে সম্পন্ন এবং পরীক্ষা করা হয়েছে (জাস্টিন উদাহরণস্বরূপ প্রাথমিক উত্তরে ইউআরআই ডিকোড করতে ভুলে যান - যা ছোট সমস্যাগুলি যা বিষয়গুলিকে প্রাথমিকভাবে দেখায় তার চেয়ে অনেক জটিল করে তুলতে পারে)।
ড্যাফ

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
ইউআরএল সার্চপ্যারামে কিছু গ্যাচাক রয়েছে যা এর জন্য ভেঙে যায়। "http://place.com?foo=bar&hello=%40world&showThingউত্পাদন { hello: "@world", http://place.com?foo: "bar", showThing: "" }। যুক্ত করার চেষ্টা করুনstr.split("?").pop()
রিড

7

ইউআরএল সার্চপ্যারামের সর্বশেষ স্ট্যান্ডার্ড ( 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()))
    : {};
}

দয়া করে মনে রাখবেন যে এই সমাধানটি ব্যবহার করছে

অ্যারে.ফ্রোম ( https://developer.mozilla.org/en-US/docs/Web/ জাভা স্ক্রিপ্ট / রেফারেন্স / গ্লোবাল_অবজেক্টস / অ্যারে / from )

এবং _.fromPairs ( https://lodash.com/docs#fromPairs ) সরলতা অনুরোধে জন্য lodash করুন।

আপনার সার্চপ্যারামসেন্ট্রি () পুনরুক্তিকারীর অ্যাক্সেস থাকার কারণে আরও সুসংগত সমাধান তৈরি করা সহজ হওয়া উচিত ।


6

আমারও একই সমস্যা ছিল, সমাধানগুলি এখানে চেষ্টা করে দেখলাম, তবে ইউটিএল প্যারামিটারে আমার অ্যারে ছিল বলে এগুলি সত্যিই কার্যকর হয়নি:

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

সুতরাং আমি আমার নিজের জেএস ফাংশনটি লিখে শেষ করেছি, যা ইউআরআইতে পরম থেকে একটি অ্যারে তৈরি করে:

/**
 * 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
এটি সত্যই সহায়ক ছিল এবং আমি যা চেয়েছিলাম ঠিক ঠিক তাই করেছিল। যদিও ইউআরএল প্যারামিটারগুলির মতো হলে "[]" কীভাবে অবজেক্টটিতে কৌশলতে রাখা হয় তা আমি পছন্দ করি না: বেকন [] = ডিম ও বেকন [] = টোস্ট। তাই আমি একটি লাইন যোগ পর if(chunk[0].search("\\[\\]") !== -1) {যেchunk[0]=chunk[0].replace(/\[\]$/,'');
rgbflawed

@ আরজিবিফ্লেইডকে আপনার ভবিষ্যতের পাঠক এবং
সুশৃঙ্খলার

constপরিবর্তে ব্যবহার করুন varকারণ কেউ হয়ত করতে পারে createObjFromURI = 'some text'এবং তারপরে তারা কোডটি বিশৃঙ্খলা করবে। আপনি যদি ব্যবহার করেন constতবে চালিত কেউ createObjFromURI = 'some text'ত্রুটি তৈরি করবে ধ্রুবক পরিবর্তনশীলকে মান নির্ধারণ করতে পারে না।
জাস্টিন লিউ

5

ES6, URL API এবং URLS SearchParams 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})
অ্যালান লেই

আমি আপনার পরামর্শ অ্যালান লেই পছন্দ করি। আমি আমার উত্তর আপডেট করছি
ফ্যাডমায়ার

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

উপকারী সংজুক

দ্রষ্টব্য : আইই সমর্থিত নয়


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

এমন কোনও নেটিভ সমাধান নেই যা সম্পর্কে আমি অবগত। আপনি যদি কাঠামোটি সুযোগমতো ব্যবহার করেন তবে ডোজোর একটি অন্তর্নির্মিত আনসিরিয়ালাইজেশন পদ্ধতি রয়েছে।

অন্যথায় আপনি এটিকে বরং বাস্তবায়িত করতে পারেন:

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;
}

সম্পাদনা করুন: ডিকোডেরিউআরকিউম্পোন্ট যুক্ত হয়েছে ()


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

ইউআরএল সার্চপ্রাম ইন্টারফেস ব্যবহার করে এটি করার সহজতম উপায়।

নীচে ওয়ার্কিং কোড স্নিপেট রয়েছে:

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 প্লাগইন পুরো url গ্রহণ করবে এবং সিরিয়ালযুক্ত পরামিতিগুলি ফিরিয়ে দেবে।


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"}

সদৃশ প্যারাম, যেমন
?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

এখানে আমার দ্রুত এবং নোংরা সংস্করণটি রয়েছে মূলত এটির ইউআরএল প্যারামিটারগুলি '&' দ্বারা অ্যারে উপাদানগুলিতে বিভক্ত করা হয় এবং তারপরে পুনরুক্ত হয় কী / মান জোড়গুলিকে কোনও বস্তুতে বিভক্ত করে কী / মান জোড় যুক্ত করে। আমি এনকোডযুক্ত অক্ষরগুলিকে তাদের সাধারণ স্ট্রিং সমতুল্যে অনুবাদ করতে ডিকোডিউরিওকোম্পোন্ট () ব্যবহার করছি (সুতরাং% 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 একটি স্ট্রিং এবং একটি সংখ্যা নয় (ডিকোডেরিউআইআরকিউম্পোনেন্ট () ব্যবহারের কারণে), তবে এর বাইরে এটি কোনও খারাপ শুরুর দিক নয়।


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 সালে) সত্যিই পছন্দ করি। যদি তীর ফাংশনটি পলিফিল করে (বা একটি traditionalতিহ্যবাহী ফাংশন হিসাবে পুনরায় লিখুন), আমি মনে করি এটি ক্রস-ব্রাউজারে বেশ ভালভাবে কাজ করা উচিত
স্ক্রিবলমাচার

@ সাবস্ক্রিপম্যাকার Babelএর সহায়তায় আপনি এটি অন্য পরিবেশের অধীনে ভাল করতে পারেন
এক্সওয়াইজ আমোস

1

পিএইচপিজেএস ব্যবহার করে

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

আমার +ইউআরএল এর কোয়েরি অংশেও ডিল করতে হবে ( ডিকোডেরিউআইআরকিউম্পোনেন্টটি দেয় না ), তাই আমি ওল্ফগ্যাংয়ের কোডটি রূপান্তর করতে পেরেছি:

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)}):{};

আমার ক্ষেত্রে, আমি ইউআরএল-তৈরি ফর্মের প্যারামিটারগুলি পেতে jQuery ব্যবহার করছি, তারপরে এটির বাইরে থেকে কোনও অবজেক্ট তৈরি করার জন্য এই কৌশলটি এবং আমি সহজেই অবজেক্টটিতে প্যারামিটারগুলি আপডেট করতে এবং ক্যোয়ারী ইউআরএল পুনর্নির্মাণ করতে পারি, যেমন:

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

আপনার যদি পুনরাবৃত্তি প্রয়োজন, আপনি ক্ষুদ্র জেএস-এক্সটেনশন- লাইব্রেরি ব্যবহার করতে পারেন ।

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' }
    }
  }
}

দ্রষ্টব্য: এটি লোকুটাস পার্সে_স্ট্রিস্ট ফাংশন ( https://locutus.io/php/strings/parse_str/ ) এর উপর ভিত্তি করে ।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.