instruction
stringlengths 15
8.46k
| input
stringclasses 1
value | output
stringlengths 55
23.5k
| task_type
dict | domain
sequencelengths 1
5
| metadata
stringclasses 1
value | answer_from
stringclasses 1
value | human_verified
bool 1
class | copyright
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|
关于Promise中this的指向问题？
## 代码
```
class Dog {
constructor() {
this.name = 'adong';
}
start() {
this.p().then(this.say);
}
p() {
return new Promise((resolve, reject)=>{
resolve('good');
})
}
say(str) {
console.log(this);
console.log(this.name + str);
}
}
let dog = new Dog();
dog.start();
```
## 题目描述
`say`方法单独调用时没有问题的，但是在`Promise`的`then`里面再调用`this`就变为`undefined`了，哪个大神帮忙分析一下，谢谢！
### 错误显示
```
undefined
(node:5784) UnhandledPromiseRejectionWarning: TypeError: Cannot read property 'name' of undefined
at say (D:\NodeJS\Test\test2.js:18:22)
``` | ```
class Dog {
constructor() {
this.name = 'adong';
}
start() {
this.p().then(this.say.bind(this));
}
p() {
return new Promise((resolve, reject)=>{
resolve('good');
})
}
say(str) {
console.log(this);
console.log(this.name + str);
}
}
let dog = new Dog();
dog.start();
```
你上面的调用写法，其本质就是：
```
class Dog {
constructor() {
this.name = 'adong';
}
start() {
// this.p().then(this.say) 本质如下
this.p().then(function(str){
console.log(str); // good
console.log(this); //undefined
//console.log(this.name + str); //this.name会报错，注释掉
});
}
p() {
return new Promise((resolve, reject)=>{
resolve('good');
})
}
say(str) {
console.log(this);
console.log(this.name + str);
}
}
let dog = new Dog();
dog.start();
```
promise的then方法传入的是一个回调函数参数！所以 then(this.say)实质只是将this.say作为一个参数使用，所以不存在this
1>. 回调函数为匿名函数时，回调函数的this会指向window，需要对回调函数bind(this)。
2>. 回调函数为箭头函数时，回调函数的this会指向他的直接上层，本例中指向dog。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"node.js",
"javascript",
"promise",
"this"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
TOKEN加在HEADER里，使用HTTPS通信，有安全隐患吗？
在写一个WEB API，我现在是把TOKEN放在网页请求头HEADER里，使用HTTPS跟服务器进行通信。
请问这样会不会被人劫持到TOKEN呢？有点担心伪造请求。 求指点~谢谢！ | `token`的作用是保证数据来源的可信,至于`token`本身的安全不在它的职责范围内.
比如用 jwt 生成的,里面存储的信息都是不加密的,他只保证里面信息的正确,比如`{id:12345}`我用这个数据生成一个`token`,这个`token`分为三段信息,第一段是头部`Header`,第二部分就是我们的数据`Payload`,通过`base64`加密,第三部分是加密的签名,通过`Header`和`Payload`以及我们的私钥生成.
当客户端带着这个`token`访问服务器的时候,我会通过我们的私钥来验证整个数据的完整性,如果通过验证,就说明这个信息是可信的.当信息被篡改时,比如有人拿到`token`,并把数据改成`{id:56789}`,但是他没有私钥,所以没法生成正确的签名,当服务端验证`token`的时候通不过,我们就知道这个数据经过了篡改,然后执行相应的处理.
这是`token`的作用,用来保证数据可信.保证这个`token`在其所在的权限范围内,而不会超出其权限范围之外,比如别的用户的信息.
当然你可以根据需求,在加上别的措施,比如就不想别人知道`token`里面的数据,那就可以在给这个数据加一下密.
或者当心这个`token`会被别人获取,照成这个用户的损失,那就需要在加别的手段来保证,比如通过验证来访的 ip ,比如设置更短的过期时间,比如你用的`HTTPS`,或者添加更多的验证等等.通过增加第三方的窃取成本,来降低被窃取的几率.
你可以把`token`想象为银行的验钞机,验钞机的职责是验证假钞保证收进来的钱都是真钱,至于这个钱是偷的抢的,还是正常交易所得,那就不是验钞机管的了,那是警察叔叔管的. | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"html"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
接口被恶意调用，如何解决
有个短信接口给用户注册时发送验证码的，然后现在发现有人每次用不同ip 不同号码进行恶意调用，现在接口被调爆，如何解决这个问题呢。
补充一下：目前APP已经发布出去了，能不能再服务器做相关的限制呢，因为在接口做限制，它不停的调的话，还是导致了该接口出现卡的现象 | 本质上就是客户端一个请求发给服务器，请求的所有参数都是来自客户端，所有在客户端做防护的措施都是浮云。有1000种方式防，就有1001种方式破。有时间不如先在服务端检查一下HTTP请求的合法性，举个例子，一个由Firefox浏览器对你APP服务器发起的短信请求`User-Agent: Firefox`，你要给它发吗？一个请求的`Refer`是`www.duanxingongzhaji.com`，你应不应该拦截呢？
最经济有效的其实是`加验证码`，因为攻击者即使是对接打码平台，也是有固定经济成本的。有大把的裸接口跑在外面，短信轰炸机这种工具是不会盯上你的，除非是有人故意要搞你。但加验证码随之而来的就是用户体验的下降。
`APP已经发版了，没办法加怎么办？ 凉拌呗！ 要么强升要么就继续忍受攻击吧`。
回答对IP和手机号做次数限制的亲们，你们认真审题了吗？？？
每次用不同ip 不同号码 不同ip 不同号码 不同ip 不同号码
IP可以考虑对代理和机房IP的识别，自己识别成本太高，可以对接第三方的saas服务，但也没有谁能100%识别代理，70%~80%是差不多的。另外有一些攻击行为是众包的，由中了木马的肉鸡发起，机器本身是在正常不过的个人PC，这种方式基本不要想怎么防了。
手机号只能考虑空号检测了，这个也不要试图自己做了，找供应商吧，同样的，没有100%的准确率，并且不是实时的。技术上讲可以有一些帮助，但是产品层面可能不太优雅。
从攻击者攻击方式考虑：
- 对于短信轰炸机这种无攻击目的性的情况来说，一般手机号都是存在的，并且IP都是分散的正常IP，除了验证码，真的没什么手段可以防。`除非你能事先知道这个号码正在被攻击`
- 对于恶意的黑客攻击行为，一般会伴随大量空号和代理IP，一定要防的话，需要一定成本，否则只能认栽。
对于短信轰炸机这种无攻击目的性的情况来说，一般手机号都是存在的，并且IP都是分散的正常IP，除了验证码，真的没什么手段可以防。`除非你能事先知道这个号码正在被攻击`
对于恶意的黑客攻击行为，一般会伴随大量空号和代理IP，一定要防的话，需要一定成本，否则只能认栽。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"centos",
"linux",
"php"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
问个跨域问题，http://www.baidu.com请求https://www.baidu.com要跨域吗？
就是http的域名请求https的域名，这个要跨域吗，为什么？ | 跨域。
不同源（域名，协议，端口）。
协议：http,https。
会触发跨域的条件还有
域名：
https://www.baidu1.com
https://www.baidu2.com
端口：
https://www.baidu.com:3000
https://www.baidu.com:3001 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"html"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
数组中选取最小值的问题
在选取数组中最小值的时候，发现如果是下面这样子的代码直接运行在<script> </script>中会有问题。
代码1
```
<script>
var name=[12,3,65,8,2,12];
var min = name[0];
for (var i = 1; i <= 1; i++) {
if (name[i]<min)
{
min = name[i];
}
}
console.log(min);
}
</script>
```
代码2
```
<script>
function test(){
var name=[12,3,65,8,2,12];
var min = name[0];
for (var i = 1; i <= 1; i++) {
if (name[i]<min)
{
min = name[i];
}
}
console.log(min);
}
}
test();
</script>
```
2段代码的结果不一样，想知道是为什么呀？ | 这是全局变量导致的，我们知道window在<script></script>标签里可以直接使用，其实还有很多这样的全局变量，比如：
name(默认为空)
length(默认为0)
你可能还会纳闷： 那第一种写法为什么得到的是1呢，接下来我们分析下你的代码：
```
<script>
var name=[12,3,65,8,2,12]; // 全局变量
var min = name[0];
for (var i = 1; i <= 1; i++) {
if (name[i]<min){
min = name[i];
}
}
console.log(min);
</script>
// name是在全局里定义的，而name本身就是一个全局变量，而且作为全局变量时只能是字符串，无论赋值什么内容，都会调用 name.toString()方法
// 所以在for循环之前，name的值是 "12,3,65,8,2,12", 因为循环只进行了一次，所以结果是1
```
我们来看第二段代码：
```
function test(){
var name=[12,3,65,8,2,12]; // 局部变量
var min = name[0];
for (var i = 1; i <= 1; i++) {
if (name[i]<min)
{
min = name[i];
}
}
console.log(min);
}
test();
// 在函数内部，name就变成了局部变量，此时可以正常赋值，即for循环之前的值是：[12,3,65,8,2,12]，因为循环执行了一次， 12 < 3，所以得到的结果是3
```
总结：在定义变量时，最好不要使用name，因为全局下name会被转化为字符串。length是可以使用，记得还有其他的全局变量，感兴趣的话自己搜一下吧！ | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
请问下大家这种代码还能优化吗
```
if (resState == 8) {//下
li_one.appendTo("#haved .ul-list");
li_one.find(".status").html("完场");
} else if (resState == 9) {
li_one.appendTo("#haved .ul-list");
li_one.find(".status").html("推迟");
} else if (resState == 10) {
li_one.appendTo("#haved .ul-list");
li_one.find(".status").html("中断");
} else if (resState == 11) {
li_one.appendTo("#haved .ul-list");
li_one.find(".status").html("腰斩");
} else if (resState == 12) {
li_one.appendTo("#haved .ul-list");
li_one.find(".status").html("取消");
} else if (resState == 13) {
li_one.appendTo("#haved .ul-list");
li_one.find(".status").html("待定");
}
```
如上,这种代码执行效率怎么样?萌新求指教蟹蟹 | 执行效率没什么问题，就是代码简化些吧
```
var textObj = { 8: "完场", 9: "推迟", 10: "中断", 11: "腰斩", 12: "取消", 13: "待定" }
if (textObj[resState]) {
li_one.appendTo("#haved .ul-list")
li_one.find(".status").html(textObj[resState])
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"css",
"html",
"html5",
"php"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js if多重判断如何优化到最简?
经常碰到循环数组之后需要把某个值转换
```
let arr = res.data.orderinformation;
for (let i = 0; i < arr.length; i++) {
if (arr[i].ctype == "11001") {
arr[i].ctype = "微信支付购买";
} else if (arr[i].ctype == "11008") {
arr[i].ctype = "余额购买";
} else if (arr[i].ctype == "11011") {
arr[i].ctype = "退款到余额";
} else if (arr[i].ctype == "11012") {
arr[i].ctype = "优惠卷兑换";
} else if (arr[i].ctype == "11013") {
arr[i].ctype = "积分兑换";
} else if (arr[i].ctype == "11014") {
arr[i].ctype = "赠送课程";
}
// switch优化, 但是这样写不对, 哪里出了问题?
// switch (arr[i].ctype) {
// case "11001":
// arr[i].ctype = "微信支付购买";
// break;
// case "11008":
// arr[i].ctype = "余额购买";
// break;
// case "11011":
// arr[i].ctype = "退款到余额";
// break;
// case "11012":
// arr[i].ctype = "优惠卷兑换";
// break;
// case "11013":
// arr[i].ctype = "积分兑换";
// break;
// case "11014":
// arr[i].ctype = "赠送课程";
// break;
// default:
// break;
// }
// 用时间戳转成日期
arr[i].ctime = new Date(arr[i].ctime);
arr[i].ctime =
arr[i].ctime.toLocaleDateString().replace(/\//g, "-") +
" " +
arr[i].ctime.toTimeString().substr(0, 8);
}
``` | ```
const d = {
'11001': '微信支付购买',
'11008': '余额购买',
'11011': '退款到余额',
'11012': '优惠卷兑换',
'11013': '积分兑换',
'11014': '赠送课程',
};
for (let i = 0; i < arr.length; i++) {
if (d[arr[i].ctype]) arr[i].ctype = d[arr[i].ctype];
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
JavaScript 为什么页面会先显示alert()框,而不是先显示页面元素?
显示顺序
1.显示提示框(此时页面一片空白)
2.点确定后正常显示HelloWorld
```
<body>
<script>
document.write("<h1>HelloWorld</h1>");
document.write("<h1>HelloWorld</h1>");
alert("你好");
</script>
</body>
```
为什么页面会先显示alert()框,而不是先显示HelloWorld,我的代码明明是HelloWorld写在上面? | 栗子：比如你有一天去饭店, 告诉老板要吃火锅了，他再给你上火锅的路上, 你出去接了个电话 他已经把火锅端上来了(但是你没看到,你走进去才会看到) (`阻塞了`)
```
document.write("<h1>HelloWorld</h1>");
document.write("<h1>HelloWorld</h1>");
setTimeout(function(){alert("你好")},1000) //定时线程走,就可以看到效果
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"web"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue 中 axios要如何做同步机制
axios 好像不能想jquery那样，设置async来实现同步请求，这导致我实现一些逻辑带来的困难。
```
methods: {
funcA() {
axios.post(
// 在请求成功后，把属性a赋值
)
return a
}
}
```
如果我有类似上面的需求，我要在请求完成后，对数据进行赋值，然后在后面的语句中要操作数据，比如返回它。如果是同步机制，那么最后我可以成功返回a的值，但是axios是异步的。
把需求写在请求的回调里面是不行的，如果我要返回这个值，只是这个请求调用返回，对于整个函数来说没有返回，这真的很难受，有没有什么解决方案？回调真的不行。 | ```
methods: {
async funA(){
var res = await axios.post('')//这里的res就是你axios请求回来的结果了
}
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"axios"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
一个php的面试题，大家看看
```
$listData = [
'111' => ['a', 'b', 'c', 'a'],
'222' => ['d', 'e', 'f', 'f', 'b'],
'333' => ['g', 'h'],
'444' => ['i', 'j'],
...
];
```
定义一个函数，传入$listData
如果`111`里面的元素，和 222/333/444... 里面的元素有重复，返回false
如果`222`里面的元素，和 111/333/444... 里面的元素有重复，返回false
如果`333`里面的元素，和 111/222/444... 里面的元素有重复，返回false
如果 ...
允许 111/222/333/444 自己里面的元素重复，返回true
其他情况返回true
已知:
$listData长度未知
111/222/333/444... 的长度未知
111/222/333/444... 里的元素为字符串和数字
我自己实现了一下，感觉算法很糟，请问有没有其他方法
```
function test ($array) {
$tempValueList = [];
foreach ($array as $key => $valueList) {
foreach ($valueList as $value) {
$tempValueList[] = $key . '~' . $value;
}
}
$result = true;
foreach ($array as $key => $valueList) {
foreach ($valueList as $value) {
foreach ($tempValueList as $_value) {
$pos = strpos($_value, '~');
$_key = substr($_value, 0, $pos);
$_val = substr($_value, $pos + 1);
if ($key == $_key) {
continue;
}
if ($_val == $value) {
$result = false;
break 3;
}
}
}
}
return $result;
}
``` | 我对子数组的定义是像 ['a', 'b', 'c', 'a'] 这样的单个数组。
我的答案：
```
$result = array();
foreach ($listData as $line) {
//子数组内部去重,再组装回原来的格式
$result[] = array_unique($line);
}
//子数组先去重再合并的结果数量 和 先合并子数组再去重的结果数量 做比较。
//如果是相同的，意味着不存在跨子数组的重复，只存在子数组内部重复，所以`True`
var_dump(count(array_merge(...$result)) === count(array_unique(array_merge(...$listData))));
```
我这个答案调用系统函数次数比较多，看起来简洁一些，但是PHP array_xxx 这类函数很大一部分性能是不具备优势的，如果不用这些函数，能相对程度提高运行效率。
另外，想要在各种情形下都能保持最高效率，可以参考以下代码。
```function check($arr)
{
$chk = [];
foreach ($arr as $k => $v)
foreach ($v as $i)
{
if (isset($chk[$i] && $chk[$i] != $k))
return false;
$chk[$i] = $k;
}
return true;
}```
方便理解的辅助参考信息：
原始数据：
```
$listData = [
'111' => ['a', 'b', 'c', 'a'],
'222' => ['d', 'e', 'f', 'f', 'b'],
'333' => ['g', 'h'],
'444' => ['i', 'j']
];
```
然后 $result 最终是这样的：
```
$listData = [
'111' => ['a', 'b', 'c'],
'222' => ['d', 'e', 'f', 'b'],
'333' => ['g', 'h'],
'444' => ['i', 'j']
];
```
子数组先去重再合并的结果
```
Array
(
[0] => a
[1] => b
[2] => c
[3] => d
[4] => e
[5] => f
[6] => b
[7] => g
[8] => h
[9] => i
[10] => j
)
```
用于和上面进行数量（数组元素数量）比较的，所谓的“先合并子数组再去重的结果”：
```
Array
(
[0] => a
[1] => b
[2] => c
[4] => d
[5] => e
[6] => f
[9] => g
[10] => h
[11] => i
[12] => j
)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"php"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
求助道面试题，在前端项目中，如何进行seo优化，你在哪些项目里有过seo优化，效果如何？
参加面试，被问到这个，在网上查阅资料，但是找不到很好的回答
在实际项目里是如何做好seo优化的，优化后的效果是什么样的？ | 您英文水品怎么样，如果还可以的话，试试读读这个系列的文章，也许会有所帮助：
https://moz.com/beginners-guide-to-seo/how-search-engines-operate。
如果是单纯应付面试的话，简单说说就可以了，毕竟这个东西要细聊，聊一天也聊不完，比如：
- 做 SPA 项目时，为解决 SEO 问题，引入了 SSR 渲染引擎
- 在首页加入 meta 标签提供一些元数据
- 使用简单、具有表意性的 title 以及使用 h5 提供的具有语义化的标签（不要一堆 div）
- 生成对 search engine 友好的 sitemap
- 使用合理的 html 结构（比如按标题、内容、页脚这样的顺序、或者将重要的内容放在 html 前，其他放在后）
现在让我想，就大概能想这么多，当然还有其他方式，但是我觉的面试回答这些应该足够了吧，毕竟也就是考察一下知识点而已。
另外也可以通过打开 devtool 的方式，看看一些流量比较大的网站的 html 以及头标签是怎么写的，比如 segmentfault.com，我觉的 SF 这个 SEO 优化的真的是很好了，搜索关键字比较明了的话，一般前 5 个搜索结果必有一个是 SF 的。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"前端",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue-cli 在写css的时候无法自动刷新浏览器是什么原因
1，修改css的时候切换到浏览器无法自动刷新，需要手动刷新才能看到效果有人遇到过这样的情况吗
修改其他到是没事 ，只是css 会有这个问题
我用的是vue-cli 3.0
附上解决后的配置：
```
// vue.config.js
module.exports = {
lintOnSave:false,
devServer:{
host:'0.0.0.0'
}
}
``` | 我也遇到这个问题，不过查明原因后发现是我的vue.config.js配置了extract:true,把style提取至独立的css文件了，而不是动态注入javascipt中。把这个参数去掉就可以了。以下是官方文档原文：
css.extract
Type: boolean | Object
Default: 生产环境下是 true，开发环境下是 false
是否将组件中的 CSS 提取至一个独立的 CSS 文件中 (而不是动态注入到 JavaScript 中的 inline 代码)。
同样当构建 Web Components 组件时它总是会被禁用 (样式是 inline 的并注入到了 shadowRoot 中)。
当作为一个库构建时，你也可以将其设置为 false 免得用户自己导入 CSS。
提取 CSS 在开发环境模式下是默认不开启的，因为它和 CSS 热重载不兼容。然而，你仍然可以将这个值显性地设置为 true 在所有情况下都强制提取。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue-cli",
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue-awesome-swiper中loop设置true无效
### vue-awesome-swiper中loop设置true无效
数据是动态加载的，在网上查不到和我相关的问题答案
是放在子组件中，首页直接引入此swiper子组件的
### 相关代码
```
<div class="wrapper" :class="cname">
<swiper :options="options">
<swiper-slide v-for="(item, index) in items" :key="index">
<slot :src="item"></slot>
</swiper-slide>
<div class="swiper-pagination" v-if="options.pagination" slot="pagination"></div>
</swiper>
</div>
name: "sliderComponent",
props: {
cname: {
type: String,
default: ""
},
options: {
type: Object,
default () {
return {
autoplay: {
delay: 3000,
disableOnInteraction: false,
//stopOnLastSlide: false
},
loop: true,
pagination: {
el: '.swiper-pagination'
},
observeParents:true,
observer:true
}
}
},
```
不循环了，轮播到最后一个图就不动了 | 试了好多次，终极答案是这样：
```
<swiper
:options="swiperOption"
ref="mySwiper"
>
<!-- slides -->
<swiper-slide
v-for="(item,index) in topBanner"
:key="item.id"
>
<img
:src="item.image_url"
:alt="index"
class="banner-img"
>
</swiper-slide>
</swiper>
```
```
data() {
return {
swiperOption: {
init:false,
loop: true,
autoplay: {
delay: 2000,
disableOnInteraction: false
},
},
}
}
```
当然，在computed()时要获取$refs:
```
computed: {
swiper() {
return this.$refs.mySwiper.swiper;
}
},
```
然后在vue生命周期的updated()时初始化swiper
```
updated() {
console.log(this.topBanner);
if (this.topBanner.length>1) {
console.log(this.swiper);
this.swiper.init();
}
},
```
不用v-if，获取到了this.swiper，问题完美解决 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
关于js柯里化做笔试题时遇到一个问题
请实现test2函数满足以下四个条件使其通过测试，以最简洁的方式完成，并保证代码质量
module.exports.test2 = (input) => {
}
(1)test2() === 0
(2)test2(1)() === 1
(3)test2(1)(2)(3)(4)() === 10
(4)const t2 = test2(1)(2); t2(3)() === 6; t2(4)() === 7
我写了一个函数，但是只能满足前三个条件，求大神赐教，怎么同时满足这四个条件，不知道咋写。 | 题目已经给出了函数的签名，那么答案是不应该擅自改动的。
```
module.exports.test2 = (input) => {
const fn = a => b => b == null ? a : fn(a + b)
return input == null ? 0 : fn(input)
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"笔试题",
"currying",
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
如何使用filter方法递归过滤Tree数组对象
```
const treeData = [{
title: "1",
key: "1",
children: [{
title: "1-1",
key: "1-1",
children:[{
title:"1-1-1",
key:"1-1-1",
},{
title:"1-1-2",
key:"1-1-2",
}]
}, {
title: "1-2",
key: "1-2",
},{
title: "1-3",
key: "1-3",
},{
title: "1-4",
key: "1-4",
}],
}];
```
想要实现通过传入的key，过滤树，如果父级被过滤掉，该父级下面所有子级也全部被过滤。
我通过递归map,还有递归filter都没有实现过滤的效果。代码如下：
```
deleteTreeData = (data,selectedKey) => {
const newTreeData = data.filter((item) => {
if(item.children){
this.deleteTreeData(item.children,selectedKey);
}
return item.key !== selectedKey;
});
this.setState({
treeData : newTreeData,
},function(){
console.log("=====newTreeData："+JSON.stringify(newTreeData));
});
}
```
这样写只能删除顶级菜单，请问正确的思路是什么，谢谢~ | ```
const treeData = [{
title: "1",
key: "1",
children: [{
title: "1-1",
key: "1-1",
children:[{
title:"1-1-1",
key:"1-1-1",
},{
title:"1-1-2",
key:"1-1-2",
}]
}, {
title: "1-2",
key: "1-2",
},{
title: "1-3",
key: "1-3",
},{
title: "1-4",
key: "1-4",
}],
}];
function f(arr, selectedKey) {
return arr.filter(item => item.key !== selectedKey).map(item => {
item = Object.assign({}, item)
if (item.children) {
item.children = f(item.children, selectedKey)
}
return item
})
}
console.log(f(treeData, '1-2'))
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"es5",
"javascript",
"filter"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
求助，关于java8 Collectors的groupingBy和mapping
### 问题描述
- 小弟尝试将一段如下json读到一个Map<String, List<String>>中，map
的key为condName，map的value为condValue
- 现在用stream结合Collectors的groupingBy和toList方法，将List<Condition>转成了Map<String, List<Condition>>
- 然后尝试通过mapping方法将List<Condition>映射为List<String>时发现无从下手。。。几次尝试后得到了一个Map<String, List<List<String>>>，多了一层List
- 想去掉这一层List，如果再遍历一遍又感觉不太优雅
- 有什么思路吗，最好是通过mapping一次得到想要的结果
- 不胜感激！
### 问题出现的环境背景及自己尝试过哪些方法
### 相关代码
```
{
"condition": [
{
"condName": "name1",
"condValue": [
"val11",
"val12"
]
},
{
"condName": "name2",
"condValue": [
"val21"
]
},
{
"condName": "name3",
"condValue": [
"val31",
"val32",
"val33"
]
}
],
"total": 3
}
```
```
@Data
public class Request {
private List<Condition> condition;
private Long total;
}
```
```
@Data
public class Condition {
private String condName;
private List<String> condValue;
}
```
转换方法（读取json和转成Request对象的代码省略。。。）：
```
String json = getContent();
try {
List<Condition> conditions = deseriliaze(json).getCondition();
Map<String, List<Condition>> map1 = conditions.stream().collect(Collectors.groupingBy(Condition::getCondName));
Map<String, List<List<String>>> map2 = conditions.stream().collect(Collectors.groupingBy(Condition::getCondName, Collectors.mapping(Condition::getCondValue, Collectors.toList())));
} catch (Exception e) {
e.printStackTrace();
}
```
### 你期待的结果是什么？实际看到的错误信息又是什么？
- map1:
```
{name3=[Condition(condName=name3, condValue=[val31, val32, val33])], name2=[Condition(condName=name2, condValue=[val21])], name1=[Condition(condName=name1, condValue=[val11, val12])]}
```
- map2:
```
{name3=[[val31, val32, val33]], name2=[[val21]], name1=[[val11, val12]]}
``` | 回答这个问题的话，我们可以先来看看为啥会出现`Map<String, List<List<String>>>`的结果，这要从`Collectors.groupingBy`的设计语义来说了，它代表把流的数据按照一定规则进行归类分组，并要求提供同一组的数据怎么进行收集的方法，所以这就是`Collectors.groupingBy`两个参数的含义
那您第一个参数写的是`Condition::getCondName`，代表流的`Condition`按照其`condName`属性进行分组，分组之后，同一组的`Condition`如何处理，这里用的`Collectors.mapping(Condition::getCondValue, Collectors.toList()))`，`mapping`代表映射转换，这里有点类似分组，`Collectors.mapping`第一个参数把流的`Condition`转化为`List<String>`，此时流里就是`List<String>`，再经过第二个参数`Collectors.toList()`，哦豁，当然最后结果就是`List<List<String>>`
这里您得不到答案的原因就是`Collectors.mapping`的第二个参数没有写对，我这里想到三种方式
第一种：还是用`Collectors.mapping`，类似您提到的再遍历一遍，哈哈
```
Map<String, List<String>> collect = conditions.stream()
.collect(Collectors.groupingBy(Condition::getCondName,
Collectors.mapping(Condition::getCondValue,
Collectors.collectingAndThen(Collectors.toList(), lists -> lists.stream().flatMap(List::stream).collect(Collectors.toList())))));
```
这里`Collectors.mapping`的第二个参数用了`Collectors.collectingAndThen`，从名字就看得出来，收集好了之后再做什么事...第一个参数当然还是按照`Collectors.toList()`，收集到之后，第二个参数再把`List`遍历一次，压平后再组成`List`
emmm，我也不太喜欢这种，不过只是引出了哈`collectingAndThen`，说不定以后您可以用到
第二种：也还是用`Collectors.mapping`，不过这次第二个参数用`Collectors.reducing`
```
Map<String, List<String>> collect2 = conditions.stream()
.collect(Collectors.groupingBy(Condition::getCondName,
Collectors.mapping(Condition::getCondValue,
Collectors.reducing(new ArrayList<>(), (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList())))));
```
这里的`Collectors.reducing`就是数据的聚合，正好也符合当前的场景，当流里的数据由`Condition`转化为`List<String>`时，我们就是要找到一种合并不同`List<String>`的方法，所以这里用到这个聚合方法`Collectors.reducing`，第一个参数是起始值，第二个参数代表怎么合并两个`list`
第二个方法要好一点，不过这里我还想到第三个方法
第三种：不用`Collectors.groupingBy`，而采用`Collectors.toMap`
```
Map<String, List<String>> collect1 = conditions.stream().collect(
Collectors.toMap(Condition::getCondName, Condition::getCondValue, (c1, c2) -> Stream.concat(c1.stream(), c2.stream()).collect(Collectors.toList())));
```
第三种方式感觉要比前两种简单点，但是这是巧用了哈`toMap`方法，`toMap`方法一般使用在数据能够有一种一对一的关系时才用，大多数的时候我们一般也只使用两个参数的方法，即传入怎么获取`map`的`key`和怎么获取`map`的`value`的两个`Function`，因为一般情况下，业务上可以保证数据是具有一对一的关系的，如果只是调用两参方法，但是实际使用过程中，确实出现了一对多的情况，那么这时候调用`toMap`两参方法是会报错的，因此就有了`toMap`这个三参方法，第三个参数代表怎么合并同一个`key`的`value`值，所以到了这里就跟第二种方法的思路差不多了，合并两个集合即可
以上就是我的回答，仅供参考
对了，再加一点，我一般是不太喜欢在流里写过长的lambda表达式的，因为流里是要体现当前流程的，不是什么都往里塞，所以第三种方式，最后的集合合并，最好还是写成一个`BinaryOperator`，毕竟现在方法也可以是一种参数或者属性了嘛
```
public static final BinaryOperator<List<String>> listMergeMethod = (l1, l2) -> Stream.concat(l1.stream(), l2.stream()).collect(Collectors.toList());
```
```
Map<String, List<String>> collect1 = conditions.stream().collect(
Collectors.toMap(Condition::getCondName, Condition::getCondValue, listMergeMethod));
```
这样我感觉要顺点。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"java",
"stream",
"group-by",
"json"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
关于mogodb缓存
```
With WiredTiger, MongoDB utilizes both the WiredTiger internal cache and the filesystem cache.
Starting in 3.4, the WiredTiger internal cache, by default, will use the larger of either:
50% of (RAM - 1 GB), or
256 MB.
```
mongodb4.0文档,大概意思是mongodb使用internal cache and the filesystem cache,
(1))请问一下如果机子内存2g,那么按照上面的计算,internal catche将占用512m,如果数据增加,内存占用超过512m,是不是就开始启用filesystem cache,把此时数据缓存放在空闲内存上,两者有没有先后顺序?
(2)既然两者都是放在内存中,为什么还要分两类缓存,是不是internal cache占据内存是不能被释放的,filesystem cache占据的是会被其他服务挤掉的,是这样吗?
(3)这些缓存是不是也是压缩过的? | internal cache 你可以理解为程序使用的内存。filesystem cache 理解为操作系统的文件系统缓存机制。
在mongo 的 WiredTiger 缓存机制中。如果不做配置的话，他会默认使用你的50% 的系统内存做索引和数据的缓存。
如果你的机器内存比较小，小于 512M 它就使用 256M 内存做缓存。
文件系统的缓存是在内核层面的。你打开一个文件，读了读。关闭了它。系统会根据你的使用程度做一些缓存。你关闭这个文件的时候，操作系统可能并没有把数据从物理内存释放。你再次打开读取这个文件就要比首次打开要快。
filesystem cache是操作系统行为，不受应用控制的。必要的时候这部分缓存会被分给其他进程。因为filesystem cache是对磁盘文件的忠实映射，而MongoDB在磁盘上存储的文件是压缩过的，所以这就代表着在filesystem cache中的内容是压缩过的。
internal cache则是MongoDB控制的部分，其中存储的是最近用到过的数据，索引等，并且是解压过的。
1) 这实际上是操作系统原理方面的知识。MongoDB要把数据加载到内存中，首先要从磁盘上读取原始的文件，那么文件内容就会进入filesystem cache. 然后要把文件内容转换为WiredTiger可以直接使用的格式，即解压，解密，之后的内容才会进到internal cache。所以一定要说先后顺序的话，internal cache中的内容肯定来自filesystem cache，后者先加载。
2) internal cache是进程内存，filesystem cache是操作系统缓存。后者在一定时候会被LRU算法驱逐出内存。如果再次被读取又会从磁盘加载。不过前者同样有可能会被驱逐出内存，因为数据容量可能比缓存大，那么就是保留需要的内容，释放掉暂时不用的部分。这里同样的是LRU。
3）internal cache未压缩，filesystem cache压缩。
额外一些需要注意的问题：
1. 索引无论在internal cache还是filesystem cache都是压缩的，压缩的是索引的键。
2. filesystem cache对性能的影响同样至关重要，不要忽略它的作用。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"mongodb"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue父组件的created和子组件的mounted的执行先后？
父组件的created和子组件的mounted的执行先后？
如果父组件的created里有.then那么子组件的created会在子组件mounted前执行吗 | 执行顺序如下：
1. 父组件 created
2. 子组件 created
3. 子组件 mounted
4. 父组件 mounted
如果有多个子组件：
1. 父组件created钩子结束后，依次执行子组件的created钩子
2. 多个子组件的created执行顺序为父组件内子组件DOM顺序
3. 多个子组件的mounted顺序无法保证，跟子组件本身复杂程度有关
4. 父组件一定在所有子组件结束mounted钩子之后，才会进入mounted钩子 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue input每次输入一个字符后自动失去焦点
代码如下，遇到的问题就是，我在输入框输入的时候，每输入一次，输入框就自动失去焦点了。
ps：实现的功能是，每点击一次添加按钮，然后就会为list对象的name数组添加一个对象，这个时候就会生成一个新的input，在这个input输入就会遇到如上问题
```
<div class="addTags" v-for="(item,index) in list.name" :key="item.data">
<input type="text" v-model="item.data">
</div>
<span class="add" @click="addData()">+请添加</span>
data() {
return: {
list: {
name: []
}
}
},
methods: {
addData() {
this.list.name.push({data:''})
}
}
``` | 问题在于:key=’item.data'，input数据绑定后进行模型更新后，div的属性要刷新，进行渲染后就重新刷新的input。如果你是要在代码中找div，建议你直接找input的父节点的方式，而不要用子节点绑定的数据给父节点的属性赋值。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js怎么监听元素属性变化
原生js监听dom元素的属性值的变化，如果监测的目标属性发生变化。执行特定语句。
监听Dom元素的Style内部的某个特定的属性，例如display，默认为none，修改为inline时触发事件
思路：
```
1.Object.defineProperty
set,get
2.Mutation Observer API
```
发生的问题：
1.defineProperty监测的目标是对象，Dom元素的属性集合[dom.attributes]也为对象{}。attributes对象是所有的属性集合的对象，style是属性集合里下属的集合，因为style的参数多。
问题：把dom.attributes当做对象监测集合下的style，当style发生改变的时候触发Set方法内的语句。但是测试的时候，当图片的display的值发生改变时，set无触发，经测试Object.defineProperty无反应。
```
var m=document.getElementById("m").attributes; //对象{}
Object.defineProperty(m,'style',{
get:function () {
console.log('get:'+m.style);
return m.style.display;
},
set:function (v) {
console.log('set:修改后的值'+v);
m.alt='图片';
}
})
```
2.Mutation Observer API它等待所有脚本任务完成后，才会运行（即异步触发方式），不知道能不能实时触发修改。 | 我觉得MutationObserver可以用啊，正常情况下，这个等待DOM操作结束再执行的异步回调没什么问题吧。什么业务实时性要那么高啊？ 一般一个事件里面同步的不会有同个属性改来改去的情况(有这种情况优化代码更好)，如果是异步的，那MutationObserver也会异步调用，倒没什么问题
```
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<div id="test" style="position: relative;" onclick="clickMe()">test</div>
<script type="text/javascript">
var MutationObserver = window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver;
var element = document.querySelector('#test');
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(mutation) {
if (mutation.type == "attributes") {
console.log('mm', new Date().getTime())
console.log("attributes changed", mutation.attributeName)
}
});
});
observer.observe(element, {
attributes: true //configure it to listen to attribute changes
});
function clickMe(){
console.log('111', new Date().getTime())
element.style.left = Math.random()* 10 + 'px';
console.log('222', new Date().getTime())
element.style.left = Math.random()* 10 + 'px';
setTimeout(function(){
console.log('333-timeout', new Date().getTime())
element.style.left = Math.random()* 10 + 'px';
}, 2000)
console.log('click-end')
}
</script>
</body>
</html>
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"css",
"html5",
"html",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js如果两个数组中有相同对象 给对象添加属性
[{id:'11'},{id:'22'},{id:'33'}] [{id:'11'},{id:'33'}]
想要下面结果
[
{id:'11',follwed:true},
{id:'22',follwed:false},
{id:'33',follwed:true}
] | ```
let arr1 = [{id:'11'},{id:'22'},{id:'33'}];
let arr2 = [{id:'11'},{id:'33'}];
let arr = [...arr1, ...arr2];
let obj = {};
arr.forEach(item=>{
if(obj[item.id]){
obj[item.id].follwed = true
}else{
obj[item.id] = item
obj[item.id].follwed = false
}
});
let result = Object.values(obj);
console.log(result)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
伪元素中content属性为什么不能设置图片尺寸？
div::before{
content: url('a.png');
display: block;
width: 100px;
height: 100px;
object-fit: fill;
}
伪元素的content属性引入的图片之所以不能设置尺寸表现为固有尺寸，是不是因为它的默认属性是boject-fit: none？
如果不是那是为什么不能设置呢？
如果是的话，那么我已经设置了object-fit: fill为什么依然不能设置呢？ | `object-fit`是图片`img`的样式，伪元素虽然可以设置图片，但毕竟不是`img`
你可以用背景图片，然后用`background-size:cover`
```
div::before{
content: '';
display: block;
width: 100px;
height: 100px;
background:url('a.png')
background-size:cover;
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"css",
"css3"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
el-scrollbar怎么滚动到锚点？
el-scrollbar用的目的是为了好看，滚动条被隐藏掉了
但是现在有个问题是正因为用了它，不能滚动到锚点，window.scrollTo也不行
el-scrollbar必须设定高度，才可以使用scrollTop的。内容区就是固定高度了，很丑啊。
我要的是`<a href="#id">` 点击直接#id到达锚点的效果 | <template>
<div class="test">
```
<a href="javascript:void(0)" @click="AnchorLinkTo('id')">我是锚点</a>
<el-scrollbar ref="myScrollbar" style="height: 300px; width: 500px;">
<div>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p ref="id">哈哈哈哈哈哈哈哈哈</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
<p>sdfsdfsd</p>
</div>
</el-scrollbar>
```
</div>
</template>
<script>
export default {
name: 'test',
data () {
```
return {}
```
},
methods: {
```
AnchorLinkTo (ref) {
this.$refs['myScrollbar'].wrap.scrollTop = this.$refs['' + ref].offsetTop
}
```
}
}
</script> | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
webpck是不是不能编译这个属性-webkit-box-orient: vertical
```
// -webkit-box-orient: vertical!important;
overflow: hidden;
-webkit-line-clamp: 2;
height: .72rem;
line-height: .36rem;
display: -webkit-box;
```
这几个属性是用来处理多行文本溢出的，但是现在webpack编译以后，
`-webkit-box-orient: vertical`检查元素样式并没有这个属性，
其他的几个属性都有，现在只有把这个属性放入内联样式才行，我用的是scss，
希望直接给出解决方案。 | 解决方案如下
```
/* autoprefixer: off */
-webkit-box-orient: vertical;
/* autoprefixer: on */
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
php数组引用的小疑问
```
$a=[1,2,3];
foreach($a as &$v){}
foreach($a as $v){}
var_dump($a);
//结果
0 => int 1
1 => int 2
2 => int 2
```
为什么最后一个元素变成了2 | 这个挺有意思的，很简单，我们来分析一下执行流程即可。
首先，第一次是
```
foreach($a as $v) {}
```
第一次是引用遍历形式，而在PHP中，foreach里的变量不是只在foreach这个范围内有效，而是在整个下文程序中都是有效的。
所以，第一次遍历，此时`$v`得到的是`$a`数组最后的一个引用，也就是 `$v == $a[2] == 3`，当前$v是$a[2]的引用。
然后来看第二次
```
foreach($a as $v) {}
```
我们来看这里的执行情况，这里执行3次，我们从第一次到第三次的执行分析。
首先第一次`foreach`后，`$v = $a[0] == 1`，也就是$v被赋值为`$a[0]`，而从上文我们知道$v是$a[2]的引用，所以，此时相当于`$a[2] = $v = $a[0] == 1`，也就是说，此时`$a = [1,2,1]`；
同理，来看第二次`foreach`，此时从第一次循环所看到的`$a = [1,2,1]`可知`$v = $a[1] == 2`,已知$v是$a[2]的引用，所以此时相当于`$a[2] = $v = $a[1] == 2`，也就是说，此时`$a = [1,2,2]`;
由此可见，第三次循环，那么`$v = $a[2]`，而从第二次循环可知`$a = [1,2,2]`，所以此时`$v == 2`，已知$v是$a[2]的引用，所以此时相当于`$a[2] = $v = $a[2] == 2`，也就是说，此时`$a = [1,2,2]`；
如果是多次循环，可以依此道理进行计算。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"php"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
react antd table滚动条事件如何实现
### react antd table滚动条事件如何实现
### 项目开发中有一个table表格需要做懒加载效果
### 滚动条事件，就是当table的竖向滚动条到底时，就触发ajax事件再拿一定条数的数据。 | 可以试试 onScrollCapture 监听
类似这样
```
<div className={styles.center} onScrollCapture={() => this.onScrollEvent()} ref={c => (this.container = c)}>
...
</div>
```
```
constructor(props) {
super(props);
this.onScrollEvent = this.onScrollEvent.bind(this);
}
onScrollEvent() {
if (this.container.scrollTop + this.container.clientHeight ===
this.container.scrollHeight) {
// todo
}
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"antd",
"react.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
typescript 泛型内的 `=` 赋值操作是什么意思？
### 描述
举个 `jQuery` 声明文件 的 栗子
```
interface JQueryStatic {
// ...
<TElement extends Element = HTMLElement>(selector: JQuery.Selector, context?: Element | Document | JQuery): JQuery<TElement>;
}
```
如果是 `<TElement extends Element>(selector: JQuery.Selector, context?: Element | Document | JQuery): JQuery<TElement>` , 我理解大概是说：“可以传入一个泛型参数 TElement，且 TElement 需要满足 Element类型的约束条件”
### 问题
这里的`=`赋值像是函数参数默认值，代表泛型的默认值么？ 但是，由官方栗子可知，类型推论会自动确定确认 T 的类型，应该是不需要泛型的默认值的吧？
```
`function identity<T>(arg: T): T {
return arg;
}
let output = identity<string>("myString"); // type of output will be 'string'
// 利用了类型推论 -- 即编译器会根据传入的参数自动地帮助我们确定T的类型
let output2 = identity("myString"); // type of output will be 'string'`
``` | 就是泛型的默认值。
阁下引用的例子里写到
而在`JQueryStatic`里，传入的参数与`TElement`一毛钱关系都没有，换言之，是无法自动推断的。在这种时候，就可以指定一个默认值。
您引用的例子里写的是“传入的参数”，所以我也就沿用了这个不严谨的表达，但是看起来导致困惑了……
这里的“传入的参数”，指的是圆括号里的东西，即函数的形参。如果圆括号里面没有出现过`TElement`，那么就不可能根据调用时的实参去自动推断泛型。至于泛型的约束条件，可以与默认值同时出现，也可以不同时出现，两者没有必然的联系。
严格来说，“传入”这个词和“泛型参数”这个词是不能搭配的。泛型是定义时使用的，运行时会被去掉。
再补上例子吧：
```
function bare<TElement>(): TElement {
return null as any as TElement;
}
const a = bare(); // typeof a === {}
function ext<TElement extends Element>(): TElement {
return null as any as TElement;
}
const b = ext(); // typeof b === Element
function dft<TElement extends Element = HTMLElement>(): TElement {
return null as any as TElement;
}
const c = dft(); // typeof c === HTMLElement
```
以上圆括号里面都没有出现过`TElement`。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"angularjs",
"node.js",
"前端",
"javascript",
"typescript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
有人说"如果是手机开发， static 会构成内存负担，memory leak 隐患，尽量少用吧。但不用实例话可以直接调用有时又更方便，相对节省内存，这个就拿捏吧。。"
java的static方法会不会造成内存负担？ | 这样的说法真是胡说八道。首先所有的方法本质上（底层）都是静态的，非静态方法只是多传了一个隐藏的 this 参数。所以任何方法不论是否静态都会占用内存空间。其次优化内存不应该关心方法，而是应该专注于对象的生存周期。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"java"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
假如数据库连接数只有1000，怎么处理100万的并发量呢？不能用负载均衡，有别的办法吗？
求大佬们给个思路，这是我上午的面试题。。。 | 1、用redis将高频查询数据存储。提高查询速度
2、mysql做主从
3、增删改加队列
4、切表分库
5、swoole解决并发
6、有必要时用grpc做服务治理
7、微服务
8、代码分割
。。。。等等等等
又是一个面试造核弹，上班拧螺丝的过程 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"php",
"负载均衡",
"缓存",
"apache",
"laravel"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js中!!有存在的必要么?为什么?
### 业务背景
- 浏览`lodash源码
- 发现了`!!`这个用法
- 查了一下,是两次取反的意思
- 但是没搞懂他存在的必要
### 示例代码
```
function isObjectLike(value) {
return !!value && typeof value == 'object';
}
```
```
function isObjectLike(value) {
return value && typeof value == 'object';
}
```
### 我的困惑
-
官方代码的含义
- 就是取反之后再取反,最后来判断这个变量是否为真
-
我的代码
- `js`会根据数据类型以及变量值,自动判断他为真为假
比如传一个0进去
-
官方的步骤:
1. !0 => true
2. !true => false
-
我的步骤
1. 0 => false
### 问题
- 既然结果都一样,那很多大佬写的代码为什么都要这样用呢?肯定不是多此一举吧 | 作用是为了类型转换, 强制转换成布尔值.
至于为什么需要. 我来详细说说:
```
function isObjectLike(value) {}
```
我们期望 isObjectLike 的返回值是个 boolean. 但 && 操作的返回值是参与操作的操作数.
```
console.log(1 && 2) // 打印 2
console.log(0 && 2) // 打印 0
```
所以如果我们传递给 && 的操作数不是布尔类型的, 那么我么得到的返回值就不是布尔值. 我们看看去掉 !! 会造成怎样的不一致性和bug.
```
function isObjectLike(value) {
return value && typeof value == 'object'; // 去掉 !!
}
isObjectLike(0) === false // false 什么? 居然不相等?
console.log(isObjectLike(0)) // 打印 0
```
你能想象一个叫 `isObjectLike` 的函数返回值类型却不是 boolean 值吗? | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vscode 如何配置路径别名?配合webpack使用
```
import { queryString } from '@/utils'
```
如果使用相对路径, 如:
```
import { queryString } from '../../utils'
```
点击 queryString 就能直接索引到对应的文件
但是用webpack alias 后 就失去这种便捷的功能了,
vscode有没有这种路径别名的配置? | 放一个jsconfig.json到项目根目录下。
```
{
"compilerOptions": {
"baseUrl": ".",
"paths": {
"@/*": ["./*"]
}
}
}
```
文档：jsconfig#_using-webpack-aliases | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"visual-studio-code",
"webpack"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js中!!有存在的必要么?为什么?
### 业务背景
- 浏览`lodash源码
- 发现了`!!`这个用法
- 查了一下,是两次取反的意思
- 但是没搞懂他存在的必要
### 示例代码
```
function isObjectLike(value) {
return !!value && typeof value == 'object';
}
```
```
function isObjectLike(value) {
return value && typeof value == 'object';
}
```
### 我的困惑
-
官方代码的含义
- 就是取反之后再取反,最后来判断这个变量是否为真
-
我的代码
- `js`会根据数据类型以及变量值,自动判断他为真为假
比如传一个0进去
-
官方的步骤:
1. !0 => true
2. !true => false
-
我的步骤
1. 0 => false
### 问题
- 既然结果都一样,那很多大佬写的代码为什么都要这样用呢?肯定不是多此一举吧 | 作用是为了类型转换, 强制转换成布尔值.
至于为什么需要. 我来详细说说:
```
function isObjectLike(value) {}
```
我们期望 isObjectLike 的返回值是个 boolean. 但 && 操作的返回值是参与操作的操作数.
```
console.log(1 && 2) // 打印 2
console.log(0 && 2) // 打印 0
```
所以如果我们传递给 && 的操作数不是布尔类型的, 那么我么得到的返回值就不是布尔值. 我们看看去掉 !! 会造成怎样的不一致性和bug.
```
function isObjectLike(value) {
return value && typeof value == 'object'; // 去掉 !!
}
isObjectLike(0) === false // false 什么? 居然不相等?
console.log(isObjectLike(0)) // 打印 0
```
你能想象一个叫 `isObjectLike` 的函数返回值类型却不是 boolean 值吗? | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
说明下为什么this指向window？
能帮我解释下为什么this指向window
```
function fn(){ console.log(this)
};
```
原理 | 1. 在这个上下文（执行环境）函数并没有绑定到任何一个对象中，意味着 this 指向 window；
2. 从作用域和调用链方面看就很好理解了，函数 fn 的上一级就是全局, 这个 this 指向全局；
3. 如果是在严格模式下执行的，而严格模式下该 this 指向 undefined。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"html5"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
typescript 往window上挂在属性报错如何解决？
编译直接报错如何解决
```
window.isWeixin = os.weixin ? os.weixin : false;
```
就想往window上挂在 有什么好的方法能解决此问题 | 1. 整个项目都能用的方法，适用于自定义属性
```
declare global {
interface Window {
isWeixin: boolean
}
}
```
2. 单文件的方法，适用于简易Polyfill，或者不希望泄漏。
```
declare var window: Window & { isWeixin: boolean }
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"typescript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
正则 exec方法 返回数组中 groups是用来存储什么值的？
var reg = /d+/;
var str = 'ac123abc456abc';
var result = reg.exec(str);
console.log(result);
//=> result: ["123", index: 2, input: "ac123abc456abc", groups: undefined]
//=> groups 作用是什么？ | `groups`是一个新的`field`，用来存储命名捕获组的信息：
```
let reg1 = /(\d)(\d)/
let str1 = '123'
console.log(reg1.exec(str1)) // => [12, 1, 2] 除去第一个以外的其他数据就是分组捕获到的数据，但是因为是一个数组，所以会存在一个记忆成本
// 命名捕获组的获取
let reg1 = /(?<first>\d)(?<second>\d)/
let str2 = '123'
console.log(reg2.exec(str2).groups) // => { first: 1, second: 2 } 而新的语法支持对这些捕获组进行命名，更方便地获取某个捕获组的数据
```
语法为：`(?<捕获组的名字>捕获组对应的规则)` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"regexp",
"正则表达式"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js算法问题
```
let arr1 = [
{
label:'张三'，
value:'1'
},
{
label:'李四',
value:'2'
},
{
label:'王五',
value:'3'
}
]
let arry2 = ['1','2']
let resArry = ?
console.log(resArry) //输出 张三、李四
```
arry2中的值能对应到arry1中的value 则放入resArry中 最终打印出张三、李四
这个怎么实现呢？ | ```
let resArry = arr1.filter(o=>arry2.indexOf(o.value)>-1).map(o=>o.label);
console.log(resArry);
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
引入vux，v-chart 报错
引入vux，v-chart 报错，错误信息如下：
```
ERROR Failed to compile with 1 errors 18:17:42
error in ./node_modules/_vux@2.9.1@vux/src/components/v-chart/mixin.js
Module parse failed: Unexpected token (18:6)
You may need an appropriate loader to handle this file type.
| this.$parent.set(this.chartName, {
| shape: defaultShapeMap[this.chartName] || '',
| ...this.$props,
| ...camelAttrs(this.$attrs)
| })
``` | vux2必须配合vux-loader使用, 请在build/webpack.base.conf.js里参照如下代码进行配置：
```
const vuxLoader = require('vux-loader')
const webpackConfig = originalConfig // 原来的 module.exports 代码赋值给变量 webpackConfig
module.exports = vuxLoader.merge(webpackConfig, {
plugins: ['vux-ui']
})
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"vux"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue路由跳转不刷新
在'game-detail'页面执行this.$router.push()方法，跳转到'game-detail'，页面不刷新。
因为路由主体没变，变的只是传递的参数id
所以从'game-detail?id=1'到'game-detail?id=2'，并没有跳转。
但是可以在watch里监听$route,监听到id的变化。
后来我就在watch里边监听路由，点击后……重新调用了获取页面数据的methods函数。
想通过刷新页面数据，再加上把滚动条归零，来模拟页面的刷新。
然后……点击后……数据刷新了，页面没变化……
父组件是通过props传递给子组件的，请问我应该在子组件里怎么做呢？
刚才百度了发现有的人说是在子组件里watch并且deep监听，
然后我监听到数据变化了以后在子组件里进行赋值也还是不行。
父组件部分内容：
```
<child :data="dataList"/>
data里边：dataList: []
this.$http.get().then((res)=>{
this.dataList.splice(0, this.dataList.length, ...res)
})
```
watch部分：
```
watch: {
$route(to, from) {
this.$http.get().then((res)=>{
this.dataList.splice(0, this.dataList.length, ...res)
})
}
}
```
子组件部分内容：
```
<div>{{ getData.name }}</div>
props: ['data']
data里边：getData: this.data[0]
``` | 受邀来答。
路由参数变化但是页面没有刷新这是Vue的组件复用的默认处理方式
文档里面写了
不想复用的话，就在父组件的router-view上加个key
`<router-view :key="$route.fullPath"></router-view>` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue-router",
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
怎么判数组中的值相等
let arr1 = ['你好','我很好'];
let arr2 = [
```
{ name: '我不知道',value: 0},
{ name: '我不好',value: 1},
{ name: '你好',value: 2},
{ name: '我特别布好',value: 3},
{ name: '我很好',value: 4},
];
```
请问该怎么判断这里面的值相等啊？最后输出value | ```
arr2.filter(function(el) {
return ~arr1.indexOf(el.name)
}).map(function(item) { return item.value })
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
optimization.runtimeChunk 具体作用是什么？
webpack 的optimization.runtimeChunk这个配置项的具体作用是什么？看了文档还是不懂 | 优化持久化缓存的, runtime 指的是 webpack 的运行环境(具体作用就是模块解析, 加载) 和 模块信息清单, 模块信息清单在每次有模块变更(hash 变更)时都会变更, 所以我们想把这部分代码单独打包出来, 配合后端缓存策略, 这样就不会因为某个模块的变更导致包含模块信息的模块(通常会被包含在最后一个 bundle 中)缓存失效. optimization.runtimeChunk 就是告诉 webpack 是否要把这部分单独打包出来. | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"webpack"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue-property-decorator 和 vue-class-component 有什么区别？
```
@Component({})
```
貌似都可以用以上方式来使用，久而久之有点混乱，请问他们之间有什么区别？或者什么场景下应该使用哪一个？ | vue class component 是vue 官方出的
vue property decorator 是社区出的
其中vue class component 提供了 vue component 等等
vue property decorator 深度依赖了 vue class component 拓展出了很多操作符 @Prop @Emit @Inject 等等 可以说是 vue class component 的一个超集
正常开发的时候 你只需要使用 vue property decorator 中提供的操作符即可 不用再从vue class componen 引入vue component | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"typescript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js一道题目，大家进来瞅一瞅
函数add可以实现连续的加法运算
函数add语法如下
add(num1)(num2)(num3)...;//注意这里是省略号哟，无限
使用举例如下：
add(10)(10)=20;
add(10)(20)(50)=80;
add(10)(20)(50)(100)=180;
请用js代码实现函数add。
```
function add(num){
var sum=num,
tmp=function(v){
sum+=v;
return tmp
};
tmp.toString=function(){
return sum
};
return tmp
}
console.log( add(10)(20)(50) ) //80
```
这个tmp又返回tmp是什么操作，这就是传说中的偏函数吗？还有toString的调用？ | ```
console.log( add(10)(20)(50) )
```
之后代码运行的过程是：
1.首先执行add(10),初始化add函数内部sum为10,
```
return tmp=function(v){
10+=v;
return tmp
};
```
2.其后执行tmp(20)即：
```
return tmp=function(20){
10+=20;
return tmp
};
```
3.其后执行tmp(50)
```
return tmp=function(50){
30+=50;
return tmp
};
```
4.其后输出时会执行一个类型转换函数即被重写的：
```
tmp.toString=function(){
return sum
};
```
5.输出tmp函数以及即内容即此时的sum：80 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
无缝轮播滚动，js代码异步，出了点小问题
要轮播5张图 ，布置 5->1->2->3->4->5->1 7张图 要实现无缝
实际思路上就是最后一张滚到第一张实际是顺着滚，动画结束再取消transition切回第一张再附加transition
现在我遇到这个个问题
```
/...5->1执行的代码（有滚动动画）.../
if (newLeft === -3600) { //滚到第7张图时的left,执行回滚
setTimeout(function () {
list.style.transition = 'none'; //取消动画
list.style.left = -600 + 'px'; //瞬间回滚
list.style.transition = 'left 2s linear';//恢复动画 //但是这句话回滚的时候会生效是为什么
},2000)
}
```
这么写回滚的时候动画会生效
必须要用下面的写法，第二个计时器必须大于2000几个毫秒才满足需求,
为什么会发生这种事情，计时器里面回调函数应该是同步的呀， list.style.left = -600 + 'px';不执行完后面应该是不会设置动画的呀？
```
if (newLeft === -3600) {
setTimeout(function () {
list.style.transition = 'none';
list.style.left = -600 + 'px';
},2000)
setTimeout(function () {
list.style.transition = 'left 2s linear';
},2020)
}
```
这里我发现：间隔时间1-4秒基本没用给，间隔10ms偶尔会出现回滚动画，设置20ms基本没问题
实际上还是刚刚的问题，js是单线程，会阻塞，2000ms执行的代码如果不执行完，2010ms是不会把异步代码拿来执行的，如果执行完了，那么我这个回滚应该是没有动画的。求大神解释一下 | 浏览器会在一个特定的点去执行渲染,在那之前的操作是没有中间态的!
```
list.style.left = 0 + 'px';
// 某一时刻 浏览器渲染
// 浏览器执行js
list.style.left = 1 + 'px';
list.style.left = 2 + 'px';
list.style.left = 3 + 'px';
list.style.left = 4 + 'px';
// 某一时刻 浏览器渲染
```
在两次渲染间,浏览器只知道 `list.style.left` 从 0 变为 4px 这个事实, 他不知道也不关心你到 4 中间发生了什么, 你可以是1个px 累加,或先到100再到4. 浏览器看到就是上一次渲染是0,这次是4.
所以
```
list.style.transition = 'none';
list.style.left = -600 + 'px';
list.style.transition = 'left 2s linear';
```
在浏览器看来就是:
```
list.style.left = -600 + 'px';
list.style.transition = 'left 2s linear';
```
解决办法是在需要被感知状态的地方让浏览器进行一次渲染, setTimeout 就可以达到这个效果,还有常见的访问 `offsetWidth` 等属性触发一次 reflow.
方案一:
```
list.style.transition = 'none';
list.style.left = -600 + 'px';
// 触发 reflow
list.offsetWidth;
list.style.transition = 'left 2s linear';
```
方案二:
```
setTimeout(function () {
list.style.transition = 'none';
list.style.left = -600 + 'px';
// 延迟这部分脚本执行, 让浏览器先渲染当前帧
setTimeout(() => {
list.style.transition = 'left 2s linear';
})
},2000)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"定时器",
"异步",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue failed to convert exception to string
使用了vue的导航守卫之后就报错
```
failed to convert exception to string
```
```
router.beforeEach(function(to, from, next){
/* 路由发生变化修改页面title */
if (to.meta.title) {
document.title = to.meta.title
}
if(!localStorage.getItem('token')){
// router.push({name:'login'})
// router.push({name: 'login'});
next({ path: '/user/login' });
}
next();
});
export default router;
``` | 你这样写会陷入无限循环的，给你个参考下
```
let login = localStorage.getItem('token')
let path = to.path
if (path === '/user/login') {
next()
return
}
if (login) {
if (path === '/') {
next({
path: '/index'
})
} else {
next()
}
} else {
next({
path: '/user/login'
})
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"vue-router"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js如何修改对象的key值？
原数据：
```
var array = [
{
id:1,
name:"小明"
},
{
id:2,
name:"小红"
}
];
```
我要改为的数据：
```
var array = [
{
value:1,
label:"小明"
},
{
value:2,
label:"小红"
}
];
```
对应的值不变，只是改key的名称，用js如何实现呢？ | ```
var array = [
{
id:1,
name:"小明"
},
{
id:2,
name:"小红"
}
];
//旧key到新key的映射
var keyMap = {
"id" : "value",
"name" : "label"
};
for(var i = 0;i < array.length;i++){
var obj = array[i];
for(var key in obj){
var newKey = keyMap[key];
if(newKey){
obj[newKey] = obj[key];
delete obj[key];
}
}
}
console.log(array);
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"css",
"html",
"html5"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
go gorm select 了字段后 结果集还是所有的struct都被返回，只是其他字段为空
### go gorm select 了字段后 结果集还是所有的struct都被返回，只是其他字段为空
### 问题出现的环境背景及自己尝试过哪些方法
### 相关代码
db.Debug().Where(s).Select([]string{"id","username","phone"}).Find(&user)
type User struct {
```
gorm.Model
Username string `json:"username"`
Phone string `json:"phone"`
Type int8 `json:"type"`
Order []Order `gorm:"ForeignKey:UId"` // hasMany 设置对应的外键
CreditCard *CreditCard `gorm:"foreignkey:CardID"`
CardID uint
```
}
### 实际结果
```
[
{
"id": 3,
"created_at": "0001-01-01T00:00:00Z",
"updated_at": "0001-01-01T00:00:00Z",
"deleted_at": null,
"username": "hello",
"phone": "18672858778",
"type": 0,
"Order": null,
"CreditCard": null,
"CardID": 0
},
{
"id": 6,
"created_at": "0001-01-01T00:00:00Z",
"updated_at": "0001-01-01T00:00:00Z",
"deleted_at": null,
"username": "hello",
"phone": "18672858778",
"type": 0,
"Order": null,
"CreditCard": null,
"CardID": 0
},
{
"id": 9,
"created_at": "0001-01-01T00:00:00Z",
"updated_at": "0001-01-01T00:00:00Z",
"deleted_at": null,
"username": "hello",
"phone": "18672858779",
"type": 0,
"Order": null,
"CreditCard": null,
"CardID": 0
},
{
"id": 12,
"created_at": "0001-01-01T00:00:00Z",
"updated_at": "0001-01-01T00:00:00Z",
"deleted_at": null,
"username": "hello",
"phone": "18672858779",
"type": 0,
"Order": null,
"CreditCard": null,
"CardID": 0
}
]
```
期望结果
```
[{
"id":6,
"username":"hello",
"phone":"18672858779"
},
{
"id":9,
"username":"hello",
"phone":"18672858779"
}
]
``` | 因为你使用是的：
```
Find(&user)
```
其中，&user 是一个 stuct ，肯定是一个完整的结构，没有值的字段会有默认值
如果不想显示那些的话，可以使用 Scan
```
type Result struct {
Name string
Age int
}
var result Result
db.Table("users").Select("name, age").Where("name = ?", 3).Scan(&result)
// Raw SQL
db.Raw("SELECT name, age FROM users WHERE name = ?", 3).Scan(&result)
```
文档，见这里 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"go",
"gorm",
"select"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue中 钩子函数如何使用async？
```
async created () {
await setTimeout(()=>{
console.log(1)
},5000);
},
async mounted () {
console.log(2)
}
```
在vue中给created使用async await，还是会先输出2，而不是等1输出完？ | 可以变相达到这个目的
```
async created () {
this.create_promise = new Promise(resolve=>this.create_promise_resolve=resolve);
setTimeout(()=>{
console.log(1);
this.create_promise_resolve();
},1000)
},
async mounted () {
await this.create_promise;
console.log(2)
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
axios的withCredentials问题
### 问题描述
我想要跨域带上`cookies`，为什么`withCredentials: true`不起作用？
### 问题出现的环境背景及自己尝试过哪些方法
我尝试过`axios.defaults.withCredentials = true`可以起作用。
但是为什么单独配置，没有作用？
### 相关代码
```
axios.post('http://101.132.138.141:8888/service/pageUsers', objectToForm({
'currentPage': '1',
'pageSize': '10',
'token': '7e987daa-6c84-46d2-be26-f345dfaed8a7',
}), {
// 单独配置
withCredentials: true
})
.then(function(res) {
console.log(res.data);
})
.catch(function(err) {
console.error(err);
});
```
### 实际看到的错误信息又是什么？
后端已经设置了`CORS`头，但是因为没有附带上`cookies`，所以被拦截器拦截了。 | withCredentials的情况下，后端要设置Access-Control-Allow-Origin为你的源地址，例如http://localhost:8080，不能是*，而且还要设置header('Access-Control-Allow-Credentials: true'); | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
Nodejs里运行npm run dev shell脚本无效果？
### 问题描述
Nodejs里如何运行npm run dev shell脚本？
### 问题出现的环境背景及自己尝试过哪些方法
1、在webpack构建的模块里，npm run script一个node脚本文件，但是我想在这个脚本文件里运行其它的npm run，尝试了require('child_process').exec但是无效，执行到这里什么反应都没。
### 相关代码
var exec = require('child_process').execSync
exec('npm run dev')
### 你期待的结果是什么？实际看到的错误信息又是什么？
或者在node脚本js文件里如何才能正确执行package.json里的script呢？
### 补充贴上
```
{
"name": "vue",
"version": "1.0.0",
"description": "A Vue.js project",
"author": "author@gmail.com",
"private": true,
"scripts": {
"dev": "webpack-dev-server --inline --progress --config build/webpack.dev.conf.js",
"modify": "node script/modify-path.js",
"build:prod": "npm run modify && npm run build --no-cache",
"start": "npm run dev",
"lint": "eslint --ext .js,.vue src",
"build": "node build/build.js"
},
"dependencies": {
"fg-loadcss": "^2.0.1",
"vue-router": "^3.0.1"
},
"devDependencies": {
"autoprefixer": "^7.1.2",
"babel-core": "^6.22.1",
"babel-eslint": "^8.2.1",
"babel-helper-vue-jsx-merge-props": "^2.0.3",
"babel-loader": "^7.1.1",
"babel-plugin-syntax-jsx": "^6.18.0",
"babel-plugin-transform-runtime": "^6.22.0",
"babel-plugin-transform-vue-jsx": "^3.5.0",
"babel-preset-env": "^1.3.2",
"babel-preset-stage-2": "^6.22.0",
"chalk": "^2.0.1",
"commander": "^2.16.0",
"copy-webpack-plugin": "^4.0.1",
"cross-env": "^5.2.0",
"css-loader": "^0.28.0",
"eslint": "^4.19.1",
"eslint-config-standard": "^11.0.0",
"eslint-friendly-formatter": "^4.0.1",
"eslint-loader": "^2.0.0",
"eslint-plugin-import": "^2.13.0",
"eslint-plugin-node": "^6.0.1",
"eslint-plugin-promise": "^3.8.0",
"eslint-plugin-standard": "^3.1.0",
"eslint-plugin-vue": "^4.7.0",
"execa": "^0.10.0",
"file-loader": "^1.1.11",
"fontfaceobserver": "^2.0.13",
"fontmin": "^0.9.7-beta",
"fontmin-webpack": "^2.0.1",
"friendly-errors-webpack-plugin": "^1.6.1",
"html-webpack-plugin": "^3.2.0",
"inquirer": "^6.0.0",
"js-yaml": "^3.12.0",
"mini-css-extract-plugin": "^0.4.1",
"node-notifier": "^5.1.2",
"node-sass": "^4.9.2",
"optimize-css-assets-webpack-plugin": "^5.0.0",
"ora": "^1.2.0",
"portfinder": "^1.0.13",
"postcss-import": "^11.0.0",
"postcss-loader": "^2.0.8",
"postcss-url": "^7.2.1",
"rimraf": "^2.6.0",
"sass-loader": "^7.0.3",
"semver": "^5.3.0",
"shelljs": "^0.7.6",
"uglifyjs-webpack-plugin": "^1.1.1",
"url-loader": "^1.0.1",
"vue": "^2.5.16",
"vue-loader": "^15.2.4",
"vue-style-loader": "^3.0.1",
"vue-template-compiler": "^2.5.2",
"webfont-webpack-plugin": "^0.2.2",
"webpack": "^4.16.0",
"webpack-bundle-analyzer": "^2.9.0",
"webpack-cli": "^3.0.8",
"webpack-dev-server": "^3.1.4",
"webpack-merge": "^4.1.0"
},
"engines": {
"node": ">= 6.0.0",
"npm": ">= 3.0.0"
},
"browserslist": [
"> 1%",
"last 2 versions",
"not ie <= 8"
]
}
``` | 这就是你想要的
```
var spawn = require('child_process').spawn;
spawn('npm', ['run','dev'], {
stdio: 'inherit'
});
```
或
```
var exec = require('child_process').execSync;
exec('npm run dev', {stdio: 'inherit'});
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"node.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
菜鸟问题：axios到底是装在devDependencies中还是装在dependencies中
之前只是用一直没有注意这个问题，在github上axios的官方安装是：
```
$ npm install axios
```
那就等于是安装在dependencies中了，但是我现在的项目中是安装在devDependencies中的，关键是打包后仍然可以正常使用，所以我有点没明白 | 除了字面的含义的区别，
`dependencies`和`devDependencies`的区别还在于：
如果你的项目是发布到`npm`的一个包，
那么这个包的`package.json`中的`dependencies`中的依赖是会被下载下来到这个包的`node_modules`文件夹中的（如果你的项目本身没有这个依赖），而`devDependencies`不会。
举个例子：
我发布了一个组件`A`，它有`dependencies：lodash`和`devDependencies：moment`。
那么，如果你的项目`npm install` 了组件`A`。
除非你的项目也依赖了`lodash`并且版本一致，那么项目的`node_modules/A`下会有一个`node_modules`，里面会有`lodash`。
而 `moment`，则无论如何也不会出现在你的项目中。
至于一般的项目，不管你是安装在dev还是dependencies中，安装的时候都会安装，打包的时候都会被打进去的，区分依赖只是为了让项目看起来更加清晰。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"node.js",
"shell"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
为什么webpack可以通过require('path')直接使用node.js的内置模块
这个问题可能看起来很搞笑，我也经常用webpack，用到node.js的模块时，因为之前跟着教程学习的缘故，所以也没觉得有什么奇怪。
可是现在想想，为什么webpack可以通过require('path')直接使用node.js的内置模块呢？
感觉webpack在打包时，通过node起了一个服务吧。或者说，用webpack时，项目本身已经是一个node项目了？ | - js是一种解释型语言，不能直接运行，需要运行环境。
- 常见的运行环境有，web浏览器，后端服务器(nodejs环境)等。
- webpack里的js不是在浏览器中运行的，而是在后端环境中运行的，这里就是nodejs环境。
- 相当于在nodejs环境中跑webpack，当然可以使用node内置模块。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"webpack"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js 数组赋值问题 ：值传递还是引用？
### 题目描述
```
var a = [1,2,3];
var b = a;
a = [4,5,6];
alert(b); //[1,2,3]
var a = [1,2,3];
var b = a;
a.pop();
alert(b); //[1,2]
//第一个我懂 第二个我不懂
```
### 题目来源
知乎
```
这是一个人回答的
a = [4,5,6];//改变的是a引用本身，没有改变数组对象
a.pop();//改变的是数组对象，a引用没有改变。
b = a;//该操作后，b直接指向数组对象，不是b指向a，a再指向数组。
//所以改变a引用并不会对b引用造成影响，改变数组对象可以
```
但是我觉得说不通啊 我觉得应该是 这个执行顺序啊 但是从结果看 我是错的~~
```
a = [4,5,6];//改变的是a引用本身，没有改变数组对象
b = a; // 这边还是指向引用
a.pop();
```
早上在知乎翻到的 看了他们的答案还是有点蒙蔽 有点蒙蔽 大佬能不能简明扼要的解答下
我有点菜 望不吝赐教 | [1,2,3]是一幢楼，
[4,5,6]也是一幢楼，
a和b是两块门牌号铁皮。
```
var a = [1,2,3]; //把a牌号挂到 123楼门口
var b = a; //把b牌号挂到 a牌号所在的楼门口，即123楼
a = [4,5,6]; //把a牌号摘下来，挂到了456楼的门口
alert(b); //[1,2,3] //此时b牌号依旧挂在123楼门口，b即代表着123楼
var a = [1,2,3]; //把a牌号挂到 123楼门口
var b = a; //把b牌号挂到 a牌号所在的楼门口，即123楼
a.pop(); //把a牌号所在的楼拆掉顶层,此时a牌号仍旧挂在123楼门口，那就拆3层
alert(b); //[1,2] //b牌号仍旧挂在 原123楼门口，但此时只剩12两层
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"node.js",
"html5",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
typescript 往window上挂在属性报错如何解决？
编译直接报错如何解决
```
window.isWeixin = os.weixin ? os.weixin : false;
```
### 就想往window上挂在 有什么好的方法能解决此问题 | 上面的any大法当然是可以解决所有问题，我补充两个漂亮点的方法吧。
整个项目都能用的方法，适用于自定义属性
```
`declare global {
interface Window {
isWeixin: boolean
}
}`
```
单文件的方法，适用于简易Polyfill，或者不希望泄漏
```
`declare var window: Window & { isWeixin: boolean }`
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"typescript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
es6中对象属性双方括号是什么意思
### es6中对象属性双方括号是什么意思?
在react表单输入输入框的change事件中
```
handleChange = (e) => {
console.log(e);
this.setState({
value: e.target.value
});
}
```
这里的event对象是一个proxy对象，将其打印到控制台输出如下
```
[[Handler]] : Object
set : ƒ (target, prop, value)
__proto__ : Object
[[Target]] : SyntheticEvent
bubbles : (...)
cancelable : (...)
currentTarget : (...)
defaultPrevented : (...)
dispatchConfig : null
eventPhase : (...)
isDefaultPrevented : null
isPropagationStopped : null
isTrusted : (...)
nativeEvent : (...)
target : (...)
timeStamp : (...)
type : (...)
_dispatchInstances : null
_dispatchListeners : null
_targetInst : null
preventDefault : (...)
stopPropagation : (...)
get bubbles : ƒ ()
set bubbles : ƒ (val)
get cancelable : ƒ ()
set cancelable : ƒ (val)
get currentTarget : ƒ ()
set currentTarget : ƒ (val)
get defaultPrevented : ƒ ()
set defaultPrevented : ƒ (val)
get eventPhase : ƒ ()
set eventPhase : ƒ (val)
get isTrusted : ƒ ()
set isTrusted : ƒ (val)
get nativeEvent : ƒ ()
set nativeEvent : ƒ (val)
get target : ƒ ()
set target : ƒ (val)
get timeStamp : ƒ ()
set timeStamp : ƒ (val)
get type : ƒ ()
set type : ƒ (val)
get preventDefault : ƒ ()
set preventDefault : ƒ (val)
get stopPropagation : ƒ ()
set stopPropagation : ƒ (val)
__proto__ : Object
[[IsRevoked]] : false
```
如果是函数对象又会有这样的结构
```
arguments : (...)
caller : (...)
length : 0
name : ""
prototype : {constructor: ƒ}
__proto__ : ƒ ()
[[FunctionLocation]] : emptyFunction.js:13
[[Scopes]] : Scopes[2]
```
那这个对象里的[[]]（双方括号）属性命名是有什么意义？ | 双方括号代表这是JavaScript引擎内部使用的属性/方法，可以帮助debug（点一下`[[FunctionLocation]]`就能跳到定义，点一下`[[Scopes]]`就能查看闭包），但是正常JavaScript代码是取不到这些属性的。
引擎看心情决定要显示哪些内部属性，显示的格式也没有规定，但在控制台里大家一般都约定俗成用双方括号，保持和规范的格式一致。
ECMA 标准： Object Internal Methods and Internal Slots | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"html5",
"css",
"node.js",
"chrome"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
面试题，http和https的区别是什么，跟TCP/IP四层模型有什么关系
在面试中被问到http和https的具体区别是什么？
与tcp/ip有什么关系了？跟三次握手有关系吗？
能不能好好讲解下 | ## 区别
HTTP协议传输的数据都是未加密的，也就是明文的，可以用抓包工具直接抓下来，而HTTPS则是利用了网景公司设计的SSL（Secure Sockets Layer）协议对HTTP协议传输的数据进行加密，抓包工具抓下来的是密文，大幅增加了中间人攻击的成本。简单来说，HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，要比http协议安全。
## 跟TCP/IP的区别
TPC/IP协议是传输层和网络层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。WEB使用HTTP协议作应用层协议，以封装HTTP 文本信息，然后使用TCP/IP做传输层协议将它发到网络上。
## 三次握手过程中的区别
太长不看版：
```
HTTP:使用三次TCP握手确认建立一个HTTP连接。
HTTPS:HTTPS在HTTP的基础上加入了SSL协议，SSL依靠证书来验证服务器的身份，并为浏览器和服务器之间的通信加密。
```
详细贼长版：
HTTP三次握手：
```
第一次握手：客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。
```
HTTPS复杂的三次握手：
```
1. 客户端发起HTTPS请求
2. 服务端的配置
采用HTTPS协议的服务器必须要有一套数字证书，可以是自己制作或者CA证书。区别就是自己颁发的证书需要客户端验证通过，才可以继续访问，而使用CA证书则不会弹出提示页面。这套证书其实就是一对公钥和私钥。公钥给别人加密使用，私钥给自己解密使用。
3. 传送证书
这个证书其实就是公钥，只是包含了很多信息，如证书的颁发机构，过期时间等。
4. 客户端解析证书
这部分工作是有客户端的TLS来完成的，首先会验证公钥是否有效，比如颁发机构，过期时间等，如果发现异常，则会弹出一个警告框，提示证书存在问题。如果证书没有问题，那么就生成一个随即值，然后用证书对该随机值进行加密。
5. 传送加密信息
这部分传送的是用证书加密后的随机值，目的就是让服务端得到这个随机值，以后客户端和服务端的通信就可以通过这个随机值来进行加密解密了。
6. 服务段解密信息
服务端用私钥解密后，得到了客户端传过来的随机值(私钥)，然后把内容通过该值进行对称加密。所谓对称加密就是，将信息和私钥通过某种算法混合在一起，这样除非知道私钥，不然无法获取内容，而正好客户端和服务端都知道这个私钥，所以只要加密算法够彪悍，私钥够复杂，数据就够安全。
7. 传输加密后的信息
这部分信息是服务段用私钥加密后的信息，可以在客户端被还原。
8. 客户端解密信息
客户端用之前生成的私钥解密服务段传过来的信息，于是获取了解密后的内容。
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"https",
"http",
"web"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
var a=5；a=6；a的地址变了没有啊？
var a=5；a=6；a的地址变了没有啊？ | 答案是“不知道”。
如果这两段代码如你所写，
```
var a=5;a=6;
```
那么没变，因为目前任何 js 引擎都会把这段代码直接优化编译为 `var a=6;`。
如果 `a` 先初始化为 5，在后面的程序中一直使用这个 `5`。然后在某一步又被重新赋值为 `6`。 那么 `a` 的地址变了吗？
这也得分情况，如果是在一个短小的函数中，也许 `a` 根本就没有内存地址，而是直接在寄存器里面进行运算。
即使 `a` 在内存中分配，也不能保证 `a` 的地址是不变的，因为在 GC 阶段要进行新生代内存区域交换和老生代内存碎片整理。
至于通常用来对比 `var` 和 `const` 的说法，“`const` 只是保证了内存地址不变，而不能保证引用的数据不变”，这个只是民间的说法，规范里面从来没有这么说。之所以这么说，是使用了 C++ 的概念来说明 `const` 的常量性质。
如果从 JavaScript 使用者的角度将，我们可以认为 `const` 定义的变量(常量)地址指向是不变的，但是如果从引擎和底层的角度讲，我们不能想当然的认为常量的地址是不变的。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
微信小程序里自定义组件，canvas组件没有效果
微信小程序里自定义组件，canvas组件没有效果，请问有没有人遇到过这个问题？
```
ready(){
const ctx = wx.createCanvasContext('back-canvas')
ctx.setFillStyle('red')
ctx.fillRect(10, 10, 150, 75)
ctx.draw();
},
```
```
<canvas class='ca' canvas-id="back-canvas" style="width:200px;height:200px;"></canvas>
``` | createCanvasContext这个是有两个参数的，在page页面默认传了一个This,组件里面 需要传this
const ctx = wx.createCanvasContext('myCanvas',this); | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"css",
"html",
"微信小程序"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue获取后端数据应该在created还是mounted方法？
vue获取后端数据应该在created还是mounted方法 | 看情况了，一般放到created里面就可以了，这样可以及早发请求获取数据，如果有依赖dom必须存在的情况，就放到`mounted(){this.$nextTick(() => { /* code */ })}`里面 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
async函数块之间如何同步执行？
请问多个async函数块之间如何同步的进行执行？
例子：以下两个async函数块如何顺序进行？
```
class Example {
first;
second;
constructor(){
}
async getFirstVal(){
this.first = await [一个promise]
}
async getSecondVal(){
this.second = await[一个依赖于first的promise]
}
async getOtherVal(){
this.other = await[一个promise]
}
doSomeWork(){
this.getFirstVal();
this.getSecondVal();
this.getOtherVal();
........
}
}
```
请问，怎么做才能保证doSomeWork里面的first和second这两个异步块顺序执行？
我不想将second这一部分的逻辑写入getFirstVal方法中，虽然这样能获得正确的执行顺序，因为getFirstVal可能在很多地方都会异步调用到，我想将他封装成一个单独的函数。请问有什么好的方法帮助我实现这种async块之间的顺序执行吗？ | ```
async doSomeWork() {
await this.getFirstVal();
this.getSecondVal();
this.getOtherVal();
}
```
这样可以吗？优雅的方案也没太研究过，但是你可以 看看 Rxjs 或者 async 这些库，能得到比较好的思路 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"node.js",
"async-await",
"ecmascript-6",
"rxjs"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
只用了el-dropdown，怎么控制el-dropdown的显示和隐藏？
我只引用了el-dropdown，没有引用el-dropdown-menu和el-dropdown-item。
dropdown里面的内容都自己写的，请问要怎么控制dropdown的显示和隐藏呢？ | 解决了，看dropdown的源码封装有hiden()和show()方法，直接给el-dropdown加个ref再通过ref运行组件内的方法即可
```
<el-dropdown trigger="click" ref="messageDrop"></el-dropdown>
this.$refs.messageDrop.hide();
this.$refs.messageDrop.show();
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"element-ui",
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
bind,call,apply在实际项目中什么地方会用到 ?
经常看到介绍call或者apply的文章,然后会以下面这种代码来举例说明 .
```
function identify() {
console.log("Hello,I'm " + this.name);
}
let me = {
name: "Kyle"
};
let you = {
name: "Reader"
};
identify.call(me); // Hello,I'm Kyle
identify.call(you); // Hello,I'm Reader
```
我有点不理解的是,实际开发的时候以参数的形式传给 `indentify(obj)` 方法不是更好吗,
```
// 传参形式
function identify(obj) {
console.log("Hello,I'm " + obj.name);
}
let me = {
name: "Kyle"
};
let you = {
name: "Reader"
};
identify(me); // Hello,I'm Kyle
identify(you); // Hello,I'm Reader
```
那么bind,call,apply一般在实际项目中什么地方会用到 ? | 我也同意第二种方法更好。实际上我觉得JavaScript没给`this`一个正式的形参地位就是设计失误，其他函数式/面向对象混合的语言都显式给出了（以至于被Python点名嘲讽，新语言都不敢用`this`这个关键字了），TypeScript如果在`class`之外引用`this`也是要求作为第一个形参显式声明的。编译器知道`this`是隐藏参数，程序员也知道，但大家都闷声大发财，这是最糟糕的。
##
`bind`可以拿来做偏函数应用，试试往后面继续填参数，这些参数会被“记住”，以便之后使用。
在现代语境下，`call`/`apply`的唯一作用就是把本来是隐藏参数的`this`提成正式参数，允许程序员显式指定。上面举的例子`Math.max.apply(null, [1, 2, 3, 4])`，推荐的做法应该是`Math.max(...[1, 2, 3, 4])`，清晰明了，而且在现代浏览器里性能会略有提升。除非是引用了别人的代码，恕我直言，自愿去搅和`call`/`apply`的，都是文明用语行为。
## 封装起来给别人使用/别人写的代码
个人观察，现在的大趋势也是不做文明用语行为，不在`class`以外乱搞`this`，所以可以期待别人写的代码里需要`call`/`apply`的也会越来越少。koa 1用`this`传上下文被喷了，koa 2马上改成显式形参。lodash这种工具库全是第二种方式传参的，如果想链式调用，都需要手动包装。
vue一大堆`this`，其实一小撮人是有意见的，考虑到一般来说组件的函数都不通用，不存在需要`call`/`apply`的场合，我也就接受了。但vuex的mutations很有可能是通用的，所以也是用的第二种方式传参，要不然真的是超级文明用语。如果是自己写的代码需要别人提供`this`，建议反思一下。
## unbound
上面有回答提到“反柯里化的实现”（实际上我觉得应该叫debound），更多是历史遗留问题的妥协方案。被设计为通用的函数，本身就不应该被绑在特定的类里面，只不过此事已经发生，ES标准又不能大改，只能将就着。像Python这种兼容性喂狗的语言，早就彻底消除了“反柯里化”这种行为的必要性，全是直接用第二种方式传参。不是因为`this`的话，没有必要自找麻烦。
## 总结
-
`call`/`apply`是历史遗留问题的解决方案
-
`bind`的用处更广泛些，偏函数应用还是相当好使的
- 为了用那些老库，学习`call`/`apply`还是有必要的
- 自己写的代码不要牵扯`call`/`apply` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"前端",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
JAVA为什么要有多个类加载器，1个不行吗 | 思考以下情景：
1. 首先，是为了区分同名的类：假定存在一个应用服务器，上面部署着许多独立的应用，同时他们拥有许多同名却不同版本的类库。试想，这时候 jvm 该怎么加载这些类同时能尽可能的避免掉类加载时对同名类的差异检测呢？当然是不同的应用都拥有自己独立的类加载器了。
2. 其次，是为了更方便的加强类的能力：类加载器可以在 load class 时对 class 进行重写和覆盖，在此期间就可以对类进行功能性的增强。比如添加面向切面编程时用到的动态代理，以及 debug 等原理。怎么样达到仅修改一个类库而不对其他类库产生影响的效果呢？一个比较方便的模式就是每个类库都可以使用独立的类加载器
小结：
jvm 需要有不同的类加载器，因为它一方面允许你在一个 jvm 里运行不同的应用程序，另一方面方便你独立的对不同类库进行运行时增强。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"类",
"java",
"类加载器",
"类加载机制",
"jvm"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
npm start 和 npm run start的关系？
npm start 和 npm run start有什么关系吗，
要是在package.json的"scripts"里有 start 项
执行 npm run start 和 npm start 好像是一样的效果
但是如果是别的命令项，
执行 npm run "别的命令" 和npm "别的命令" 效果就会不一样
向大佬求解 | `npm start`和 `npm run start`是等效关系，在一个npm管理项目中，一般默认有`start`的定义，且会经常使用，所以就在`npm`执行中简化输入目的设置了`npm run start`的简写，类似的还有`npm stop`、`npm test`等等。而其他的一些不太通用的命令项则只能通过`npm run <命令项>`的形式执行啦。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"css",
"python",
"html",
"node.js",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
Javascript的生成器函数要多加一个星号，Python却不需要额外标识，为什么这样设计？
一个Javascript的生成器函数是这样的：
```
function *gen(n) {
for (let i = 0; i < n; i++) {
yield i;
}
}
[...gen(10)]
// <- (10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```
Javascript在声明的时候要多加一个星号。如果不加星号，会报`SyntaxError`。
一个python的生成器函数是这样的：
```
def gen(n):
for i in range(n):
yield i
>>> list(gen(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```
python在声明的时候不需要额外标识。直接用`yield`就行了。
两个语言都用了`yield`关键词，工作原理也几乎相同，甚至可以说Javascript就是抄的python。那为什么Javascript反而要多加一个星号呢？这个星号有什么意义？为什么要这样设计？是Javascipt太特殊，还是python太特殊？
我相信这应该是有原因的，毕竟ES2015的制定过程相当和谐（字面意义上的） | ES 一直以来在坚持的一个原则便是完全避免 breaking changes，毕竟用户的浏览器版本不是编程人员所能干涉的。如果用户的升级导致某些网站的旧代码失效了，组委会肯定会被喷死。这点和其他语言很不一样。因此 Compatibility 是首要原因，新版 ES 必须完全兼容旧版 ES。
Readability 和 Generality 其实都是产生的附加效果。Generality 其实是个伪需求，空 Generator 都可以被有 0 条或 1 条 yield 语句的 Generator 替代，而且后者可读性比前者更好。Readability 这点 ES 的确实比 Python 的要优秀，至少只阅读函数头我便可以知道这是个 Generator 还是 Normal Function，但优势只有在读长代码时才明显。仅凭这些不足以 diss Python 的设计。
而至于 Python 当年为什么沿用了 `def`，其实没有过多什么“意义”，仅仅是出于 Guido 的直觉而已:-)。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"python"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
typescript 结合 vue 中 :! 是什么意思
最近在学习结合typescript开发vue，在github中看到这样地问题，一直无法理解
```
private today!: {
active: string[] | never[] | number[];
finishedDate: string[] | never[];
isReceived: boolean;
};
private title?: string;
private num!: number;
private isDone!: boolean;
private isReceived!: boolean;
```
请指点迷津 | 分开看就好了
`!`是和`?`相对的，是typescript的语法，表示强制解析（也就是告诉typescript编译器，我这里一定有值）。你写`?`的时候再调用，typescript会提示`可能为undefined`
`:`是类型声明 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"typescript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js 判断一个数是否为正整数？
if ( ( ( number - 0 ) | 0 ) !== number - 0 ){ // 输入购买数量是否为正整数
```
nextBtn.disabled = true;
nextBtn.innerHTML = '请输入正确的购买数量';
return;
```
}
书上看到这样的代码 ( number - 0 ) | 0 ) !== number - 0
负数 或 0 还不是负数吗？
是不是写错了
如果写错了 按这本书的写法可以怎么写呢？
请大佬帮忙！谢谢了 | 你这个判断的关键在那个按位或操作符上，如果number是整数的话，比如 10, 那么 `10 | 0 == 10`, 但是 如果是小数的话，或出来的结果也是整数 `10.1 | 0 == 10`。同时有number - 0 操作，那么如果number == 'abc'这样的字符串 `number - 0 == NaN` 这时候再按位与为 `NaN | 0 == 0` 就避免了报错。
回到你的条件，如果number是整数，那么条件不成立，也就不用提示用户再输入正确的数量，如果number是小数，那么条件成立，提示用户输入正确的数量。这个条件不会判断正负，只关心是不是整数。如果number 是 '123'这样的字符串，条件不成立, 如果是 'abc' 这样的字符串，条件成立。
结论： 书上没写错。这个条件会在用户输入小数，非数字的字符串时成立。
如果非要判断>0的话，可以这样写
```
if ((( number - 0 ) | 0 ) !== (number - 0) && (( number - 0 ) | 0 ) <= 0)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js switch奇怪的问题
```
var result_time = 45852221;
var simple_text;
switch (result_time) {
case result_time < 60:
simple_text = '刚刚';
break;
case result_time > 60 && result_time < 3600 : //分钟前
simple_text = Math.round(result_time/60)+'分钟前';
break;
case result_time > 3600 && result_time < 86400 : //小时前
simple_text = Math.round(result_time/60/24)+'小时前';
break;
case result_time > 86400 && result_time < 2592000 : //天前
simple_text = Math.round(result_time/60/60/24)+'天前';
break;
case result_time > 2592000 && result_time < 31104000 : //月前
simple_text = Math.round(result_time/60/60/24/30)+'月前';
break;
case result_time > 31104000: //年前
simple_text = Math.round(result_time/60/60/24/30/12)+'年前';
break;
}
document.write(simple_text)
```
如上图所示，这是一个简化时间的判断语句，为什么它判断不出任何case？ | 把`switch (result_time)`改为`switch (true)`就行
`switch`的用法：
```
switch (expression)
case value:
statement;
break;
case value:
statement;
break;
```
`expression`和`value`可以是值，也可以是表达式(表达式其实也是值，`1 < 2` 等价于 `true`)，
只要`expression`等于`value`就会执行相关语句
比如:
```
switch (1 < 2)
{
case true:
console.log('true');
break;
case false :
console.log('false');
break;
}
```
```
switch (true)
{
case 1 < 2:
console.log('true');
break;
case 1 > 2 :
console.log('false');
break;
}
```
上面两个代码其实是一样的 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
Jsdoc 函数有解构参数时如何注释呢
```
/**
* 这个函数用来示范一般函数参数注释方式！
* @param {String} unit
* @param {Number} item
*/
function foo(name,age) {
return {name, age}
}
foo("Luke",18)
/**
* 这个函数的注释写法是什么呢？
* @param {String} ??? 此时应该如何注释呢
* @param {Number} ??? 此时应该如何注释呢
*/
function bar({name,age}) {
return {name, age}
}
bar({
age: 18
name: "Luke"
})
```
第二个函数这样写可以不用刻意安排参数的输入顺序，但是如果我想用JsDoc注释时应该怎么写呢？？ | ```
/**
* @param {Object} option - foo
* @param {String} option.name - bar
* @param {Number} option.age - baz
*/
function bar({name,age}) {
return {name, age}
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"注释",
"jsdoc",
"jsdoc-3"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js中forEach跳出循环问题
去重的时候用for循环是没什么问题的
```
var arr=[2,3,2,2,2,4,5],
arr2=[];
function find(arr2,ele){
for(var i= 0,len=arr2.length;i<len;i++){
if(arr2[i]==ele) return true;
}
return false;
}
for(var i= 0,len=arr.length;i<len;i++){
if(!find(arr2,arr[i])){
arr2.push(arr[i]);
}
}
```
改用forEach的时候
```
function find(arr2,ele){
arr2.forEach(function(item,i){
if(item==ele) return true;
});
return false;
}
arr.forEach(function(item,i,array){
if(!find(arr2,arr[i])){
arr2.push(arr[i]);
}
})
```
发现结果不对forEach貌似没有在return的时候跳出循环，求教应该如何写呢。。。。 | `forEach`函数不支持`break`，可以用`every`函数替代：
```
function find(arr2, ele) {
arr2.every(function (item, i) {
if (item === ele) {
return false
}
return true
})
}
```
`return false`跳出循环，`return true`继续循环，详见 https://developer.mozilla.org... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vscode怎么设置打开新文件的时候不关闭没有修改过的旧文件？
经常需要对比两个文件，vscode自动给我关闭了这个有点蛋疼 | // 控制是否将打开的编辑器显示为预览。预览编辑器将会重用至其被保留(例如，通过双击或编辑)，且其字体样式将为斜体。
```
"workbench.editor.enablePreview": true,
```
这个设置改为false，就好了 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"visual-studio-code"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
Vue刷新当前路由，有什么好的解决方式么？
```
this.$router.go(0);
location.reload()
//这两种方式都相当于f5刷新，页面会有卡顿的情况
```
```
this.$router.push({ path: '/kong', query: {} });
// 这种方式是进入一个空白页，在空白页里面跳转回原来的页面，这种方式页面刷新相对流畅，
// 但是我发现，使用这种方式的话，在用户点击浏览器的后退键的时候，会再次进入/kong 这个空白页然后马上回来
// 导致页面无法后退
```
请问，有其他好的方式实现页面刷新吗？ | 如果你希望能从`breforeCreate`开始重走整个生命周期的话
其实在你的这个方法上略作修改就可以
```
this.$router.push({ path: '/kong', query: {} });
```
把`push`换成`replace`
同样的`kong`这个页面里`beforeRouteEnter`时也用`replace`
就不会有那个后退的问题了
附上我用的代码吧
```
// 使用页面
refresh () {
this.$router.replace({
path: '/refresh',
query: {
t: Date.now()
}
})
}
// refresh.vue
<script>
export default {
beforeRouteEnter(to, from, next) {
next(vm => {
vm.$router.replace(from.path)
})
}
}
</script>
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
安装好php为什么要复制一份php.ini 到/usr/local/php/lib/php.ini
安装好php为什么要复制一份php.ini 到/usr/local/php/lib/php.ini
我试过了 如果不复制一份 php也能正常运行 为什么要从安装包里复制一份php.ini 到 /usr/local/php/lib/php.ini 目录下呢 | 对于您的问题，为什么要拷贝到那个目录，那时因为 PHP 编译时指定了配置文件目录，而指定的目录是 /usr/local/php/lib 因此 PHP 启动时会去那个目录下读取 php.ini 的配置文件，不拷贝不影响 PHP 正常运行，只不过无法添加配置项罢了。要查看当前 PHP 会去哪个目录下找配置文件，可以在 phpinfo() 中看到，（命令行下运行 php -i 也可以），看到 'Configuration File (php.ini) Path' 和 'Scan this dir for additional .ini files' 两项，这里面记录了 PHP 加载 .ini 配置文件的路径。
建议下载一份 PHP 的 source code 自己尝试着去编译运行一遍。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"php",
"linux",
"nginx"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
npm run dev和npm start的区别？
这是vue脚手架的官方Webpack模版，请问一下其中的"start": "npm run dev"有什么意义
npm run dev和npm start的区别是什么呢？
为什么直接输入npm dev就不能执行scripts配置下的dev命令，而npm start就可以呢？
```
"scripts": {
"dev": "webpack-dev-server --inline --progress --config build/webpack.dev.conf.js",
"start": "npm run dev",
"lint": "eslint --ext .js,.vue src",
"build": "node build/build.js"
},
``` | 执行`scripts`里的命令要`npm run 命令名`。
`npm start`可以运行是为了方便开发者使用，npm-start。
`npm start`会执行`scripts`里的`start`字段。 如果没有`start`字段则执行`node server.js`。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"html5",
"css",
"html",
"node.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
try/catch无法捕获promise.reject的问题
```
function f2() {
try {
Promise.reject('出错了');
} catch(e) {
console.log(e)
}
}
```
- 执行`f2()`，无法通过try/catch捕获promise.reject，控制台抛出`Uncaught (in promise)`
```
async function f() {
try {
await Promise.reject('出错了')
} catch(e) {
console.log(e)
}
}
```
- 为什么改成await/async后，执行`f()`就能在catch中捕获到错误了，并不会抛出`Uncaught (in promise)` | 这样应该就理解了吧，拒绝发生在未来回调只会在未来的事件循环中执行。
```
function f2() {
try {
Promise.reject('出错了').catch(err => {
console.log('2', err)
});
console.log('1')
} catch (e) {
console.log(e)
}
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"node.js",
"ecmascript-6"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
js数组中对象怎么合并
var list=[{id:1,number:2,title:2},{id:1,number:3,title:2}]
如果数组中id和title的值相同,数组中两个对象合并,number值相加,怎么实现
最终得到[{id:1,number:5,title:2}] | ```
var list=[{id:1,number:2,title:2},{id:1,number:3,title:2}]
function merge (list) {
let result = []
let cache = {}
list.forEach(item => {
let key = `id:${item.id},title${item.title`
let index = cache[key]
if (index !== undefined) {
result[index].number += item.number
} else {
result.push(Object.assign({}, item))
cache[key] = result.length - 1
}
})
return result
}
merge(list)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"html5"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
rpc服务器是不是一般是服务器内部交互用的，这样有什么好处？
最近在学习rpc框架，因为我看有些rpc框架还没跨语言,序列化只有自己语言认识，而那些语言我看很少在客户端开发用到，我这里说的客户端指移动端，浏览器这种。比如golang,python。 那意味着是不是rpc框架主要是用于服务器内网交互的一种架构？ 这样做有什么好处啊？我看貌似好处就是分散流量压力啊，因为用rpc做分布式，计算工作还不全都交到那台server的服务器去做了吗？
我原来还以为rpc架构是客户端软件和服务器交互用的。。。 | RPC从概念上讲，不是一种协议，也不属于通信的范畴；
而是一种编程技术，一种代码封装方式，目的是提高代码构建和维护效率。
RPC（Remote Procedure Call）把进程间（包括跨服务器）的通信过程封装成函数调用方式，隐藏复杂的通信处理细节，方便使用、简化代码；使得调用者可以像调用本地函数那样调用其他进程提供的处理过程。
一旦我们把RPC理解为一种代码封装技术，就很容易理解为啥看上去“内网用的多”，“客户端用的少”。
内网并不是关键。
关键是RPC在简化代码的同时增加了耦合。
如果我们定义两个实体之间通过HTTP通信（或其他任何协议），只要双方遵循HTTP协议，就没有问题，和双方的语言实现没有任何关系。
而如果是RPC，那么我们对外部呈现的是函数接口，这就和语言以及平台相关，需要给调用者提供函数声明文件和链接库。
当我们的场景耦合成本比较高时，例如我们构建的服务是提供给团队之外甚至是公司之外的用户使用，用RPC就比直接用HTTP麻烦多了——
我们需要提供各种版本，以支持用户的各种平台和语言。
即使采用支持多语言的RPC框架，那么这个框架（本质是一个代码库）也要双方都引用和依赖，这和直接采用协议比起来耦合要重的多。
显然您所看到的“服务器内网交互用的多“，并不是本质，本质是：
同一个系统内部交互，因为可以采用相同的基础平台（或框架），所以可以考虑使用RPC封装通信过程，以提高代码构建和维护效率，而恰恰系统内部交互大都是走内网。。。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"rpc",
"go",
"java",
"python"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
es6方法过滤掉两个数组中对象id值相等的项
```
const arr1=[{id:1,name:'网'},{id:2,name:'二位'}]
const arr2=[{id:1,name:'老二'},{id:3,name:'老三'}]
```
es6方法过滤掉arr2中id和arr1 id相同的项 | 我自己来分享个
```
let arr1=[{id:1,name:'网'},{id:2,name:'二位'}]
let arr2=[{id:1,name:'问问'},{id:3,name:'多少'},{id:44,name:'多少'},{id:45,name:'多少'},]
let add=arr2.filter(item=>!arr1.some(ele=>ele.id===item.id))
console.log(add)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"ecmascript-6"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
go, python做WEB哪个最合适?
目前处于迷茫状态, 到底该专注一种语言还是同时使用多种语言?
使用golang开发web连续一年了, 频繁的写err!=nil, 频繁的循环断言,reflect,unsafe....感觉大部分时间都在写轮子, 或者考虑轮子的性能. 开发效率来看,是PHP50%吧; 最大的问题的是代码不优雅, 别的语言1行代码, 我用轮子的情况下, 至少要多写两三行.
python,只是看过手册, 很讨厌缩进; 但的确是理想语言, 动态类型更适合快速开发, 库多! 想深入学习, 但又怕go会慢慢淡忘.
我最开始学c#, 后来用php, c#忘了. 再后来学go, php也几乎忘了. 更别提以前就没学好的C++, 现在连复杂的指针都看不懂了. 但js没忘, 因为几乎天天用啊.
很纠结! 求老鸟指点. | 我个人主要是PHP和Golang方向，我谈谈个人的看法吧。
对于开发项目语言技术栈方案的选择，不能仅仅从开发语言本身来进行考虑，还要考虑对应的生态环境，包括软件生态、社区情况和人力资源。
目前整个行业来看的话，PHP拿来做页面级的开发非常适合，也很高效，也就是很多大型互联网公司所谓的“应用层”。Java通过几十年的发展，它的生态环境已经非常繁荣，这也是很多企业选择Java的原因，并且也稳定。Golang相对来说比较新，其实仅仅从开发语言上来讲的话它更加高级(这根设计思想有很大关系)，也是Google踩了几十年的坑产出的结果之一，它并不是为了替代谁，而是给了大家更多的选择。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"编程语言"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vue递归组件如何传递事件给父组件？
如题，根据数据遍历递归，不明确具体会遍历几次，形式大概如下：
```
<parent>
<children>
<children>
<children>
...
</children>
</children>
</children>
</parent>
```
我现在要在最后一层children传出数据到parent接收，但是emit只能向上传递一层，有什么好的解决方案吗？除了用vuex我没好的想法了 | 用eventBus 策略。
定义：
```
// bus.js
import Vue from 'vue'
export default new Vue()
```
使用：
parent
```
// parent.vue
import bus from './bus'
export default {
mounted(){
bus.$on('post-message',(msg)=>{
console.log(msg)
})
}
}
```
children：
```
// children.vue
import bus from './bus'
export default {
mounted(){
bus.$emit('post-message','发送')
}
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
为什么JS用分号结尾和没用分号结尾执行的结果不一致？
代码1：
var a = 'Aaa';
var b = 'Bbb';
[a, b] = [b, a];
console.log(a);
console.log(b);
结果：
Bbb
Aaa
代码2：
var a = 'Aaa'
var b = 'Bbb'
[a, b] = [b, a]
console.log(a);
console.log(b);
结果：
Aaa
[ undefined, 'Aaa' ]
如果说JS并不强行要求每行语句末尾必须要用分号结尾的话，上面两段代码按道理来说结果不是应该一致的吗？
测试环境：node v6.10.2 | 不强行要求分号不代表不写分号是正确的。解释器会自动加分号，不保证完全能按你的意思加分号也许就加错分号了，结果就错了。变成了
```
var a = 'Aaa';
var b = 'Bbb'[a, b] = [b, a];
console.log(a);
console.log(b);
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"ecmascript-6"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
PHP怎么实现数组键名不变，值互换？
```
$arr = array('a'=>'aaa','b'=>'bbb');
转变为
$arr = array('a'=>'bbb','b'=>'aaa');
``` | ```
$arr = array('a'=>'aaa','b'=>'bbb');
$arr_new = array_combine(array_keys($arr),array_reverse(array_values($arr)));
var_dump($arr_new);
```
=============
哎，迟了一步，@熊猫桑 握爪 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"php"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
vim怎么粘贴其他地方复制的代码？
我在网页上复制了一段代码，想粘贴到vim中。
第一次粘贴的时候，总会丢失复制内容的起始几个字符，紧接着第二次粘贴则正常，是什么原因？
下面是`<title>Hello, world!</title>`为粘贴内容的测试结果，共粘贴两次，可以看到，第一次(前面两行)很奇怪，第二次(第三行)正常。
```
1
2 , world!</title>
3 <title>Hello, world!</title>
```
左侧的1 2 3为行号 | 简单原因: 你没有进入编辑模式就试图编辑文件, 所以产生了你意想不到的结果.
具体原因:
1. 你打开了 vim, 此时 vim 处于 `正常模式`.
2. 你粘贴了 `<title>Hello, world!</title>`, 相当于向 vim 申请执行 该指令, vim 会顺次执行. 在正常模式下, `<` 和 `>` 表示缩进, 但因为你没有选中文本, 因此什么也没有发生, 两个中括号中间的 `title` 是无效的. `Hell` 也不会有具体效果. 但执行到 `o` 时, `o` 表示在光标所在行的下一行进入 `插入模式`, 剩下的内容被当做 插入文本处理. 因此你文件中的第一行是空白行, 第二行是 `o` 后面的内容, 即 `, world!</title>`
3. 因为上面的操作已经使 vim 进入 `插入模式`, 且你并未点击 `ESC` 退出该模式, 因此在你继续进行第二次粘贴的时候, 就会直接执行插入操作, 这行被完整的插入进去了。
疑问:
如果两次粘贴中间没有其他操作, 那么第二次粘贴时不应该会另起一行. 我猜测你应该敲了一个回车符后进行的粘贴.
建议:
了解下 vi 操作基础. | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vim",
"linux"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
关于前后端分离数据接口的问题？
公司有一个小项目自己采用了前后端分离的方式，就是我在js中采用ajax请求后端提供的数据接口（主要是一些文字内容）。有的同事对这种做法提出了自己的疑问，就是数据接口都是写在js中的，那么上线后就有可能被其他人通过查看js的数据接口地址恶意破坏，比如多次循环访问这个接口，造成服务器负荷比较大。
疑问：前后端分离会造成诸如以上的安全问题吗？如何有效避免呢？ | 你那个同事水平有限，不要跟他做朋友。
ajax请求也可以加各种权限校验啊。如果能破解了校验，那就算通过页面返回数据，不是一样能模拟发页面请求么？
再说，多次调接口对服务器有压力，那多次请求页面不也有压力么？ | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"html5",
"ajax",
"前后端分离",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
前端进行兼容性测试的标准流程是什么？
现在业界是怎么进行兼容性测试的？不仅包括IE低版本，还有Chrome、Firefox等的低版本，还是说现在默认不测现代浏览器低版本的兼容性了？那这个低版本有没有一个具体的分界点？ | 看项目需求吧，一般看项目的兼容性需求；
- 一般来说，PC端兼容性测试指IE的兼容性，Chrome、Firefox的兼容性一般来说很少人测，基本上IE的兼容性测试通过了就OK；
- IE兼容性又大概分两个阶段，IE10和IE8；目前一般甚少需要兼容到IE8或以下的了（除非是政府项目，有些还需要兼容到IE6），所以如果项目不特别说明兼容性，一般兼容到IE10就可以了。
- 兼容性测试没有什么标准流程，一般来说都是测试人员手动测试的（听说目前有云测，不过了解了下基本是针对APP的）
- 至于测试平台，可以安装浏览器插件进行基本测试，不过兼容性没有真机测试准确，会有偏差；严格点的测试应该在真机或者虚拟机上测试。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"兼容性"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
为什么Webpack生成JavaScript代码要引入eval模式
最近在看Webpack的生成的JavaScript，有一个疑问想不明白：为什么Webpack要提供`eval`的模式，将模块的generated code用`eval`来包裹？
这里的讨论不仅限于`devtool`是`eval`，还包括`eval-source-map`, `cheap-eval-source-map`等各种包含了`eval`的衍生组合。如果说`eval`的好处是build速度快，因为它不生成source map，那类似于`eval-source-map`这样的呢？
所以我的疑问并不在于source map，而是`eval`本身。既然它如此被诟病，为什么Webpack还是要引入这样一种代码生成机制，它究竟有什么好处？ | goto也被诟病，但你仍然可以在C/C++中使用goto。
真正被诟病的不是eval，而且eval的滥用。如果你确认拿到的代码是你自己的（或任何你信任的），用eval是完全可以接受的，而且可以享受到速度快的好处。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"webpack",
"前端",
"eval"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
css如何让某个元素不继承父元素的宽度，而让子元素撑开他？
这里这个例子：
https://jsfiddle.net/93bh7vpz/
如何让inner这一层和里面所有层的宽度都等于最最最里面的 | html元素宽度不具有继承特性，块级元素(block)的宽度会占据一整行，所以看似继承了，实则不是。
让一个元素的宽度根据内容撑开，只要设置其display不为块级元素，不设置宽度就可以了
比如float,inline,position为absolute,fixed等等等等(真的很多，不是块元素，不要设置宽度) | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"css"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
Js怎么做这题目，
4444
333
22
1
22
333
4444
用JS怎么做。我只会做1以上那半求大神
4444
333
22
1
22
333
4444
我只会做1上面那半 | ```
function f(n) {
for (let i = -n; i <= n; i++) {
if (i === 0 || i === 1) {
continue
}
let k = Math.abs(i)
console.log(k.toString().repeat(k))
}
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"javascript专题系列"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
将一个对象填入window.localStorage后访问不到其中的属性？
```
window.localStorage.setItem('obj', {name: 'hhh', age: 100});
```
localStorage.obj 是存在的，但 localStorage.obj.name 是undefined.
请问如何访问到name的value？ | `localStorage注意事项`
一般我们会将JSON存入localStorage中，但是在localStorage会自动将localStorage转换成为字符串形式
这个时候我们可以使用JSON.stringify()这个方法，来将JSON转换成为JSON字符串
示例：
```
if(!window.localStorage){
alert("浏览器不支持localstorage");
}else{
var storage=window.localStorage;
var data={
name:'luozz',
sex:'man',
hobby:'program'
};
var d=JSON.stringify(data);
storage.setItem("data",d);
console.log(storage.data);
}
```
读取之后要将JSON字符串转换成为JSON对象，使用JSON.parse()方法
```
var storage=window.localStorage;
var data={
name:'luozz',
sex:'man',
hobby:'program'
};
var d=JSON.stringify(data);
storage.setItem("data",d);
//将JSON字符串转换成为JSON对象输出
var json=storage.getItem("data");
var jsonObj=JSON.parse(json);
console.log(typeof jsonObj);
```
另外还有一点要注意的是，其他类型读取出来也要进行转换 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"html5",
"localstorage"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
如何在学习在工作中用不到的技术？
在工作中一些技术并没有实践机会，比如一些公司项目并没有用到vue、webpack等等，在这种情况下如何去学习用不上的技术？ | 这个问题我应该很有发言权
1 首先找个早八晚五的公司，不要相信996能提高技术，提高的只是1+1=2这种问题的熟练度，而且你回家以后很累并不能坚持学习
2 满足1的前提下，学自己想学的知识。强迫自己回家之后写代码，不需要太多一百多行就行 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"程序员"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
前后端分离koa2的作用是什么？
如前后端分离项目 vue + axios + koa2 + java（springboot） 使用restful风格api
问题：
1. koa2到底扮演什么角色？具体点就是什么代码应该写在koa2中呢？
2. vue+koa2 前端组合下，路由应该写在哪里呢？vue-router？ koa？ koa-router？，如果vue和koa2中写两次路由意义在哪里？
3. 有人说的一个场景，后台一般不会把数据根据前端展示字段包装，而是一坨扔过来，然后用koa2进行拆解整合，在给vue显示，这算koa2存在的一个理由么？
4. 用 vue-cli 生成一个项目， 其实就都可以实现前端要求了包括node服务器、webpack等，那么极端点说：在加上axios就都可以啦，koa2没用啊...... | 1.你用vue-cli生成的项目里的koa只是在开发环境里有用，模拟server，在生产环境里是不需要koa的
2.一般的前后端分离的项目也很少需要在前端后后端java之间加一层node，也就是koa，除非是像淘宝这种，需要首屏优化或者有强烈的seo需求的，需要浏览器请求到的就是可以直接展示的静态页面的，或者是后端java提供的api不能直接给前端展示的，需要经过转换的，才会需要node中间层
3.vue-router是前端路由，是在浏览器里执行的，url改变，切换不同的页面，而 koa-router主要是针对服务端的，对于api的路由 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"前后端分离",
"koa2",
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
webpack4，不再支持extract-text-webpack-plugin
今天体验了一下webpack4.1.0，发现不再支持 extract-text-webpack-plugin。
那应该用什么方法去单独提取css文件呢？
还有一个问题是，我在看别人用webpack打包的一个开源项目的时候，发现它的html中，是这样引入css的
```
<link type="text/css" rel="stylesheet" href="blob:null/e83446f1-423b-40a8-a91a-d885bde94722">
```
那个 href 中的内容是什么意思啊，是用什么插件完成的？
而且我在文件内也没找到它生成的css文件，只有源码中的scss文件。
实在的搜索不到答案。请大神指教一下，先谢过了。 | 原因：`extract-text-webpack-plugin` 最新版本为 `3.0.2`，这个版本还没有适应 `webpack 4` 的版本
解决办法：使用 `4.0 beta` 版，`npm install --save-dev extract-text-webpack-plugin@next` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"webpack"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
关于token不理解的地方
目前在写api接口，是为移动端提供的接口，那么我们为用户设定了用户名密码的同时，为何还要加一个token？而且文档还说以token的方式来验证？那每次直接确认用户的密码不行吗？这个token作用是啥？百度说的不清楚啊 | 例如：
云冲印应用要访问你的百度网盘，读取网盘图片然后打印给你。但是它需要你的账号和密码才能登录访问你的网盘。你会放心把账号密码给它用吗？但是你可以授权网盘给云冲印一个令牌，这个令牌有效期10天。云冲印有了这个token，就相当于有了你的账号和密码。就可以拿着token去访问你的网盘数据了。这样你的密码不会泄露。你可以随时取消这个授权，这样可以禁止别人去读取你的数据。如果你给了账号和密码，那么以后想取消授权就只能改密码了。
用户密码存储在本地是不安全了，别人有机会可以看到你的明文密码。API是无状态的，难道每次请求都要把用户名和密码带上吗，这样会不安全。
本质上 token = 用户名 + 密码 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"python",
"django",
"java",
"c"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
node中跨域代理 proxyTable的原理是什么？
1.node中跨域代理 proxyTable的原理是什么？
2.我在浏览器和服务端都没有设置CORS的情况下，只要设置proxytable就可以跨域了，这样是不是就违背了同源策略的初衷？
ps: 希望见到比较有水准的解释 | 跨域是浏览器禁止的，服务端并不禁止跨域
所以浏览器可以发给自己的服务端然后，由自己的服务端再转发给要跨域的服务端，做一层代理
`vue-cli`的`proxyTable`用的是`http-proxy-middleware`中间件
`create-react-app`用的是`webpack-dev-server`内部也是用的`http-proxy-middleware`
`http-proxy-middleware`内部用的`http-proxy` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"node.js",
"vue.js",
"跨域"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
关于promise中reject和catch的问题
reject和catch是否都会执行，或者只执行其中一个，分别在什么情况下执行？ | ### 一、reject后的东西，一定会进入then中的第二个回调，如果then中没有写第二个回调，则进入catch
```
var p1=new Promise((resolve,rej) => {
console.log('没有resolve')
//throw new Error('手动返回错误')
rej('失败了')
})
p1.then(data =>{
console.log('data::',data);
},err=> {
console.log('err::',err)
}).catch(
res => {
console.log('catch data::', res)
})
VM367054:2 没有resolve
VM367054:11 err:: 失败了
```
- then中没有第二个回调的情况
```
var p1=new Promise((resolve,rej) => {
console.log('没有resolve')
//throw new Error('手动返回错误')
rej('失败了')
})
p1.then(data =>{
console.log('data::',data);
}).catch(
res => {
console.log('catch data::', res)
})
VM367054:2 没有resolve
VM367054:11 catch data:: 失败了
```
- 如果没有then， 也可以直接进入catch
```
var p1=new Promise((resolve,rej) => {
console.log('没有 resolve')
//throw new Error('手动返回错误')
rej('失败了')
})
p1.catch(
res => {
console.log('catch data::', res)
})
VM367087:2 没有resolve
VM367087:9 catch data:: 失败了
```
### 二、resolve的东西，一定会进入then的第一个回调，肯定不会进入catch
```
var p1=new Promise((resolve,rej) => {
console.log('resolve')
//throw new Error('手动返回错误')
resolve('成功了')
})
p1.then(data =>{
console.log('data::',data);
}).catch(
res => {
console.log('catch data::', res)
})
VM367087:2 resolve
VM367087:9 data:: 成功了
```
- 不会进入catch的情况
```
var p1=new Promise((resolve,rej) => {
console.log('resolve')
//throw new Error('手动返回错误')
resolve('成功了')
})
p1.catch(
res => {
console.log('catch data::', res)
})
VM367087:2 resolve
```
throw new Error 的情况和rej一样，但是他俩只会有一个发生
另外，网络异常（比如断网），会直接进入catch而不会进入then的第二个回调 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"回调"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
Js在数组中添加元素
如何提取数组中的字段，然后添加新的字段，获取数据如下：
```
var data = [
{"id":"1","name":"华为","data":"25u6s8f545d3"},
{"id":"2","name":"小米","data":"cd58de9d3c5d"},
];
```
我想获得的数据格式如下：
```
var data = [
{"id":"1","name":"华为","data":"25u6s8f545d3","mac":"25:u6:s8:f5:45:d3"},
{"id":"2","name":"小米","data":"cd58de9d3c5d","mac":"cd:58:de:9d:3c:5d"},
];
```
我现在方法如下：
```
for (var i = 0; i < data.length; i++) {
var mac = data[i].data.toUpperCase();
mac1 = mac.substring(0, 2);
mac2 = mac.substring(2, 4);
mac3 = mac.substring(4, 6);
mac4 = mac.substring(6, 8);
mac5 = mac.substring(8, 10);
mac6 = mac.substring(10, 12);
var mac = mac1 + ':' + mac2 + ':' + mac3 + ':' + mac4 + ':' + mac5 + ':' + mac6;
data[i].mac = mac;
};
```
请教下有没有更好的方法？我觉得自己方法有点烂。 | ```
var data = [
{ "id": "1", "name": "华为", "data": "25u6s8f545d3" },
{ "id": "2", "name": "小米", "data": "cd58de9d3c5d" },
];
data.forEach(item => {
item.mac = item.data.replace(/\w{2}\B/g, '$&:')
})
console.log(data)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
web框架中的controller、service层、dao层、logic层的联系与作用啊
### 一直不太理解controller、service层、dao层、logic层这几个概念，以及具体如何用、为何这样用 | 说下个人目前在用的分布
Controller:接受Web请求,分发调用不同的逻辑或服务完成一项事情,返回数据
service:做些服务Api接口相关的代码
dao:和数据库打交道(对表进行增删改查)
logic:自己的业务逻辑相关
```
现在有个PC注册账号的功能
1:初始阶段,controller收到请求,直接在controler里面写数据库连接，进行增删改查,没毛病，可以运行。
2:慢慢发展,功能多了，Controller多起来了，contoller到处都是sql和数据库打交道的代码,虽然不影响运行,但是有时候发现,如果我要修改一个数据表的字段或其他东西,得到好几个Controller里面去找相同的一个代码并修改,太麻烦了,干脆都放到一个里面,全部对增删改查从同一个地方多好,这时候出现了dao层。
3:继续发展,进军移动端,有了手机注册的功能，简单,写呗，写着写着发现,我去，怎么和PC注册功能这么像？都要校验用户信息->判断数据库有无重复->插入数据库（重复的业务功能在几个控制器都要被重复使用），有了第二步的经验,把这些相同的业务操作抽离放到一起呗，出现了logic层(logic层负责做些处理并调用dao层完成数据的入库等和数据库打交道的事情),RegisterLogic，规定所有的注册功能都走这一个逻辑了,维护更加方便了,以后即使增加一百种注册方式,只要 new RegisterLogic()->register();就行了。
4:继续发展下去,公司有声有色的,老板说，网站太无聊了，加点天气预报,随机推送笑话的附属功能吧,这行功能不属于自己的系统的业务逻辑,更具第二步和第三步的经验，应该单独放一个地方,没准以后其他的地方会用到,这时候service层就出现了。
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"php",
"java"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
jwt前端加密后端解密
最近在学习jwt，但是遇到一个问题。
用户输入用户名和密码之后发送给服务器，服务器将其加密后返回token，每次前端请求都带上这个token。
于是我产生一个问题：用户输入账号和密码如果这个请求被拦截了就能拿到了账号密码，但是有一种叫openssl的东西，就是要求域名用https。但是这种方式也不是十分安全。
既然jwt有JavaScript版，那为啥不在前端就加密了，之后后端解密去验证呢？
问题：jwt前端加密账号密码，后端解密如何实现？
现在做的项目也有token的做法，实现方式：
1.页面加载前端发送一个16位后端就会返回一个publick_key。
2.前端收到这个public_key将用户名密码还有一个16位的随机数用md5加密。
3.登陆的时候将上面的加密发送给后端，后端使用private_key解密后得到加密的数据。
我想上面的实现方式就跟jwt类似。 | 先不管JWT和SESSION机制，我来讨论下网络安全问题，可能说的不对，欢迎指正。
假定现在你的电脑不安全，电脑中被安装了木马监听，同时网关里有也中间人：
1. 无论你的网页中是否加密，你在键盘中输入的任何数据都会被木马监听到，这是操作系统层的监听；
2. 你在网页中键入的请求以及接收到的响应，通过网关都会被中间人拦截，这是路由层的监听；
所以，加密密码必须采用哈希算法，而不是对称加密；不然中间人既然可以拦截所有的请求和响应，而js又是明文，你如何保证对称加密的秘钥不被中间人看到呢？
> 你可能会问加密的密码也会被看到，中间人也可以绕开网页，直接发包模拟请求。是的，确实如此；加密密码解决的是不让你的密码被明文泄露，这样中间人无法用你的账户密码去其他应用中撞库。
但是传输的主体内容是不能采用哈希算法，因为双方必须知道具体的内容，这导致了中间人会看到明文的内容；(简单的JS对称加密是无用的，因为HTML是明文的，中间人也可以看到对称加密的秘钥)
HTTPS解决的就是对称加密的问题，将证书提前准备好，并通过浏览器预先安装的根证书来避免中间人伪造证书，这从根本上解决对称加密的秘钥问题。
而JWT我觉得从根本上，并不是为了解决网页安全问题，而是想通过一种分布式无状态的方式来解决服务端的SESSION问题。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"html5",
"php"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
mongoose 的Virtual是什么？
Virtual properties are document properties that you can get and set but that do not get persisted to MongoDB.
这句话看不是很懂。请不要翻译，希望能用自己的话解释，有例子更好。谢谢 | 大致意思就是，你可以用mongoose添加和设置虚拟属性，但是这虚拟属性的值不会保存到数据库中。
比如，前台传到后台一个参数name，代表用户的名称，但是数据库保存的是两个字段，姓和名，这就可以用虚拟属性
```
// 数据库中缓存的格式
var schema = new Schema({
name: {
first: { 'type': String },
last: { 'type': String },
}
});
// 当获取该 schema 的fullname属性时,将 schema 中的 name.first 和 name.last 拼接起来返回
var virtual = schema.virtual('fullname');
virtual.get(function () {
return this.name.first + ' ' + this.name.last;
});
// 当设置该schema的 fullname 属性时,将设置的字以空格分开,分别赋值给 schema 中的 name.first 和 name.last 属性
var virtual = schema.virtual('fullname');
virtual.set(function (v) {
var parts = v.split(' ');
this.name.first = parts[0];
this.name.last = parts[1];
});
// 将该 schema 保存到数据库中时,只会保存 name.first 和 name.last
// fullname属性的值不会保存到数据库中,这就是virtual
```
http://mongoosejs.com/docs/ap...
set 中的 function 的参数 v,是设置虚拟属性时的值.不保存到数据库中,但是它也是有存在的意义的,比如,就像例子中的,在用户看来,它只有一个名字,但是在数据库中,是要保存姓和名,因为分为姓和名,我们后续可以对用户做统计,姓张的多少人.(这也只是举个例子).
再比如,订单的状态,数据库中保存的是0,1,2,3,4,5,6,7.但是在页面上,显示的是未支付,已付款,待发货,已发货,待收货,已完成,待评价等.我们就可以设置一个虚拟属性
```
var virtual = schema.virtual('statusName');
virtual.get(function () {
switch(this.status){
case 0: return '待发货';
case 1: return '待收获';
case 2: return '已完成';
default: return '待支付';
}
return this.name.first + ' ' + this.name.last;
});
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"mongoose",
"mongodb"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
angular4项目中使用ng server启动 别人在局域网里访问无效
angular4项目中使用ng server启动后本地用localhost:4200可以打开，在局域网里别人用我的局域网地址无法访问我的项目 | 运行ng serve --host xxx.xxx.x.xxx（自己的ip地址）,然后别就可以通过你的ip地址访问了。
好像在项目里面也可以配置的，配置了的话可以直接运行ng serve就行，具体怎么弄我也忘了 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"server",
"angular4",
"局域网"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
|
CSS3 Transform 引起的 z-index "失效"
两个页面使用的css3 Transform动画之后，页面下子元素的z-index就失效了，就算设置的再大的值也不会起作用，但是一个页面的时候是没有问题的 | 这里涉及到一个`stacking context`（有人翻译为`层叠上下文`）的概念。
给元素设置`transform`属性会创建一个新的`stacking context`。
请看下面的具体讲解：
注：以下两个例子最好先想象一下预览效果，再查看结果预览页面。
先上一个小例子（你可以在https://jsfiddle.net/运行）：
```html
'<div class="test test-1">
</div>
<div class="test test-2">
</div>
```
```css
.test {
width: 100px;
height: 100px;
}
.test-1 {
-webkit-transform: scale(.9);
transform: scale(.9);
/*opacity: 0.9*/
background: #f20;
}
.test-2 {
margin-top: -50px;
background: #000;
}
```
上面这个例子中，两个div都没有设置任何`position`，如果没有给`test-1`添加`transform`属性的话，第二个div将会覆盖第一个div。但是如果设置了`transform`的话呢？由于`transform`会创建一个新的`stacking context`。在层级关系上就要比`test-2`高一级，因此，显示在上面。
再来一个例子，
```html
'<div class="test test-1">
</div>
<div class="test test-2">
</div>
```
```css
.test {
width: 100px;
height: 100px;
}
.test-1 {
position: relative;
background: #f20;
}
.test-2 {
-webkit-transform: scale(.9);
transform: scale(.9);
margin-top: -50px;
background: #000;
}
```
这个例子了是对上面那个例子作了个简单的修改。我们给`test-1`添加了一个`position: relative`，`test-2`没有任何`position`属性，只是添加了一个`transform`的属性。如果不看预览页面的话，可能会以为`test-1`会显示在`test-2`上方，其实不然。由于`transform`会创建新的`stacking context`，同时`test-2`在文档中又处于`test-1`的后面，所以最终的效果是`test-2`显示在`test-1`的上方。
那么问题来了，哪些情况下会创建新的`stacking context`呢？
MDN上有相关的介绍：
- the root element (HTML),
- positioned (absolutely or relatively) with a z-index value other than "auto",
- a flex item with a z-index value other than "auto",
- elements with an opacity value less than 1,
- elements with a transform value other than "none",
- elements with a mix-blend-mode value other than "normal",
- elements with isolation set to "isolate", on mobile WebKit and Chrome 22+, position: fixed always creates a new stacking context, even when z-index is "auto",
- specifing any attribute above in will-change even you don't write themselves directly
其中，第二条是我们平时最常见的，另外几条加粗的会随着CSS3的普及越来越常见。令我感到惊奇是，`opacity`竟然也会创建新的`stacking context`，你可以试着将上面两个例子中的`transform`换成`opacity`，会得到同样的效果。
值得注意的是，介绍`stacking context`的文章显然不像介绍CSS中另外一个“上下文”——`Block formatting context`（块级格式上下文）的文章多，原因可能是，我们在平常很少遇到`stacking context`相关的问题，但是随着CSS3的普及，这方面的问题可能会多起来的。
这也算是CSS中一个比较有趣而且有用的知识点，之前在工作中遇到过一次，正好此处有人问到，特整理了一下，供参考。
### 补充
说了这么多，回到你这个具体的问题上来，由于你没有提供具体的代码，不好说出具体的问题所在，但可以推测出你的代码中可能有类似下面这个例子中的结构。你给`.child`设置再大的`z-index`都没有用。但是如果将`.inner`的`transform`去掉就不一样了。试试看。
```html
<div class="test test-1">
<div class="inner">
<div class="child">
Child
</div>
</div>
</div>
<div class="test test-2">
</div>
```
```css
.test {
width: 100px;
height: 100px;
}
.test-1 {
position: relative;
background: #f20;
}
.inner {
width: 80px;
height: 80px;
transform: scale(1); /*此处会产生新的stacking context*/
background: green;
}
.child {
position: absolute;
bottom: 15px;
color: #fff;
font-size: 30px;
z-index: 1000;
}
.test-2 {
position: relative;
margin-top: -50px;
background: #000;
}
```
### 参考链接
- [The stacking context](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_positioned_layout/Understanding_z-index/Stacking_context) | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"css3动画"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |