Обратная функция $ .param () в JavaScript / jQuery


122

Учитывая следующую форму:

<form>
    <input name="foo" value="bar">
    <input name="hello" value="hello world">
</form>

Я могу использовать $.param( .. )конструкцию для сериализации формы:

$.param( $('form input') )

=> foo=bar&hello=hello+world

Как я могу десериализовать указанную выше строку с помощью JavaScript и получить обратно хэш?

Например,

$.magicFunction("foo=bar&hello=hello+world")

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

Ссылка: jQuery.param( obj ).


2
Эй, я просто добавляю этот комментарий, чтобы вы могли увидеть обновление, которое я сделал для кода, на случай, если вы его используете ... Я случайно написал его, чтобы он заменил только первое +. Теперь он заменяет их все!
— Blixt

Есть плагины под названием QueryString. Я сделал один, но он не принимает параметры, он только читает из window.location.search. Я помню других, которые принимают параметры ...
— BrunoLM

1
рефакторинг jquery BBQ deparam () как модуль NPM без зависимостей npmjs.com/package/deparam
— alexey2baranov

alexey2baranov как насчет рефакторинга deparam () без NPM как зависимости? :)
— Эндрю

Ответы:


62

Вы должны использовать JQuery BBQ «s deparam функцию. Это хорошо протестировано и задокументировано.


Хороший плагин! Спасибо, что поделился.
— Джонатан

29
Если вы не хотите получать весь плагин BBQ, функция deparam была извлечена как отдельный плагин здесь: github.com/chrissrogers/jquery-deparam
— Фелипе Кастро

2
К сожалению, на странице github не было обновлений годами, и когда я попробовал, она не показалась совместимой с последней версией jQuery ... Но похоже, что мне нужно.
— pilavdzice

31

Это немного измененная версия функции, которую я написал недавно, чтобы сделать что-то подобное.

var QueryStringToHash = function QueryStringToHash  (query) {
  var query_string = {};
  var vars = query.split("&");
  for (var i=0;i<vars.length;i++) {
    var pair = vars[i].split("=");
    pair[0] = decodeURIComponent(pair[0]);
    pair[1] = decodeURIComponent(pair[1]);
        // If first entry with this name
    if (typeof query_string[pair[0]] === "undefined") {
      query_string[pair[0]] = pair[1];
        // If second entry with this name
    } else if (typeof query_string[pair[0]] === "string") {
      var arr = [ query_string[pair[0]], pair[1] ];
      query_string[pair[0]] = arr;
        // If third or later entry with this name
    } else {
      query_string[pair[0]].push(pair[1]);
    }
  } 
  return query_string;
};

1
Именно то, что я подумал, с принятым ответом «с массивами работать не будет». Ваше решение работает нормально.
— Роберт Коритник,

20

Как насчет этого краткого функционального подхода?

function parseParams(str) {
    return str.split('&').reduce(function (params, param) {
        var paramSplit = param.split('=').map(function (value) {
            return decodeURIComponent(value.replace(/\+/g, ' '));
        });
        params[paramSplit[0]] = paramSplit[1];
        return params;
    }, {});
}

Пример:

parseParams("this=is&just=an&example") // Object {this: "is", just: "an", example: undefined}

1
Это должен быть принятый ответ, без внешних зависимостей.
— Майкл Робинсон

Простое, надежное и мощное решение. Респект, сэр.
— fmquaglia

5
Для того, что он делает, это, безусловно, хорошее решение. Но он не заботится о передаваемых массивах или объектах. URL-адрес field[][]=a&field[0][]=b&field[0][]=cобрабатывается так, как Object { field[][]: "a", field[0][]: "c" }должен resultobject.field[0] = Array [ "a", "b", "c" ]. Это поведение, ожидаемое от PHP. Решение @ JackyLi позаботится об этом.
— cars10m 05

16

Мой ответ:

function(query){
  var setValue = function(root, path, value){
    if(path.length > 1){
      var dir = path.shift();
      if( typeof root[dir] == 'undefined' ){
        root[dir] = path[0] == '' ? [] : {};
      }

      arguments.callee(root[dir], path, value);
    }else{
      if( root instanceof Array ){
        root.push(value);
      }else{
        root[path] = value;
      }
    }
  };
  var nvp = query.split('&');
  var data = {};
  for( var i = 0 ; i < nvp.length ; i++ ){
    var pair = nvp[i].split('=');
    var name = decodeURIComponent(pair[0]);
    var value = decodeURIComponent(pair[1]);

    var path = name.match(/(^[^\[]+)(\[.*\]$)?/);
    var first = path[1];
    if(path[2]){
      //case of 'array[level1]' || 'array[level1][level2]'
      path = path[2].match(/(?=\[(.*)\]$)/)[1].split('][')
    }else{
      //case of 'name'
      path = [];
    }
    path.unshift(first);

    setValue(data, path, value);
  }
  return data;
}

Да! Да! Да! Это именно то, что мне нужно для анализа параметров, отправляемых JQuery в вызове $ .ajax. Это возвращает правильно вложенные хэши. Большое спасибо, Джеки Ли!
— Паскаль Линделауф

Лучшее решение на данный момент - ведет себя довольно хорошо! Но когда я использую, JSON.stringify(geturlargs('fld[2][]=2&fld[][]=3&fld[3][]=4&fld[]=bb&fld[]=cc').fld)я получаю {"2":["2"],"3":["4"],"":"cc"}не [null,null,[2],[3,4],"bb","cc"]то, на что надеялся (это то, что мне дал PHP).
— cars10m 05

1
Это ПРАВИЛЬНЫЙ ответ, и, пожалуйста, игнорируйте все другие ответы, они не работают должным образом
— Эндрю

1
Этот ответ - единственный, который касается моего конкретного варианта использования (где я передал объект с вложенными ключами / значениями в jQuery $ .param, это правильно гидратирует эти значения при извлечении).
— delinear

9

Я использую ответ Дэвида Дорварда и понял, что он не ведет себя как PHP или Ruby on Rails, как они анализируют параметры:

1) переменная является массивом, только если она заканчивается [], например ?choice[]=1&choice[]=12, not, когда она?a=1&a=2

2) когда существует несколько параметров с тем же именем, более поздние заменяют более ранние, как на серверах PHP (Ruby on Rails сохраняет первый и игнорирует более поздние), например ?a=1&b=2&a=3

Итак, изменяя версию Дэвида, у меня есть:

function QueryStringToHash(query) {

  if (query == '') return null;

  var hash = {};

  var vars = query.split("&");

  for (var i = 0; i < vars.length; i++) {
    var pair = vars[i].split("=");
    var k = decodeURIComponent(pair[0]);
    var v = decodeURIComponent(pair[1]);

    // If it is the first entry with this name
    if (typeof hash[k] === "undefined") {

      if (k.substr(k.length-2) != '[]')  // not end with []. cannot use negative index as IE doesn't understand it
        hash[k] = v;
      else
        hash[k.substr(0, k.length-2)] = [v];

    // If subsequent entry with this name and not array
    } else if (typeof hash[k] === "string") {
      hash[k] = v;  // replace it

    // If subsequent entry with this name and is array
    } else {
      hash[k.substr(0, k.length-2)].push(v);
    }
  } 
  return hash;
};

который протестирован достаточно тщательно.


Спецификация uri заключается в том, что? A = 1 & a = 2 должен быть массивом. Ruby on Rails и PHP не соответствуют фактической спецификации.
— adiktofsugar

Строка, в которую вы добавляете массив, должна быть hash[k.substr(0, k.length-2)] = [v];иhash[k.substr(0, k.length-2)].push(v);
— Baptiste Pernet

Было бы неплохо, если бы это можно было сделать доступным через npm
— Эрик ван Велзен,

7

Я знаю, что это старая ветка, но, может быть, она все еще актуальна?

Вдохновленный хорошим решением Джеки Ли, я попробовал небольшое собственное изменение, чтобы также иметь возможность обрабатывать произвольные комбинации массивов и объектов в качестве входных данных. Я посмотрел, как PHP мог бы это сделать, и попытался добиться чего-то «похожего». Вот мой код:

function getargs(str){
   var ret={};
   function build(urlnam,urlval,obj){ // extend the return object ...
    var i,k,o=obj, x, rx=/\[([^\]]*)\]/g, idx=[urlnam.replace(rx,'')];
    while (x=rx.exec(urlnam)) idx.push(x[1]); 
    while(true){
     k=idx.shift();
     if(k.trim()=='') {// key is empty: autoincremented index
       if (o.constructor.name=='Array') k=o.length; // for Array
       else if (o===obj ) {k=null}  // for first level property name
       else {k=-1;                                  // for Object
         for(i in o) if (+i>k) k=+i;
         k++;
       }
     }
     if(idx.length) { 
       // set up an array if the next key (idx[0]) appears to be
       // numeric or empty, otherwise set up an object:
       if (o[k]==null || typeof o[k]!='object') o[k]=isNaN(idx[0])?{}:[]; 
       o=o[k]; // move on to the next level
     }
     else { // OK, time to store the urlval in its chosen place ...
       // console.log('key',k,'val',urlval);                 
       o[k]=urlval===""?null:urlval; break; // ... and leave the while loop.
     } 
    }
    return obj;
   }
   // ncnvt: is a flag that governs the conversion of
   // numeric strings into numbers
   var ncnvt=true,i,k,p,v,argarr=[],
       ar=(str||window.location.search.substring(1)).split("&"),
       l=ar.length;
   for (i=0;i<l;i++) {if (ar[i]==="") continue;
     p=ar[i].split("=");k=decodeURIComponent(p[0]);
     v=p[1];v=(v!=null)?decodeURIComponent(v.replace(/\+/g,'%20')):'';
     if (ncnvt && v.trim()>"" && !isNaN(v)) v-=0;
     argarr.push([k,v]);  // array: key-value-pairs of all arguments
   }
   for (i=0,l=argarr.length;i<l;i++) build(argarr[i][0],argarr[i][1],ret);
   return ret;
}

Если функция вызывается без strаргумента -аргумента, она будет считаться window.location.search.slice(1)входной.

Некоторые примеры:

['a=1&a=2',                               // 1
 'x[y][0][z][]=1',                        // 2
 'hello=[%22world%22]&world=hello',       // 3
 'a=1&a=2&&b&c=3&d=&=e&',                 // 4
 'fld[2][]=2&fld[][]=3&fld[3][]=4&fld[]=bb&fld[]=cc',  // 5
 $.param({a:[[1,2],[3,4],{aa:'one',bb:'two'},[5,6]]}), // 6
 'a[]=hi&a[]=2&a[3][]=7&a[3][]=99&a[]=13',// 7
 'a[x]=hi&a[]=2&a[3][]=7&a[3][]=99&a[]=13'// 8
].map(function(v){return JSON.stringify(getargs(v));}).join('\n')

приводит к

{"a":2}                                    // 1
{"x":{"y":[{"z":[1]}]}}                    // 2
{"hello":"[\"world\"]","world":"hello"}    // 3
{"a":2,"b":null,"c":3,"d":null,"null":"e"} // 4 = { a: 2, b: null, c: 3, d: null, null: "e" }
{"fld":[null,null,[2],[3,4],"bb","cc"]}    // 5 
{"a":[[1,2],[3,4],{"aa":"one","bb":"two"},[5,6]]}  // 6
{"a":["hi",2,null,[7,99],13]}              // 7
{"a":{"0":2,"3":[7,99],"4":13,"x":"hi"}}   // 8

В то время как решение Джеки Ли позволило бы создать внешний контейнер для a как простой объект.

{a:{"0":["1","2"],"1":["3","4"],"2":["5","6"]}} // 6: JackyLi's output

getargs() смотрит на первый заданный индекс для любого уровня, чтобы определить, будет ли этот уровень объектом (нечисловым индексом) или массивом (числовым или пустым), в результате чего будет получен результат, как показано в листинге bove (№ 6).

Если текущий объект является массивом, то nulls вставляются везде, где необходимо, для представления пустых позиций. Массивы всегда нумеруются последовательно и отсчитываются от нуля).

Обратите внимание, что в примере нет. 8 «автоинкремент» для пустых индексов по-прежнему работает, хотя сейчас мы имеем дело с объектом, а не массивом.

Насколько я тестировал, мой getargs()ведет себя почти так же, как отличный $.deparam() плагин jQuery Крисса Роджера, упомянутый в принятом ответе. Основное отличие заключается в том, что он getargsработает без jQuery и выполняет автоинкремент в объектах, в то время как $.deparam()этого не происходит:

JSON.stringify($.deparam('a[x]=hi&a[]=2&a[3][]=7&a[3][]=99&a[]=13').a);

приводит к

{"3":["7","99"],"x":"hi","undefined":"13"}

В $.deparam()индексе []интерпретируется как undefinedвместо автоматически увеличивающегося числового индекса.


спасибо за эту отличную функцию. Однако я заметил, что если вы используете число в качестве ключа в массиве, например, как '? A [5] [] = x', тогда ключ используется как число при создании объекта и, таким образом, в моем случае он создает 5 пустых элементов. Он должен рассматривать числовой ключ как строку и, таким образом, создавать объект с «5» (с кавычками) как ключ и x как значение. Я мог бы заставить url быть '?
— Эндрю

@Andrew: Это было сознательное дизайнерское решение с моей стороны: насколько я помню, решение Джека будет вести себя так, как вы этого ожидаете. Я ввел строку o[k]=isNaN(idx[0])?{}:[];с намерением создать массив всякий раз, когда я встречаю числовой индекс в качестве первого, заданного для нового объекта. В противном случае я сделаю общий объект. Вы можете изменить эту часть кода в соответствии со своими потребностями. I. e. что-то вроде o[k]={}должно сработать.
— cars10m

Спасибо. PS обязательно удалите console.log посреди функции;)
— Эндрю

@ Андрей: Спасибо, только что прокомментировал. Должно быть, я не заметил этого, когда разместил код.
— cars10m 01

6

Вот как можно создать новую функцию jQuery:

jQuery.unparam = function (value) {
    var
    // Object that holds names => values.
    params = {},
    // Get query string pieces (separated by &)
    pieces = value.split('&'),
    // Temporary variables used in loop.
    pair, i, l;

    // Loop through query string pieces and assign params.
    for (i = 0, l = pieces.length; i < l; i++) {
        pair = pieces[i].split('=', 2);
        // Repeated parameters with the same name are overwritten. Parameters
        // with no value get set to boolean true.
        params[decodeURIComponent(pair[0])] = (pair.length == 2 ?
            decodeURIComponent(pair[1].replace(/\+/g, ' ')) : true);
    }

    return params;
};

4
Мне эта функция не нравится. Почему параметр без значения должен иметь значение «истина»? Почему не ноль? Я думаю, что такое дизайнерское решение может привести к очень тонким ошибкам. Кроме того, почему бы не справиться с ситуацией, когда параметр может иметь несколько значений вместо выбора «последнего» значения? Решение, опубликованное Дэвидом, намного лучше.
— SolutionYogi

4
Это trueтак, чтобы можно было проверить if (params.redirect)или подобное. Если вы хотите различать trueи другое значение, вы должны использовать if (params.redirect === true). nullЗначение не помогло бы в любом случае , что я могу думать. Причина, по которой я не делал этого, как Дэвид, заключается в том, что я ценю последовательность выше гибкости. С его методом я должен проверить, является ли значение строкой или массивом, чтобы использовать его значение. На мой взгляд, это всегда должна быть строка ( trueзначение преобразуется в то, 'true'что я считаю нормальным) или всегда массив. Я выбрал струну.
— Blixt,

Согласно этой учетной записи, если бы это был params.delete, для него было бы установлено значение true, и я сделаю что-нибудь вредное. Как видите, привести пример несложно. «null» ясно указывает, что значение не существует, и решение остается за вызывающим, как он хочет его интерпретировать. Что касается нескольких значений, посмотрите на это с другой стороны. Поедая, вы гарантируете, что любой вызывающий будет тратить время на отладку, почему он получает только одно значение, ИЛИ позже придет и изменит код. Вернув массив заранее, вызывающая сторона сразу узнает, как с ними обращаться. Отказ от информации никогда не годится, ИМХО.
— SolutionYogi,

2
Если URL-адрес /abc?delete то я ожидаю, что будет запись для delete. Я не понимаю, чем это отличается? Я даже не понимаю, как вы можете предпочесть другой код по этой причине, потому что этот код установит значение для строки, 'undefined'которая не лучше. А что касается нескольких значений, это случай простоты и гибкости. Я редко вижу использование нескольких значений в строках запроса, но если они вам нужны, всегда возвращайте массив со значениями 1+. Никогда не смешивайте возвращаемый тип; то вам будет нужно тратить время на отладку , потому , что, как правило , строка может внезапно быть массивом.
— Blixt

Спасибо. Я не думаю, что есть серебряная пуля. Я взял ваш код и немного изменил его, убрал булевы значения, добавил парсинг параметров массива. ? foo [] = 1 & foo [] = 2 => foo: ["1", "2"]
— сен

6

Благодаря ему http://james.padolsey.com/javascript/parsing-urls-with-the-dom/

Довольно просто: D

function params_unserialize(p){
var ret = {},
    seg = p.replace(/^\?/,'').split('&'),
    len = seg.length, i = 0, s;
for (;i<len;i++) {
    if (!seg[i]) { continue; }
    s = seg[i].split('=');
    ret[s[0]] = s[1];
}
return ret;}

2
Это не работает с полями выбора с несколькими вариантами, потому что он сохраняет только последний выбранный.
— Фернандо Фабрети

Извините, но я не понимаю, о чем вы говорите в комментарии. Упомянутая здесь функция предназначена для десериализации / анализа URI с параметрами, подобными ?something=1&param2=value2массиву. Что вы имеете в виду под «не работать с полями выбора с несколькими вариантами»?
— brutuscat

4

Вот моя реализация JavaScript, которую я использую на странице JScript ASP Classic на стороне сервера ( демонстрация ):

// Transforms a query string in the form x[y][0][z][]=1 into {x:{y:[{z:[1]}]}}
function parseJQueryParams(p) {
    var params = {};
    var pairs = p.split('&');
    for (var i=0; i<pairs.length; i++) {
        var pair = pairs[i].split('=');
        var indices = [];
        var name = decodeURIComponent(pair[0]),
            value = decodeURIComponent(pair[1]);

        var name = name.replace(/\[([^\]]*)\]/g, 
            function(k, idx) { indices.push(idx); return ""; });

        indices.unshift(name);
        var o = params;

        for (var j=0; j<indices.length-1; j++) {
            var idx = indices[j];
            var nextIdx = indices[j+1];
            if (!o[idx]) {
                if ((nextIdx == "") || (/^[0-9]+$/.test(nextIdx)))
                    o[idx] = [];
                else
                    o[idx] = {};
            }
            o = o[idx];
        }

        idx = indices[indices.length-1];
        if (idx == "") {
            o.push(value);
        }
        else {
            o[idx] = value;
        }
    }
    return params;
}

Пока что лучшее, что я нашел для вложенных массивов
— ymakux

3

использовать это :

// convert query string to json object
var queryString = "cat=3&sort=1&page=1";

queryString
    .split("&")
    .forEach((item) => {
        const prop = item.split("=");
        filter[prop[0]] = prop[1];
    });

console.log(queryString);

1

Я придумал это решение, которое ведет себя как функция .Net HttpUtility.ParseQueryString.

В результате параметры строки запроса сохраняются в свойствах как списки значений, так что qsObj["param"]это будет то же самое, что и вызов GetValues("param")в .Net.

Я надеюсь тебе это понравится. JQuery не требуется.

var parseQueryString = function (querystring) {
    var qsObj = new Object();
    if (querystring) {
        var parts = querystring.replace(/\?/, "").split("&");
        var up = function (k, v) {
            var a = qsObj[k];
            if (typeof a == "undefined") {
                qsObj[k] = [v];
            }
            else if (a instanceof Array) {
                a.push(v);
            }
        };
        for (var i in parts) {
            var part = parts[i];
            var kv = part.split('=');
            if (kv.length == 1) {
                var v = decodeURIComponent(kv[0] || "");
                up(null, v);
            }
            else if (kv.length > 1) {
                var k = decodeURIComponent(kv[0] || "");
                var v = decodeURIComponent(kv[1] || "");
                up(k, v);
            }
        }
    }
    return qsObj;
};

Вот как им пользоваться:

var qsObj = parseQueryString("a=1&a=2&&b&c=3&d=&=e&");

Чтобы просмотреть результат в консоли, введите:

JSON.stringify(qsObj)

Вывод:

"{"a":["1","2"],"null":["","b",""],"c":["3"],"d":[""],"":["e"]}"

1

На CSS-Tricks есть красивый однострочный текст (исходный код от Николаса Ортенцио ):

function getQueryParameters(str) {
    return (str || document.location.search).replace(/(^\?)/,'').split("&").map(function(n){return n = n.split("="),this[n[0]] = n[1],this}.bind({}))[0];
}

По-настоящему умно то, как он использует thisобъект анонимной функции , добавляя пару ключ / значение для каждого запроса в строке. Тем не менее, есть возможности для улучшения. Я изменил его немного ниже, со следующими изменениями:

  1. Добавлена ​​обработка пустых строк и нестрокового ввода.

  2. Обработанные строки в кодировке URI ( %40-> @и т. Д.).

  3. Удалено использование по умолчанию, document.location.searchкогда вход был пуст.

  4. Изменили название, сделали более читабельным, добавили комментарии.

function deparam(str) {
    // Uses an empty 'this' to build up the results internally
    function splitQuery(query) {
        query = query.split('=').map(decodeURIComponent);
        this[query[0]] = query[1];
        return this;
    }

    // Catch bad input
    if (!str || !(typeof str === 'string' || str instanceof String))
        return {};

    // Split the string, run splitQuery on each piece, and return 'this'
    var queries = str.replace(/(^\?)/,'').split('&');
    return queries.map(splitQuery.bind({}))[0];
}

1

Это действительно старый вопрос, но раз уж я пришел - другие люди могут прийти к этому сообщению, и я хочу немного обновить эту тему. Сегодня нет необходимости делать нестандартные решения - есть интерфейс 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);
}

Единственное известное мне ограничение - эта функция не поддерживается в IE / Edge.


К сожалению, не поддерживается IE, как обычно, если вам нужно поддерживать этот браузер.
— Lauren

0

Это моя версия в Coffeescript. Также работает для URL, например http://localhost:4567/index.html?hello=[%22world%22]&world=hello#/home

getQueryString: (url)->
    return null if typeof url isnt 'string' or url.indexOf("http") is -1

    split = url.split "?"

    return null if split.length < 2 
    path = split[1]

    hash_pos = path.indexOf "#"
    path = path[0...hash_pos] if hash_pos isnt -1

    data = path.split "&"
    ret = {}
    for d in data
      [name, val] = d.split "=" 
      name = decodeURIComponent name
      val = decodeURIComponent val
      try 
        ret[name] = JSON.parse val
      catch error
        ret[name] = val
    return ret

0

Вот простой и компактный вариант, если вы хотите быстро получить параметры только из запроса GET:

function httpGet() {
    var a={},b,i,q=location.search.replace(/^\?/,"").split(/\&/);
    for(i in q) if(q[i]) {b=q[i].split("=");if(b[0]) a[b[0]]=
    decodeURIComponent(b[1]).replace(/\+/g," ");} return a;
}

Он преобразует

something?aa=1&bb=2&cc=3

в объект вроде

{aa:1,bb:2,cc:3}

0

Создает сериализованное представление массива или объекта (может использоваться как строка запроса URL для запросов AJAX).

<button id='param'>GET</button> 
<div id="show"></div>
<script>
  $('#param').click(function () {
    var personObj = new Object();
    personObj.firstname = "vishal"
    personObj.lastname = "pambhar";
    document.getElementById('show').innerHTML=$.param(`personObj`));
  });
</script>
output:firstname=vishal&lastname=pambhar

1
Код без объяснений не приветствуется. Может быть, объясните свой код?
— L. Guthardt

Создает сериализованное представление массива или объекта (может использоваться как строка запроса URL для запросов AJAX)
— Вишал Патель

Пожалуйста, добавляйте объяснения прямо в свой ответ, редактируя его. Но не в комментариях.
— L. Guthardt

-1

ответы могут использовать немного элегантности jQuery :

(function($) {
var re = /([^&=]+)=?([^&]*)/g;
var decodeRE = /\+/g; // Regex for replacing addition symbol with a space
var decode = function (str) {return decodeURIComponent( str.replace(decodeRE, " ") );};
$.parseParams = function(query) {
    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;
    }
    return params;
};
})(jQuery);

вилка на https://gist.github.com/956897


-1

Вы можете использовать функцию .serializeArray()( Link ) самого jQuery. Эта функция возвращает массив пары ключ-значение. Пример результата:

[
  { name: "id", value: "1" },
  { name: "version", value: "100" }
]

1
Спрашивали не об этом. Он хочет превратить строку в хэш. serializeArray принимает форму и возвращает массив.
— Дэниел Банг
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.