# qs <sup>[![Version Badge][2]][1]</sup>
[![github actions][actions-image]][actions-url]
[![coverage][codecov-image]][codecov-url]
[![dependency status][deps-svg]][deps-url]
[![dev dependency status][dev-deps-svg]][dev-deps-url]
[![License][license-image]][license-url]
[![Downloads][downloads-image]][downloads-url]
[![npm badge][npm-badge-png]][package-url]
A querystring parsing and stringifying library with some added security.
Lead Maintainer: [Jordan Harband](https://github.com/ljharb)
The **qs** module was originally created and maintained by [TJ Holowaychuk](https://github.com/visionmedia/node-querystring).
## Usage
```javascript
var qs = require('qs');
var assert = require('assert');
var obj = qs.parse('a=c');
assert.deepEqual(obj, { a: 'c' });
var str = qs.stringify(obj);
assert.equal(str, 'a=c');
```
### Parsing Objects
[](#preventEval)
```javascript
qs.parse(string, [options]);
```
**qs** allows you to create nested objects within your query strings, by surrounding the name of sub-keys with square brackets `[]`.
For example, the string `'foo[bar]=baz'` converts to:
```javascript
assert.deepEqual(qs.parse('foo[bar]=baz'), {
foo: {
bar: 'baz'
}
});
```
When using the `plainObjects` option the parsed value is returned as a null object, created via `Object.create(null)` and as such you should be aware that prototype methods will not exist on it and a user may set those names to whatever value they like:
```javascript
var nullObject = qs.parse('a[hasOwnProperty]=b', { plainObjects: true });
assert.deepEqual(nullObject, { a: { hasOwnProperty: 'b' } });
```
By default parameters that would overwrite properties on the object prototype are ignored, if you wish to keep the data from those fields either use `plainObjects` as mentioned above, or set `allowPrototypes` to `true` which will allow user input to overwrite those properties. *WARNING* It is generally a bad idea to enable this option as it can cause problems when attempting to use the properties that have been overwritten. Always be careful with this option.
```javascript
var protoObject = qs.parse('a[hasOwnProperty]=b', { allowPrototypes: true });
assert.deepEqual(protoObject, { a: { hasOwnProperty: 'b' } });
```
URI encoded strings work too:
```javascript
assert.deepEqual(qs.parse('a%5Bb%5D=c'), {
a: { b: 'c' }
});
```
You can also nest your objects, like `'foo[bar][baz]=foobarbaz'`:
```javascript
assert.deepEqual(qs.parse('foo[bar][baz]=foobarbaz'), {
foo: {
bar: {
baz: 'foobarbaz'
}
}
});
```
By default, when nesting objects **qs** will only parse up to 5 children deep. This means if you attempt to parse a string like
`'a[b][c][d][e][f][g][h][i]=j'` your resulting object will be:
```javascript
var expected = {
a: {
b: {
c: {
d: {
e: {
f: {
'[g][h][i]': 'j'
}
}
}
}
}
}
};
var string = 'a[b][c][d][e][f][g][h][i]=j';
assert.deepEqual(qs.parse(string), expected);
```
This depth can be overridden by passing a `depth` option to `qs.parse(string, [options])`:
```javascript
var deep = qs.parse('a[b][c][d][e][f][g][h][i]=j', { depth: 1 });
assert.deepEqual(deep, { a: { b: { '[c][d][e][f][g][h][i]': 'j' } } });
```
The depth limit helps mitigate abuse when **qs** is used to parse user input, and it is recommended to keep it a reasonably small number.
For similar reasons, by default **qs** will only parse up to 1000 parameters. This can be overridden by passing a `parameterLimit` option:
```javascript
var limited = qs.parse('a=b&c=d', { parameterLimit: 1 });
assert.deepEqual(limited, { a: 'b' });
```
To bypass the leading question mark, use `ignoreQueryPrefix`:
```javascript
var prefixed = qs.parse('?a=b&c=d', { ignoreQueryPrefix: true });
assert.deepEqual(prefixed, { a: 'b', c: 'd' });
```
An optional delimiter can also be passed:
```javascript
var delimited = qs.parse('a=b;c=d', { delimiter: ';' });
assert.deepEqual(delimited, { a: 'b', c: 'd' });
```
Delimiters can be a regular expression too:
```javascript
var regexed = qs.parse('a=b;c=d,e=f', { delimiter: /[;,]/ });
assert.deepEqual(regexed, { a: 'b', c: 'd', e: 'f' });
```
Option `allowDots` can be used to enable dot notation:
```javascript
var withDots = qs.parse('a.b=c', { allowDots: true });
assert.deepEqual(withDots, { a: { b: 'c' } });
```
If you have to deal with legacy browsers or services, there's
also support for decoding percent-encoded octets as iso-8859-1:
```javascript
var oldCharset = qs.parse('a=%A7', { charset: 'iso-8859-1' });
assert.deepEqual(oldCharset, { a: '§' });
```
Some services add an initial `utf8=✓` value to forms so that old
Internet Explorer versions are more likely to submit the form as
utf-8. Additionally, the server can check the value against wrong
encodings of the checkmark character and detect that a query string
or `application/x-www-form-urlencoded` body was *not* sent as
utf-8, eg. if the form had an `accept-charset` parameter or the
containing page had a different character set.
**qs** supports this mechanism via the `charsetSentinel` option.
If specified, the `utf8` parameter will be omitted from the
returned object. It will be used to switch to `iso-8859-1`/`utf-8`
mode depending on how the checkmark is encoded.
**Important**: When you specify both the `charset` option and the
`charsetSentinel` option, the `charset` will be overridden when
the request contains a `utf8` parameter from which the actual
charset can be deduced. In that sense the `charset` will behave
as the default charset rather than the authoritative charset.
```javascript
var detectedAsUtf8 = qs.parse('utf8=%E2%9C%93&a=%C3%B8', {
charset: 'iso-8859-1',
charsetSentinel: true
});
assert.deepEqual(detectedAsUtf8, { a: 'ø' });
// Browsers encode the checkmark as ✓ when submitting as iso-8859-1:
var detectedAsIso8859_1 = qs.parse('utf8=%26%2310003%3B&a=%F8', {
charset: 'utf-8',
charsetSentinel: true
});
assert.deepEqual(detectedAsIso8859_1, { a: 'ø' });
```
If you want to decode the `&#...;` syntax to the actual character,
you can specify the `interpretNumericEntities` option as well:
```javascript
var detectedAsIso8859_1 = qs.parse('a=%26%239786%3B', {
charset: 'iso-8859-1',
interpretNumericEntities: true
});
assert.deepEqual(detectedAsIso8859_1, { a: '☺' });
```
It also works when the charset has been detected in `charsetSentinel`
mode.
### Parsing Arrays
**qs** can also parse arrays using a similar `[]` notation:
```javascript
var withArray = qs.parse('a[]=b&a[]=c');
assert.deepEqual(withArray, { a: ['b', 'c'] });
```
You may specify an index as well:
```javascript
var withIndexes = qs.parse('a[1]=c&a[0]=b');
assert.deepEqual(withIndexes, { a: ['b', 'c'] });
```
Note that the only difference between an index in an array and a key in an object is that the value between the brackets must be a number
to create an array. When creating arrays with specific indices, **qs** will compact a sparse array to only the existing values preserving
their order:
```javascript
var noSparse = qs.parse('a[1]=b&a[15]=c');
assert.deepEqual(noSparse, { a: ['b', 'c'] });
```
Note that an empty string is also a value, and will be preserved:
```javascript
var withEmptyString = qs.parse('a[]=&a[]=b');
assert.deepEqual(withEmptyString, { a: ['', 'b'] });
var withIndexedEmptyString = qs.parse('a[0]=b&a[1]=&a[2]=c');
assert.deepEqual(withIndexedEmptyString, { a: ['b', '', 'c'] });
```
**qs** will also limit specifying indices in an array to a maximum index of `20`. Any array members with an index of greater than `20` will
instead be converted to an object with the index as the key. This is needed to handle cases when someone sent, for example, `a[999999999]` and it will take significant time to iterate over this huge array.
```j
没有合适的资源?快使用搜索试试~ 我知道了~
大前端面试题内容,包括vue,JavaScript,CSS,html,node,算法,面试题目遇到问题整理等其他汇总
共503个文件
md:180个
js:128个
json:66个
需积分: 5 1 下载量 171 浏览量
2023-10-05
11:24:23
上传
评论
收藏 2.2MB ZIP 举报
温馨提示
vue 记录日常遇见的大前端面试题内容,包括vue,JavaScript,CSS,html,node,算法,面试题目遇到问题整理等其他汇总.zip
资源推荐
资源详情
资源评论
收起资源包目录
大前端面试题内容,包括vue,JavaScript,CSS,html,node,算法,面试题目遇到问题整理等其他汇总 (503个子文件)
mime.cmd 299B
main.css 4KB
reset.css 434B
.editorconfig 540B
.eslintrc 1022B
.eslintrc 180B
myVue.html 10KB
lbt.html 8KB
框选checkbox.html 8KB
lbt2.html 6KB
index.html 5KB
瀑布图.html 3KB
手写利用H的地理定位的实际应用.html 3KB
event loop.html 3KB
this指向.html 2KB
Lazyman类任务队列.html 2KB
Lazyman类任务队列.html 2KB
计算两个日期相隔几天.html 2KB
json扁平.html 2KB
json树状结构转换.html 2KB
树状结构.html 1KB
解析url地址.html 1KB
2022的阶乘.html 1KB
函数柯里化.html 1KB
树状结构寻址.html 1KB
new具体做了什么.html 1KB
唯一落单的数.html 1018B
连续数.html 988B
js深拷贝.html 986B
reduce计算数组元素重复出现.html 951B
reduce计算数组元素重复出现.html 951B
js大数相加.html 913B
js大数相加.html 913B
带记忆的高阶函数.html 903B
柯里化.html 781B
求n项斐波那契数列的后n位.html 738B
drag事件.html 671B
this.html 606B
数组合并.html 541B
Promise实现异步编程.html 537B
遍历dom树.html 422B
small0028383FvYT1643300918.jpg 292KB
small001309ZlXg61645719189.jpg 237KB
small002919f5FKu1644164959.jpg 214KB
small003031cObfG1643992231.jpg 167KB
small004443MTnFb1644338683.jpg 157KB
jquery-1.12.4.min.js 95KB
jquery-ui.min.js 69KB
parse.js 34KB
websocket.js 32KB
sbcs-data-generated.js 31KB
stringify.js 30KB
response.js 27KB
qs.js 26KB
index.js 23KB
dbcs-codec.js 21KB
ipaddr.js 19KB
tests.js 15KB
index.js 15KB
receiver.js 14KB
application.js 14KB
permessage-deflate.js 14KB
websocket-server.js 14KB
sender.js 12KB
request.js 12KB
index.js 10KB
index.js 10KB
ipaddr.min.js 10KB
utf7.js 9KB
parse.js 9KB
stringify.js 9KB
extend-node.js 8KB
dbcs-data.js 8KB
jquery.mousewheel.js 8KB
utils.js 7KB
event-target.js 6KB
index.js 6KB
index.js 6KB
index.js 6KB
extension.js 6KB
internal.js 6KB
index.js 6KB
node.js 6KB
index.js 6KB
utils.js 6KB
urlencoded.js 6KB
index.js 5KB
mediaType.js 5KB
index.js 5KB
index.js 5KB
utils.js 5KB
utf16.js 5KB
json.js 5KB
index.js 5KB
browser.js 5KB
sbcs-data.js 5KB
index.js 4KB
debug.js 4KB
route.js 4KB
stream.js 4KB
共 503 条
- 1
- 2
- 3
- 4
- 5
- 6
资源评论
天天501
- 粉丝: 551
- 资源: 4666
上传资源 快速赚钱
- 我的内容管理 展开
- 我的资源 快来上传第一个资源
- 我的收益 登录查看自己的收益
- 我的积分 登录查看自己的积分
- 我的C币 登录后查看C币余额
- 我的收藏
- 我的下载
- 下载帮助
安全验证
文档复制为VIP权益,开通VIP直接复制
信息提交成功