URL 매개 변수를 JavaScript 객체로 변환하는 방법


223

다음과 같은 문자열이 있습니다.

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

이와 같은 JavaScript 객체로 변환하려면 어떻게해야합니까?

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


1
그것은 아니다 : developer.mozilla.org/en-US/docs/Web/API/URLSearchParams/... developer.mozilla.org/en-US/docs/Web/API/URL/... (우리가 기다려야 할 것입니다하지만 모든 브라우저가 이것을 선택하는 데 시간이 조금 더
Arthur

답변:


334

편집하다

이 편집은 주석을 기반으로 답변을 개선하고 설명합니다.

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

abc=foo&def=%5Basf%5D&xyz=55 단계로 구문 분석 하십시오.

  • decodeURI : abc = foo & def = [asf] & xyz = 5
  • 따옴표 탈출 : 따옴표가 없으므로 동일
  • 대체 : abc=foo","def=[asf]","xyz=5
  • 교체 = : abc":"foo","def":"[asf]","xyz":"5
  • curlies와 따옴표가있는 서라운드 : {"abc":"foo","def":"[asf]","xyz":"5"}

이것은 합법적 인 JSON입니다.

개선 솔루션은 검색 문자열에서 더 많은 문자 수 있습니다. URI 디코딩에 reviver 함수를 사용합니다.

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에서 작동하려면 정규 표현식에서 '='를 이스케이프하십시오. .replace (/ \ = / g, "\": \ "")
airlok

175
그것은 하나의 라이너가 아닙니다. 그것은 우주 정거장입니다.
Ziggy

5
사용하면 더 좋습니다JSON.parse('{"' + decodeURI(location.search.substring(1).replace(/&/g, "\",\"").replace(/=/g, "\":\"")) + '"}')
Daniël Tulp

4
구문 분석 할 URL에 등호 기호 문자가 있으면 실패합니다. 예 : "cookie = dlksdlfj = sodkfjhsdlfj"
jholloman

3
값이없는 매개 변수 중 하나가있는 경우에도 작동하지 않습니다.
Sych

113

2020 ES6 / 7 / 8 및 접근

ES6 이상부터 Javascript는이 문제에 대한 성능 솔루션을 만들기 위해 여러 가지 구성을 제공합니다.

여기에는 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 리드

1
미안하지만 논리와는 아무런 관련이 없습니다. search stringURL과는 상관없이 파서 (parser) 라고 주장 할 수도 있습니다. – URL과 관련이있는
실리카 케익

Object.fromEntries반복 키에는 작동하지 않습니다. 우리가 같은 ?foo=bar1&foo=bar2일을 하려고한다면 우리 는 오직 얻을 것이다 { foo: 'bar2' }. 예를 들어 Node.js 요청 객체는 다음과 같이 구문 분석합니다.{ foo: ['bar1', 'bar2'] }
Siipe

당신 맞아요 그러나이 더 사양이 없으며 많은 언어들이 그것을 구문 분석 방법 등의 독단적 인 접근을 : stackoverflow.com/a/1746566/1194694
silicakes을

이것은 나에게는 좋아 보이지만 반복 키의 값을 얻기 위해 우리는 이것을 사용할 수 있습니다 let temp={};Object.keys(params).map(key=>{temp[key]=urlParams.getAll(key)})
Tirumaleshwar Keregadde

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: "" }
Seph Reed

1
질문에서 알 수 있듯이 전체 URL이 아닌 "foo = bar & hello = % 40world & showThing"과 같은 쿼리 문자열 (location.search의)과 함께 사용해야합니다.

1
이 사용할 수 있지만,주의 할 ?someValue=false됩니다{ someValue: "false" }
사이먼

반복 키에는 작동하지 않습니다. 우리가 같은 ?foo=bar1&foo=bar2일을 하려고한다면 우리 는 오직 얻을 것이다 { foo: 'bar2' }. Node.js 요청 객체는 다음과 같이 구문 분석합니다.{ foo: ['bar1', 'bar2'] }
Siipe

@SephReed, 귀하의 의견은 다음을 사용하는 업데이트 된 버전으로 해결 될 것으로 생각합니다.location.search
KyleMit

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

이것은 John Resig의 "Search and Do n't Replace"에서 수정되었습니다 .


tx! 또한 왼쪽에 decodeURIComponen (p [0])을 추가해야합니다. :
Alex

첫 번째 예제는 빈 쿼리 문자열에서 작동하지 않습니다.
Michał Perłakowski

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

@Alex-업데이트 된 코드 또는 원본을 사용 했습니까? 원본에는 한 가지 문제와 오타가있었습니다.
Justin Niessner

값에 '='이 포함되어 있으면 매개 변수를 올바르게 처리 할 수 ​​없습니다. 값을 먼저 '='로 자릅니다.
Greck

JSON.parse('{"' + decodeURIComponent(query.replace(/"/g, '\\"').replace(/&/g, '","').replace(/=/g,'":"') + '"}'));나를 위해 작동
Danil Gaponov

1
그것의 작동하지 name[]=test1&name[]=test2않으며 결과name[]=test2
Rafee

10

내가 발견 $ .String.deparam에게 가장 완벽한 사전 구축 솔루션을 (등 중첩 된 객체를 할 수 있습니다). 설명서를 확인하십시오 .


입력이 항상 직렬화 된 쿼리 문자열이 될 것인지 지적하면 중첩에 대해 걱정할 필요가 없으며 더 가벼운 솔루션이 더 좋습니다.
Mattacular

물론 ... 이미 수행되고 테스트되었습니다 (예 : 초기 답변에서 URI 디코딩을 잊어 버리십시오-처음에는 보이는 것보다 훨씬 복잡하게 만드는 작은 문제입니다).
Daff

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()
Seph Reed

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 ) 단순화를 위해 lodash의.

searchParams.entries () 반복자에 액세스 할 수 있으므로보다 호환 가능한 솔루션을 쉽게 작성할 수 있습니다 .


6

나는 같은 문제가 있었고 여기서 해결책을 시도했지만 URL 매개 변수에 다음과 같이 배열이 있었기 때문에 실제로 작동하지 않았습니다.

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

그래서 URI에서 매개 변수로 배열을 만드는 자체 JS 함수를 작성했습니다.

/**
 * 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 매개 변수가 다음과 같은 경우 "[]"가 객체에 그대로 유지되는 방법을 좋아하지 않았습니다. bacon [] = eggs & bacon [] = toast. 후 나는 라인에 추가 그래서 if(chunk[0].search("\\[\\]") !== -1) {그가되어chunk[0]=chunk[0].replace(/\[\]$/,'');
rgbflawed

@rgbflawed 당신은 미래의 독자와 가독성을 위해 답변을 편집해야합니다
Webwoman

누군가가 할 수 있기 때문에 const대신 사용 하면 코드가 엉망이됩니다. 당신이 사용하는 경우 누군가 가 오류를 만들면 상수 변수에 값을 할당 할 수 없습니다. varcreateObjFromURI = 'some text'constcreateObjFromURI = '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})
Allan Lei

나는 당신의 제안 Allan Lei를 좋아합니다. 나는 내 대답을 업데이 트
fadomire

3

URLSearchParamsJavaScript 웹 API를 사용하면 매우 쉽습니다 .

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에서는 지원되지 않습니다



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 플러그인은 전체 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 / 정규식 솔루션은이 엉뚱한 URL에서 구문 오류를 발생시킵니다.
?a=aa&b=bb&c=&=dd&e
Object {a: "aa", b: "bb", c: ""}


1

여기에 빠르고 더러운 버전이 있습니다. 기본적으로 '&'로 구분 된 URL 매개 변수를 배열 요소로 분할 한 다음 '='로 구분 된 키 / 값 쌍을 객체에 추가하여 해당 배열을 반복합니다. encodeURIComponent ()를 사용하여 인코딩 된 문자를 해당하는 일반 문자열로 변환합니다 (따라서 % 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 년)을 정말로 좋아합니다. 화살표 기능을 polyfill (또는 전통적인 기능으로 다시 작성)한다면, 이것이 브라우저간에 잘 작동한다고 생각합니다.
Scribblemacher

@Scribblemacher 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

위에 구축 마이크 원인이되는 사람의 대답은 내가 고려 동일한 키를 가진 여러 PARAMS (소요이 기능을했습니다 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"]
}


1

console.log(decodeURI('abc=foo&def=%5Basf%5D&xyz=5')
  .split('&')
  .reduce((result, current) => {
    const [key, value] = current.split('=');

    result[key] = value;

    return result
  }, {}))


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

답변을 병합하십시오. 다른 것을 편집 한 다음이 것을 삭제하십시오.
Bergi

0

또한 처리하는 데 필요한 +(URL의 쿼리 부분에 decodeURIComponent하지 않습니다 내가되기 위해 볼프강의 코드를 적용) : 그래서,

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를 사용하여 URL 준비 양식 매개 변수를 가져 오고이 트릭을 사용하여 객체를 작성하고 객체에서 매개 변수를 쉽게 업데이트하고 쿼리 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 함수 ( https://locutus.io/php/strings/parse_str/ )를 기반으로 합니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.