yzt
2023-05-26 2f70f6727314edd84d8ec2bfe3ce832803f1ea77
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
define(["./_base/lang"], function(lang){
 
// module:
//      dojo/io-query
 
var backstop = {};
 
return {
// summary:
//      This module defines query string processing functions.
 
    objectToQuery: function objectToQuery(/*Object*/ map){
        // summary:
        //      takes a name/value mapping object and returns a string representing
        //      a URL-encoded version of that object.
        // example:
        //      this object:
        //
        //  |   {
        //  |       blah: "blah",
        //  |       multi: [
        //  |           "thud",
        //  |           "thonk"
        //  |       ]
        //  |   };
        //
        //      yields the following query string:
        //
        //  |   "blah=blah&multi=thud&multi=thonk"
 
        // FIXME: need to implement encodeAscii!!
        var enc = encodeURIComponent, pairs = [];
        for(var name in map){
            var value = map[name];
            if(value != backstop[name]){
                var assign = enc(name) + "=";
                if(lang.isArray(value)){
                    for(var i = 0, l = value.length; i < l; ++i){
                        pairs.push(assign + enc(value[i]));
                    }
                }else{
                    pairs.push(assign + enc(value));
                }
            }
        }
        return pairs.join("&"); // String
    },
 
    queryToObject: function queryToObject(/*String*/ str){
        // summary:
        //      Create an object representing a de-serialized query section of a
        //      URL. Query keys with multiple values are returned in an array.
        //
        // example:
        //      This string:
        //
        //  |       "foo=bar&foo=baz&thinger=%20spaces%20=blah&zonk=blarg&"
        //
        //      results in this object structure:
        //
        //  |       {
        //  |           foo: [ "bar", "baz" ],
        //  |           thinger: " spaces =blah",
        //  |           zonk: "blarg"
        //  |       }
        //
        //      Note that spaces and other urlencoded entities are correctly
        //      handled.
 
        // FIXME: should we grab the URL string if we're not passed one?
        var dec = decodeURIComponent, qp = str.split("&"), ret = {}, name, val;
        for(var i = 0, l = qp.length, item; i < l; ++i){
            item = qp[i];
            if(item.length){
                var s = item.indexOf("=");
                if(s < 0){
                    name = dec(item);
                    val = "";
                }else{
                    name = dec(item.slice(0, s));
                    val  = dec(item.slice(s + 1));
                }
                if(typeof ret[name] == "string"){ // inline'd type check
                    ret[name] = [ret[name]];
                }
 
                if(lang.isArray(ret[name])){
                    ret[name].push(val);
                }else{
                    ret[name] = val;
                }
            }
        }
        return ret; // Object
    }
};
});