如何将 URL 参数转换为 JavaScript 对象？

Question

我有一个像这样的字符串：

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

如何将它转换为这样的 JavaScript 对象？

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

Answer 1

到了 2021 年……请认为这个已经过时了。

编辑

此编辑根据评论改进并解释了答案。

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

示例

分五步解析 abc=foo&def=%5Basf%5D&xyz=5：

• decodeURI: abc=foo&def=[asf]&xyz=5
• 转义引号：相同，因为没有引号
• 替换 &: abc=foo","def=[asf]","xyz=5
• 替换 =: abc":"foo","def":"[asf]","xyz":"5
• 用花括号和引号括起来：{"abc":"foo","def ":"[asf]","xyz":"5"}

这是合法的 JSON。

改进的解决方案允许在搜索字符串中使用更多字符。它使用 reviver 函数进行 URI 解码：

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,"\":\"")) + '"}')

Answer 2

一个班轮。干净简单。

const params = Object.fromEntries(new URLSearchParams(location.search));

对于您的具体情况，它将是：

const str = 'abc=foo&def=%5Basf%5D&xyz=5';
const params = Object.fromEntries(new URLSearchParams(str));
console.log(params);

Answer 3

2023 ES6/7/8 及后续方法

从 ES6 及后续版本开始，Javascript 提供了多种构造来为此问题创建高性能解决方案。

这包括使用 URLSearchParams 和 迭代器

let params = new URLSearchParams('abc=foo&def=%5Basf%5D&xyz=5');
params.get("abc"); // "foo"

如果您的用例需要您实际转换它要对象，可以实现以下功能：

function paramsToObject(entries) {
  const result = {}
  for(const [key, value] of entries) { // each 'entry' is a [key, value] tupple
    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，将 paramsToObject 替换为 Object.fromEntries(entries)。

要迭代的值对是列表名称-值对，其中
键是名称，值是值。

从 URLParams 开始，返回一个 iterable 对象，使用 扩展运算符而不是调用.entries也将根据其规范生成条目：

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

注意：所有值都会根据< a href="https://url.spec.whatwg.org/#interface-urlsearchparams" rel="noreferrer">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}

Answer 4

2024 单行方法

对于您想要将查询参数解析为对象的一般情况：

Object.fromEntries(new URLSearchParams(location.search));

对于您的特定情况：

Object.fromEntries(new URLSearchParams('abc=foo&def=%5Basf%5D&xyz=5'));

用于解析重复（数组）查询参数的 TypeScript 解决方案：

type QueryParams = Record<string, string | string[]>;

const parseQueryParams = (url: string): QueryParams => 
  Array.from(new URL(url).searchParams.entries()).reduce((q, [key, value]) => 
    ({
      ...q,
      [key]: q[key]
        ? Array.isArray(q[key])
          ? [...q[key], value]
          : [q[key] as string, value]
        : value,
    }), {} as QueryParams);

Answer 5

在 & 上拆分以获取名称/值对，然后在 = 上拆分每一对。这是一个示例：

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 的 “搜索但不替换” 。

Answer 6

到目前为止我发现的建议解决方案并未涵盖更复杂的场景。

我需要转换一个查询字符串，例如

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&f ields%5B%5D=Stat.clicks&fields%5B%5D=Stat.conversions&fields%5B%5D=Stat.cpa&fields%5B%5D=Stat.payout&fields%5B%5D=Sta t.date&fields%5B%5D=Stat.offer_id&fields%5B%5D=Affiliate.company&groups%5B%5D=Stat.offer_id&groups%5B%5D=Stat.date&a mp;filters%5BStat.affiliate_id%5D%5Bconditional%5D=EQUAL_TO&filters%5BStat.affiliate_id%5D%5Bvalues%5D=1831&limit=9999

INTO：

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

Answer 7

一个简洁的解决方案：

location.search
  .slice(1)
  .split('&')
  .map(p => p.split('='))
  .reduce((obj, pair) => {
    const [key, value] = pair.map(decodeURIComponent);
    obj[key] = value;
    return obj;
  }, {});

Answer 8

这是简单的版本，显然您需要添加一些错误检查：

var obj = {};
var pairs = queryString.split('&');
for(i in pairs){
    var split = pairs[i].split('=');
    obj[decodeURIComponent(split[0])] = decodeURIComponent(split[1]);
}

Answer 9

对于 Node JS，您可以使用 Node JS API querystring：

const querystring = require('querystring');

querystring.parse('abc=foo&def=%5Basf%5D&xyz=5&foo=b%3Dar');
// returns the object

文档：https:// /nodejs.org/api/querystring.html

Answer 10

我发现 $.String.deparam 最完整的预构建解决方案（可以执行嵌套对象等）。查看文档。

Answer 11

另一个基于 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）。

由于您可以访问 searchParams.entries() 迭代器，因此创建更兼容的解决方案应该很容易。

Answer 12

ES6 有一个非常简单且不正确的答案：

console.log(
  Object.fromEntries(new URLSearchParams(`abc=foo&def=%5Basf%5D&xyz=5`))
);

但这一行代码不涵盖多个相同的键，你必须使用更复杂的东西：

function parseParams(params) {
  const output = [];
  const searchParams = new URLSearchParams(params);

  // Set will return only unique keys()
  new Set([...searchParams.keys()])
    .forEach(key => {
      output[key] = searchParams.getAll(key).length > 1 ?  
        searchParams.getAll(key) : // get multiple values
        searchParams.get(key); // get single value
    });

  return output;
}

console.log(
   parseParams('abc=foo&cars=Ford&cars=BMW&cars=Skoda&cars=Mercedes')
)

代码将生成以下结构：

[
  abc: "foo"
  cars: ["Ford", "BMW", "Skoda", "Mercedes"]
]

Answer 13

我遇到了同样的问题，尝试了这里的解决方案，但没有一个真正起作用，因为我在 URL 参数中有数组，如下所示：

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

所以我最终编写了自己的 JS 函数，它从 URI 中的参数生成一个数组:

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

Answer 14

ES6 one liner（如果我们可以这样称呼它）

[...new URLSearchParams(location.search).entries()].reduce((prev, [key,val]) =>; {上一个[键] = val; 返回上一个}, {})


Answer 15

最简单的方法之一是使用 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;
   });

Answer 16

使用 URLSearchParams JavaScript Web API 非常简单，

var paramsString = "abc=foo&def=%5Basf%5D&xyz=5";

//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 = {abc:"forum",def:"%5Basf%5D",xyz:"5"}

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

##有用的链接

• URLSearchParams - Web API | MDN
• 使用 URLSearchParams 轻松操作 URL |网络
  |谷歌开发者

注意：IE 不支持

Answer 17

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

Answer 18

一个简单的答案是内置原生 Node 模块。（无第三方 npm 模块）

querystring 模块提供了用于解析和格式化 URL 查询字符串的实用程序。可以使用以下方式访问它：

const querystring = require('querystring');

const body = "abc=foo&def=%5Basf%5D&xyz=5"
const parseJSON = querystring.parse(body);
console.log(parseJSON);

Answer 19

据我所知，没有本地解决方案。如果您偶然使用该框架，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()

Answer 20

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

    result[key] = value;

    return result
  }, {}))

Answer 21

/**
 * Parses and builds Object of URL query string.
 * @param {string} query The URL query string.
 * @return {!Object<string, string>}
 */
function parseQueryString(query) {
  if (!query) {
    return {};
  }
  return (/^[?#]/.test(query) ? query.slice(1) : query)
      .split('&')
      .reduce((params, param) => {
        const item = param.split('=');
        const key = decodeURIComponent(item[0] || '');
        const value = decodeURIComponent(item[1] || '');
        if (key) {
          params[key] = value;
        }
        return params;
      }, {});
}

console.log(parseQueryString('?v=MFa9pvnVe0w&ku=user&from=89&aw=1'))

see log

Answer 22

有一个名为 YouAreI.js 的轻量级库，它经过测试并且使这变得非常简单。

YouAreI = require('YouAreI')
uri = new YouAreI('http://user:[email protected]:3000/a/b/c?d=dad&e=1&f=12.3#fragment');

uri.query_get() => { d: 'dad', e: '1', f: '12.3' }

Answer 23

如果您使用 URI.js，则可以使用：

https:// medialize.github.io/URI.js/docs.html#static-parseQuery

var result = URI.parseQuery("?foo=bar&hello=world&hello=mars&bam=&yup");
result === {
  foo: "bar",
  hello: ["world", "mars"],
  bam: "",
  yup: null
};

Answer 24

这似乎是最好的解决方案，因为它考虑了多个同名参数。

    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 并返回序列化参数。

Answer 25

这是我使用的一个：

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
对象 {a: "aa", b: "bb"}

重复参数，例如
?a=aa&b=bb&c=cc&c=马铃薯
对象 {a: "aa", b: "bb", c: ["cc","potato"]}

缺少键，例如。
?a=aa&b=bb&=cc
对象 {a: "aa", b: "bb"}

缺少值，例如。
?a=aa&b=bb&c
Object {a: "aa", b: "bb"}

上述 JSON/regex 解决方案在这个古怪的网址上抛出语法错误：
?a=aa&b=bb&c=&=dd&e
对象 {a: "aa", b: "bb", c: ""}

Answer 26

这是我的快速但肮脏的版本，基本上它拆分了用“&”分隔的 URL 参数到数组元素中，然后迭代该数组，将由“=”分隔的键/值对添加到对象中。我使用decodeURIComponent()将编码字符转换为其正常的字符串等效项（因此%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()），但除此之外，它是一个不错的起点。

Answer 27

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

Answer 28

如果您需要递归，可以使用小型 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/）。

Answer 29

首先你需要定义什么是 GET VAR：

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

Answer 30

我还需要在 URL 的查询部分处理 + （decodeURIComponent 不't），所以我将 Wolfgang 的代码改编为：

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