instruction stringlengths 15 8.46k | input stringclasses 1
value | output stringlengths 55 23.5k | task_type dict | domain listlengths 1 5 | metadata stringclasses 1
value | answer_from stringclasses 1
value | human_verified bool 1
class | copyright stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|
http和https的区别?
我知道https更加安全,问题是怎么个安全法?
比如,我现在有一个纯的静态页面,就是做信息展示,就是我们说的marketing site,这里面也没有什么ajax请求啥的,是不是就http/https从安全角度就没有区别了????
但是浏览器还是标记Http not secure呢?哪里不安全了? | 小明要给小红写信,但小明小红之间离的太远了,没法直接交换信件,只能是小明先给小强、小强再给小刚、小刚再给小红,小红收到了以后回信给小刚、小刚再给小强、小强才能给到小明。小强和小刚在这个过程中都可以拆开信看到内容、甚至模仿小明小红的字迹去篡改这封信。本来可能小明写的是情书,被小刚改成了战书,小红收到了不得气炸了。
你现在用浏览器访问了思否网站,但你的电脑跟思否网站服务器显然并不是一根网线直连的,中间会经过层层设备转发,有路由器、交换机、中继器、代理、网关等等等等。而 HTTP 是明文的,也就是这中间的每一个设备都可以监听、甚至篡改 HTTP 报文。即便你是纯静态的网站,但你怎么确保浏览器收到的一定就是你的服务器返回的那个 HTTP 报... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"http",
"https"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
为什么感觉redis队列不如mysql稳定,容易丢数据,原因何在?
目前的开发环境:php7.2 | thinkphp
1.用mysql实现的架构:
生产者:大量数据先存入mysql中间表(mysql中间表用唯一索引约束唯一性)
多个消费者:循环从mysql中间表中取数据,进行计算后存入mysql结果表
2.用redis实现的架构:
生产者:大量数据先进入redis集合(为了保证重复数据不入队列),确定能进入集合的数据再塞入redis队列
多个生产者:循环从redis队列中取数据,每取一条数据后将该数据从redis集合中删除,对数据进行计算,计算后的数据存入mysql结果表
两种架构在实际使用中发现,用纯mysql的方式实现,结果数... | 首先,Redis什么时候会出现`丢数据`?
Redis持久化有两种方式`RDB`和`AOF`,它只会在重启时可能丢失数据。正常运行的情况下,是不会丢失数据的。
找不到丢失的原因?,为什么不稳定?
MySQL有ACID,强一致性事务支持。而Redis分步操作,每步都可能出问题。
`而且还找不到数据丢失的原因`
分步骤来看:
- 大量数据先进入redis集合? 是否正常
- 再塞入redis队列? 是否正常
`循环从redis队列中取数据,每取一条数据后将该数据从redis集合中删除,对数据进行计算,计算后的数据存入mysql结果表`
这是一个很大的步骤。最简答的方法,加日志,看看是哪里丢的数据。比如取了数据从Redis删除了,计算时... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"后端",
"php",
"java",
"mysql",
"redis"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
JS 中通过apply实现数组中,查找最大值的方法原理是什么?
JS数组中无法直接通过`Math.max`查找数组中元素的最大值,但可以通过`apply`方法实现,底层实现逻辑及原理是什么样的呢?
```
Math.max.apply(null, [1,2,3]);
``` | 我们这样来理解,
首先,
```
Math.max(value0, value1, /* … ,*/ valueN)
```
这个函数的参数并不是数组,比如你有N个数字比大小,哪它就要输入N个参数,
对于在数组中的数字,你把整个数组当参数给它,Math.max就认为只有一个参数了。所以比不了
也就是说,你要把数组中每一位数字,都转成它的参数
```
const arr=[1,2,3]
//最笨的办法是
Math.max(arr[0],arr[1],arr[2])
//最新的办法
Math.max(...arr)
```
上面都是把数组的每一位,变成参数传个Math.max
哪为什么,Function.prototype.apply... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
为什么mysql的依赖scope是runtime?
如题,runtime意味着打包时不包含mysql依赖,没有mysql驱动发布后的项目如何正常连接数据库呢? | 因为JDBC通常你在编码的时候依赖的只是JDBC接口,而不直接依赖mysql JDBC对吧?
想想你在连接mysql的时候是不是用的类似于这样的代码?
```
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection(url, username, password);
// ...
```
我们会发现我们会使用反射方法`Class.forName`在运行的时候从ClassPath中加载Mysql JDBC,后续调用的时候均没有使用任何MySQL JDBC的专有方法,而是用的JDBC接口,对吧?
所以JDBC Driver... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"mysql",
"java"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
chrome控制台调试:f9 和 f11 有何区别?
f10(跳过下一个函数调用)、f11(进入下一个函数调用)用的很熟,但f9(单步调试)没用过,经过测试感觉和f11一样,遇到函数就进入函数里边执行。那么f9 和 f11 有何区别? | stackoverflow
You can spot the difference while running async code or multi-threaded code.
Step into: DevTools assumes that you want to pause in the asynchronous code that eventually runs
Step: DevTools pause in code as it chronologically ran
Consider this example:
```
setTimeout(() => {
console.log('inside')
}, 30... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"前端",
"javascript",
"chrome",
"chrome-devtools",
"调试"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
函数传入的值,作为对象的 key 返回,TS 应该如何写?
返回的 `ts` 一定有 `a` 这个 `key`:
```
function test(a:string, b:object){
return {
[a]:b[a]
}
}
``` | ```
function test<T extends Record<string, any>, K extends keyof T>(a:K, b:T){
return {
[a]:b[a]
} as Pick<T, K>
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"typescript",
"前端",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
如果一次网页操作本身就只会触发一次回流/重绘,那么虚拟 dom 还有优势吗?
按照我目前的理解,虚拟dom的优势在于把当前的变化打包给浏览器,让浏览器一次性更新,而不是来一个更新一个,减少页面的回流和重绘.
但是如果只有一个按钮, 点一下文字变色或者改变某个元素的显隐性,那么这种操作浏览器应该本身就是只回流/重绘一次,这个时候虚拟dom还有优势吗?
#### 还有个小问题: 默认浏览器是怎么更新元素的?
如果我一次 display:none 了页面中的9个元素,那么在没有虚拟dom的情况下,浏览器会回流/重绘9次吗 | Q1:
> 但是如果只有一个按钮, 点一下文字变色或者改变某个元素的显隐性,那么这种操作浏览器应该本身就是只回流/重绘一次,这个时候虚拟 DOM 还有优势吗?那肯定是原生直接操作 DOM 更快。
但问题是这种简单页面的场景为啥你要用 MVVM 框架?
Q2:
> 如果我一次 display:none 了页面中的 9 个元素,那么在没有虚拟 DOM 的情况下,浏览器会回流/重绘 9 次吗。
这里的“一次”,我理解为是一段代码里连续控制 9 个元素隐藏,类似:
```
el1.style.display = 'none';
el2.style.display = 'none';
el3.style.display = 'none';
/... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"前端",
"javascript",
"vue.js",
"react.js",
"chrome"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
来个 js 算法大牛看看这个题,有没有优雅点的代码?
`源数据`
```
const data = [
{
city:'浙江',
children:[
{
city:'宁波',
children:[{
city:'鄞州区',
children:[]
},{
city:'江北区',
children:[]
}]
},
{
city:'杭州',
children:[{
city:'富阳',... | ## solution 1
```
function flatTree(nodes, parents = []) {
const pathes = nodes
.filter(({ children }) => !children?.length)
.map(({ city }) => [...parents, city]);
const subPathes = nodes.filter(({ children }) => children?.length)
.flatMap(({ city, children }) => flatTree(children, [...... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
怎么让 a == 1 && a==2 && a==3 的结果为 true?
让 a == 1 && a==2 && a==3 的结果为 true | ```
function A() {
this.value = 0;
this.toString = function() {
return ++this.value
}
}
const a = new A();
a == 1 && a == 2 && a == 3
```
相等运算符 `==` 和 `!=` 使用 抽象相等比较算法 比较两个操作数。可以大致概括如下:
- 如果两个操作数都是对象,则仅当两个操作数都引用同一个对象时才返回 `true` 。
- 如果一个操作数是 `null`,另一个操作数是 `undefined`,则返回`true` 。
- 如果两个操作数是不同类型的,就会尝... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
js 函数 return false 跳出外部函数,怎么写?
```
function a(){
if(true)
return false;
}
```
这是没有任何问题的,如果我改成这种
```
function Test(){
a();
b();
c();
}
```
js 函数a() return false 跳出外部函数Test(),怎么写? | `return` 只能退出当前函数,不具备跨函数的功能。但是 `throw` 具有不限层次中断的功能,所以这个需要可能需要使用 throw 来完成。
一般情况下 `throw` 应该抛出一个 `Error` 对象。但是 JavaScript 并未对 `throw` 的对象有所有限制,所以也可以抛出其它东西,在确实不需要抛出错误的情况下,抛出一个状态对象,甚至值都是可以的。但不管抛出什么,要想外面的程序能正常运行,都是需要 `try ... catch` 的。
举例:
```
function a() {
console.log("[Trace] a()");
if (true) {
throw "tr... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
判断一个字符串,A-Z对应输出0-25,a-z对应输出26-51,有什么简洁的写法吗?
比如:'AZaz' => '0 25 26 51'
我目前的做法:
```
function Words(words){
let strArray = []
for (let s of words){
if(/[A-Z]/.test(s)) strArray.push(s.charCodeAt(0)-65)
else if(/[a-z]/.test(s)) strArray.push(s.charCodeAt(0)-71)
}
return(strArray.join(' '))... | ```
var Words=(s,a='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz')=>s.split('').map(v=>a.indexOf(v)).join('');
Words('AZaz');
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"算法"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
来个 js 大牛,如何简洁的处理这种数组转换成对象?
有这样一个 Array,
`[{key:xxx},{value:xxx}]`
`key` `value`是固定的属性
```
[
{key:'alan',value:12},
{key:'mike',value:18}
]
```
期望值
```
{alan:12,mike:18}
```
希望不借助新的变量,简洁优雅一些~ | 其实所谓简洁,无非就是找现成的功能函数替换掉一堆逻辑代码……所以,自己封个工具函数,一句调用是最简洁的!
```
const data = [
{ key: "alan", value: 12 },
{ key: "mike", value: 18 }
];
// 就这句话,换行主要是为了看清楚,可以不换
const result = Object.fromEntries(
data.map(({ key, value }) => [key, value])
);
console.log(result);
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
Vue如何动态修改template?
先上代码:
```
<template>
<div v-html="marked(content)"></div>
</template>
<script>
....
....
methods:{
markdown (content) {
var renderer = new marked.Renderer()
renderer.image = (href, title, text) => {
return '<a @click="showFullImage">' + text + '</a>'
}
marked.se... | 我是在一个子组件中实现的,你可以动态的添加该子组件:
下面的`content`是markdown格式的数据,
`../common/markdown`文件是自己写好的基于marked的解析函数,它会将`Markdown`格式析为`Vue`格式的字符串:
```

// 上面会解析为:
<img src="url" @click="showInfo('图片文字')">
```
用下面的方法即可以实现点击图片时,会输出信息。当然其他的vue处理方法同样支持。
```
<template >
<div ref="markedContent"></div>
</template>
<script>
import... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"marked"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
怎么判断一个数组里是否嵌套子数组
我怎么判断一个数组是不是双层呢,判断后返回true和false,比如[1,1,1,1]就是false,[1,[2,2,2],1,1,1]就是true,有啥方法么,如果是三层,怎么判断呢 | `isDeepThen()` 用来判断最大深度是否超出指定 level;`getMaxDeep()` 用来获取最大深度。都是递归实现。两个函数没有直接关系,只是用来干不同的事情。
```
const cases = [
[1, [2, [3, [4], [5]]]],
[1, [2, [3]]],
[2, [2, 3]],
[1, 2, 4],
1
];
// 检查最大深度是否超过指定 level,如果 level 传 0 表示只要是数组就行
// 可以通过 getMaxDeep() 来判断,但是 getMaxDeep() 会遍历所有项,效率较低
// isDeepThen() 有快递中断机... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
Mysql 为什么要有最左前缀的要求,优化器不能自己优化调整顺序吗
比如一个联合索引 `index('user_id', 'created_at')` ,我写了下面的 `SQL` 语句
```
select
*
from
tweet
where
created_at < '2021-11-11'
and user_id = 1
```
优化器会把上面的语句优化为下面的语句吗?
```
select
*
from
tweet
where
user_id = 1
and created_at < '2021-11-11'
``` | 你对左前缀理解错了。
你这种情况是可以用到索引的。
左前缀是指这种情况走不了索引
```
select
*
from
tweet
where
created_at < '2021-11-11'
```
而这种情况可以
```
select
*
from
tweet
where
user_id = 1
```
因为 `user_id` 在联合索引的左边。
如果有索引 (a, b, c) 那么 `where a, b, c`、`where a, b`、`where a` (where 后的顺序无关,可以随意组合,但是跟出现的字段有关)都是可以走到索引的。但是 `where b, c` 就不... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"mysql"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
请问大家,这个小算法问题,怎么改?
[
```
{
"categoryId": "373",
"parentId": "3",
"categoryName": "张三",
"sunCategorys": [
{
"categoryId": "374",
"parentId": "373",
"categoryName": "张三一",
},
{
"categoryId": "375",
"parentId": "373",
... | ```
const result = data.map((item) => ({
text: item.categoryName,
children: item.sunCategorys.map((category) => ({
text: category.categoryName,
id: category.categoryId,
})),
}));
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"vue.js",
"react.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
vue的nextTick为什么一定会比promise更先执行?
nextTick内部打比按照promise进行,那么是怎么做到比逻辑中的promise更早执行的?看源码写的是Promise.resolve().then(callback)执行回调代码callback
```
if (typeof Promise !== 'undefined' && isNative(Promise)) {
const p = Promise.resolve()
timerFunc = () => {
p.then(flushCallbacks)
// In problematic UIWebViews, Promise.th... | 首先我不知道您是怎么得出一定这个结果的,nextTick并不一定比Promise快,它本来就是Promise就得遵循Promise的规范和顺序,但是nextTick是对Promise的封装,所以
```
nextTick(fn1) // Promise
nextTick(fn2)
nextTick(fn3)
```
实际上就初始化了一个Promise就在第一个nextTick执行的时候
后面调用的fn2,fn3可以理解为都是往第一个fn1函数里push的,所以下面的执行顺序就是fn1 fn2 fn3 fn4因为fn1 fn2 fn3合并为了一个函数,就造成了 fn2 和fn3比fn4快
```
nextTick(fn1) // Pr... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
在 JavaScript 中,如何实现 const a = [...5] 就可以创建一个 [1, 2, 3, 4, 5] 数组
如何实现在编写 JavaScript 项目时,可以以下面这样的方式,创建一个新的数组:
```
const a = [...5];
// a = [1, 2, 3, 4, 5];
``` | ```
Number.prototype[Symbol.iterator] = function () {
const i = +this;
let value = 0;
return {
next() {
value += 1;
return {done: value > i, value};
}
};
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"变态面试题"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
请问 prettier 与 EditorConfig 功能是不是重复了?
prettier 与 EditorConfig 都是代码格式化工具,他们到底有什么区别?我只知道他们的配置文件不同,一个是.prettierrc文件,而另外一个是.editorconfig文件,但感觉他们功能一样,在网上看别人教程,为何都是两个一起使用的?不是功能重复了吗?求解答? | EditorConfig 格式化的是比较基础的东西,基本上你用“Editor”(编辑器)本身能干的操作就可以用它来干。比如 Tab 变几个空格啊、换行符是 CR 还是 CRLF 啊、文件编码是不是 UTF-8 啊这种的。
而且它不只局限于格式化,名字也能看出来是“Config”(配置)而不是“Formatter”(格式化器)。你也可以用它来配置诸如让 IDE 忽略特定的编译警告错误之类的。
所以你会发现它跟编程语言本身没什么关系,各个语言的项目都能看到 `.editorconfig` 的身影,它更多地干的是当你用特定 IDE 时能配置的那些东西,好让那些不用这个 IDE 的、或者它 IDE 配置跟你不一样的开发者也能使用相同的编辑器... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"前端",
"prettier"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
请求返回的是 字符串 格式的 js代码,我要怎么 import 到内部的 模块呢
手动@大佬回答 @边城
如题 后端接口返回给我的是
字符串格式的
```
var a = 1
function setA(v){
a = v
}
export function getA(){
return a
}
```
我要怎么 `import` 到内部的 `getA` 模块呢
使用的 `vue` | https://stackoverflow.com/que...
```
<script type="module">
const code = `
var a = 1
function setA(v){
a = v
}
export function getA(){
return a
}
`;
const objectURL = URL.createObjectURL(new Blob([code], { type: 'text/javascript' }));
const module = await import(objectURL);
console.log(module.getA());
</script>... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
vue怎么监听数组项?
如下数组,其中ccc属性值根据bbb属性和ddd属性计算得到的,我需要监听数据项的变化,动态计算ccc属性值
```
export default {
data() {
return {
aaa: [{
bbb: "xxx",
ddd: "xxx",
ccc: ""
}, {
bbb: "yyy",
ddd: "yyy... | ```
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width">
<title>JS Bin</title>
</head>
<body>
<div id="app">
<div v-for="v of list">
<input type="number" v-model="v.a">
<input type="number" v-model="v.b">
<span>sum: {{v|sum}}</span>
... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
JS的onclick在Chrome和Safari中均不能被触发
写了一段很简单的源码,就是最基本的使用 <button> 触发事件:
HTML 源码如下:
```
<body>
<button>Click this button to trigger an event</button>
</body>
<script src="Event.js"></script>
```
JS 源码如下:
```
var btn = document.getElementsByTagName("button")
btn.onclick = function () {
alert("Successfully Triggered a... | 因为getElementsByTagName获取的是元素集合,不是元素本身,所以你需要先从这个集合中取到元素,再进行绑定
```
var btns = document.getElementsByTagName("button")
// 或者使用遍历,需要注意它是一个为数组,不能直接当数组进行遍历
btns[0].onclick = function () {
alert("Successfully Triggered an Event !");
console.log("Good");
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"onclick",
"html"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
JS排序问题(凑满减)
```
const list =[
{title:'苹果',price:1},
{title:'香蕉',price:4},
{title:'鸭梨',price:3},
{title:'西瓜',price:5},
{title:'山竹',price:2}];
```
我想排序, 按照price大于3的正序, 然后再把小于3的倒序, 排在大于的数据后面, 求最优算法.
期望如下:
```
const list =[
{title:'香蕉',price:4},
{title:'西瓜',price:5},
{title:'鸭梨',price:3},
{title:'山竹',price:2}... | ```
list.sort((a, b) => {
if(a.price > 3 && b.price > 3){
return a.price - b.price
}
return b.price - a.price
})
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
if判断是否有值,但是这个值为0,它也判了不过请问怎么写呢
```
// row保存
saveRow (record) {
const { num, id } = record
if (!num) { // 这里为0也走了,怎么判断单纯有没有值
this.tableLoading = false
this.$message.error('请填写完整信息。')
return
}
},
``` | 这里先要搞明白 `num` 允许是哪些值。如果只能是数字的话,可以这样
```
if (typeof num === "number") { ... }
```
不过这样的话,`num` 还有可能是 `NaN`,一般 `NaN` 也需要过滤掉(要不要过滤看业务),所以
```
if (typeof num === "number" && !isNaN(num)) { ... }
```
接下来,如果逻辑可以保证 `num` 只会是数字,或者空(含 `undefined`),那么可以这样判断
```
if (!(num === undefined || num === null || isNaN(num))) { ... }
```
... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
定义一个数组,调用方法报错
通过不同方式定义一个数组,直接调用方法报错
感觉可能和js自动装包有点关系
但是每种情况报错文案还不太一样
为什么借用一个变量就ok了
它们内部机制是什么,求大佬详细讲解下
```
const a = 1
const b = 2
[a,b].forEach(e => {
console.log(e);
});
//VM409:3 Uncaught ReferenceError: Cannot access 'b' before initialization
```
```
let a = 1
let b = 2
[a,b].forEach(e => {
console.log(e);
... | 少写了分号
每一行最后都加上分号
const a = 1;
const b = 2;
分号会和下一行的 [ 连在一起
相当于
```
const b = 2[a,b].forEach(e => {
console.log(e);
});
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"数组"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
问个java很白痴的问题
为什么`String`类型是大写的 别的类型都是小写的? | 小写的,应该是基本类型。Java 基本类型只有 8 种,这 8 种类型不是类类型,但有对应的类类型
- `byte` ⇔ `java.lang.Byte`
- `short` ⇔ `java.lang.Short`
- `int` ⇔ `java.lang.Integer`
- `long` ⇔ `java.lang.Long`
- `float` ⇔ `java.lang.Float`
- `double` ⇔ `java.lang.Double`
- `boolean` ⇔ `java.lang.Boolean`
- `char` ⇔ `java.lang.Character`
基本类型不是类,也不会在任何包里。其他类型,都是... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"后端",
"java"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
for...of 循环含有辅助平面字符的字符串,输出让我感到困惑
## 代码
```
let count = 0,
s = "𠮷a";
for(let i of s){
count ++;
console.log(i);
}
for...of 输出:𠮷 a
console.log(count);//2
console.log(s.length);//3
```
## 疑惑的地方
1、字符串s的length为3,循环次数是2次;我用for循环测试,循环次数是3
次。
2、for...of在循环中做了那些事情导致循环次数少了一次? | Javascript 采用 Unicode字符集,在 UTF-16 之前使用的是 UCS-2 编码,该编码方法使用2个字节表示字符(基本平面字符)。
UTF-16 编码发布后,UCS-2 被整合进 UTF-16,基本平面字符仍用2个字节,辅助平面字符使用4个字节表示。
因此,Javascript 的字符操作函数在处理4个字节的字符时,会当成两个双字节的字符处理,从而无法返回正确的结果。
```
s.slice(0, 1) // �
s.substr(0, 1) // �
s.charAt(0) // \uD842
```
"𠮷" 的 UTF-16 编码是4个字节的 `0xD842 DFB7`,而4个字节的字符不属于 UCS-2编码... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"ecmascript-6"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
CSRF攻击者是如何向网站注入欺诈链接的?
我明白CSRF的运作过程,但想不出来攻击者是如何在目标网站注入欺诈链接来骗用户点击的? | 比如这个 看似人畜无害的链接,就可以把人从思否诱导到一条不归之路[手动狗头],这里利用的原理是只要构造出合适的 URL 就可以发起百度搜索,仅此而已,但是你跳过去之后,浏览器会把本地的 `Cookie` 给你带上,百度后台就会认为是你本人在搜这种奇怪的东西,换成字节搜索的话,没准明天你的抖音就会刷到震撼的短视频了。
这个例子只是一个不怀好意的诱导,还算不上攻击,因为百度搜索的这个特点不算什么漏洞。但是如果某个银行的转账接口也是在 URL 里拼参数的话,那可就危险了:如果用户恰好登过这个银行的网页,`Cookie` 还在,那么只要构造一条转账的 `URL`,找机会让用户去点,就能神不知鬼不觉地把用户的钱拿到手。
那么,我有没有在百度的... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"安全"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
js简写,能不能用一行写出来
看注释,希望能用一句写出来,有没有这种简便写法?
```
const t = [
{name: 'John', value: 111},
{name: 'Mary', value: 222}
];
const param = t.reduce((p, n) => {
// 这儿能不能用一行写出来,类似于这样 t.map(k => k.child);
p[n.name] = n.value;
return p;
}, {})
``` | ```
const t = [
{name: 'John', value: 111},
{name: 'Mary', value: 222}
];
const param = t.reduce((p, n) => (p[n.name] = n.value,p), {})
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
TypeScript怎么实现接口的重载入?
### 题目描述
TS中是怎么实现接口的重载入?
### 相关代码
```
type ItemProps = {
a: string;
b?: boolean;
c?: string;
}
const arr: ItemProps[] = [
{
a: 'demo',
b: true,
c: 'test'
},
{
a: 'demo2'
}
]
```
在上面定义中,怎么定义`ItemProps`类型才能达到: 如果`b`属性存在,则`c`属性必需存在 的效果
### 期待结果
```
const arr: ItemProps[] = [
... | ```
type ExcludeKeys<T> = { [P in keyof T]: never; }
type RequireOrExcludeKeys<T, Keys extends keyof T = keyof T> =
Pick<T, Exclude<keyof T, Keys>>
& (Required<Pick<T, Keys>> | ExcludeKeys<Pick<T, Keys>>)
type ItemProps = RequireOrExcludeKeys<{
a: string;
b?: boolean;
c?: string;
}, 'b' | 'c'>
```... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"typescript",
"前端",
"react.js",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
请问如何将监听事件改为promise的形式
现在的代码结构是这样:
```
function receiver(type, callback) {
document.addEventListener(type, (ev) => {
callback(ev);
});
}
```
然后通过回调函数来执行:
```
receiver('click', (ev) => {
console.log(ev)
})
```
现在想改为promise的形式:
```
receiver('click').then(ev => {
console.log(ev)
})
```
请问需要怎么修改? | Promise就像一个状态机,而且是一个状态不可逆的状态机,这就意味它只会在到达Fullfiled或者Rejected状态时会执行你注册的函数,所以用Promise实现是不合适的
但是可以写成这样以达成相似效果
```
function receiver(type) {
const listeners = [];
const listen = {
then(callback) {
listeners.push(callback);
return listen;
}
};
document.addEventListener(type, async (ev) => {
... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"ecmascript-6"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
$nextTick和setTimeout有什么区别?
①$nextTick和setTimeout有什么区别?
②在实际项目中使用两者哪个会好点?没有优缺点之类的,需要注意什么
在实际项目中遇到元素还没渲染出来就执行了事件,甚至是有些接口先调用了
除了这种延时调用的方法还有更好的解决方案嘛
大神们求解 | `nextTick`:在下次 DOM 更新循环结束之后执行延迟回调。在修改数据之后立即使用这个方法,获取更新后的 DOM。
`setTimeout`:只是延迟执行,在延迟执行的方法里,`DOM`有可能会更新也有可能没有更新。
常规做法就是延迟500ms或者1s
建议使用`nextTick`在有涉及`DOM`更新的场景 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
在js中执行顺序?
在js中,假设执行五万条log(1)需要5秒钟,在这个js中的第一行写个setTimeout一秒后执行log(2),这个log(2)是一秒后执行还是log(1)执行完以后再执行? | - log(1)执行完以后再执行。这里涉及到浏览器端的js事件循环机制。js代码由上到下执行,在调用栈里面执行。
- 执行到setTimeout函数,是宏任务,放到回调队列里面。
- 然后继续执行调用栈里面的代码,五万条log(1),是同步任务,在调用栈里面执行,一条一条先进先出。
- 等到过了1秒后,setTimeout函数执行完。但是此时的调用栈还没有空,继续等待,等到5秒后,调用栈空了,就会执行回调队列里面的任务。此时打印log(2)
- 附上js事件循环的链接:https://segmentfault.com/a/11... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
网站如何检测到是否开启开发者工具?
http://211.149.185.229:8080/l...
上面这个网站打开开发者工具就会跳转到错误页面,请问如何做到的 | ```
! function(e) {
var im = new Image();
Object.defineProperty(im, 'id', {
get: function() {
window.location.href = "http://106.53.103.200:8082/error.html"
blast();
}
});
console.log(im); //谷歌最新版失效
let num = 0; //谷歌最新版有效
var devtools = new Date();
d... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"前端",
"javascript",
"react.js",
"html5"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
js for循环以逗号拆分为新数组
原数据格式↓
```
const data = [{ name: 'apple', cut: 'a,b,c' }, { name: 'trigger', cut: 'a,g' }]
```
期望数据格式↓
```
const data1 = [{ name: 'apple', final: 'a' },
{ name: 'apple', final: 'b' },
{ name: 'apple', final: 'c' },
{ name: 'trigger', final: 'a' },
... | 基本思路:把 `cut` 拆分之后进行一次映射,可以拿到每个原始对象对应的一个数组,组合起来就是一个二维数据;再把这个二维数据展开,就是你要的答案。
`flatMap` 就是先映射再展开
```
const data = [{ name: 'apple', cut: 'a,b,c' }, { name: 'trigger', cut: 'a,g' }];
const data1 = data.flatMap(it =>
it.cut.split(",")
.map(s => ({ name: it.name, final: s }))
);
console.log(data1);
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"vue.js",
"react.js",
"ecmascript-6"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
每日百万数据量的订单表如何导出到excel
需求是这样的:系统每日会产生上百万的成交订单,客户需要每天导出一份给他们,因此需要每天生成一份大数据量的excel。
首先想到的就是在定时任务中通过for循环分页访问数据库,然后分批导出到excel。但是for循环中访问数据库,如果测试不充分或者程序有bug会导致频繁访问数据库,会严重影响数据库的性能。其实在循环中访问数据库本来就是一种不好的习惯。
有什么好的方案或者建议吗? | 我貌似get到了您的想法
总得来说就是觉得数据已经存进去了,但由于导出`excel`,需要再循环查询数据读出来,感觉有点"多此一举",这个多此一举导致了循环访问数据库,对此感到不安
那我提供一种思路,不一定能解决你的问题,但是或多或少是一种思路叭
即:能不能在插入订单数据的同时也能发个通知,也就是做个消息中间件,这样消费者就是`execl`导出服务,读取消息直接此时就写入到`excel`中
当然那肯定要准备一个消息中间件了,看你百万的数据量,肯定`kafka`没跑了,至于如何往`kafka`里扔消息,这里面有两种方案可以提供给你
1. 在插入订单的代码中新增一个消息发布
2. 做数据库的CDC(Change data captur... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"java",
"node.js",
"python",
"后端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
请问现在那个使用那个跨前端技术会比较好。
React Native / Weex / Flutter / uni-app 如何选择好呢 | ReactNative 适合有一定 React 前端基础的人。不过性能瓶颈是天坑,稍微复杂一点儿的组件还是得写原生配合。胜在出生较早,生态相对完善,社区活跃。
Flutter 是用得 Dart 基本就是重学一门语言了,但性能要比 RN 强很多。出生虽比 RN 晚,但后发制人,社区也很活跃。
uni-app 严格意义上来说不是跨端 App,只是 Web 浏览器套壳。你写 Web 有啥瓶颈,它就有啥瓶颈。(别说它也封装了一些 Native API,性能还不如 RN 呢)。
Weex 还活着? | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"react-native",
"weex",
"flutter",
"uni-app"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
美团前端二面,读代码题求解
```
var a = 0;
if (true) {
a = 1;
function a() {}
a = 21;
console.log(a);
}
console.log(a);
```
求两次 console 出来的值。
答案是21 1。
本菜鸡想了很久也没想明白第二个为啥是1。。
求大佬解惑 ? | 21 1 的输出结果不完全正确,在不同的浏览器下结果不同
在safari下结果为21 21
在chrome下结果为21 1
同时ECMAScript规范中说函数声明可以嵌套在条件语句块内,但是其运行的结果依赖于JS解析器的实现,其结果具有不确定性,不推荐在生产环境下使用 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"面试"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
JavaScript 两个对象大小比较的机制?
偶然见看到的一个关于类型转换的题目:
对象 ab 是两个字面量函数,在进行比较的时候,可以发现大小和相等的比较结果都是 `false`
```
var a = {b: 42};
var b = {b: 43};
```
```
a < b; //false
a == b; //false
a > b; //false
a <= b; //true
a >= b; //true
```
在这个过程之,a 和 b 比较的时候,到底比较的是什么?为什么 <=> 三个运算符都是 false。?
为什么 `a<=b` 是 true?
`a<=b == true` 是因为 JS 计算的是 ... | ES 规定如此。
`==`、`!=` 不说了,基础问题了;说下 `>`、`<` 这种吧,最后都会转换为数值形式做比较。
首先尝试调用对象的 `Symbol.toPrimitive` 方法得到原始值。
如果没有这个方法就再尝试调用 `valueOf`。
经过以上转换后,如果两边都是 `string`,则按 Unicode 逐位比较;否则,都强转成 `number` 比较。
`Object` 强转后就变成了 `NaN`。`NaN` 是个特殊的 `number`,它跟任意数(包括它自己)做任何比较运算,恒为 `false`。
至于 `>=`、`<=` 你说的对,确实是取反。
P.S. 完整讲述可以自己搜索一下 ECMA-262 文档中关于... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
关于实际代码中如何用策略模式处理频繁的 if else 的问题
直接上代码吧 都在代码里写清楚了
问题就是
如何把函数中 tabs.filter.forEach 这些几乎相同的逻辑 独立出来 之前学习了策略模式 但是想不到好的方案 请大佬指点一二
```
let tabs = [{index:0,name:'angelaBaby'},{index:1,'陈冠西'},{index:2,'李bingbing'},{index:3,'范特西'}]
let COMMAND_TYPE_LIST = {
OTHER:'other',
RIGHT:'right',
SELF:'self',
}
/**
* @desc ... | 解耦最终操作放在外面,可用性更高点
```
function checkedPerson1(type,randomIndex) {
const other = (randomIndex, index) => index !== randomIndex;
const right = (randomIndex, index) => index > randomIndex;
const self = (randomIndex, index) => index === randomIndex;
const dict = {
other,
right,
self
... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"ecmascript-6",
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
.ts文件识别不了.vue 文件?
main.ts
```
import Vue from "vue";
import Component from "vue-class-component";
import App from "./App.vue";
```
报这个错误
Cannot find module './App.vue' or its corresponding type declarations.
tsconfig.json
```
{ // 编译选项
"compilerOptions": {
// 编译输出目标 ES 版本
"target": "esnext",
// 采用的模块系统
... | 不要再shims-vue.d.ts中最外层使用import,使用这种写法
```
declare module '*.vue' {
import Vue from 'vue';
export default Vue;
}
declare module "vue/types/vue" {
import VueRouter, { Route } from 'vue-router';
interface Vue {
$router: VueRouter; // 这表示this下有这个东西
$route: Route;
$http: any;
$Message: any;
$Moda... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"typescript",
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
webpack使用CopyWebpackPlugin插件一直报错,麻烦大佬看看?
```
const CopyWebpackPlugin = require("copy-webpack-plugin");
const path = require("path");
module.exports = {
entry: "./src/index.js",
output: {
filename: "bundle.js",
path: path.resolve(__dirname, "dist"),
},
module: {
rules: [],
},
plugins: [
new ... | 仔细看错误信息,缺少了 `patterns` 字段。实际上 copy-webpack-plugin 从 6.0 以后,把配置改成了
```
new CopyWebpackPlugin(
patterns:
[
{ from: path.resolve(__dirname, './src/assets/'), },
]
),
)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"webpack"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
前端路由是全部都由后端返回,还是后端返回对应角色下的权限,然后前端通过遍历的方式来修改当前路由呢?
在看vue-element-admin中有个权限验证,现在不知道这2者有啥区别,请大佬说说有什么好的方式来处理这个动态路由
https://panjiachen.github.io/... | 第一种后台返回路由,第二种后台返回权限。
共同点:
- 两种方法都可以实现需求
- 前端都要维护一份路由地址与模块文件地址的映射
- 后段返回的数据一般都要再遍历做二次处理
- 有关页面内元素(按钮)的权限都要另做处理
- 技术点都会涉及路由守卫和路由鉴权
差异点:
- 默认路由列表:方法一只维护home、login等无权限需求路由,其他路由需要后续通过接口和路由api:`addRoutes`动态添加;方法二需要维护一个全量的路由列表,不需要额外添加路由,通过配置每个路由的access数组来做鉴权。
- 路由跳转:因为方法一返回的就是该用户权限下的路由,所以不需要再做权限鉴权;方法二需要。
- 路由的自定义程度:方法一可以通过修改... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
promise then 的回调函数是在什么时候进入微任务队列的?
promise then 的回调函数是在遇到 resolve 语句的时候就被加入微任务队列,还是在遇到 then 语句的时候被加入到微任务队列?
在网上查了一些资料,发现有不同的说法:
1. 比如在《深入理解ES6》中文版 244 页里是这么说的:“调用 resolve( ) 后会触发一个异步操作, 传入 then( ) 和 catch( ) 方法的函数会被添加到任务队列中并异步执行”,所以 then 方法的回调应该是在调用 resolve 后就被加入到队列中的?
2. 对应的英文版原文是这么说的:“Calling resolve() triggers an asy... | 都没问题。
关键在于,`then` 是在 `resolve` 之前被调用的,还是 `resolve` 之后呢?
`then` 在 `resolve` 之前,`then` 不会加微任务,而是缓存起来,`resolve` 看到缓存里又 `then` 的回调,于是加微任务。
`resolve` 在 `then` 之前,`resolve` 的时候还没有任何回调要执行,自然不会加微任务。`then` 的时候发现已经 fullfilled ,于是直接加微任务。
也就是说,他们都有可能加,也都有可能不加,就看调用时的 promise 的状态了。
你的引用有些只说明了其一,但是说明里条件写得还是很清楚的,比如 4 里 "because the pr... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"eventloop",
"异步编程",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
JS怎么获取变量名称(反射)
JS中怎么在程序执行的时候,获取变量名称。
比如通过一个函数返回指定参数的参数名。
```
jsvar paramName = 'asdf' // 不管等于什么。
var paramName2 = new Object(); // 不管等于什么。
function getParamName(p) {
// ...实现过程
var result = ...; // 这里只是模拟
return result;
}
getParamName(paramName);
getParamName(paramName2);
```
最终参数的返回结果应该为:
```
output Ou... | 2017.1.5 答案已重写
每一个上下文都有一个与之对应的变量对象,任何声明的变量都是这个变量对象的属性。全局上下文的变量对象是全局对象,因而在全局声明的变量就变成了全局对象的属性。相应地,函数上下文的变量对象是活化对象,在函数上下文声明的变量是活化对象的属性。然而,活化对象是引擎内部的一个对象,不可被外部访问,因而不可在 JS 中获取函数上下文变量的名称。
此外基本类型的函数实参是以传值的方式传入函数的,对象类型的实参是以引用的方式传入函数的,无论哪种方式,函数都只能得到传入的值或者引用,而无法访问调用函数的上下文的变量对象,因而不能在函数内部获得传入函数的变量的名称。
既然没有函数能够返回调用这个函数的上下文中变量的名称,JS... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"反射",
"node.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
在DolphinDB中,如何对连续的相同值分组
比如有表如下:
```
t = table(1 1 1 1 2 2 2 2 1 1 1 1 3 3 3 as bs_flag)
```
希望根据 bs_flag 进行分组,连续相同的 bs_flag 的行group 为一组
即希望分组后是
1
2
1
3
如何写sql语句? | 可以用
```
select first(bs_flag) from t group by segmentby(first, bs_flag.rowNo(), bs_flag)
```
或
```
select first(bs_flag), first(bs_flag.rowNo()) from t group by eachPre(ne, bs_flag).cumsum()
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"nosql",
"sql",
"数据库",
"dolphindb"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
DolphinDB的流数据表怎么查询
我有一个流数据表,然后
```
enableTableShareAndPersistence(table, tableName, [asynWrite=true], [compress=true], [cacheSize=-1], [retentionMinutes=1440], [flushMode=0])
```
我把cacheSize 设为100,000.
现在假设流进来的数据已经超过了100,000行, 也就是部分数据已经存入persisenceDir。如果用select * from tableName会不会返回所有的行?
问的原因,是因为我在考虑要不要单独建一个实时数据仓,来que... | 用select * from tableName不会返回所有的行。默认情况下,流计算的表把所有数据保存在内存中。如果流数据表太大,系统可能会出现内存不足的情况。为了避免内存不足的问题,我们可以设置缓存大小的界限。如果流数据表的行数达到这个界限,前面一半的记录行会从内存中清理。
可以用getPersistenceMeta(table)观察一下。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"大数据",
"nosql",
"数据库",
"sql",
"dolphindb"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
在DolphinDB中怎么拼接Matrix
如果我有一个结果是一个ANY 向量,他的每一个元素是shape相同的Matrix,我怎么样可以把他合并成一个大的Matrix? 最好是纵向拼接,列数不变增加行数。 | 横向拼接两个矩阵:
a = 1..4$2:2
b = 1..4$2:2
a.join(b)
纵向拼接:用 a.transpose().join(b.transpose()).transpose()
假设ANY vector c,如下
```
c = [a, b]
def transposeJoin(a, b) {
return a.transpose().join(b.transpose()).transpose()
}
reduce(transposeJoin, c)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"nosql",
"数据库",
"sql",
"dolphindb"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
提问关于 mysql得联合主键和复合主键的问题
如下sql:
CREATE TABLE `film_actor` (
`actor_id` smallint(5) unsigned NOT NULL,
`film_id` smallint(5) unsigned NOT NULL,
`name` varchar(50) NOT NULL,
`last_update` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`actor_id`,`film_id`) USING BTREE,
KEY `idx... | 这个问题要是问外国开发者,TA们能一脸懵逼。
在英文语境中只有 `Composite Primary Key`(也有叫 `Compound Primary Key` 的),就是一个表中如果是多个字段组成一个主键,那么这个主键就被称为这玩意儿。
至于这玩意儿你翻译成“联合主键”、“组合主键”、“混合主键”还是“复合主键”,都特么是一回事儿。
结果到了中文编程界,不知道是哪位神仙起的头儿,非得编个“联合主键”和“复合主键”的区别出来。再加上中文编程界有一大特点,就是博客或者问答习惯性东抄西搬,结果错的知识也能流传广泛甚至成为“主流”。
搬一个“流传最广”的对于“联合主键”和“复合主键”区别的文章:
“联合主键”还是单一主键,只不过往往用... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"mysql"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
new Promise((resolve)=>{resolve()}) 与 Promise.resolve() 等价吗
### 处理以下类型的时候这个两个方法感觉差不多
参数是一个 Promise 实例
参数是一个thenable对象
参数不是具有then方法的对象,或根本就不是对象
但我看有人说:`promise.resolve(v)`不等于`new Promise(r => r(v))`,因为如果 v 是一个 Promise 对象,前者会直接返回 v,而后者需要经过一系列的处理(主要是 PromiseResolveThenableJob) | ## 我自己做了一个详细的测试
先说结论:在v是一个promise实例的时候,`promise.resolve(v)`与`new Promise(r => r(v))`有明显的差异
区别表现:new Promise(r => r(v))的.then()回调会被推迟两个时序(事件循环)
原因:new Promise(r => r(v))里浏览器会创建一个 PromiseResolveThenableJob 去处理这个 Promise 实例,这是一个微任务。具体分析如下
```
// v是一个实例化的promise,且状态为fulfilled
let v = new Promise(resolve => {
... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"promise",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
上海字节跳动一道关于http缓存的面试题
首先这个问题是http的缓存,我答了强缓存和协商缓存。
我说道协商缓存,是会请求到后端服务器,然后对比响应头last-modified或者etag,来决定时候使用缓存。
此时面试官问我,已经请求到后端了,为什么还要再去取缓存,而不是直接使用response,我就没答出来。
网上搜了很多,主要还是都是介绍2种缓存的,并没有提到这个问题,望解答! | 我猜你说的 response 指的是 response body?
协商缓存如果命中返回的是 304 啊……只有 header 没有 body。
虽然还是请求了一次服务器,但只需要传输 header 部分就可以了,节省了传输文件本身的开销。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"前端",
"javascript",
"http",
"http缓存"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
如何高效的监控多台服务器,该做哪些方面的监控?
系统的服务器多了,独立运行的服务进程多了,服务进程间的通讯多了,该做那些监控,该怎么监控?有没有什么成熟的思想想法?
监控是不是可以分为2个方面:1)系统级别的监控(cpu,memory,io,disk,net),服务是否存活
2)应用级别(各子系统业务相关异常监控)
具体的,怎么来实现这个监控,做到一个可灵活配置、扩展的插件式监控平台?感觉还是比较棘手
查阅了资料后,我打算先这么做:
1:Nagios作为CPU、内存、硬盘等各个基本非业务的监控
2:各个业务模块做自己相关的监控:服务异常监控、服务统计信息等
1)服务异常信息通过mq异步的发送给监控主服务器,由监控主服务器... | `以下都是自己想到什么写什么
监控从方向来分为: 系统级别监控和业务逻辑层监控。一般的开源软件都是面向系统软件级别的监控, 不可能会有业务逻辑的监控; 业务逻辑的监控因为不同的应用而不同, 这个需要程序员预留接口可以进行监控, 运维是可以提需求的。
监控从功能上分为: 报警监控和性能监控。 报警监控,就像大家说的nagios是非常好的开源软件, 其实nagios提供的也是一种监控的框架, 所以他比较的灵活; 性能监控, 主要是用来查看变化趋势, 可以更好的找到问题, 或者提早发现问题, 有时候因为报警的阀值是需要不断的调整才能到最佳状态,像cacti和ganglia
监控的选择 一般要看你的服务器分布:
如果是分布式的机房,... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"集群",
"监控"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
java 如何通过反射修改类的私有方法
网上能找到的都是修改私有变量, 访问私有方法, 我想要修改私有方法, 请问如何操作? | 反射是不能修改方法的,但是可以使用修改字节码的方式来实现修改。
使用javassist工具在类加载器加载这个类之前修改他的字节码。
比如修改这个方法的字节码:
org.jboss.resteasy.core.InjectorFactoryImpl.createMethodInjector()
```
ClassPool pool = new ClassPool(true);
CtClass ct = pool.getCtClass("org.jboss.resteasy.core.InjectorFactoryImpl");// 加载这个类
// 获取被修改的方法
CtMethod m = ct.getDeclaredMet... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"java",
"javascript",
"oop"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
JS树结构的遍历、创建
这样树结构的数组:
```
let tree =[
{id: '1',
title: '节点1',
children: [
{
id: '1-1',
title: '节点1-1',
children: [
{
id: '1-1-1',
title: '节点1-1-1'
},]
},
{
... | 你可以先了解一下什么是 递归
这个需求通过递归可以很轻易实现
```
function getTree(ary) {
return ary.map(v => {
const item = {
title: v.title, //这是创建的新对象 根据需要的键随意更改
};
if (v.children) item.children = getTree(v.children);
return item;
});
}
```
```
const newTree = getTree(tree);
console.log(newTree)
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
如何让一个元素hover时,让指定区域的产生背景色,在线等?
### 问题描述
现在一个div高为50px宽为200px,我想让它hover时,只让这个div的高为40px,宽为200px的区域产生背景色,切要居中
### 相关代码
css
```
div{
height: 50px;
width: 200px;
background: slategrey;
}
div:hover{
/*background: red;*/
}
```
html结构
```
<div>
TEST
</div>
```
### 有什么解决方法吗? | ```
div:hover {
background: linear-gradient(to bottom,slategrey 5px,red 0,red 45px,slategrey 0);
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"css",
"html5",
"前端",
"css3"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
请问vue或者uniapp如何实现背景色自动根据图片的主色进行渲染?
请问如何实现背景色自动根据图片的主色进行渲染? | 把图片绘制到一个与图片大小相等的 canvas 上,然后在图片上取样,确定图片的主色,把这个色值作为背景色即可。
```
const picUrl = __YOUR_PIC_URL__;
const canvas = document.getElementById('yourCanvasId');
const ctx = canvas.getContext('2d');
const image = new Image();
image.setAttribute('crossOrigin', 'anonymous');
canvas.setAttribute('crossOrigin', 'anonymous');
image.ad... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"配色",
"背景"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
使用axios发送请求的时候 什么时候算请求出错,什么情况算响应出错
在设置请求拦截器与响应拦截器的时候失败状态下的情况,遇到的一些疑问
```
Axios.interceptors.request.use(config={
//这里会最先拿到你的请求配置
},err=>{
//这里什么情况下会进来?并且进来之后对你接下来的程序执行有什么影响
})
Axios.interceptors.response.use(res ={
//这里会最先拿到你的response
},err=>{
//这里什么情况下会进来? 并且进来之后对你接下来的程序执行有什么影响
})
``` | ```
Axios.interceptors.request.use(config={
//这里会最先拿到你的请求配置
},err=>{
// 这里极少情况会进来,暂时没有找到主动触发的方法,估计只有浏览器不兼容时才会触发,欢迎后面同学补充
// 看了几个GitHub的issue,有人甚至提出了这个方法是不必要的(因为没有触发的场景),不过还是建议大家按照官方的写法,避免不必要的错误
// 进来之后没法发起请求
})
Axios.interceptors.response.use(res ={
//这里会最先拿到你的response
// 只有返回的状态码是2xx,都会进来这里
},err=>{... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"axios"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
一个面试题关于函数的优先级
```
function Foo(){
getName = function() {
alert(1)
};
return this
};
Foo.getName = function () {
alert(2)
};
Foo.prototype.getName = function () {
alert(3)
};
var getName = function () {
alert(4)
}
function getName() {
alert(5)
}
Foo.getName();
getName();
Foo().... | 挺有意思的一道题。
第一个 2 不用多解释,直接用的是 `Foo.getName` 静态方法。
第二个为啥是 4 呢?你会注意到最后有一个 `var getName = funtion() {}` 和一个 `function getName`,后声明的 `function` 咋没覆盖前面的 `var` 呢?因为 `function` 有函数提升,虽然是后声明的,反而会被提到当前作用域最前面去执行。(你可能会说 `var` 不也有变量提升吗?因为 JS 里函数是一等公民,函数提升比变量提升更优先!)
第三个和第四个为啥都是 1 呢?因为没 `new` 所以 `Foo()` 里的返回值 `this` 实际是 `window`,而 `wi... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"html5"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
原生js如何获取json字符串中某个对象的内容
有如下json字符串:
```
const str = `
input: {
label: "输入框input",
name: "input",
option: {
rules: [{ required: true, message: "Please select your country!" }]
},
on: {
change: e => {
const { value } = e.target;
con... | 这是一段`js`脚本。`eval`函数不安全,可以模拟实现类似功能。如下:
```
function equalEval(str){
return new Function('return ' + str)();
}
let obj = equalEval(str);
console.log(obj.input);
console.log(obj.number);
```
这样相对安全一些。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
为什么linux 创建文件是touch 而不是create
好奇~ 为什么linux 创建文件是touch 而不是create | touch 的作用本来不是创建文件,而是将指定文件的修改时间设置为当前时间。
就是假装“碰”(touch)了一下这个文件,假装文件被“修改”了,于是文件的修改时间就是被设置为当前时间。
这带来了一个副作用,就是当 touch 一个不存在的文件的时候,它会创建这个文件。
然后,由于 touch 已经可以完成创建文件的功能了,就不再需要一个单独的 create 了。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"linux"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
网站大量无用图片如何处理?
比如富文本这样的功能,或者一些存储图片的字段。
当执行编辑操作的时候,有时候数据库中新图片会替代旧图片(旧图片链接名称在数据库中不存在了),但旧图片的文件还存在在硬盘中。
这种已经没用的图片一般如何处理?
我想到的方案:
方案1:在编辑的时候就把没用的图片一同处理掉,但这样会增加很多代码量,因为很多图片的存储结构不同,需要在各个功能代码处写专门的处理函数。
方案2:定期处理。扫描图片在各个表中是否用到,没有用到就删除。但这样做的话,如果增加了新的功能,还要去添加"要扫描的表和字段",遗漏的话会造成误删。
方案3:不处理。冗余图片不会对网站产生大的影响(猜测)。
求解答。 | 建一个图片文件表:
```
create table pic(
id int,
path varchar(256),
md5 varchar(32),
size int,
refer_count int,
)
```
refer_count 为引用计数,多少文章里用到了,就是多少,文章修改时,先减少再增加,少到为零就可以删了。
用md5做摘要,可以把重复上传的图版合二为一。size和可以与用户结合进行配额限制,防止被恶意使用。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"php",
"c#",
"python",
"java",
"go"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
关于 useEffect 重复调用以及依赖数组的问题?
关于`useEffect`有有一些疑惑疑惑, 如下, 代码已经放入codesandbox 的 CounterHook.js 文件中
代码简化如下:
```
const CounterHook = props => {
const [count, setCount] = useState(0)
const [loading, setLoading] = useState(false)
useEffect(() => {
setLoading(true)
console.log(loading) // false, true, false, ture.... | 第一个问题:
对。
第二个问题:
函数组件的每次渲染都是执行一遍这个函数,在你的例子中,也就是 `CounterHook` 函数。那么两次执行中创建的局部函数,还会是同一个引用吗?不会的。所以本次执行中的 `fetchApi` 和上次执行中的 `fetchApi` 是两个不同的函数,因此 `useEffect` 的依赖被更新了,触发执行。
第三个问题:
`useCallback` 的返回值即为它接收的第一个参数,直到依赖更新。因此使用 `useCallback` 包裹的 `fetchApi` ,在依赖更新之前,总是同一个函数。也就不会触发 `useEffect`。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"react.js",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
为什么需要申请SSL证书?
最近在研究把现有网站换成https,看了下SSL原理介绍,有一点不明白,既然https的本质是为了在通讯过程中讯息对称加密的方式传输,为什么浏览器不直接支持服务端自己生产的加密证书,加密证书只需要提供RSA的公钥不就好了?为什么需要花很多钱申请这个证书呢 | 如果抛开安全只看加密,那确实,只要像你说的那样提供个公钥就行了。
但这样做的问题是,虽然确保了传输过程中的数据是被加密的,但没办法确保最后解密的那台服务器是你真的想要发送给它的那台。
举个例子,在不使用证书加密之前,我想给你(服务器)传纸条,中间需要经过N个人传话(如路由器等各级中间节点),那么在你收到消息的时候,很可能在中间某个传话的就给它篡改了,或者说没篡改、但是被传话的偷看了小秘密。
那么现在咱俩之间约定一个非对称加密的方式,你先给我个公钥,我用公钥把要给你的纸条加密了,你收到后再用私钥解密,这样中间传话的看不懂密码就没法偷看内容、即使瞎改的话你那解密不出来,你就知道纸条内容被篡改了。
到此为止就像你所说的那样,但这样还有个问... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"https"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
通过docker命令行,报错:Fatal error, can't open config file,在容器内执行没问题
首先,我的dockerfile如下:
```
FROM redis:latest
COPY $PWD/redis.conf /root/
RUN ["chmod", "777", "/root/redis.conf"]
CMD ["redis-server", "/root/redis.conf"]
```
redis.conf文件的内容是从这里复制的https://raw.githubusercontent...
使用`docker build .`之后,使用`docker run -it --rm 7141... | 用 docker inspect 可以看到,redis 的 docker 镜像的默认的 Entrypoint 是 `docker-entrypoint.sh` 。也就是说,CMD 定义的命令是由这个脚本执行的。
这个脚本的内容如下(可能不同的版本会有所不同):
```
#!/bin/sh
set -e
# first arg is `-f` or `--some-option`
# or first arg is `something.conf`
if [ "${1#-}" != "$1" ] || [ "${1%.conf}" != "$1" ]; then
set -- redis-server "$@"
fi... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"redis集群",
"redis",
"docker"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
refresh token安全问题
如果`access_token`有效期一个小时,`refresh_token`有效期7天;
- 那么在这7内天我都可以通过`refresh_token`获得`access_token`那不是等价于`access_token`有效期为7天了吗?
- 7天的有效期也会让安全风险增加那为什么还要用`refresh_token`呢? | 这是一个有关暴露风险大小和有效期时长的问题,如果我们只有一个 token ,每次请求中都要携带这个,那么它暴露的风险会很高,如果这个 token 的有效期还比较长,那么它一旦暴露,损失会很高,所以 access_token 的有效期需要比较短。
但是我们又不希望用户的登录有效期只能这么短,那么怎么办呢?refresh_token 的存在价值正在这里,refresh_token 只需要在刷新 access_token 的请求里面携带,相对于 access_token 而言,它暴露的风险小很多,所以即便它的有效期比较长,相对来说造成损失的可能性也没那么高。
更详细的看看这个Why Does OAuth v2 Have Both Acce... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"node.js",
"java",
"php",
"typescript",
"asp.net"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
js:关于遍历数组中对象封装数据问题
有个数组如下结构:
```
let a = [
{0: '内容11', 1: '内容12', 2: '内容13', 3: '内容14', head: '头部1'} ,
{0: '内容21', 1: '内容22', 2: '内容23', 3: '内容24', head: '头部2'} ,
{0: '内容31', 1: '内容32', 2: '内容33', 3: '内容34', head: '头部3'} ,
]
```
怎么变成下面的结构
```
let b = [
{头部1: '内容11', 头部2: '内容21... | ```
// 你这期望值给的我也是看不懂 大致猜测是行变列
let a = [
{ 0: '内容11', 1: '内容12', 2: '内容13', 3: '内容14', head: '头部1' },
{ 0: '内容21', 1: '内容22', 2: '内容23', 3: '内容24', head: '头部2' },
{ 0: '内容31', 1: '内容32', 2: '内容33', 3: '内容34', head: '头部3' }
]
function transformList(arr) {
if (!Array.isArray(arr)) return
return arr.... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"算法"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
为什么MySQL8.0直接把查询缓存的功能删除了呢?
一种说法是不建议使用查询缓存,因为查询缓存往往弊大于利。
查询缓存的失效非常频繁,只要有对一个表的更新,这个表上的所有的查询缓存都会被清空。
因此很可能你费劲地把结果存起来,还没使用呢,就被一个更新全清空了。对于更新压力大的数据库来说,查询缓存的命中率会非常低。除非你的业务有一张静态表,很长时间更新一次,比如系统配置表,那么这张表的查询才适合做查询缓存。
在我看来,大多数应用都把缓存做到了应用逻辑层,简单的如一个map的mybatis,复杂的可以用redis或者memcache,直接操作内存远远比走网络访问快,所以mysql直接抛弃了查询缓存? | MySQL服务器团队有一篇关于此的详细博客,其中Matt Lord说:
我们考虑了可以对查询缓存进行哪些改进,以及我们可以进行的优化,这些优化可以改善所有工作负载。
虽然这些选择本身是正交的,但工程资源是有限的。也就是说,我们正在转变战略,投资于更普遍适用于所有工作负载的改进。
建议把缓存放到客户端 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"mysql"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
js 树形结构数据 已知某一子节点 一次向上获取所有父节点
```
var res = [{
code: 1,
name: "湖北省",
children: [{
code: 1,
name: "武汉市",
children: [{
code: 1,
name: "汉阳区",
children: [{
code: 1,
name: "水上分局1"
}]
}, {
c... | ```
function treeFindPath (tree, func, path = []) {
if (!tree) return []
for (const data of tree) {
// 这里按照你的需求来存放最后返回的内容吧
path.push(data.name)
if (func(data)) return path
if (data.children) {
const findChildren = treeFindPath(data.children, func, path)
if (findChildren.length) return fi... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
为什么要用vue-cli3?
其实这个问您要是想了解vue-cli3与vue-cli2相比是否存在一些不得不升级的好处和优点?
产生这个问题的原因是在试用完vue-cli3之后并没有觉得好用,反而觉得束手束脚,我cli2时,webpack想怎么配怎么配为什么到了cli3我要在vue.config.js中配置
众所周知vue-cli的通用配置并不适合每种情况,而在vue.config.js只能做增添和覆盖,所以一直没有用vue-cli3构建项目
所以想请教下 这个版本有没有值得升级的优点 | 好问题,vue-cli3相对vue-cli有很多重要的更新。
首先说一些vue-cli这些工具的初衷吧: 这些工具就是为了让开发者能够开箱即用快速地进行应用开发而开发的,它们秉承的是“约定大于配置”思想,简单说就是"能不配置的就不配置,你就按照我的方式来,也不要去争论这个好不好,快速进行业务开发才是正经事". 它们不建议你去配置,但也不会拦着你去配置。
另外Webpack对初学者并不是十分友好,‘又长又臭’的配置,普通开发者很难写入定义良好,性能优化的配置。不然就不会各种cli工具冒出来了,比如parcel,create-react-app。这些工具都宣称零配置,目的就是让开发者能够愉快的进行代码开发。
现在来看看Vue-cli v... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"vue-cli"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
Typescript内置类型中的Exclude实现原理?
#### lib.es5.d.ts
```
/**
* Exclude from T those types that are assignable to U
*/
type Exclude<T, U> = T extends U ? never : T;
```
#### 问题
```
type AB = 'a' | 'b'
type BC = 'b' | 'c'
type Demo = Exclude<AB, BC> // => type Demo = 'a'
```
从结果上看,`T extends U`判断了 truthy 和 falsy,同时进行逻辑运算并把结果... | `T extends U ? never : T` 表示如果 `T`是 `U`的子类返回`never`类型,如果不是返回`T`类型。
当`T`为联合类型的时候,它会自动分发条件。
TS 一些工具泛型的使用及其实现 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"typescript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
计算一个整数数组中最大差值的元素?
#### 我用php实现的代码,比较暴力,类似于冒泡排序.
```
$arr = [4,2,7,5,11,13,9,1];
$a = 0;
$b = 0;
for ($i = count($arr) - 1; $i >= 0; $i--) {
for ($j = 0; $j <= $i - 1; $j++) {
$tmp = $arr[$i] - $arr[$j];
if ($tmp > $a) {
$a = $tmp;
$b = $arr[$i];
}
}
}
echo $b;
`... | @Reming 的算法有一个小漏洞, 如果数据是这样的话, 算出来的实际上是有问题的.
```
[4, 2, 7, 5, 11, 13, 9, 0, 12]
```
个人认为, 这个问题有两个关注点:
- 最小值
- 最大差值
但和最大值无关, 我们需要关注的是最大差值, 可能最大值出现的时候, 最小值还没有出现, 而后面出现的数值减去最小值可能反而比较大. 上面的用例就是基于这种逻辑设计出来的.
修改后逻辑为: 向后循环遍历, 记录下到目前为止的最小值 以及 最大差值, 然后计算当前元素-目前为止最小值, 判断大小. 记录最大的差值即可.
基于 @Reming 的代码稍微修改了下:
```
var arr = [4, 2, 7,... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"python",
"php",
"javascript",
"go",
"java"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
flutter:进入首页的时候判断是否登录,没登录则跳到登录页,这个怎么实现
进入首页的时候判断是否登录,没登录则跳到登录页,这个怎么实现 | 链接描述
这是我写的一个demo,实现了你要的功能
```
class _StartAppState extends State<StartApp>{
var loginState;
void initState(){
super.initState();
_validateLogin();
}
@override
Widget build(BuildContext context){
ScreenUtil.instance = ScreenUtil(width: 750,height: 1334)..init(context);
... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"flutter"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
面试遇到的问题,面试之后,感觉十分好奇
考官问我做的前端页面是组件切换还是跳转的页面。举个例子,比如一个 类似淘宝“个人中心” 页面上,可以选择不同的订单状态的tab,点击就会进入订单列表页面,这样的页面是直接用一个页面然后切换状态显示还是直接两个不同的页面呢?
我回答是两个页面,因为我觉得两个页面的内容都不一样,也符合跳转的逻辑。但是面试官明显的失望了,所以我后来琢磨是不是写成一个页面然后切换状态体验比较好,而且不用传递订单的状态参数过去呢?具体有什么原因呢?我想起来京东也是做成切换的,他的商品分类页面的搜索框,点击搜索框会切换到搜索页面,实际上是一个页面在切换状态显示不同的内容,这么做的意义是什么呢
如果说做成一个页面切换显示,... | 单独从京东的搜索界面来说。
大部分情况下搜索界面的内容不是很复杂,基本就是一个input,一些搜索记录和热搜的 item ,为页面加载不会带来太大的鸭梨,而且,一般搜索记录是本地存储,可以优先读入,提升用户体验,搜索记录是 ajax 后端读取,即使预读也不会有太多的鸭梨,这些都是可以用 Redis 做到缓冲,而且 搜索相对于用户体验体验来说,也应该是点击就能出现的,所以做成一个 `图层` 我觉得没什么问题,是一个比较好的设计。即使在 wap 2.0 时代,搜索只是嵌入在页面亦是如此,点击即可输入进行操作。
至于题干中的 个人中心 > 订单列表,无论从项目设计还是实践来说,都应该采用分页面的方式,当然现在的单页用了 router 后,... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
npm 的 --unsafe-perm 参数是有何作用呢?
npm 的 --unsafe-perm 参数是有何作用呢? | 这玩意儿看官方文档啊:https://docs.npmjs.com/misc/c...
就是说 npm 出于安全考虑不支持以 root 用户运行,即使你用 root 用户身份运行了,npm 会自动转成一个叫 nobody 的用户来运行,而这个用户几乎没有任何权限。这样的话如果你脚本里有一些需要权限的操作,比如写文件(尤其是写 /root/.node-gyp),就会崩掉了。
为了避免这种情况,要么按照 npm 的规矩来,专门建一个用于运行 npm 的高权限用户;要么加 --unsafe-perm 参数,这样就不会切换到 nobody 上,运行时是哪个用户就是哪个用户,即使是 root。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"npm",
"node.js",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
Java集合 modCount为什么不用volatile修饰?
2个线程 访问一个list 其中一个remove操作了 另一个在迭代 假如不用vol修饰 那么在迭代的那个线程可能感知不到modcount的变化啊
甚至于说官方认为有volatile是一个BUG?https://bugs.java.com/bugdata... | 我觉得你是理解有误,首先Java集合中有`modCount`属性未加`volatile`的都是线程不安全的集合类,都是单线程集合类`single thread collections`,讲单线程集合类放到多线程中去讨论,是很不合适的。
所以你的假设,在多线程情况下的可见行问题,根本就不应该出现这个问题!因为你的思路就有问题。
要保证有这个属性的集合类的正确使用至少不会出现在多线程的编程中这是前提条件,为什么呢?
`fail-fast`机制是确保集合类遍历过程中集合类不会出现结构性修改(增、删元素)
一般认为在遍历时出现结构性修改那么遍历将无法保证所有元素均能被遍历到(新增时)也无法顺利完成遍历(删除时)
要在遍历是进行结构性修改必须... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"java",
"多线程"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
JS正则中的$1的一个问题
```
var str = 'this is a test'
console.log(str.replace(/\b(\w)/g, ('$1'+'a').toUpperCase()))
// tAhis iAs aA tAest
```
为什么输出的不是TAhis IAs AA TAest
str.replace(/b(w)/g, ('$1').toUpperCase()),为什么调用的toUpperCase这个方法无效。 | 你对于toUpperCase的作用范围理解错了
```
str.replace(/\b(\w)/g, ('$1'+'a').toUpperCase())
```
相当于
```
str.replace(/\b(\w)/g, '$1A')
```
$1的大写还是$1,你只是把替换规则的字符串大写了,并没有把替换的结果大写
如果需要大写的话,用以下方法就可以了
str.replace(/b(w)/g, v => `${v}a`.toUpperCase()) | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"前端",
"正则表达式"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
echarts地图能不能通过加减按钮控制缩放
### 项目中用到了echarts的地图,在geo里有roam参数,不过是通过滚轮控制缩放的,这样用户体验不太好,能不能通过加减按钮或者地图比例尺的形式来控制缩放 | 可以试试我写的这个
```
<button onclick="roamMap(0)" style="position: absolute; z-index: 999">+</button>
<button onclick="roamMap(1)" style="position: absolute; left: 5%; z-index: 999">-</button>
```
```
// 地图缩放 flag: 0->放大 1->缩小
function roamMap(flag) {
let currentZoom = nationalChart.getOption().geo[0].zoom; //... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"echarts",
"前端"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
如何让img里的图片自适应div,并填充不变形?
```
<div>
<img src="..." alt="image">
<div>
img如何随父元素div改变尺寸,填充整个img,并且不变形?
就是background-size: cover;的感觉。
或者保持不变形,只显示图片的一部分也可以?
谢谢大家。
``` | img标签在固定高宽的div里的显示,除了JS,以及背景图片,可以试一下使用css属性object-fit属性。
它的几个属性
```
fill(不保持纵横比缩放图片,使图片完全适应)
contain(保持纵横比缩放图片,使图片的长边能完全显示出来)
cover(保持纵横比缩放图片,只保证图片的短边能完全显示出来)
none(保持图片宽高不变)
scale-down(当图片实际宽高小于所设置的图片宽高时,显示效果与none一致;否则,显示效果与contain一致)
inherit
initial
unset
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"html",
"css"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
vscode怎么快速重启?
## 如题:
## 当
## 可是我在菜单没有找到
## 因为可能经常会用到 | 打开:“命令面板”
CTRL + SHITF + P
输入:
```
> Reload Window
```
也可以绑定`快捷键`
```
{
"key": "ctrl+f5",
"command": "workbench.action.reloadWindow",
"when": "editorTextFocus"
}
``` | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"visual-studio-code"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
vue中v-for写成render的形式,key怎么解决?
项目中有部分代码,写层render的形式比template会更好...
但是遇到了一个问题,我们都知道v-for的时候是必须要设置key的,当我用render去遍历一个数组的时候,key怎么设置呢?我将key放在单个组件的props或是domProps都不起作用。一下是render代码:
这里Goup和Cell都是vue对象...也就是components
```
render(h): any {
const mapNode = (h): any =>{
const conArray = [];
let hVn... | ```
return h(vNodeName, {
key: part.partId,
});
```
教个小诀窍,如果对`render`不是很熟,可以先写好`template`,然后借助`Vue.compile`来生成`render`
```
import Vue from 'vue';
const res = Vue.compile(`
<div class='group-list' id="group-list">
<div v-for="item of partList" :key="item.partId">
<template v-if="item.partType === 'group'">
... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
webpack 打包库时出现 window is not defined
按照官网的步骤进行库的打包 创建library
webpack.config.js
```
var path = require('path');
module.exports = {
entry: './src/index.js',
mode: 'production',
output: {
path: path.resolve(__dirname, 'dist'),
filename: 'webpack-numbers.js',
library: 'webpackNumbers', // 支持多种模式的导出
l... | 你需要在`output`里面设置`globalObject`
```
// webpack.config.js
module.exports = {
...
output: {
path: path.resolve(__dirname, 'dist'),
filename: 'webpack-numbers.js',
library: 'webpackNumbers',
globalObject: 'this', // 添加这个选项
libraryTarget: 'umd'
}
...
}
```
output.globalObject | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"css",
"html",
"html5"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
【编程进阶】js实现一个map函数
实现一个myOwnMap函数:
输入:
```
[1,2,3].myOwnMap((item, index) => {
return item *2
})
```
输出: `[2,4,6]` | 首先要搞清楚`map()`函数的用法,传入一个函数,函数允许传三个参数(数组每一项,数组索引,数组本身),并且`map()`函数有返回值,如此一来也就有思路了:
```
Array.prototype.newMap = function(fn,context){
if(typeof fn !== 'function')return;
var newArr = [];
for(var i = 0;i < this.length;i++){
newArr.push(fn.call(context,this[i],i,this,context));
... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
typescript声明联合类型元组后加入新元素
刚刚看ts的文档看到元组越界的时候,尝试了下
```
let x: [string, number];
x = ['hello', 10];
当访问一个越界的元素,会使用联合类型替代:
x[3] = 'world'; // OK, 字符串可以赋值给(string | number)类型
console.log(x[5].toString()); // OK, 'string' 和 'number' 都有 toString
x[6] = true; // Error, 布尔不是(string | number)类型
```
写到这里就会报错了,表示不能直接更改一个长度为2的数组的第三... | 官方文档关于这一点上没有更新。
事实上在 Typescript 2.7(Fixed Length Tuples 一节中) 之后, Tuple 的定义已经变成了有限制长度的数组了。
```
interface NumStrTuple extends Array<number | string> {
0: number;
1: string;
length: 2; // using the numeric literal type '2'
}
```
所以你不能再越界访问了。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"typescript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
闭包:js这样写有什么好处?
很多地方都可以看到js代码用
```
(function($){
//代码
var demo = function(){
};
var demo2 = function(){
};
})(jQuery)
```
这样包起来,这是js闭包吧。把js代码写到这个里面有什么好处呢?
```
<script type="text/javascript">
(function($){
var hehe = funcion(){
alert('hehe');
};
}... | 这是一个立即执行匿名函数,同时也是一个闭包。
闭包的作用主要有两个:减少全局变量,保护变量
举两个例子请您揣摩:
```
// 第一例:
var a = function(){
alert('global');
};
(function(){
var a = function(){
alert('closure');
}
a();
})();
a();
// 第二例:
var setter = function(){
var privateVar;
return {
set: function(v){
privateVar =... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
python爬虫程序的原理是什么?PHP不能写爬虫吗?
python爬虫程序的原理是什么?PHP不能写爬虫吗? | 爬虫的原理是从一个起始`种子链接`开始,发`http请求`这个链接,得到该链接中的内容,然后大多使用`正则匹配`出页面里面的`有效链接`,然后将这些链接保存到待访问队列中,等待`爬取线程`取这个待访队列,一旦链接访问过了,为了有效的减少不必要的网络请求,我们应该把访问过的链接放到一个`已访问map`中,已防止重复抓取及死循环。我以上提到的过程可能是一个比较简单的爬虫实现,复杂的可能不会这么简单,但这里面有几个概念,一个是发`http请求`,一个是`正则匹配`你感兴趣的链接,一个是`多线程`,另外还有`两个队列`,理论上,任何能实现这么些概念的编程语言去写爬虫都是可以的,期间取舍还是看自己对熟练成都。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"python"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
关于递归问题 js
原数据格式
```
let obj =[
{1:'20190805',2:'1',3:'success'},
{1:'20191120',2:'1.1',3:'success'},
{1:'20190212',2:'1.1.1',3:'success'},
{1:'20190212',2:'1.1.2',3:'success'},
{1:'20190212',2:'1.1.3',3:'success'},
{1:'20190212',2:'1.2',3:'success'},
{1:'2019021... | ```
/**
*
* @param {Array} source
* @returns {Array} 分类好的数据
*/
function mark(source) {
var temp = {};
source.forEach(item => {
temp[item["2"]] = item;
});
source.forEach(item => {
var key = item["2"],
parent;
//子级
if (key.length > 1) {
//子级的父 id
key = key.slice(0, -2);
... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"react.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
关于js 递归方法
### 题目描述
有2个数组
### 相关代码
```
var a = ['customer','supplier','materal','purchaseOrder','rolesMenge']
var b = [
{
name:'maindata',
children:[
{
name:'customer',
meta:{
title:'customer'
}
},
... | 前不久刚回答了另一个类似的问题,本来以为是一样的,仔细分析之后发现这两个问题有一点重大差异:
- 这个问题要求结果保留原树结构,也就是说,符合条件节点的父路径上所有节点都要保留
新的 `deal()` 修改如下(含注释),顺便处理了之前那个问题结果中含大量空 `children` 的问题
```
/**
* 递归过滤节点,但保留原树结构,即符合条件节点的父路径上所有节点不管是否符合条件都保留
* @param {Node[]} nodes 要过滤的节点
* @param {node => boolean} predicate 过滤条件,符合条件的节点保留
* @return 过滤后的根节点数组
*/
function d... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
微信浏览器H5页面软键盘关闭导致页面空缺的问题
1. 微信6.7.4 H5页面里的select,input软键盘弹起的时候页面会上移,软键盘关闭页面不会下移。导致页面空缺了一部分。
2. 微信6.7.3及其它版本不会有这个问题!页面会随着软键盘关闭而下移恢复正常! | 您可以尝试以下代码
```
$('textarea').on('blur',function(){
setTimeout(function(){
window.scrollTo(0, 0)
},100)
})
```
如果出现同页面有两个以上输入框,当输入完第一个未关闭软键盘就去点第二个输入框的时候,页面回滚到顶部,导致输入框被软键盘盖住的问题,也可以将以上代码改写一下:```
'$("input,textarea").on("blur",function(){
setTi... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript",
"html5"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
Java8 unordered() 无序化无效
### Java8 unordered()无序化无效, 多次运行结果还是与流中元素顺序一致
// 多次运行结果: 5, 1, 2, 6, 3, 7, 4 没有达到无序的效果
Stream.of(5, 1, 2, 6, 3, 7, 4).unordered().forEach(System.out::println);
求大神指教
### 相关代码
```
/**
* S unordered(); 产生一个与当前流中元素相同的无序流, 当流本身就是无序或流已经无序, 会返回流本身
*/
@Test
public void unorderedT... | `unordered()`操作不会执行任何操作来显式地对流进行排序。它的作用是消除了流必须保持有序的约束,从而允许后续操作使用不必考虑排序的优化。
您可以在Java 8文档中阅读此内容:
在流有序时, 但用户不特别关心该顺序的情况下,使用 unordered 明确地对流进行去除有序约束可以改善某些有状态或终端操作的并行性能。
可以比较下面的结果
```
Stream.of(5, 1, 2, 6, 3, 7, 4).unordered().forEach(System.out::println);
Stream.of(5, 1, 2, 6, 3, 7, 4).unordered().parallel().forEach(S... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"java"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
vuedraggable中如何设置部分元素不可拖拽?
draggable渲染成了ul,但是想让ul中部分li元素可拖拽,部分li元素不可拖拽。
文档只给出了在option中设置disabled;sort等属性可以让整个标签不能拖拽,但是没有给出让子元素不可拖拽的实现方法。
如果要实现部分子元素可拖拽,部分子元素不可拖拽的话除了把一个ul拆分成两个ul还有其他方法吗? | handle: selector 格式为简单css选择器的字符串,使列表单元中符合选择器的元素成为拖动的手柄,只有按住拖动手柄才能使列表单元进行拖动
根据上述进行配置可拖动手柄,例:handle:'.header' | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"draggable"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
关于 js 函数默认值的问题
下面这两种写法为什么会产生两种不同的结果?求大佬详细解答.... 个人觉得是跟函数参数的块级作用域有关.....但是理解起来还是怪怪的,而且用 chrome debugger 来查看也觉得怪怪的,为啥最后那个输入 x,是根据 Block 来输出的?万分感谢~
```
function test (x, y = function t () { x = 2 }) {
var x
y()
console.log(x) // undefined
}
test()
```
```
function test (x, y = function t () { x = 2 }) {
// var x
... | 9.2.12 FunctionDeclarationInstantiation
如果存在函数默认值,那么会为函数体部分创建第二个环境记录,这个第二个环境是在函数默认值之下的。
类似于:
```
// ES6
function foo(x, y = function() { x = 2; }) {
var x = 3;
y(); // is `x` shared?
console.log(x); // no, still 3, not 2
}
// Compiled to ES5
function foo(x, y) {
// Setup defaults.
if (typeof y == 'undefined... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
java反射使用setAccessible(true)调用private方法问题
如题,定义了一个Person类有一个private方法
```
public Person {
private void test();//private方法
}
```
使用反射来调用
先说有问题的方法
```
Constructor con= Person.class.getConstructor();//构造方法
Object object = con.newInstance();//生成对象
//有问题
Person.class.getDeclareMethod("test").setAccessible(true);
Person.c... | 每次获取方法得到不是同一个`Method`对象
`setAccessable`仅作用于得到的方法对象,也不是全局的
所以第一种写法会报错
另外,`setAccessable`的属性并没有被包含在`Method`的`equals` 和`hashCode`中 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"java"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
一道关于js类型转换的面试题?
if([] == false){console.log('a')}
if({} == false){console.log('b')}
if([] == {}){console.log('c')}
if([]){console.log('d')}
这几道题的隐式转换的方式大神帮忙解答下吧 | 对象和非对象之间的相等比较
ES5 规范 11.9.3.8-9 做如下规定:
`ToPrimitive`就是尝试返回它的原始值,也就是`string`或者`number`。
因此:
1. [] == false,`{[]}`会先通过`{valueOf}`,得到`{[]}`,不是原始值,再通过`{toString}`,得到`{""}`
2. ({}) == false,同上面步骤,最终的到`{"[object Object]"}`
3. 同上,`{''!="[object Object]"}`
4. 没有`{==}`,[]默认为true | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
合并数组用 concat 还是 扩展运算符比较好?
```
let arr1 = [1, 2];
let arr2 = [3, 4];
// concat
arr1 = arr1.concat(arr2);
// 扩展运算符
arr1 = [...arr1, ...arr2];
// 或者
arr1.push(...arr2);
```
哪种更好,为什么?性能? | 究竟用哪种还是得根据你实际需求来的
`concat`是`es5`时就有的,优点是`兼容性`高,不需要转译
`...`是`es6`新出的语法,`简化`了写法,代码看上去更简洁直观,但实际只是做了`封装`,底层还是用的原来的方法,如下为babel转译的结果
#### 第二种写法
```
arr1 = [...arr1, ...arr2];
↓ 相当于
function _toConsumableArray(arr) {
if (Array.isArray(arr)) {
for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = ar... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
GET查询,加.keyword与不加.keyword的区别是什么,为什么没有结果
```
GET production-index-info/index_info/_search
{
"query": {
"bool": {
"minimum_should_match": 0,
"must": [
{
"term": {
"is_resolved.keyword": "解决"
}
}
],
"should": []
}
}
}
```
使用这种方式查询,就可以得到数据... | 1.ES5.0及以后的版本取消了`string`类型,将原先的`string`类型拆分为`text`和`keyword`两种类型。它们的区别在于`text`会对字段进行分词处理而`keyword`则不会。
2.当你没有以IndexTemplate等形式为你的索引字段预先指定mapping的话,ES就会使用Dynamic Mapping,通过推断你传入的文档中字段的值对字段进行动态映射。例如传入的文档中字段price的值为12,那么price将被映射为`long`类型;字段addr的值为"192.168.0.1",那么addr将被映射为`ip`类型。然而对于不满足ip和date格式的普通字符串来说,情况有些不同:ES会将它们映射为te... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"elasticsearch",
"elastic-search",
"elk"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
bind和call的笔试题,为什么用call和没用call执行的结果一样?
面试题是这样的:
```
var s = {
s: 'student',
getS:function(){
console.log(this.s);
}
};
var t = {
s: 'teacher chen'
}
var getS = s.getS;
var getS1 = getS.bind(s);
```
正确的运行结果是:
```
getS1(); // student
getS1.call(t); //student
```
var getS1 = getS.b... | 对这个问题很感兴趣,查了一些资料
以下是 MDN 里 bind 的 Polyfill , 可以看出来 bind 返回的函数只有用 new 方法当做构造函数调用时才会改变 this, 其他情况下的 this 一直是绑定的那个
```
if (!Function.prototype.bind) {
Function.prototype.bind = function(oThis) {
if (typeof this !== 'function') {
// closest thing possible to the ECMAScript 5
// internal IsCallable functio... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
React组件方法全部用箭头函数这样好吗?
React的组件中不用bind(this),全部用箭头函数,这样会有什么缺点吗? | 箭头函数的优点就是可以自动绑定上下文中的`this`箭头函数的优点是不会创建自己的`this`,它只会从自己的作用域链的上一层继承`this`.当然这也有可能是缺点,比如在你需要改变`this`的时候,这个时候就需要改成普通函数了.
我遇到的另外一种情况是需要使用装饰器的情况,普通的函数使用装饰器直接覆盖`descriptor.value`就好了.但是如果装饰在箭头函数上面的话`descriptor.value`为空,需要通过别的方法来操作,有点麻烦,最后我直接改成普通函数,在最外面加了层绑定`this`的装饰器解决的.
其实也没多少好纠结的,只要你明白什么情况下不能用,其他情况下就大胆用.当你什么时候遇到问题了,就在心中记一笔,这... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"react.js"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
vue中v-if影响同级audio标签播放?
### 问题描述
#### 以下是部分代码
```
<audio class="basic-audio" :src="audio" autoplay="autoplay" @ended="ended"></audio>
<div class="content-region" v-if="chooseCard">
<el-row type="flex" v-for="(item,index) in contentList" :key="index" >
<el-col class="content-lattice" v-for="(item,i... | 可以了解一下`vue`中`diff`算法相关的实现。比如这篇文章。
这种情况应该会出现于`audio`前后(不仅限于相邻)的兄弟节点中都存在`v-if`的情况。
因为`vue`中`diff`是基于同层级比较的,并且`updateChildren`方法中的`VNode`比较是从节点左右两侧向中间靠拢的,所以当`audio`前后都存在`v-if`时,`virtual dom`重新渲染时,会将`audio`这个`dom`进行移动,所以实际上`audio`是会被从父节点移除然后再重新加入(可以通过给`audio`绑定`DOMNodeRemoved`来验证)。
由于`audio`被移除过,所以播放会被停止。至于`v-show`没有此问题,是因... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"音频",
"vue.js",
"前端",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
vuex中存储的数据在页面刷新之后都是失去,我想让vuex中的数据在刷新之后不会丢失怎么办。
1.vuex中存储的数据在刷新页面(F5)之后会丢失全部的数据
2.我想刷新页面之后不丢失。同时我还不想存储在window中的session和local中
vuex中有没有相应的数据存储方法或者设置可以做到这样的效果 | 你的这个业务场景跟vuex没有关系吧?
vuex就是一个“提升变量”的一个工具,它是将state当做全局变量存储。F5刷新页面之后自然随着页面的刷新重新初始化state。
目前想让浏览器记住数据,一般都会采用cookie或者localStorage等方法,如果有什么其它方法,欢迎分享。 | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"vue.js",
"vuex",
"vue-router",
"vue-cli",
"javascript"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 | |
java nio 与 nio 的关系
## 以前遇到问题,总是可以在网上找到绝对正确的答案,现在遇到的很多问题,博客上会有很多种不同的答案,比如说关于java nio,有人说是同步非阻塞,还有人说是异步阻塞,我只知道java nio是采用的reactor模式,也可以说是io多路复用,netty也是这种方式。希望大鸟们可以给我一个详细的解释,关于java nio与linux nio,在此谢过大家 | 首先我想说下我对 同步异步 阻塞非阻塞的理解:
`同步异步 指的是线程在处理一件事的时候,能不能去处理另外一件事,然后过一会再给上一件事结果`
`阻塞非阻塞 指的是线程在处理一件事的时候,会不会被阻塞住 (linux 里的NIO 意思就是no block io)`
这在java 等编程语言里 ,应该是一种编程模型,
而在linux 的IO模型里 ,这种表述就不成立 ,因为不管什么IO模型,在从内核复制到用户态的过程 中都是阻塞的,即使是 同步非阻塞模型,
在linux 模型中,阻塞非阻塞指的是 使用系统调用看用户态准备好没有这个过程 ,而对于linux多路复用,系统调用select也阻塞,也没有办法去做别的任务,看起来他应该是同步... | {
"major": [
"问答"
],
"minor": [
"代码问答"
]
} | [
"linux",
"java"
] | 暂无元数据信息 | human | false | 暂无版权及作者信息 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.