मैं जावास्क्रिप्ट में क्वेरी स्ट्रिंग मान कैसे प्राप्त कर सकता हूं?


2697

क्या jQuery के माध्यम से (या बिना) क्वेरी स्ट्रिंग मान प्राप्त करने का एक प्लगइन-कम तरीका है ?

यदि हां, तो कैसे? यदि नहीं, तो क्या कोई प्लगइन है जो ऐसा कर सकता है?


मैं jQuery- प्लगइन में वर्णित प्लगइन getUrlParam का उपयोग करता हूं - getUrlParam (संस्करण 2)
कोमा

69
RegEx के बिना एक सादा जावास्क्रिप्ट समाधान: css-tricks.com/snippets/javascript/get-url-variables
Lorenzo Polidori

6
यद्यपि प्रश्न का शीर्ष समाधान इसकी लोकप्रियता के लायक है क्योंकि इसके उत्कृष्ट अवलोकन के लिए jQuery की आवश्यकता नहीं है, नए नियमित अभिव्यक्ति बनाने की अपनी विधि और वांछित पैरामीटर के लिए क्वेरी स्ट्रिंग को फिर से पार्स करना बेहद अक्षम है। बहुत अधिक कुशल (और बहुमुखी) समाधान लंबे समय से अस्तित्व में हैं, उदाहरण के लिए इस लेख के भीतर यहां पुनर्मुद्रित किया गया है: htmlgoodies.com/beyond/javascript/article.php/11877_3755006/3-…
जोसेफ मायर्स


4
जोसेफ, "jQuery की आवश्यकता नहीं है कि उत्कृष्ट अवलोकन"? बेशक इसकी जरूरत नहीं है। सब कुछ jQuery करता है, यह जावास्क्रिप्ट का उपयोग करता है। लोग jQuery का उपयोग नहीं करते हैं क्योंकि यह सामान करता है जो जावास्क्रिप्ट नहीं कर सकता है। JQuery की बात सुविधा है।
व्लादिमीर कोर्निया

जवाबों:


8321

अपडेट: सितम्बर -२०१8

आप URLSearchParams का उपयोग कर सकते हैं जो सरल है और इसमें सभ्य (लेकिन पूर्ण नहीं) ब्राउज़र समर्थन है

const urlParams = new URLSearchParams(window.location.search);
const myParam = urlParams.get('myParam');

मूल

आपको उस उद्देश्य के लिए jQuery की आवश्यकता नहीं है। आप बस कुछ शुद्ध जावास्क्रिप्ट का उपयोग कर सकते हैं:

function getParameterByName(name, url) {
    if (!url) url = window.location.href;
    name = name.replace(/[\[\]]/g, '\\$&');
    var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),
        results = regex.exec(url);
    if (!results) return null;
    if (!results[2]) return '';
    return decodeURIComponent(results[2].replace(/\+/g, ' '));
}

उपयोग:

// query string: ?foo=lorem&bar=&baz
var foo = getParameterByName('foo'); // "lorem"
var bar = getParameterByName('bar'); // "" (present with empty value)
var baz = getParameterByName('baz'); // "" (present with no value)
var qux = getParameterByName('qux'); // null (absent)


नोट: यदि कोई पैरामीटर कई बार मौजूद है ( ?foo=lorem&foo=ipsum), तो आपको पहला मान मिलेगा ( lorem)। इसके बारे में कोई मानक नहीं है और इसमें भिन्नताएँ हैं, उदाहरण के लिए देखें यह प्रश्न: डुप्लिकेट HTTP GET क्वेरी कुंजियों की आधिकारिक स्थिति
नोट: फ़ंक्शन केस-संवेदी है। यदि आप केस-असंवेदनशील पैरामीटर नाम पसंद करते हैं, तो RegExp में 'i' संशोधक जोड़ें


यह नए URLSearchParams स्पेक्स के आधार पर एक अपडेट है जो समान परिणाम को अधिक सफलतापूर्वक प्राप्त करने के लिए है। नीचे " URLSearchParams " शीर्षक वाला उत्तर देखें ।


131
यह फ़ंक्शन कैसे संभालता http://www.mysite.com/index.php?x=x1&x=x2&x=x3है फ़ील्ड xका मान अस्पष्ट है।
डीपीपी

94
यह बहु-मूल्यवान कुंजियों को भी नहीं संभालता है , जो पूरी तरह से कानूनी हैं।
जल्‍दी से जल्‍दी hurry

17
आप इसके लिए एक नियमित अभिव्यक्ति का उपयोग क्यों करेंगे?
Ry-

28
के एक झंझट के लिए ?mykey=0&m.+key=1, के बजाय कॉलिंग getParameterByName("m.+key")वापस आ जाएगी । आपको अपनी नियमित अभिव्यक्ति बनाने से पहले नियमित अभिव्यक्ति मेटाचैकर्स से बचना होगा । और आपको केवल वैश्विक ध्वज का उपयोग करके और प्रतिस्थापन अभिव्यक्ति के रूप में उपयोग करके एक बार कॉल करने की आवश्यकता है । आप के बजाय पर खोज करनी चाहिए । 400 से अधिक upvotes के साथ एक उत्तर इन विवरणों के लिए होना चाहिए। 01name.replace()"\\$&"location.searchlocation.href
gilly3

7
आपको उस या किसी अन्य उद्देश्य के लिए jQuery की आवश्यकता नहीं है। आप वास्तव में यह जरूरत नहीं है।
gztomas

1707

यहां पोस्ट किए गए कुछ समाधान अक्षम हैं। हर बार नियमित अभिव्यक्ति खोज को दोहराते हुए स्क्रिप्ट को एक पैरामीटर तक पहुंचने की आवश्यकता पूरी तरह से अनावश्यक है, मापदंडों को एक साहचर्य-सरणी शैली ऑब्जेक्ट में विभाजित करने के लिए एक एकल फ़ंक्शन पर्याप्त है। यदि आप HTML 5 इतिहास एपीआई के साथ काम नहीं कर रहे हैं, तो यह केवल एक बार प्रति पृष्ठ लोड आवश्यक है। यहाँ अन्य सुझाव भी URL को सही ढंग से डिकोड करने में विफल हैं।

var urlParams;
(window.onpopstate = function () {
    var match,
        pl     = /\+/g,  // Regex for replacing addition symbol with a space
        search = /([^&=]+)=?([^&]*)/g,
        decode = function (s) { return decodeURIComponent(s.replace(pl, " ")); },
        query  = window.location.search.substring(1);

    urlParams = {};
    while (match = search.exec(query))
       urlParams[decode(match[1])] = decode(match[2]);
})();

उदाहरण क्वेरिस्ट्रिंग:

?i=main&mode=front&sid=de8d49b78a85a322c4155015fdce22c4&enc=+Hello%20&empty

परिणाम:

 urlParams = {
    enc: " Hello ",
    i: "main",
    mode: "front",
    sid: "de8d49b78a85a322c4155015fdce22c4",
    empty: ""
}

alert(urlParams["mode"]);
// -> "front"

alert("empty" in urlParams);
// -> true

यह आसानी से सरणी शैली क्वेरी तार भी संभाल करने के लिए सुधार किया जा सकता है। इसका एक उदाहरण यहाँ है , लेकिन चूंकि RFC 3986 में सरणी-शैली पैरामीटर परिभाषित नहीं हैं, इसलिए मैं स्रोत कोड के साथ इस उत्तर को प्रदूषित नहीं करूंगा। "प्रदूषित" संस्करण में रुचि रखने वालों के लिए, नीचे दिए गए कैम्पबेलन के उत्तर को देखें

इसके अलावा, जैसा कि टिप्पणियों में बताया गया है, जोड़े के ;लिए एक कानूनी परिसीमन है key=value। इसे संभालने के लिए अधिक जटिल रेगेक्स की आवश्यकता होगी ;या &, जो मुझे लगता है कि अनावश्यक है क्योंकि यह दुर्लभ ;है जिसका उपयोग किया जाता है और मैं यह भी कहूंगा कि दोनों का उपयोग नहीं किया जाएगा। यदि आपको ;इसके बजाय समर्थन करने की आवश्यकता है &, तो बस उन्हें regex में स्वैप करें।


यदि आप सर्वर-साइड प्रीप्रोसेसिंग भाषा का उपयोग कर रहे हैं, तो आप अपने मूल JSON फ़ंक्शन का उपयोग अपने लिए भारी उठाने के लिए कर सकते हैं। उदाहरण के लिए, PHP में आप लिख सकते हैं:

<script>var urlParams = <?php echo json_encode($_GET, JSON_HEX_TAG);?>;</script>

बहुत सरल!

UPDATED

निम्नलिखित के रूप में दोहराया परमर्स को पुनः प्राप्त करने की एक नई क्षमता होगी myparam=1&myparam=2। एक विनिर्देश नहीं है , हालांकि, अधिकांश वर्तमान दृष्टिकोण एक सरणी की पीढ़ी का पालन करते हैं।

myparam = ["1", "2"]

तो, यह इसे प्रबंधित करने का तरीका है:

let urlParams = {};
(window.onpopstate = function () {
    let match,
        pl = /\+/g,  // Regex for replacing addition symbol with a space
        search = /([^&=]+)=?([^&]*)/g,
        decode = function (s) {
            return decodeURIComponent(s.replace(pl, " "));
        },
        query = window.location.search.substring(1);

    while (match = search.exec(query)) {
        if (decode(match[1]) in urlParams) {
            if (!Array.isArray(urlParams[decode(match[1])])) {
                urlParams[decode(match[1])] = [urlParams[decode(match[1])]];
            }
            urlParams[decode(match[1])].push(decode(match[2]));
        } else {
            urlParams[decode(match[1])] = decode(match[2]);
        }
    }
})();

11
यदि आप एक भारी ajax'd एप्लिकेशन कर रहे हैं, तो आप हैश (#) का उपयोग "बैक बटन को सक्षम करने के लिए" कर सकते हैं ... उस स्थिति में क्वैरिस्ट्रिंग हर समय बदल जाएगा (देखें कि यह फेसबुक कैसे करता है)। .. हालाँकि ये समाधान # aways ... के बाद आने वाली चीजों को नजरअंदाज करते हैं ...
Nick Franceschina

100
@ निक: कुछ भी हैश के बाद window.location.hashसंपत्ति में रहता है , जो window.location.searchसंपत्ति से अलग है । अगर हैश बदलता है, तो यह क्वेरिस्ट्रिंग को बिल्कुल भी प्रभावित नहीं करता है।
एंडी ई

27
मत भूलो कि GET जोड़े के लिए ;एक कानूनी परिसीमन हैkey=value । यह दुर्लभ है, लेकिन इसे लागू करने में 5 सेकंड लगते हैं।
एलेक्स

4
निष्पक्ष होने के लिए, RFC3986 द्वारा क्वेरी स्ट्रिंग के लिए कोई विशिष्ट प्रारूप निर्धारित नहीं किया गया है। ?a=b&c=dपारंपरिक है, और वेब रूपों के लिए एक W3C सिफारिश है, लेकिन यूआरआई कल्पना सिर्फ परिभाषित करती है query = *( pchar / "/" / "?" )
मैथ्यू गिलियार्ड

21
JSHint के एक काफी सख्त सेटअप का उपयोग करने वाले हम में से लोगों के while(match = search.exec(query))साथwhile((match = search.exec(query)) !== null)
स्वैपिंग करें

1282

ES2015 (ES6)

getQueryStringParams = query => {
    return query
        ? (/^[?#]/.test(query) ? query.slice(1) : query)
            .split('&')
            .reduce((params, param) => {
                    let [key, value] = param.split('=');
                    params[key] = value ? decodeURIComponent(value.replace(/\+/g, ' ')) : '';
                    return params;
                }, {}
            )
        : {}
};

बिना jQuery के

var qs = (function(a) {
    if (a == "") return {};
    var b = {};
    for (var i = 0; i < a.length; ++i)
    {
        var p=a[i].split('=', 2);
        if (p.length == 1)
            b[p[0]] = "";
        else
            b[p[0]] = decodeURIComponent(p[1].replace(/\+/g, " "));
    }
    return b;
})(window.location.search.substr(1).split('&'));

जैसे URL के साथ ?topic=123&name=query+string, निम्नलिखित वापस आएगा:

qs["topic"];    // 123
qs["name"];     // query string
qs["nothere"];  // undefined (object)

Google विधि

Google के कोड को फाड़ते हुए मुझे उनकी विधि का पता चला: getUrlParameters

function (b) {
    var c = typeof b === "undefined";
    if (a !== h && c) return a;
    for (var d = {}, b = b || k[B][vb], e = b[p]("?"), f = b[p]("#"), b = (f === -1 ? b[Ya](e + 1) : [b[Ya](e + 1, f - e - 1), "&", b[Ya](f + 1)][K](""))[z]("&"), e = i.dd ? ia : unescape, f = 0, g = b[w]; f < g; ++f) {
        var l = b[f][p]("=");
        if (l !== -1) {
            var q = b[f][I](0, l),
                l = b[f][I](l + 1),
                l = l[Ca](/\+/g, " ");
            try {
                d[q] = e(l)
            } catch (A) {}
        }
    }
    c && (a = d);
    return d
}

यह बाधित है, लेकिन यह समझ में आता है। यह काम नहीं करता है क्योंकि कुछ चर अपरिभाषित हैं।

वे यूआरएल से मापदंडों की तलाश शुरू करते हैं ? और हैश से भी# । फिर प्रत्येक पैरामीटर के लिए वे समान चिह्न में विभाजित होते हैं b[f][p]("=")(जो दिखता है indexOf, वे कुंजी / मूल्य प्राप्त करने के लिए चार की स्थिति का उपयोग करते हैं)। विभाजित होने के बाद, वे जाँचते हैं कि पैरामीटर का कोई मान है या नहीं, अगर ऐसा है तो वे मान को संग्रहीत करते हैं d, अन्यथा वे जारी रखते हैं।

अंत में वस्तु dको वापस लौटा दिया जाता है, बचकर निकल जाता है और +हस्ताक्षर हो जाता है। यह वस्तु मेरे जैसी ही है, इसका व्यवहार भी ऐसा ही है।


मेरी विधि ए के रूप में jQuery प्लगइन के

(function($) {
    $.QueryString = (function(paramsArray) {
        let params = {};

        for (let i = 0; i < paramsArray.length; ++i)
        {
            let param = paramsArray[i]
                .split('=', 2);

            if (param.length !== 2)
                continue;

            params[param[0]] = decodeURIComponent(param[1].replace(/\+/g, " "));
        }

        return params;
    })(window.location.search.substr(1).split('&'))
})(jQuery);

प्रयोग

//Get a param
$.QueryString.param
//-or-
$.QueryString["param"]
//This outputs something like...
//"val"

//Get all params as object
$.QueryString
//This outputs something like...
//Object { param: "val", param2: "val" }

//Set a param (only in the $.QueryString object, doesn't affect the browser's querystring)
$.QueryString.param = "newvalue"
//This doesn't output anything, it just updates the $.QueryString object

//Convert object into string suitable for url a querystring (Requires jQuery)
$.param($.QueryString)
//This outputs something like...
//"param=newvalue&param2=val"

//Update the url/querystring in the browser's location bar with the $.QueryString object
history.replaceState({}, '', "?" + $.param($.QueryString));
//-or-
history.pushState({}, '', "?" + $.param($.QueryString));

प्रदर्शन परीक्षण (रेगेक्स विधि के खिलाफ विभाजन विधि) ( jsPerf ) )

तैयारी कोड: विधियाँ घोषणा

स्प्लिट टेस्ट कोड

var qs = window.GetQueryString(query);

var search = qs["q"];
var value = qs["value"];
var undef = qs["undefinedstring"];

रेगेक्स टेस्ट कोड

var search = window.getParameterByName("q");
var value = window.getParameterByName("value");
var undef = window.getParameterByName("undefinedstring");

Windows Server 2008 R2 / 7 x64 पर फ़ायरफ़ॉक्स 4.0 x86 में परीक्षण

  • विभाजन की विधि : 144,780 17 2.17% सबसे तेज
  • रेगेक्स विधि : 13,891 13 0.85% | 90% धीमा

1
यह भी एक अच्छा तरीका है, नियमित अभिव्यक्ति का उपयोग करने के बजाय स्ट्रिंग विभाजन। हालांकि, कुछ चीजें इंगित करने लायक हैं, हालांकि :-) 1. unescapeएक पदावनत समारोह है और इसके साथ प्रतिस्थापित किया जाता है decodeURIComponent(), ध्यान दें कि इन कार्यों में से कोई +भी एक अंतरिक्ष चरित्र के लिए सही ढंग से डिकोड नहीं करेगा । 2. आपको परिणाम को ऑब्जेक्ट के रूप में घोषित करना चाहिए, बजाय एक सरणी के क्योंकि जावास्क्रिप्ट में साहचर्य सरणियाँ नहीं हैं, प्रति se, और आपके द्वारा घोषित सरणी को किसी भी तरह नामित गुणों को असाइन करके ऑब्जेक्ट के रूप में माना जाता है।
एंडी ई

55
जिज्ञासु आप इसे एक jQuery प्लगइन क्यों बनायेंगे जब इसमें कोई jQuery विशिष्ट कोड नहीं है?
zachleat

63
@zachleat यदि आपके पास ढांचा नहीं है तो आपके कार्य आपके कोड में फैल जाएंगे। यदि आप jQuery का विस्तार करते हैं तो आपके पास अपने कार्यों के लिए एक गुंजाइश होगी, यह आपके कोड में कहीं भी नहीं होगा। मुझे लगता है कि यही एकमात्र कारण है।
ब्रूनो

6
यहाँ JSLint (कम से कम सेमी-मूविंग टारगेट ऑफ़ JSLint.com को 2011-06-15) पास करने के लिए jQuery का संस्करण दिया गया है । ज्यादातर सिर्फ द क्रॉकफोर्ड को खुश करने के लिए चीजों को घुमाते हुए।
पितृ पक्ष

3
जैसा कि @BenjaminGruenbaum ने मजाक किया है, मैं भी URL पार्सिंग के प्रदर्शन को बेंचमार्क करने में बहुत महत्वपूर्ण नहीं हूँ। यदि यह एक आइसोमोर्फिक जावास्क्रिप्ट मॉड्यूल में बनाया गया था जिसे नोड से, कहने, पार्स लॉग से बुलाया जा सकता है, तो हाँ। लेकिन URL मापदंडों को निकालने के लिए इसका उपयोग करने से window.locationकिसी भी प्रदर्शन की चिंता मूक हो जाती है, यह देखते हुए कि क्लाइंट को URL पर नेविगेट करना कहीं अधिक महंगा है।
डैन डस्केल्सस्कु

659

Artem Barger के उत्तर का बेहतर संस्करण :

function getParameterByName(name) {
    var match = RegExp('[?&]' + name + '=([^&]*)').exec(window.location.search);
    return match && decodeURIComponent(match[1].replace(/\+/g, ' '));
}

सुधार के बारे में अधिक जानकारी के लिए देखें: http://james.padolsey.com/javascript/bujs-1-getparameterbyname/


23
यदि आप इसे थोड़ा और छोटा करना चाहते हैं, तो आप टर्नरी सशर्त के साथ दूर कर सकते हैं और इसे उस अंतिम लाइन पर शॉर्ट-सर्किट्री के साथ बदल सकते हैं - return match && decodeURIComponent(match[1].replace(/\+/g, ' '));
एंडी ई

nullयदि पैरामीटर = '=' के बाद आता है तो यह वापस आ जाता है। आप if (!RegExp('[?&]'+name+'(&.*)?$').exec(window.location.search)) return false;इसे वापस करने के लिए तैयार कर सकते हैं boolean falseयदि पैरामीटर बिल्कुल भी नहीं है।
commonpike

9
newरेगीज़ बनाते समय मैं उपसर्ग का उपयोग करूंगा :var match = new RegExp('...
पैट्रिक बर्कले

2
IE11 बग: IE एएससीआई वर्ण 8206 (हेक्स: 200 ई - "लेफ्ट-टू-राइट कैरेक्टर") के साथ लौटे मूल्य को पूर्व निर्धारित करने का फैसला करता है। मैं यह पता लगाने में 6 घंटे से अधिक बर्बाद कर दिया! चिकित्सीय वेंटिंग .... ठीक करने के लिए, अंतिम पंक्ति के अंत तक .replace('\u200E', '')
व्यवहार करें

कम से कम एक मैक पर क्रोम में (शायद अन्य ब्राउज़र भी) अंतिम मान एक '/' जोड़ा जा रहा था। इसलिए मैंने इसे अनदेखा करने के लिए रेगेक्स को संशोधित किया। var results = new RegExp('[\\?&]' + name + '=([^&#/]*)').exec(url);
केसीबी

594

URLSearchParams

फ़ायरफ़ॉक्स 44+, ओपेरा 36+, एज 17+, सफारी 10.3+ और क्रोम 49+ URLSearchParams API का समर्थन करते हैं :

IE के स्थिर संस्करणों के लिए एक Google द्वारा सुझाया गया URLSearchParams पॉलीफ़िल है

यह W3C द्वारा मानकीकृत नहीं है , लेकिन यह व्हाट्सएप द्वारा एक जीवित मानक है ।

आप इस पर उपयोग कर सकते हैं location:

let params = new URLSearchParams(location.search);

या

let params = (new URL(location)).searchParams;

या किसी भी यूआरएल पर:

let url = new URL('https://example.com?foo=1&bar=2');
let params = new URLSearchParams(url.search);

आप .searchParamsURL ऑब्जेक्ट पर शॉर्टहैंड प्रॉपर्टी का उपयोग करके भी इस तरह से परमर्स प्राप्त कर सकते हैं :

let params = new URL('https://example.com?foo=1&bar=2').searchParams;
params.get('foo'); // "1"
params.get('bar'); // "2" 

आप , एपीआई get(KEY), के माध्यम से मापदंडों को पढ़ते हैं / सेट करते हैं । आप सभी मूल्यों पर पुनरावृति भी कर सकते हैं ।set(KEY, VALUE)append(KEY, VALUE)for (let p of params) {}

एक संदर्भ कार्यान्वयन और एक नमूना पृष्ठ ऑडिटिंग और परीक्षण के लिए उपलब्ध हैं।


उन दो डाउनवोटर्स को शायद याद किया (जैसे मैंने अभी किया था) इस तथ्य का उपयोग करना है कि आपको .getइसके बजाय सिर्फ उपयोग करना है.
Nakilon

20
आप वास्तव में जरूरत नहीं है slice(1)पर .search, तो आप सीधे उपयोग कर सकते हैं। URLSearchParams अग्रणी को संभाल सकता है ?
जेसन सी।

URLSearchParamsयह अच्छा नहीं है क्योंकि यह URL के मापदंडों के वास्तविक मूल्यों को वापस नहीं करता है।
मेलब

यह new URL('https://example.com?foo=1&bar=2') एंड्रॉइड urlfile:///android_asset/...
shah

@Melab यह अभी भी अच्छा है कि यह अन्य उत्तरों में सभी अजीब रीजॉन्ग के लिए एक सरल एपीआई प्रदान करता है। लेकिन यह मुझे यह भी बताता है कि आईडी डिफ़ॉल्ट रूप से window.location.search नहीं करती है और इसमें वर्तमान यूरिया को अपडेट करने का कोई तरीका नहीं है।
डेमॉन

400

बस एक और सिफारिश। प्लगइन Purl URL के सभी भागों को पुनः प्राप्त करने की अनुमति देता है, जिसमें एंकर, होस्ट आदि शामिल हैं।

इसे jQuery के साथ या बिना उपयोग किया जा सकता है।

उपयोग बहुत सरल और अच्छा है:

var url = $.url('http://allmarkedup.com/folder/dir/index.html?item=value'); // jQuery version
var url = purl('http://allmarkedup.com/folder/dir/index.html?item=value'); // plain JS version
url.attr('protocol'); // returns 'http'
url.attr('path'); // returns '/folder/dir/index.html'

हालाँकि, 11 नवंबर 2014 तक, Purl का रखरखाव नहीं किया गया है और लेखक इसके बजाय URI.js का उपयोग करने की सलाह देता है । JQuery प्लगइन अलग है कि यह तत्वों पर केंद्रित है - स्ट्रिंग्स के साथ उपयोग के लिए, बस URIसीधे उपयोग करें, साथ या बिना jQuery के। समान कोड इस तरह दिखेगा, फुलर डॉक्स यहां :

var url = new URI('http://allmarkedup.com/folder/dir/index.html?item=value'); // plain JS version
url.protocol(); // returns 'http'
url.path(); // returns '/folder/dir/index.html'

7
जैसा कि लेखन purl
Dan Pantry

238

tl; डॉ

एक त्वरित, पूर्ण समाधान , जो बहुस्तरीय कुंजियों और एन्कोड किए गए वर्णों को संभालता है ।

var qd = {};
if (location.search) location.search.substr(1).split("&").forEach(function(item) {var s = item.split("="), k = s[0], v = s[1] && decodeURIComponent(s[1]); (qd[k] = qd[k] || []).push(v)})

//using ES6   (23 characters cooler)
var qd = {};
if (location.search) location.search.substr(1).split`&`.forEach(item => {let [k,v] = item.split`=`; v = v && decodeURIComponent(v); (qd[k] = qd[k] || []).push(v)})
मल्टी लाइन:
var qd = {};
if (location.search) location.search.substr(1).split("&").forEach(function(item) {
    var s = item.split("="),
        k = s[0],
        v = s[1] && decodeURIComponent(s[1]); //  null-coalescing / short-circuit
    //(k in qd) ? qd[k].push(v) : qd[k] = [v]
    (qd[k] = qd[k] || []).push(v) // null-coalescing / short-circuit
})

यह सब कोड क्या है ...
"null-coalescing" , शॉर्ट-सर्किट मूल्यांकन
ES6 विनाशकारी असाइनमेंट , एरो फ़ंक्शंस , टेम्पलेट स्ट्रिंग्स

उदाहरण:
"?a=1&b=0&c=3&d&e&a=5&a=t%20e%20x%20t&e=http%3A%2F%2Fw3schools.com%2Fmy%20test.asp%3Fname%3Dståle%26car%3Dsaab"
> qd
a: ["1", "5", "t e x t"]
b: ["0"]
c: ["3"]
d: [undefined]
e: [undefined, "http://w3schools.com/my test.asp?name=ståle&car=saab"]

> qd.a[1]    // "5"
> qd["a"][1] // "5"



और पढ़ें ... वेनिला जावास्क्रिप्ट समाधान के बारे में।

URL उपयोग के विभिन्न भागों तक पहुँचने के लिए location.(search|hash)

सबसे आसान (डमी) समाधान

var queryDict = {};
location.search.substr(1).split("&").forEach(function(item) {queryDict[item.split("=")[0]] = item.split("=")[1]})
  • खाली कुंजी को सही ढंग से संभालता है।
  • पिछले मान के साथ बहु-कुंजी को ओवरराइड करता है।
"?a=1&b=0&c=3&d&e&a=5"
> queryDict
a: "5"
b: "0"
c: "3"
d: undefined
e: undefined

बहु-मूल्यवान कुंजियाँ

सरल कुंजी की जाँच करें (item in dict) ? dict.item.push(val) : dict.item = [val]

var qd = {};
location.search.substr(1).split("&").forEach(function(item) {(item.split("=")[0] in qd) ? qd[item.split("=")[0]].push(item.split("=")[1]) : qd[item.split("=")[0]] = [item.split("=")[1]]})
  • अब इसके बदले एरियर देता है ।
  • द्वारा मूल्यों का उपयोग qd.key[index]याqd[key][index]
> qd
a: ["1", "5"]
b: ["0"]
c: ["3"]
d: [undefined]
e: [undefined]

एन्कोडेड अक्षर?

decodeURIComponent()दूसरे या दोनों विभाजन के लिए उपयोग करें ।

var qd = {};
location.search.substr(1).split("&").forEach(function(item) {var k = item.split("=")[0], v = decodeURIComponent(item.split("=")[1]); (k in qd) ? qd[k].push(v) : qd[k] = [v]})
उदाहरण:
"?a=1&b=0&c=3&d&e&a=5&a=t%20e%20x%20t&e=http%3A%2F%2Fw3schools.com%2Fmy%20test.asp%3Fname%3Dståle%26car%3Dsaab"
> qd
a: ["1", "5", "t e x t"]
b: ["0"]
c: ["3"]
d: ["undefined"]  // decodeURIComponent(undefined) returns "undefined" !!!*
e: ["undefined", "http://w3schools.com/my test.asp?name=ståle&car=saab"]



टिप्पणियों से

* !!! कृपया ध्यान दें, यह decodeURIComponent(undefined)स्ट्रिंग लौटाता है "undefined"। समाधान एक सरल उपयोग में है &&, जो यह सुनिश्चित करता है कि decodeURIComponent()अपरिभाषित मूल्यों पर नहीं कहा जाता है। (शीर्ष पर "पूर्ण समाधान" देखें।)

v = v && decodeURIComponent(v);


यदि querystring खाली है ( location.search == ""), तो परिणाम कुछ भ्रामक है qd == {"": undefined}। यह सुझाव दिया जाता है कि पार्सिंग फंक्शन पसंद शुरू करने से पहले क्वेरिस्ट्रिंग की जांच करें:

if (location.search) location.search.substr(1).split("&").forEach(...)

1
अच्छा लगा। केवल एक चीज जो मैं बदलूंगा - वह यह है कि यदि कुंजी के लिए एक से अधिक मान नहीं हैं, तो इसके लिए सरणी होने की कोई आवश्यकता नहीं है। केवल सरणी का उपयोग करें यदि प्रति कुंजी एक से अधिक मूल्य है।
पावेल निकोलोव

2
@PavelNikolov मुझे लगता है कि यह कभी-कभी एक सरणी और कभी-कभी एक मूल्य प्राप्त करने में कठिनाइयों को पेश करता है। आपको इसके लिए पहले जांच करनी होगी, अब आप केवल लंबाई की जांच करते हैं, क्योंकि आप उन मानों को फिर से प्राप्त करने के लिए साइकिल का उपयोग करेंगे। इसके अलावा यह सबसे आसान, लेकिन कार्यात्मक, समाधान था।
क्वर्टी

@katsh हां वास्तव में, यह> = IE9 में काम करता है, हालांकि, आप array.forEach()अपनी स्क्रिप्ट की शुरुआत में कुछ कोड इंजेक्ट करके अपने जावास्क्रिप्ट प्रोसेसर को सिखा सकते हैं । देखें Polyfill developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Qwerty

1
पठनीयता के लिए थोड़ा सा चपटा हुआ, एक फ़ंक्शन में बनाया गया, और विभाजित कॉल का पुनः उपयोग किया गया: फ़ंक्शन parseQueryString () {var qd = {}; location.search.substr (1) .plplit ("&")। forEach (फंक्शन (आइटम) {var parts = item.split ("="); var k = parts [0]; var v = decururIComponent (भागों [] 1]); (q में kd); qd [k] .push (v): qd [k] = [v,]}); वापसी qd; }
केसी

1
decodeDocumentURI (अपरिभाषित) अपरिभाषित के बजाय "अपरिभाषित" देता है। एक कार्यात्मक लेकिन बहुत सुंदर पैच नहीं: var qd = {}; location.search.substr(1).split("&").forEach( function(item) { var s = item.split("="), k = s[0], v; if(s.length>1) v = decodeURIComponent(s[1]); (k in qd) ? qd[k].push(v) : qd[k] = [v] })
लूप

218

Rosippbo on snipplr.com पर इसे प्राप्त करने के लिए एक सरल स्क्रिप्ट है, जिसे यूआरएल यूआरएल के साथ गेट URL पैरामीटर में वर्णित किया गया है सुधार हुआ । उसकी स्क्रिप्ट के साथ आप आसानी से सिर्फ अपने इच्छित मापदंडों को बाहर निकाल सकते हैं।

यहाँ है जिस्ट:

$.urlParam = function(name, url) {
    if (!url) {
     url = window.location.href;
    }
    var results = new RegExp('[\\?&]' + name + '=([^&#]*)').exec(url);
    if (!results) { 
        return undefined;
    }
    return results[1] || undefined;
}

फिर क्वेरी स्ट्रिंग से बस अपने पैरामीटर प्राप्त करें।

तो अगर URL / क्वेरी स्ट्रिंग था xyz.com/index.html?lang=de

बस फोन करो var langval = $.urlParam('lang');, और तुम मिल गया है।

UZBEKJON के पास इस पर एक बढ़िया ब्लॉग पोस्ट है, URL पैरामीटर और jQuery के साथ मान प्राप्त करें


13
jQuery के साथ jQuery ऑब्जेक्ट के लिए फ़ंक्शन नामस्थान का मतलब लगता है। इसके अलावा, अमान्य मूल्य क्यों है 0? ज़रूर, मैं सख्त समानता जांच का उपयोग कर सकता हूं, लेकिन क्या ऐसा नहीं होना चाहिए null?
एलेक्स

माना। यह उस तरह से एक सामान्य जावास्क्रिप्ट चर संदर्भ की तरह काम करता है (शायद अपरिभाषित लौटकर अधिक सटीक होगा)।
Isochronous

'नाम' ठीक से बच नहीं रहा है, यह सीधे RegExp में अंतःक्षिप्त है। यह विफल हो जाता है। जैसा कि दूसरों ने कहा है, यह अविश्वसनीय है कि ये जवाब पहिया को फिर से मजबूत कर रहे हैं और बहुत सारे वोट प्राप्त कर रहे हैं, जब इसे एक अच्छी तरह से परीक्षण किए गए पुस्तकालय में लागू किया जाना चाहिए।
त्रिनको

167

यदि आप jQuery का उपयोग कर रहे हैं, तो आप एक पुस्तकालय का उपयोग कर सकते हैं, जैसे jQuery BBQ: बैक बटन और क्वेरी लाइब्रेरी

... jQuery के BBQ .deparam()दोनों हैश राज्य प्रबंधन, और टुकड़ा / क्वेरी स्ट्रिंग पार्स और मर्ज उपयोगिता विधियों के साथ एक पूर्ण विधि प्रदान करता है ।

संपादित करें: Deparam उदाहरण जोड़ना:

 var DeparamExample = function() {
            var params = $.deparam.querystring();

            //nameofparam is the name of a param from url
            //code below will get param if ajax refresh with hash
            if (typeof params.nameofparam == 'undefined') {
                params = jQuery.deparam.fragment(window.location.href);
            }
            
            if (typeof params.nameofparam != 'undefined') {
                var paramValue = params.nameofparam.toString();
                  
            }
        };

यदि आप केवल सादे जावास्क्रिप्ट का उपयोग करना चाहते हैं, तो आप उपयोग कर सकते हैं ...

var getParamValue = (function() {
    var params;
    var resetParams = function() {
            var query = window.location.search;
            var regex = /[?&;](.+?)=([^&;]+)/g;
            var match;

            params = {};

            if (query) {
                while (match = regex.exec(query)) {
                    params[match[1]] = decodeURIComponent(match[2]);
                }
            }    
        };

    window.addEventListener
    && window.addEventListener('popstate', resetParams);

    resetParams();

    return function(param) {
        return params.hasOwnProperty(param) ? params[param] : null;
    }

})();​

नए HTML इतिहास API और विशेष रूप से history.pushState()और के कारण history.replaceState(), URL बदल सकता है जो मापदंडों और उनके मूल्यों के कैश को अमान्य कर देगा।

यह संस्करण इतिहास में परिवर्तन होने पर हर बार अपने आंतरिक कैश के मापदंडों को अपडेट करेगा।


100

बस दो विभाजन का उपयोग करें :

function get(n) {
    var half = location.search.split(n + '=')[1];
    return half !== undefined ? decodeURIComponent(half.split('&')[0]) : null;
}

मैं सभी पिछले और अधिक पूर्ण उत्तरों को पढ़ रहा था। लेकिन मुझे लगता है कि यह सबसे सरल और तेज़ तरीका है। आप इस jsPerf बेंचमार्क में देख सकते हैं

रूप की टिप्पणी में समस्या को हल करने के लिए, पहली पंक्ति को नीचे दो में बदलकर एक सशर्त विभाजन जोड़ें। लेकिन पूर्ण सटीकता का मतलब है कि यह अब regexp की तुलना में धीमा है (देखें jsPerf )।

function get(n) {
    var half = location.search.split('&' + n + '=')[1];
    if (!half) half = location.search.split('?' + n + '=')[1];
    return half !== undefined ? decodeURIComponent(half.split('&')[0]) : null;
}

इसलिए यदि आप जानते हैं कि आप रूप के काउंटर-केस में नहीं चलेंगे, तो यह जीत जाता है। अन्यथा, regexp।

या अगर आपके पास क्वेरिस्ट्रिंग का नियंत्रण है और यह गारंटी दे सकता है कि आप जो मूल्य प्राप्त करने की कोशिश कर रहे हैं, उसमें कभी भी कोई URL एन्कोडेड वर्ण नहीं होंगे (इनका मूल्य होना एक बुरा विचार होगा) - आप निम्न को थोड़ा और सरल और पठनीय संस्करण का उपयोग कर सकते हैं 1 विकल्प का:

    function getQueryStringValueByName(name) {
        var queryStringFromStartOfValue = location.search.split(name + '=')[1];
         return queryStringFromStartOfValue !== undefined ? queryStringFromStartOfValue.split('&')[0] : null;

7
बहुत साफ़! यह काम नहीं करेगा, हालांकि आप एक प्रमुख नाम के साथ पहले के एक मूल्य है, तो यह है कि आप जो चाहते है, जैसे के साथ समाप्त होता है get('value')पर http://the-url?oldvalue=1&value=2
रुप

3
हालांकि, अगर आपको पता है कि पैरामीटर नाम की उम्मीद है, तो यह तेज दृष्टिकोण होगा।
मार्टिन बोरथिरि

संपादित: यदि आप परीक्षण करते हैं कि halfयह सत्य है, तो यह रिक्त पैरामीटर के लिए अशक्त है ?param=। इसे इस मामले में खाली स्ट्रिंग लौटा देना चाहिए, और जाँच कर half !== undefinedहल करना चाहिए।
दर्शन

ठंडा! मैंने एक-लाइनर बनाया:function get(param){return decodeURIComponent((location.search.split(param+'=')[1]||'').split('&')[0])}
nuteutech

मुझे return half !== undefined ? decodeURIComponent(half[1].split('&')[0]) : null;इसे काम करने के लिए दूसरी पंक्ति
बदलनी पड़ी

95

यहाँ एक पूर्ण jQuery प्लगइन में एंडी ई के उत्कृष्ट समाधान बनाने में मेरा छुरा है:

;(function ($) {
    $.extend({      
        getQueryString: function (name) {           
            function parseParams() {
                var params = {},
                    e,
                    a = /\+/g,  // Regex for replacing addition symbol with a space
                    r = /([^&=]+)=?([^&]*)/g,
                    d = function (s) { return decodeURIComponent(s.replace(a, " ")); },
                    q = window.location.search.substring(1);

                while (e = r.exec(q))
                    params[d(e[1])] = d(e[2]);

                return params;
            }

            if (!this.queryStringParams)
                this.queryStringParams = parseParams(); 

            return this.queryStringParams[name];
        }
    });
})(jQuery);

वाक्य रचना है:

var someVar = $.getQueryString('myParam');

दोनों ओर से लाभदायक!


76

यदि आप क्वेरिस्ट्रिंग को पार्स करने की तुलना में अधिक URL हेरफेर कर रहे हैं, तो आपको URI.js मददगार मिल सकता है । यह URL में हेरफेर करने के लिए एक लाइब्रेरी है - और सभी घंटियाँ और सीटी आती हैं। (यहां स्व-विज्ञापन के लिए क्षमा करें)

अपने querystring को एक मानचित्र में बदलने के लिए:

var data = URI('?foo=bar&bar=baz&foo=world').query(true);
data == {
  "foo": ["bar", "world"],
  "bar": "baz"
}

(URI.js भी जैसे खराब क्लेरिस्ट "फिक्स" करता ?&foo&&bar=baz&है ?foo&bar=baz)


// आवश्यक src / URI.fragmentURI.js लोड किया जाना है
जोब

1
+1 URI.js एक बहुत छोटा प्लगइन है। आप var data = URI.parseQuery('?foo=bar&bar=baz&foo=world');उसी परिणाम ( डॉक्स ) के लिए भी कर सकते हैं ।
यारिन

62

मुझे रयान फेलन का समाधान पसंद है । लेकिन मुझे उसके लिए jQuery के विस्तार का कोई मतलब नहीं दिखता है? JQuery कार्यक्षमता का कोई उपयोग नहीं है।

दूसरी ओर, मुझे Google Chrome में अंतर्निहित फ़ंक्शन पसंद है: window.location.getParameter।

तो क्यों नहीं इस का उपयोग करने के लिए? ठीक है, अन्य ब्राउज़रों के पास नहीं है। तो चलो यह फ़ंक्शन बनाते हैं यदि यह मौजूद नहीं है:

if (!window.location.getParameter ) {
  window.location.getParameter = function(key) {
    function parseParams() {
        var params = {},
            e,
            a = /\+/g,  // Regex for replacing addition symbol with a space
            r = /([^&=]+)=?([^&]*)/g,
            d = function (s) { return decodeURIComponent(s.replace(a, " ")); },
            q = window.location.search.substring(1);

        while (e = r.exec(q))
            params[d(e[1])] = d(e[2]);

        return params;
    }

    if (!this.queryStringParams)
        this.queryStringParams = parseParams(); 

    return this.queryStringParams[key];
  };
}

यह फ़ंक्शन रयान फेलन से कम या ज्यादा है, लेकिन इसे अलग तरह से लपेटा गया है: स्पष्ट नाम और अन्य जावास्क्रिप्ट लाइब्रेरी की कोई निर्भरता नहीं। मेरे ब्लॉग पर इस फ़ंक्शन के बारे में अधिक


3
Chrome से window.location.getParameter () जैसा दिखता है।
mhenry1384

54

यहां PHP $ _GET सरणी के समान ऑब्जेक्ट प्राप्त करने का एक तेज़ तरीका है :

function get_query(){
    var url = location.search;
    var qs = url.substring(url.indexOf('?') + 1).split('&');
    for(var i = 0, result = {}; i < qs.length; i++){
        qs[i] = qs[i].split('=');
        result[qs[i][0]] = decodeURIComponent(qs[i][1]);
    }
    return result;
}

उपयोग:

var $_GET = get_query();

क्वेरी स्ट्रिंग के लिए x=5&y&z=hello&x=6यह ऑब्जेक्ट लौटाता है:

{
  x: "6",
  y: undefined,
  z: "hello"
}

अगर आपको इसकी आवश्यकता jQuery प्लगइन के रूप में है, तो यह यहाँ है: (function($) { $.extend({ get_query: function (name) { var url = location.href; var qs = url.substring(url.indexOf('?') + 1).split('&'); for(var i = 0, result = {}; i < qs.length; i++){ qs[i] = qs[i].split('='); result[qs[i][0]] = qs[i][1]; } return result; } }); })(jQuery);और इस तरह का उपयोग करें:$.get_query()
टिम

धन्यवाद। मैंने भी इसका उपयोग करना समाप्त कर दिया। मैंने इसे आपके रिटर्न स्टेटमेंट से पहले जोड़ा था: यदि (परम) रिटर्न रिजल्ट [परम], तो इस तरह मैं भी जरूरत पड़ने पर
get_query

1
अगर आपके पास हैश नहीं है तो काम नहीं कर रहा है। उदाहरण के लिए: test.aspx? Test = t1 # default । {Test: "t1 # default"} लौटेंगे और मुझे उम्मीद है कि {test: "t1"}
बोगदान एम।

@ बोगदानम: वास्तव में। location.hrefके साथ प्रतिस्थापित करना होगा location.search
डैन डैस्केल्स्कु

53

सादे जावास्क्रिप्ट कोड में इसे सरल रखें:

function qs(key) {
    var vars = [], hash;
    var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');
    for(var i = 0; i < hashes.length; i++)
    {
        hash = hashes[i].split('=');
        vars.push(hash[0]);
        vars[hash[0]] = hash[1];
    }
    return vars[key];
}

इसे जावास्क्रिप्ट कोड में कहीं से भी कॉल करें:

var result = qs('someKey');

1
मुझे लगता है कि आप मेरे जैसा ही कुछ कर रहे हैं, लेकिन मुझे लगता है कि मेरा दृष्टिकोण बहुत सरल है stackoverflow.com/a/21152762/985454
Qwerty

मैं आपको (ड्रमोल प्लीज़) से मिलवाता हूँ window.location.search!
एरिक

46

ये सभी महान जवाब हैं, लेकिन मुझे कुछ और मजबूत बनाने की जरूरत है, और मुझे लगता है कि आप सभी ने मुझे बनाया है।

यह एक सरल पुस्तकालय विधि है जो URL मापदंडों के विच्छेदन और हेरफेर करती है। स्थैतिक विधि में निम्नलिखित उप विधियाँ होती हैं जिन्हें विषय URL पर कहा जा सकता है:

  • getHost
  • getPath
  • getHash
  • setHash
  • getParams
  • getQuery
  • setParam
  • getParam
  • hasParam
  • removeParam

उदाहरण:

URLParser(url).getParam('myparam1')

var url = "http://www.test.com/folder/mypage.html?myparam1=1&myparam2=2#something";

function URLParser(u){
    var path="",query="",hash="",params;
    if(u.indexOf("#") > 0){
        hash = u.substr(u.indexOf("#") + 1);
        u = u.substr(0 , u.indexOf("#"));
    }
    if(u.indexOf("?") > 0){
        path = u.substr(0 , u.indexOf("?"));
        query = u.substr(u.indexOf("?") + 1);
        params= query.split('&');
    }else
        path = u;
    return {
        getHost: function(){
            var hostexp = /\/\/([\w.-]*)/;
            var match = hostexp.exec(path);
            if (match != null && match.length > 1)
                return match[1];
            return "";
        },
        getPath: function(){
            var pathexp = /\/\/[\w.-]*(?:\/([^?]*))/;
            var match = pathexp.exec(path);
            if (match != null && match.length > 1)
                return match[1];
            return "";
        },
        getHash: function(){
            return hash;
        },
        getParams: function(){
            return params
        },
        getQuery: function(){
            return query;
        },
        setHash: function(value){
            if(query.length > 0)
                query = "?" + query;
            if(value.length > 0)
                query = query + "#" + value;
            return path + query;
        },
        setParam: function(name, value){
            if(!params){
                params= new Array();
            }
            params.push(name + '=' + value);
            for (var i = 0; i < params.length; i++) {
                if(query.length > 0)
                    query += "&";
                query += params[i];
            }
            if(query.length > 0)
                query = "?" + query;
            if(hash.length > 0)
                query = query + "#" + hash;
            return path + query;
        },
        getParam: function(name){
            if(params){
                for (var i = 0; i < params.length; i++) {
                    var pair = params[i].split('=');
                    if (decodeURIComponent(pair[0]) == name)
                        return decodeURIComponent(pair[1]);
                }
            }
            console.log('Query variable %s not found', name);
        },
        hasParam: function(name){
            if(params){
                for (var i = 0; i < params.length; i++) {
                    var pair = params[i].split('=');
                    if (decodeURIComponent(pair[0]) == name)
                        return true;
                }
            }
            console.log('Query variable %s not found', name);
        },
        removeParam: function(name){
            query = "";
            if(params){
                var newparams = new Array();
                for (var i = 0;i < params.length;i++) {
                    var pair = params[i].split('=');
                    if (decodeURIComponent(pair[0]) != name)
                          newparams .push(params[i]);
                }
                params = newparams;
                for (var i = 0; i < params.length; i++) {
                    if(query.length > 0)
                        query += "&";
                    query += params[i];
                }
            }
            if(query.length > 0)
                query = "?" + query;
            if(hash.length > 0)
                query = query + "#" + hash;
            return path + query;
        },
    }
}


document.write("Host: " + URLParser(url).getHost() + '<br>');
document.write("Path: " + URLParser(url).getPath() + '<br>');
document.write("Query: " + URLParser(url).getQuery() + '<br>');
document.write("Hash: " + URLParser(url).getHash() + '<br>');
document.write("Params Array: " + URLParser(url).getParams() + '<br>');
document.write("Param: " + URLParser(url).getParam('myparam1') + '<br>');
document.write("Has Param: " + URLParser(url).hasParam('myparam1') + '<br>');

document.write(url + '<br>');

// Remove the first parameter
url = URLParser(url).removeParam('myparam1');
document.write(url + ' - Remove the first parameter<br>');

// Add a third parameter
url = URLParser(url).setParam('myparam3',3);
document.write(url + ' - Add a third parameter<br>');

// Remove the second parameter
url = URLParser(url).removeParam('myparam2');
document.write(url + ' - Remove the second parameter<br>');

// Add a hash
url = URLParser(url).setHash('newhash');
document.write(url + ' - Set Hash<br>');

// Remove the last parameter
url = URLParser(url).removeParam('myparam3');
document.write(url + ' - Remove the last parameter<br>');

// Remove a parameter that doesn't exist
url = URLParser(url).removeParam('myparam3');
document.write(url + ' - Remove a parameter that doesn\"t exist<br>');

44

से MDN :

function loadPageVar (sVar) {
  return unescape(window.location.search.replace(new RegExp("^(?:.*[&\\?]" + escape(sVar).replace(/[\.\+\*]/g, "\\$&") + "(?:\\=([^&]*))?)?.*$", "i"), "$1"));
}

alert(loadPageVar("name"));

39

कोड गोल्फ:

var a = location.search&&location.search.substr(1).replace(/\+/gi," ").split("&");
for (var i in a) {
    var s = a[i].split("=");
    a[i]  = a[unescape(s[0])] = unescape(s[1]);
}

इसे प्रदर्शित करें!

for (i in a) {
    document.write(i + ":" + a[i] + "<br/>");   
};

मेरे मैक पर: test.htm?i=can&has=cheezburgerप्रदर्शित करता है

0:can
1:cheezburger
i:can
has:cheezburger

9
मुझे आपका उत्तर पसंद है, विशेष रूप से स्क्रिप्ट कितनी संक्षिप्त है, लेकिन आपको संभवतः डिकोडिकॉमपोनेंट का उपयोग करना चाहिए। देखें xkr.us/articles/javascript/encode-compare और stackoverflow.com/questions/619323/…
plincglen

39

मैं नियमित अभिव्यक्ति का उपयोग बहुत करता हूं, लेकिन इसके लिए नहीं।

मेरे आवेदन में एक बार क्वेरी स्ट्रिंग पढ़ने, और सभी कुंजी / मान जोड़े जैसे ऑब्जेक्ट बनाने के लिए यह मेरे लिए आसान और अधिक कुशल लगता है:

var search = function() {
  var s = window.location.search.substr(1),
    p = s.split(/\&/), l = p.length, kv, r = {};
  if (l === 0) {return false;}
  while (l--) {
    kv = p[l].split(/\=/);
    r[kv[0]] = decodeURIComponent(kv[1] || '') || true;
  }
  return r;
}();

जैसे URL के लिए http://domain.com?param1=val1&param2=val2आप अपने कोड के रूप में search.param1और बाद में उनका मान प्राप्त कर सकते हैं search.param2


38
function GET() {
        var data = [];
        for(x = 0; x < arguments.length; ++x)
            data.push(location.href.match(new RegExp("/\?".concat(arguments[x],"=","([^\n&]*)")))[1])
                return data;
    }


example:
data = GET("id","name","foo");
query string : ?id=3&name=jet&foo=b
returns:
    data[0] // 3
    data[1] // jet
    data[2] // b
or
    alert(GET("id")[0]) // return 3

5
यह एक दिलचस्प दृष्टिकोण है, निर्दिष्ट मापदंडों से मूल्यों वाले एक सरणी को लौटाता है। इसमें कम से कम एक समस्या है - मानों को सही ढंग से निर्धारित नहीं करने वाला URL, और URL को मैच में उपयोग किए जाने वाले पैरामीटर नामों को भी एन्कोड करना होगा। यह अपने वर्तमान रूप में सरल क्वेरी स्ट्रिंग्स पर कार्य करेगा। ps जब में चर घोषित करने वर कीवर्ड का उपयोग करने के लिए मत भूलना के लिए बयान।
एंडी ई

38

रोशाम्बो jQuery विधि डिकोड यूआरएल की देखभाल नहीं कर रहा था

http://snipplr.com/view/26662/get-url-parameters-with-jquery--improved/

रिटर्न स्टेटमेंट में जोड़ते समय उस क्षमता को भी जोड़ा

return decodeURIComponent(results[1].replace(/\+/g, " ")) || 0;

अब आप अपडेट किए गए जिस्ट को पा सकते हैं:

$.urlParam = function(name){
var results = new RegExp('[\\?&]' + name + '=([^&#]*)').exec(window.location.href);
if (!results) { return 0; }
return decodeURIComponent(results[1].replace(/\+/g, " ")) || 0;
}

36

मुझे यह पसंद है (jquery-howto.blogspot.co.uk से लिया गया):

// get an array with all querystring values
// example: var valor = getUrlVars()["valor"];
function getUrlVars() {
    var vars = [], hash;
    var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');
    for (var i = 0; i < hashes.length; i++) {
        hash = hashes[i].split('=');
        vars.push(hash[0]);
        vars[hash[0]] = hash[1];
    }
    return vars;
}

मेरे लिए बहुत अच्छा काम करता है।


36

यहाँ इस उत्कृष्ट उत्तर के लिए मेरा संपादन है - बिना मानों के कुंजी के साथ क्वेरी तार को पार्स करने की अतिरिक्त क्षमता के साथ।

var url = 'http://sb.com/reg/step1?param';
var qs = (function(a) {
    if (a == "") return {};
    var b = {};
    for (var i = 0; i < a.length; ++i) {
        var p=a[i].split('=', 2);
        if (p[1]) p[1] = decodeURIComponent(p[1].replace(/\+/g, " "));
        b[p[0]] = p[1];
    }
    return b;
})((url.split('?'))[1].split('&'));

जरूरी! अंतिम पंक्ति में उस फ़ंक्शन का पैरामीटर अलग है। यह सिर्फ एक उदाहरण है कि कोई व्यक्ति कैसे एक मनमाना URL पास कर सकता है। आप वर्तमान URL को पार्स करने के लिए ब्रूनो के उत्तर से अंतिम पंक्ति का उपयोग कर सकते हैं।

तो क्या बिल्कुल बदल गया? Url के साथ http://sb.com/reg/step1?param=परिणाम समान होंगे। लेकिन url के साथ http://sb.com/reg/step1?paramब्रूनो का समाधान बिना चाबी के एक वस्तु देता है, जबकि मेरा एक कुंजी paramऔर undefinedमूल्य के साथ वस्तु देता है ।


34

मुझे क्वेरी स्ट्रिंग से एक ऑब्जेक्ट की आवश्यकता थी, और मुझे बहुत सारे कोड से नफरत है। यह ब्रह्मांड में सबसे मजबूत नहीं हो सकता है, लेकिन यह कोड की कुछ लाइनें हैं।

var q = {};
location.href.split('?')[1].split('&').forEach(function(i){
    q[i.split('=')[0]]=i.split('=')[1];
});

जैसा URL this.htm?hello=world&foo=barबनाएगा:

{hello:'world', foo:'bar'}

4
साफ। हालांकि, मोज़िला के अनुसार, IE7 या 8 पर forEach काम नहीं करता है और मुझे संदेह है कि अगर कोई क्वेरी स्ट्रिंग नहीं है तो यह खत्म हो जाएगा। एक न्यूनतम सुधार जो अधिक मामलों को कवर करेगा, वह decodeURIComponentआपके द्वारा संग्रहित मूल्य के रूप में होगा - और यकीनन कुंजी भी।
रुप

1
अच्छा और सरल। सरणी मापदंडों को नहीं संभालती है और न ही ?a&b&cयह वास्तव में बहुत पठनीय है (और संयोग से मेरे पहले विचार के समान है)। इसके अलावा splitबेमानी है, लेकिन मुझे 10 चरित्र स्ट्रिंग को दो बार विभाजित करने की तुलना में तलना करने के लिए बड़ी प्रदर्शन मछली मिली है।
cod3monk3y

1
जब querystring "है? हैलो = दुनिया और एक = एक = बी और दो = 2" तब जब आप 'एक' के मूल्य को पकड़ते हैं तो आपको केवल मूल्य में पहले '=' से पहले भाग मिलता है। इसका मान शूद्र 'a = b' होना चाहिए, लेकिन आपको केवल 'a' ही मिलता है क्योंकि आप '=' a 'b' को '=' पर विभाजित करते हैं। यह बस छोटी गाड़ी है। : (
शॉन कोवाक

2
मैं अंतिम क्वेरी पैरामीटर के साथ हैश ( ) को लेने से बचने के location.search.substr(1)बजाय उपयोग करूंगा । location.href.split('?')[1]#anchor
3

हाँ, मुझे भी आपको मिलवा दो location.search!
एरिक

32

यहां एंडी ई के लिंक किए गए "हैंडल सरणी-स्टाइल क्वेरी स्ट्रिंग्स" -version का विस्तारित संस्करण है। एक बग फिक्स्ड ( ?key=1&key[]=2&key[]=3; 1खो दिया है और साथ बदल दिया है [2,3]), कुछ मामूली प्रदर्शन सुधार किया (मूल्यों की फिर से डिकोडिंग, recalculating "[" स्थिति, आदि) (क्रियाशील, के लिए समर्थन और सुधार के एक नंबर जोड़ा ?key=1&key=2के लिए, समर्थन ;सीमांकक) । मैंने चरों को झुंझलाहट से छोटा छोड़ दिया, लेकिन उन्हें पठनीय बनाने के लिए टिप्पणियां जोड़ दीं (ओह, और मैंने vस्थानीय कार्यों के भीतर पुन: उपयोग किया , क्षमा करें यदि यह भ्रामक है;)।

यह निम्नलिखित क्वेरिस्ट्रिंग को संभालेगा ...

? परीक्षण = नमस्ते और व्यक्ति = Neek और व्यक्ति [] = जेफ और व्यक्ति [] = जिम और व्यक्ति [अतिरिक्त] = जॉन और test3 और nocache = 1398914891264

... इसे एक ऐसी वस्तु में बनाना जो दिखता है ...

{
    "test": "Hello",
    "person": {
        "0": "neek",
        "1": "jeff",
        "2": "jim",
        "length": 3,
        "extra": "john"
    },
    "test3": "",
    "nocache": "1398914891264"
}

जैसा कि आप ऊपर देख सकते हैं, यह संस्करण "विकृत" सरणियों के कुछ माप को संभालता है, अर्थात - person=neek&person[]=jeff&person[]=jimया person=neek&person=jeff&person=jimजैसा कि कुंजी पहचानने योग्य और वैध है (कम से कम डॉटनेट के नेमवेल्यूकोलेक्शनियन में जोड़ें ):

यदि निर्दिष्ट कुंजी पहले से ही टारगेट NameValueCollection उदाहरण में मौजूद है, तो निर्दिष्ट मान को मौजूदा अल्पविराम से अलग की गई मानों की सूची में जोड़ा गया है "मान 1, मान 2, मान 3"।

ऐसा लगता है कि जूरी बार-बार चाबी पर बाहर है क्योंकि कोई कल्पना नहीं है। इस स्थिति में, एकाधिक कुंजियों को एक (नकली) सरणी के रूप में संग्रहीत किया जाता है। लेकिन ध्यान दें कि मैं कॉमन एरेस के आधार पर मानों को संसाधित नहीं करता

कोड:

getQueryStringKey = function(key) {
    return getQueryStringAsObject()[key];
};


getQueryStringAsObject = function() {
    var b, cv, e, k, ma, sk, v, r = {},
        d = function (v) { return decodeURIComponent(v).replace(/\+/g, " "); }, //# d(ecode) the v(alue)
        q = window.location.search.substring(1), //# suggested: q = decodeURIComponent(window.location.search.substring(1)),
        s = /([^&;=]+)=?([^&;]*)/g //# original regex that does not allow for ; as a delimiter:   /([^&=]+)=?([^&]*)/g
    ;

    //# ma(make array) out of the v(alue)
    ma = function(v) {
        //# If the passed v(alue) hasn't been setup as an object
        if (typeof v != "object") {
            //# Grab the cv(current value) then setup the v(alue) as an object
            cv = v;
            v = {};
            v.length = 0;

            //# If there was a cv(current value), .push it into the new v(alue)'s array
            //#     NOTE: This may or may not be 100% logical to do... but it's better than loosing the original value
            if (cv) { Array.prototype.push.call(v, cv); }
        }
        return v;
    };

    //# While we still have key-value e(ntries) from the q(uerystring) via the s(earch regex)...
    while (e = s.exec(q)) { //# while((e = s.exec(q)) !== null) {
        //# Collect the open b(racket) location (if any) then set the d(ecoded) v(alue) from the above split key-value e(ntry) 
        b = e[1].indexOf("[");
        v = d(e[2]);

        //# As long as this is NOT a hash[]-style key-value e(ntry)
        if (b < 0) { //# b == "-1"
            //# d(ecode) the simple k(ey)
            k = d(e[1]);

            //# If the k(ey) already exists
            if (r[k]) {
                //# ma(make array) out of the k(ey) then .push the v(alue) into the k(ey)'s array in the r(eturn value)
                r[k] = ma(r[k]);
                Array.prototype.push.call(r[k], v);
            }
            //# Else this is a new k(ey), so just add the k(ey)/v(alue) into the r(eturn value)
            else {
                r[k] = v;
            }
        }
        //# Else we've got ourselves a hash[]-style key-value e(ntry) 
        else {
            //# Collect the d(ecoded) k(ey) and the d(ecoded) sk(sub-key) based on the b(racket) locations
            k = d(e[1].slice(0, b));
            sk = d(e[1].slice(b + 1, e[1].indexOf("]", b)));

            //# ma(make array) out of the k(ey) 
            r[k] = ma(r[k]);

            //# If we have a sk(sub-key), plug the v(alue) into it
            if (sk) { r[k][sk] = v; }
            //# Else .push the v(alue) into the k(ey)'s array
            else { Array.prototype.push.call(r[k], v); }
        }
    }

    //# Return the r(eturn value)
    return r;
};

क्वेरी स्ट्रिंग मान प्राप्त करने के लिए आप "GetParameterValues" फ़ंक्शन का उपयोग कर सकते हैं। इसमें आपको बस क्वेरी हलचल पैरामीटर नाम पास करना होगा और यह आपको $ मूल्य (दस्तावेज़) लौटा देगा। पहले से ही (फ़ंक्शन () {var बोली = GetParameterValues ​​('token');}); फ़ंक्शन GetParameterValues ​​(परम) {var url = decodeURIComponent (window.location.ref); url = url.slice (url.indexOf ('?') + 1) .plplit ('&'); for (var i = 0; मैं <url.length; i ++) {var urlparam = url [i] .split ('='); if (urlparam [0] == param) {वापसी urlparam [1]; }}
माइक क्लार्क

1
मैं कुछ समय के लिए इसका उपयोग कर रहा हूं, और यह अब तक बहुत अच्छा रहा है। Urlencoded सरणियों को संभालने के लिए छोड़कर। का उपयोग q = decodeURIComponent(window.location.search.substring(1)),करने से यह भी करने में मदद करता है।
व्लादिस्लाव दिमित्रोव

31

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

मैं इस के एक संपीड़ित संस्करण का उपयोग करता हूं। मैं नौसिखिया प्रकारों के लिए असम्पीडित पोस्ट कर रहा हूँ ताकि बेहतर समझा जा सके कि क्या हो रहा है

मुझे यकीन है कि यह तेजी से काम करने के लिए अनुकूलित किया जा सकता है या अलग तरह से किया जा सकता है, लेकिन मुझे जो भी चाहिए उसके लिए यह हमेशा बहुत काम आया है।

का आनंद लें।

function getQSP(sName, sURL) {
    var theItmToRtn = "";
    var theSrchStrg = location.search;
    if (sURL) theSrchStrg = sURL;
    var sOrig = theSrchStrg;
    theSrchStrg = theSrchStrg.toUpperCase();
    sName = sName.toUpperCase();
    theSrchStrg = theSrchStrg.replace("?", "&") theSrchStrg = theSrchStrg + "&";
    var theSrchToken = "&" + sName + "=";
    if (theSrchStrg.indexOf(theSrchToken) != -1) {
        var theSrchTokenLth = theSrchToken.length;
        var theSrchTokenLocStart = theSrchStrg.indexOf(theSrchToken) + theSrchTokenLth;
        var theLocOfNextAndSign = theSrchStrg.indexOf("&", theSrchTokenLocStart);
        theItmToRtn = unescape(sOrig.substring(theSrchTokenLocStart, theLocOfNextAndSign));
    }
    return unescape(theItmToRtn);
}

इसके अलावा, unescape () के बजाय decodeURI () या decodeURIComponent () के लिए जाना बेहतर है। developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
आदर्श कोनचेडी

27

हमने अभी-अभी arg.js जारी किया है , जिसका उद्देश्य एक बार और सभी के लिए इस समस्या को हल करना है। यह पारंपरिक रूप से इतना कठिन रहा है लेकिन अब आप यह कर सकते हैं:

var name = Arg.get("name");

या पूरी बहुत मिल रही है:

var params = Arg.all();

और यदि आप के बीच अंतर के बारे में परवाह है ?query=trueऔर #hash=trueफिर आप Arg.query()और Arg.hash()विधियों का उपयोग कर सकते हैं ।


आपने मुझे बचा लिया यार .. arg.js समाधान है कोई भी समाधान IE 8 में # से मान प्राप्त नहीं कर रहा है .. :( किसी भी IE8 के लिए खोज # अनुरोध से यह समाधान है ..
दिलीप राजकुमार

27

उस प्रश्न पर शीर्ष उत्तर के साथ समस्या यह है कि यह # के बाद रखा-समर्थित पैरामीटर नहीं है, लेकिन कभी-कभी यह मान भी आवश्यक है।

मैंने उत्तर को संशोधित करने के लिए इसे एक हैश चिन्ह के साथ पूर्ण क्वेरी स्ट्रिंग पार्स करने दिया:

var getQueryStringData = function(name) {
    var result = null;
    var regexS = "[\\?&#]" + name + "=([^&#]*)";
    var regex = new RegExp(regexS);
    var results = regex.exec('?' + window.location.href.split('?')[1]);
    if (results != null) {
        result = decodeURIComponent(results[1].replace(/\+/g, " "));
    }
    return result;
};

1
यह दिलचस्प है अगर आपको इसकी आवश्यकता है, लेकिन हैश भाग AFAIK के प्रारूप के लिए कोई मानक नहीं है, तो यह उचित नहीं है कि इसे दूसरे उत्तर की कमजोरी के रूप में कहें।
रूप

2
हाँ मैं जानता हूँ। लेकिन मेरे ऐप में मैं 3rd पार्टी जेएस नेविगेशन को एकीकृत करता हूं, जिसमें हैश साइन के बाद कुछ पैरामीटर हैं।
Ph0en1x

उदाहरण के लिए, Google खोज पृष्ठ में, खोज क्वेरी हैश साइन '#' के बाद है।
एटोरस

25
function GetQueryStringParams(sParam)
{
    var sPageURL = window.location.search.substring(1);
    var sURLVariables = sPageURL.split('&');

    for (var i = 0; i < sURLVariables.length; i++)
    {
        var sParameterName = sURLVariables[i].split('=');
        if (sParameterName[0] == sParam)
        {
            return sParameterName[1];
        }
    }
}​

और यह है कि आप इस फ़ंक्शन को URL मानकर कैसे उपयोग कर सकते हैं

http://dummy.com/?stringtext=jquery&stringword=jquerybyexample

var tech = GetQueryStringParams('stringtext');
var blog = GetQueryStringParams('stringword');

इस दृष्टिकोण के कुछ कार्यान्वयन यहाँ पहले से ही हैं। बहुत कम से कम आपको परिणाम मान को डीकोड करने की आवश्यकता है ()। यदि आप कोई मान निर्दिष्ट नहीं करते हैं, तो यह भी दुर्व्यवहार हो सकता है ?stringtext&stringword=foo
Rup

24

यदि आप Browserify का उपयोग कर रहे हैं, तो आप Node.jsurl से मॉड्यूल का उपयोग कर सकते हैं :

var url = require('url');

url.parse('http://example.com/?bob=123', true).query;

// returns { "bob": "123" }

आगे पढ़ने: URL Node.js v0.12.2 मैनुअल और प्रलेखन

EDIT: आप URL इंटरफ़ेस का उपयोग कर सकते हैं , यह काफी व्यापक रूप से लगभग सभी नए ब्राउज़र में अपनाया गया है और यदि कोड किसी पुराने ब्राउज़र पर चलने वाला है तो आप इस तरह के पॉलीफ़िल का उपयोग कर सकते हैं । क्वेरी पैरामीटर (उर्फ खोज पैरामीटर) प्राप्त करने के लिए URL इंटरफ़ेस का उपयोग करने के तरीके के बारे में एक कोड उदाहरण यहां दिया गया है

const url = new URL('http://example.com/?bob=123');
url.searchParams.get('bob'); 

आप इसके लिए URLSearchParams का उपयोग भी कर सकते हैं, यहाँ MDS से एक उदाहरण URLSearchParams के साथ किया जा सकता है:

var paramsString = "q=URLUtils.searchParams&topic=api";
var searchParams = new URLSearchParams(paramsString);

//Iterate the search parameters.
for (let p of searchParams) {
  console.log(p);
}

searchParams.has("topic") === true; // true
searchParams.get("topic") === "api"; // true
searchParams.getAll("topic"); // ["api"]
searchParams.get("foo") === null; // true
searchParams.append("topic", "webdev");
searchParams.toString(); // "q=URLUtils.searchParams&topic=api&topic=webdev"
searchParams.set("topic", "More webdev");
searchParams.toString(); // "q=URLUtils.searchParams&topic=More+webdev"
searchParams.delete("topic");
searchParams.toString(); // "q=URLUtils.searchParams"

urlमॉड्यूल के एपीआई के लिए दस्तावेज़ीकरण यहाँ है: nodejs.org/api/url.html
andrezsanchez

यह nw.js विकास के लिए अच्छा है। ब्राउजर की जरूरत भी नहीं है क्योंकि अधिकांश नोड मॉड्यूल काम करते हैं जैसा कि nw.js विंडो में है। मैंने इस कोड का परीक्षण किया है और बिना किसी संशोधन के एक आकर्षण की तरह काम करता है।
एंड्रयू ग्रोटे

ओह, यह कमाल है! URLSearchParams सही काम करता है। बहुत धन्यवाद!
बारां इमरे

1
शायद सबसे अच्छा मतदान होना चाहिए, कस्टम कार्यों और अतिरिक्त पुस्तकालयों के साथ कोई परेशानी नहीं। यह ज्यादातर ब्राउज़र 2019 द्वारा अपनाया गया लगता है।
TheWhiteLlama
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.