[TOC]
1、结果是什么？为什么？
```
<script>
function Foo() {
getName = function () {
console.log(1)
}
return this
}
Foo.getName = function () {
console.log(2)
}
Foo.prototype.getName = function () {
console.log(3)
}
function getName() {
console.log(5)
}
var getName = function () {
console.log(4)
}
// 运行结果
Foo.getName() // 2
getName() // 4
Foo().getName() // 1
getName() // 1
new Foo.getName() // 2
new Foo().getName() // 3
new new Foo().getName() // 3
/*
* 预解析：
* function Foo() {
getName = function () {
console.log(1)
}
return this
}
function getName() {
console.log(5)
}
重名：PK！！！
getName = undefined // 没有值 失败了
最终结果就是只有两个函数：
Foo、getName
* 逐行解读代码：
* 函数声明，不会改变值；函数表达式，会改变值；
* Foo.getName = function() { console.log(2) }
* Foo.prototype.getName = function() { console.log(3) }
* getName = function() { console.log(4) }
*
* Foo.getName() // 2 自身上有停止向上查找
* getName() // 4
* Foo().getName() // 先执行Foo()函数，开启新的一轮预解析、解读代码；再执行getName()函数，
* 预解析：
* 空
* 逐行解读：
* getName = function() { console.log(1) }
* this指向的是window，因为Foo是window调用的；
* Foo().getName()变形为：window.getName = function() { console.log(1) }，全局作用域挂载了getName()方法
* 所以：getName = function() { console.log(4) } 被 window.getName = function() { console.log(1) }覆盖了
* 因此：Foo().getName() 结果就是：1
* getName() // 1
* new Foo.getName() // 点的优先级是最高的，因此变形为：Foo.getName() -> 结果是：2；接下来相当于 new function() { console.log(2) }，所以最终结果肯定是：2
* new Foo().getName() // 点的优先级最高，但是更高的是先执行整体，因此变形为：new Foo()先执行 结果为：Foo实例对象，然后再在实例对象上查找getName()，变形为：Foo.getName()，按照实例对象的查找规则，自身上有停止，没有会按照原型链__proto__查找，结果就是：3
* new new Foo().getName() // 变形：new Foo().getName()，运行结果是: 3，然后new function() { console.log(3) }，最终结果肯定是：3
* */
// new Foo.getName() 和 new Foo().getName() 不好理解看这里
function Foo() {
// this.getName = function() {
// console.log(1)
// }
}
Foo.getName = function () {
console.log(2)
}
Foo.prototype.getName = function() {
console.log(3)
}
console.log(new Foo().getName())
</script>
```
*****
2、运行结果是什么？为什么？
```
<script>
var arr = [1,2,3]
function test(arr) {
arr = []
}
test(arr)
// 结果
console.log(arr) //1,2,3
/*
* 预解析：
* arr = undefined
* function test(arr) { arr = [] }
* 逐行解读代码：
* arr = [1,2,3]
* function test(arr) { arr = [] } // 函数声明，跳过
* test(arr) // 函数调用，开启新的预解析、解读代码
* 预解析：
* arr = undefined
* 解读代码：
* arr = []
* console.log(arr) // 此arr非函数内部的arr，因为作用域额关系，因此结果就是1,2,3
* */
</script>
```
*****
3、运行结果是什么？为什么？
```
<script>
var a = 1;
if (!(b in window)) { // false
var b = 2;
a+=1
} else {
a+=2
}
// 结果
console.log(a) // 3
console.log(b) // undefined
/*
* 预解析：
* a = undefined
* b = undefined
* 逐行解读代码：
* a = 1
* !(b in window) // 预解析中有了b，因此b是挂载到window上，所以b in window 为true，然后取反，所以是false，因此不走if，走了else，所以：a += 2，a最终结果就是：3
* console.log(a) // 3
* console.log(b) // undefined
* */
</script>
```
*****
4、运行结果是什么？为什么？
```
<script>
var scope = 'global scope'
function checkscope() {
var scope = 'local scope'
function f() {
return scope
}
return f
}
// 结果
console.log(checkscope()()) // local scope
/*
* 预解析：
* scope = undefined
* function checkscope() { var scope = 'local scope'; function f() { return scope }; return f }
* 逐行解读代码：
* scope = 'global scope'
* function checkscope() { var scope = 'local scope'; function f() { return scope }; return f } // 函数声明，跳过
* console.log(checkscope()()) // 分开两次执行：第一次执行，checkscope(),函数调用，开启新一轮的
* 预解析：
* scope = undefined
* function f() { return scope }
* 逐行解读：
* scope = 'local scope'
* function f() { return scope }; // 函数声明
* return f // 返回出去
* checkscope() // 结果就是：function f() { return scope }
* checkscope()() // 第二次执行：相当于：function f() { return scope } () 执行，开启新的预解析、解读代码：
* 预解析：
* 空
* 逐行解读：
* return scope // 预解析后没有，按照作用域链向上级查找，上级的scope = 'local scope'，因此最终结果就是：local scope
* */
</script>
```
5、运行结果是什么？为什么？
```
<script>
var y = 10
if (!(x in window)) {
var x = 10;
} else {
++y
}
//结果
console.log(x) // undefined
console.log(y) // 11
/*
* 预解析：
* y = undefined
* x = undefined
* 逐行解读代码：
* y = 10
* (x in window) // x 在预解析中存在，因此是挂载在window上面的，所以结果是：true；但是!(x in window)结果就是：false，因此，if不执行
* else ++y // 前++在这里，结果是：11
* console.log(x) // undefined
* console.log(y) // 11
* */
</script>
```
6、运行结果是什么？为什么？怎么修改达到预期
```
for(var i = 0; i< 5; i++) {
setTimeout(function () {
// 结果
console.log(i) // 5
}, 300)
}
~~~
for( var i = 0;i<5;i++) {
(function(i){
setTimeout(function () {
console.log(i);
},1000)
})(i);
}
~~~~~~
/*
* 这个setTimout在for里面是异步执行的，在延迟输出的时候，i的值已经是5了，因此会输出 5,5,5,5,5
* */
for( var i = 0;i<5;i++) {
(function(i){
setTimeout(function () {
console.log(i);
},1000)
})(i);
}
/*得采用闭包的方法，将里面的i值保存下来；结果就是 01234*/
```
7、运行结果是什么？为什么？
```
var str1 = 'abc123def456';
var str2 = str1.replace(/\d+/gi, '*')
// 结果
console.log(str2) // abc*def*
```
8、1&&2和1||2的值分别是多少？
```
1&&2 // 2
1||2 // 1
```
9、指出以下代码的区别
```
function Person() {}
var person = Person()
var person = new Person()
```
10、alert(undefined == null)弹出什么
```
alert(undefined == null) // true
```
11、以下代码输出的结果是什么
```
console.log(1 + '2' + '2')
console.log(1 ++ '2' + '2')
console.log('A' - 'B' + '2')
console.log('A' - 'B' + 2)
```
12、以下代码输出的结果是什么？
```
A:var test = 1; typeof test = 'number'
B:var test = 1.2; typeof test = 'float'
C:var test = undefined; typeof test = 'undefined'
D:var test = {}; typeof test = 'object'
E:var test = '4299' - 0; typeof test = 'number'
F:var test = null; typeof test = 'object'
```
13、以下代码的运行结果是
```
var arr = new Array(2,3,4,5,6)
var newArr = 0
for(var i=1;i<arr.length;i++) {
newArr+=arr[i]
}
// 结果
document.write(newArr) // 18
```
14、分析下面代码，结果是
```
var s1 = parseInt('101 小四')
document.write(s1)
```
*****
15、看下列代码输出为何？解释原因
```
var a = null;
alert(typeof a); //object
// 解释：null 是一个只有一个值的数据类型，这个值就是 null。表示一个空指针对象，所以用 typeof 检测会
返回”object”
```
*****
16、看下列代码,输出什么？解释原因
```
var undefined;
undefined == null; // true
1 == true; // true
2 == true; // false
0 == false; // true
0 == ''; // true
NaN == NaN; // false
[] == false; // true
[] == ![]; // true
解释：
undefined 与 null 相等，但不恒等（===）
一个是 number 一个是 string 时，会尝试将 string 转换为 number
尝试将 boolean 转换为 number，0 或 1
尝试将 Object 转换成 number 或 string，取决于另外一个对比量的类型
所以，对于 0、空字符串的判断，建议使用 “===” 。“===”会先判断两边的值类型，类型不匹配时
为 false。
```
*****
17、看下面的代码，输出什么，foo 的值为什么
```
var foo = "11"+2-"1";
console.log(foo);
console.log(typeof foo);
结果：
执行完后 foo 的值为 111，foo 的类型为 String
```
18、看代码给答案
```
var a = new Object();
a.value = 1;
b = a;
b.value = 2;
alert(a.value);
答案：2（考察引用数据类型细节）
```
19、看程序，写结果
```
function setN(obj){
obj.name='屌丝';
obj = new Object();
obj.name = '腐女';
};
var per = new Object();
setN(per);
alert(per.name); //屌丝
```
20、下面输出多少
```
var o1 = new Object();
var o2 = o1;
o2.name = "CSSer";
console.log(o1.name); // CSSer
```
21、a 输出多少
~~~
var a = 6;
setTimeout(function () {
var a = 666;
alert(a); // 666
}, 1000);
/*
* 逐行解读：
* a = 6
* 遇到了setTimeout，执行function函数，开启新的预解析、逐行解读
* 预解析：
* a = undefined
* 逐行解读：
* a = 666
* alert(a) // 666，作用域链查找规则：自己有，拿自己的，自己没有找父级的
* */
var a = 6;
setTimeout(function () {
alert(a);
var a = 666;
}, 1000);
/*
* 逐行解读：
* a = 6
* 遇到了setTimeout，执行function函数，开启新的预解析、逐行解读
* 预解析：
* a = undefined
* 逐行解读：
* alert(a) // undefined
* a = 666
* */
var a = 6;
setTimeout(function () {
alert(a);
var a = 66;
}, 1000);
a = 666;
alert(a);
/*
* 逐行解读：
* a = 6
* 遇到了setTimeout，执行function函数，开启新的预解析、逐行解读
* 预解析：
* a = undefined
* 逐行解读：
* alert(a) // undefined
* a = 66
* a = 666
* alert(a) // 666
*
* */
/*
* 预解析（总）：
* a = undefined
* 逐行解读：
* 直接看代码！！！
*
* */
~~~
*****
22、看下列代码输出为何？解释原因
```
var a;
alert(typeof a); // undefined
alert(b); // 报错
```
解释：Undefined 是一个只有一个值的数据类型，这个值就是“undefined”，在使用 var 声明变量但并
未对其赋值进行初始化时，这个变量的值就是 undefined。而 b 由于未声明将报错。注意未申明的变量和
声明了未赋值的是不一样的
*****
23、分析代码，得出正确的结果
```
var a=10, b=20 , c=30;
++a;
a++;
e=++a + (++b) + (c++) + a++;
alert(e);
弹出提示对话框：77
```
24、写出函数 DateDemo 的返回结果，系统时间假定为今天
```
function DateDemo(){
var d, s="今天日期是：";
d = new Date();
s += d.getMonth() +1+ "/";
s += d.getDate() + "/";
s += d.getFullYear();
return s;
}
结果：今天日期是：7/21/2016
```
25、写出程序运行的结果？
```
for(i=0, j=0; i<10, j<6; i++, j++){
k = i + j;}
结果：10
```
26、阅读以下代码，请分析出结果
```
var arr = new Array(1 ,3 ,5);
arr[4]='z';
arr2 = arr.reverse();
arr3 = arr.concat(arr2);
alert(arr3);
弹出提示对话框：z,,5,3,1,z,,5,3,1
```
27、看题作答
```
function f1(){
var tmp = 1;
this.x = 3;
console.log(tmp); //A
console.log(this.x)； //B
}
var obj = new f1(); //1
console.log(obj.x) //2
console.log(f1()); //3
这道题让我重新认识了对象和函数，首先看代码（1），这里实例话化了 f1 这个类。相当于执行了 f1
函数。所以这个时候 A 会输出 1， 而 B 这个时候的 this 代表的是 实例化的当前对象 obj B 输出 3.。
代码（2）毋庸置疑会输出 3， 重点 代码（3）首先这里将不再是一个类，它只是一个函数。那么 A 输
出 1，B 呢？这里的 this 代表的其实就是 window 对象，那么 this.x 就是一个全局变量 相当于在外部 的
一个全局变量。所以 B 输出 3。最后代码由于 f 没有返回值那么一个函数如果没返回值的话，将会返回
underfined ，所以答案就是 ： 1， 3， 3， 1， 3， underfined 。
```
28、下面输出多少
```
var o1 = new Object();
var o2 = o1;
o2.name = "CSSer";
console.log(o1.name);
如果不看答案，你回答真确了的话，那么说明你对 javascript 的数据类型了解的还是比较清楚了。js 中有
两种数据类型，分别是：基本数据类型和引用数据类型（object Array）。对于保存基本类型值的变量，
变量是按值访问的，因为我们操作的是变量实际保存的值。对于保存引用类型值的变量，变量是按引用访
问的，我们操作的是变量值所引用（指向）的对象。答案就清楚了： //CSSer;
```
29、再来一个
```
function changeObjectProperty (o) {
o.siteUrl = "http://www.csser.com/";
o = new Object();
o.siteUrl = "http://www.popcg.com/";
}
var CSSer = new Object();
changeObjectProperty(CSSer);
console.log(CSSer.siteUrl); // “http://www.csser.com/”
如果 CSSer 参数是按引用传递的，那么结果应该是"http://www.popcg.com/"，但实际结果却仍是
"http://www.csser.com/"。事实是这样的：在函数内部修改了引用类型值的参数，该参数值的原始引用保持不变。我们可以把参数想象成局部变量，当参数被重写时，这个变量引用的就是一个局部变量，局部
变量的生存期仅限于函数执行的过程中，函数执行完毕，局部变量即被销毁以释放内存。
（补充：内部环境可以通过作用域链访问所有的外部环境中的变量对象，但外部环境无法访问内部环境。
每个环境都可以向上搜索作用域链，以查询变量和函数名，反之向下则不能。）
```
30、a 输出多少？
```
var a = 6;
setTimeout(function () {
var a = 666;
alert(a); // 输出 666，
}, 1000);
因为 var a = 666;定义了局部变量 a，并且赋值为 666，根据变量作用域链，
全局变量处在作用域末端，优先访问了局部变量，从而覆盖了全局变量 。
var a = 6;
setTimeout(function () {
alert(a); // 输出 undefined
var a = 666;
}, 1000);
因为 var a = 666;定义了局部变量 a，同样覆盖了全局变量，但是在 alert(a);之前
a 并未赋值，所以输出 undefined。
var a = 6;
setTimeout(function(){
alert(a);
var a = 66;
}, 1000);
a = 666;
alert(a);
// 666, undefined;
记住： 异步处理，一切 OK 声明提前
```
31、精度问题: JS 精度不能精确到 0.1 所以 。。。。同时存在于值和差值中
```
var n = 0.3,m = 0.2, i = 0.2, j = 0.1;
alert((n - m) == (i - j)); //false
alert((n-m) == 0.1); //false
alert((i-j)==0.1); //true
```
32、加减运算
```
alert('5'+3); //53 string
alert('5'+'3'); //53 string
alert('5'-3); //2 number
alert('5'-'3'); //2 number
```
33、结果是什么？
```
function foo(){
foo.a = function(){alert(1)};
this.a = function(){alert(2)};
a = function(){alert(3)};
var a = function(){alert(4)};
};
foo.prototype.a = function(){alert(5)};
foo.a = function(){alert(6)};
foo.a(); //6
var obj = new foo();
obj.a(); //2
foo.a(); //1
```
34、输出结果
```
var a = 5;
function test(){
a = 0;
alert(a);
alert(this.a); //没有定义 a 这个属性
var a;
alert(a)
}
test(); // 0, 5, 0
new test(); // 0, undefined, 0 //由于类它自身没有属性 a， 所以是 undefined
```
35、结果是
```
var bool = !!2; alert(bool)；//true;
双向非操作可以把字符串和数字转换为布尔值。
```
36、下面这段代码想要循环输出结果 01234，请问输出结果是否正确，如果不正
确，请说明为什么，并修改循环内的代码使其输出正确结果
~~~
for(var i=0;i<5;++i){
setTimeout(function(){
console.log(i+'');
},100*i);
}
~~~
37、.JavaScript alert(0.4*0.2);结果是多少？和你预期的一样吗？如果不一样该如何
处理？
有误差，应该比准确结果偏大。
原因：
java和JavaScript中计算小数运算时,都会先将十进制的小数换算到对应的二进制,一部分小数并不能完整的换算为二进制,这里就出现了第一次的误差
解决方案：
一般我会将小数变为整数来处理。当然原理也是一致先转为整数再计算。
```
alert(((0.4*10)*(0.2*10))/10);
```
38、下列 JavaScript 代码执行后，依次 alert 的结果是
```
(function test(){
var a=b=5;
alert(typeof a);
alert(typeof b);
})();
alert(typeof a);
alert(typeof b);
答案：number
number
undefined
number
```
39、下列 JavaScript 代码执行后，iNum 的值是
```
var iNum = 0;
for(var i = 1; i< 10; i++){
if(i % 5 == 0){
continue;
}
iNum++;
}
答案：8
```
40、输出结果是多少？
```
1） var a;
var b = a * 0;
if (b == b) {
console.log(b * 2 + "2" - 0 + 4);
} else {
console.log(!b * 2 + "2" - 0 + 4);
}
答案：26
2）
<script>
var a = 1;
</script>
<script>
var a;
var b = a * 0;
if (b == b) {
console.log(b * 2 + "2" - 0 + 4);
} else {
console.log(!b * 2 + "2" - 0 + 4);
}
</script>
答案：6
3）
var t = 10;
function test(t){
var t = t++;
}test(t);
console.log(t);
答案：10
4）
var t = 10;
function test(test){
var t = test++;
}test(t);
console.log(t);
答案：10
6） var t = 10;
function test(test){
t = test++;
}test(t);
console.log(t);
答案：10
7）
var t = 10;
function test(test){
t = t + test;
console.log(t);
var t = 3;
}test(t);
console.log(t);
答案：NaN 10
8）
var a;
var b = a / 0;
if (b == b) {
console.log(b * 2 + "2" - 0 + 4);
} else {
console.log(!b * 2 + "2" - 0 + 4);
}
答案：26
9）
<script>
var a = 1;
</script>
<script>
var a;
var b = a / 0;
if (b == b) {
console.log(b * 2 + "2" + 4);
} else {
console.log(!b * 2 + "2" + 4);
}
</script>
答案：Infinity24
```
41、下列 JavaScript 代码执行后，运行的结果是
```
<button id='btn'>点击我</button>
var btn = document.getElementById('btn');
var handler = {
id: '_eventHandler',
exec: function(){
alert(this.id);
}
}
btn.addEventListener('click', handler.exec);
答案：”btn"
```
42、下列 JavaScript 代码执行后，依次 alert 的结果是
```
var obj = {proto: {a:1,b:2}};
function F(){};
F.prototype = obj.proto;
var f = new F();
obj.proto.c = 3;
obj.proto = {a:-1, b:-2};
alert(f.a);
alert(f.c);
delete F.prototype['a'];
alert(f.a);
alert(obj.proto.a);
答案：
1
3
undefined
-1
```
43、下列 JavaScript 代码执行后的效果是
```
<ul id='list'>
<li>item</li>
<li>item</li>
<li>item</li>
<li>item</li>
<li>item</li>
</ul>
var items = document.querySelectorAll('#list>li');
for(var i = 0;i < items.length; i++){
setTimeout(function(){
items[i].style.backgroundColor = '#fee';
}, 5);
}
答案：报错，因为 i 一直等于 5，items[i]获取不到元素
```
44、下列 JavaScript 代码执行后的 li 元素的数量是
```
<ul>
<li>Item</li>
<li></li>
<li></li>
<li>Item</li>
<li>Item</li>
</ul>
var items = document.getElementsByTagName('li');
for(var i = 0; i< items.length; i++){
if(items[i].innerHTML == ''){
items[i].parentNode.removeChild(items[i]);
}
}
```
45、数组和字符串
```
<script lang="JavaScript" type="text/javascript">
function outPut(s) {
document.writeln(s);
}
var a = "lashou";
var b = a;
outPut(b);
a = "拉手";
outPut(a);
outPut(b);
var a_array = [1, 2, 3];
var b_array = a_array;
outPut(b_array);
a_array[3] = 4;
outPut(a_array);
outPut(b_array);
</script>
输出结果：
答案：lashou 拉手 lashou 1,2,3 1,2,3,4 1,2,3,4
```
46、下列控制台都输出什么
```
第 1 题：
function setName(){
name="张三";
}
setName();
console.log(name);
答案："张三"
第 2 题：
//考点：1、变量声明提升 2、变量搜索机制
var a=1;
function test(){
console.log(a);
var a=1;
}
test();
答案：undefined
第 3 题：
var b=2;
function test2(){
window.b=3;
console.log(b);
}
test2();
答案：3
第 4 题：
c=5;//声明一个全局变量 c
function test3(){
window.c=3;
console.log(c); //答案：undefined，原因：由于此时的 c 是一个局
部变量 c，并且没有被赋值
var c;
console.log(window.c);//答案：3，原因：这里的 c 就是一个全局变量 c
}
test3();
第 5 题：
var arr = [];
arr[0] = 'a';
arr[1] = 'b';
arr[10] = 'c';
alert(arr.length); //答案：11
console.log(arr[5]); //答案：undefined
第 6 题：
var a=1;
console.log(a++); //答案：1
console.log(++a); //答案：3
第 7 题：
console.log(null==undefined); //答案：true
console.log("1"==1); //答案：true，因为会将数字 1 先转换为字符串 1
console.log("1"===1); //答案：false，因为数据类型不一致
第 8 题：
typeof 1; "number"
typeof "hello"; "string"
typeof /[0-9]/; "object"
typeof {}; "object"
typeof null; "object"
typeof undefined; "undefined"
typeof [1,2,3]; "object"
typeof function(){}; //"function"
第 9 题：
parseInt(3.14); //3
parseFloat("3asdf"); //3
parseInt("1.23abc456");
parseInt(true);//"true" NaN
第 10 题：
//考点：函数声明提前
function bar() {
return foo;
foo = 10;
function foo() {}
//var foo = 11;
}
alert(typeof bar());//"function"
第 11 题：
//考点：函数声明提前
var foo = 1;
function bar() {
foo = 10;
return;
function foo() {}
}
bar();
alert(foo);//答案：1
第 12 题：
console.log(a);//是一个函数
var a = 3;
function a(){}
console.log(a);////3
第 13 题：
//考点：对 arguments 的操作
function foo(a) {
arguments[0] = 2;
alert(a);//答案：2，因为：a、arguments 是对实参的访问，b、通过 arguments[i]可以修
改指定实参的值
}
foo(1);
第 14 题：
function foo(a) {
alert(arguments.length);//答案：3，因为 arguments 是对实参的访问
}
foo(1, 2, 3);
第 15 题
bar();//报错
var foo = function bar(name) {
console.log("hello"+name);
console.log(bar);
};
//alert(typeof bar);
foo("world");//"hello"
console.log(bar);//undefined
console.log(foo.toString());
bar();//报错
第 16 题：
function test(){
console.log("test 函数");
}
setTimeout(function(){
console.log("定时器回调函数");
}, 0)
test();
结果：
test 函数
定时器回调函数
```
47、对作用域上下文和 this 的理解，看下列代码：
```
var User = {
count: 1,
getCount: function() {
return this.count;
}
};
console.log(User.getCount()); // what?
var func = User.getCount;
console.log(func()); // what?
问两处 console 输出什么？为什么？
答案是 1 和 undefined。
func 是在 winodw 的上下文中被执行的，所以会访问不到 count 属性。
继续追问，那么如何确保 Uesr 总是能访问到 func 的上下文，即正确返回 1。正确的方法是使用
Function.prototype.bind。兼容各个浏览器完整代码如下：
Function.prototype.bind = Function.prototype.bind || function(context){
var self = this;
return function(){
return self.apply(context, arguments);
};
}
var func = User.getCount.bind(User);
console.log(func());
```
48、运行结果
~~~
console.log(a)
var a = 12
function fn() {
console.log(a)
var a = 13
}
fn()
console.log(a)
/*
* 预解析：
* a = undefined
* function fn() { console.log(a); var a = 13 }
* 逐行解读代码：
* console.log(a) // undefined
* var a = 12
* function fn() { console.log(a); var a = 13 } // 函数声明，不执行跳过
* fn() // 函数调用
* 预解析：
* a = undefined
* 逐行解读代码：
* console.log(a) // undefined
*
* console.log(12) // 12
* */
~~~
49、运行结果
~~~
console.log(a)
var a = 12
function fn() {
console.log(a)
a = 13
}
fn()
console.log(a)
/*
* 预解析：
* a = undefined
* function fn() { console.log(a); a = 13 }
* 逐行解读代码：
* consosle.log(a) // undefined
* var a = 12
* function fn() { console.log(a); a = 13 } // 不执行，因为是函数声明
* fn() // 这个函数调用，开启新的局部作用域解析机制
* 预解析：
* 空 // 因为没有var、参数、function、this，预解析找的就是这些东西
* 逐行解读代码：
* console.log(a) // 12
* a = 13
* console.log(a) // 13
*
* */
~~~
50、运行结果 ~ O(∩_∩)O哈哈~
~~~
console.log(a)
a = 12
function fn() {
console.log(a)
a = 13
}
fn()
console.log(a)
/*
* 实际情况是下面这样：
* 预解析：
* function fn() { console.log(a); a = 13 }
* 逐行解读代码：
* console.log(a) // a is not defined，程序报错后续代码不执行
* */
/*
* 把第一行注释掉就是下面的结果
* 预解析：
* function fn() { console.log(a); a = 13 }
* 逐行解读代码：
* console.log(a) // a is not defined
* a = 12
* function fn() { console.log(a); a = 13 } // 函数声明，不理会它，跳过
* fn() // 函数执行，开启新的局部预解析、逐行解读代码
* 预解析：
* 空
* 逐行解读代码：
* console.log(a) // 12
* a = 13
* console.log(a) // 13
* */
~~~
51、运行结果：
~~~
var foo = 1
function bar() {
if (!foo) {
var foo = 10
}
console.log(foo)
}
bar()
/*
* 预解析：
* foo = undefined
* function bar() { if(!foo) { var foo = 100 } console.log(100) }
* 逐行解读代码：
* foo = 1
* function bar() { if(!foo) { var foo = 100 } console.log(100) } // 函数声明，不理会它，跳过
* bar() // 函数执行，开启新的局部解析作用域
* 预解析：
* foo = undefined
* 逐行解读代码：
* if(!foo) { var foo = 100 } // 此时foo = undefined， undefined取反，不就是真么，所以条件成立
* foo = 10
* console.log(10) // 最终结果就是：10
* */
~~~
52、运行结果：
~~~
var n = 0
function a() {
var n = 10
function b() {
n++
console.log(n)
}
b()
return b
}
var c = a()
c()
console.log(n)
/*
* 预解析：
* n = undefined
* function a() {
var n = 10
function b() {
n++
console.log(n)
}
b()
return b
}
c = undefined
逐行解读代码：
n = 0
c = a()
c() // 执行a开启新的局部作用域
* 预解析：
* n = undefined
* function b() { n++; console.log(n) }
* 逐行解读代码：
* n = 10
* function b() { n++; console.log(n) } // 函数声明 跳过 不理它
* b() // 函数调用，开启新的局部作用域：
* 预解析：
* 空
* 逐行解读代码：
* n++ // 按照作用域链线上及查找
* console.log(n) // 11
* return b // n++; console.log(n)
c() 会导致B()函数的里面的n再次++，因此结果就是:n = 12
console.log(n) // 但是外部作用域无法访问内部的变量，结果就是：0
*
* 最终结果就是：11 12 0
*
* */
~~~
53、运行结果
~~~
var a = 10, b = 11, c = 12
function test(a) {
a = 1
var b = 2
c = 3
}
test(10)
console.log(a)
console.log(b)
console.log(c)
/*
* 预解析：
* a = undefined
* b = undefined
* c = undefined
* function test(a) { a = 1; var b = 2; c = 3 }
* 逐行解读代码：
* a = 10
* b = 11
* c = 12
* function test(a) { a = 1; var b = 2; c = 3 } // 跳过，不理会，因为是函数声明
* test(10) // 函数执行，开启新的作用域解析：
* 预解析：
* a = undefined
* b = undefined
* 逐行解读代码：
* a = 10 // 实参传递进来的
* b = 2 // 私有的
* c = 3 // 全局的
* console.log(a) // 10
* console.log(b) // 11
* console.log(c) // 3
* */
~~~
54、分析运行结果
~~~
if (!("a" in window)) {
var a = 1
}
console.log(a)
/*
* 预解析：
* a = undefined
* 在全局声明的变量相当于挂载到了window上面，因此window上面此时就存在了a变量
* 逐行解读代码：
* if语句不成立，所以不进入
* console.log(a) // undefined
* */
~~~
55、分析运行结果
~~~
// 'use strict'
var a = 4
function b(x, y, a) {
console.log(a)
arguments[2] = 10
console.log(a)
}
a = b(1, 2, 3)
console.log(a)
/*
* 预解析：
* a = undefined
* function b(x, y, a) {
console.log(a)
arguments[2] = 10
console.log(a)
}
逐行解读代码：
a = 4
function b() {} // 函数声明，跳过，不执行
a = b(1, 2, 3) // 函数调用，执行代码，开启新的局部作用域：
* 预解析：
* x = undefined
* y = undefined
* a = undefined
* 逐行解读代码：
* console.log(a) // 3
* arguments[2] = 10 -> a = 10
* console.log(a) // 10
a = b(1, 2, 3) // 把b函数的返回值给我到a变量，而此时b没有返回值，所以 a = undefined
console.log(a) // 结果就是：undefined
*
*
* */
/*
* 在JS的非严格模式下，函数的实参集合与形参变量存在映射关系，不管其中一个谁改变了，另外一个都会跟着改变
* function fn(a) {
* // a = 10
* arguments[0] = 100
* // a = 100
* }
* fn(10)
*
* 在JS严格模式下，arguments和形参变量的映射关系就被切断了，相互之间互不干扰
* */
~~~
56、分析结果：
~~~
var foo = 'hello';
(function (foo) {
console.log(foo)
var foo = foo || 'world'
console.log(foo)
})(foo) // 把全局foo的值当做实参传递给私有作用域中的形参
console.log(foo)
/*
* 预解析：
* foo = undefined
* 逐行解读代码：
* foo = 'hello'
* 自执行函数执行，开启函数内部的解析
* 预解析：
* foo = undefined // 注意：这里的foo和外部全局的foo，不是同一个
* 逐行解读代码：
* console.log(foo) // hello - 外部传递进来的数据是hello，虽然此foo非彼foo但是值是同一个
* var foo = foo || 'world' //
* console.log(foo) // hello
* console.log(foo) // hello
*
*
*
* 逻辑&& 与 逻辑||
* 在&&和||一起使用的时候：
* &&的优先级高于||
* 在条件判断中：
* &&：所有条件都为真，整体才为真
* ||：只要有一个条件为真，整体就为真
* 在赋值操作中：
* ||：A||B，首先看A的真假，A为真返回的是A的值，A为假返回的是B的值(不管B是啥)
* 1||2 => 1
* 0||false => false
* &&：A&&B，首先看A的真假，A为假返回A的值，A为真返回B的值
* 1&&2 => 2
* 0&&false => 0
* // 在实际中的应用
function fn(num, callback) {
// 如果num没有传值，让其默认为0
num = num || 0 // 这种做法不太严谨
callback && callback() // 如果传了就执行，如果不传就不执行
}
* // 调用
fn(1, function() {})
* */
~~~
57、分析结果：
~~~
console.log(0||2&&false||3)
/*
* 按照运算符优先级来看的话：
* 先计算：2 && false
* 结果是：2 为真 返回 false
* 接下来就是：
* 0 || false || 3 对比
* 结果：0 为假 返回 false
* false || 3
* 结果：false 为假 返回 3
* 最终结果就是：3
*
* */
~~~
*****
预解析规则：
1，预解析：找东西通过var、function、参数、this
2，逐行解读代码，遇到表达式就会改变原来预解析仓库中的内容，如果遇到函数调用就开了一个新的 作用域，重新开始预解析、逐行解读代码；如果在函数作用于内部没有通过var、function、参数找到任何东西，那么就会返回到父级继续查找，这就是作用域链的过程
58、分析结果
~~~
console.log(a); // undefined
var a = 1;
~~~
59、分析结果
~~~
console.log(a); // a is not defined
a = 1;
~~~
60、分析结果
~~~
alert(a);
var a = 1;
function fn() {
alert(2)
};
解析顺序：
1，找一些东西：var、function、参数（先把需要的东西找齐了才去逐行解读代码）
根据var找到a = 未定义（为什么不去读取呢？我们有理由相信一个偷懒机制，万一a = \[\]或{}那默认上来读取的数据量就比较庞大），所有的变量在正式运行代码之前都会提前赋值：未定义
根据function找到fn = function fn() {alert(2)}（所有函数，在正式运行代码之前都是整个函数块）
我们把这个步骤称为：JS的预解析
2，逐行解读代码
当逐行解读代码的时候，每次都要去仓库里看一眼，看看里面有没有现在遇到的东西：当读取到a的时候不会往下继续读取而是先回到仓库里面看看有没有a，我们仓库中现在有一个a = 未定义，所以alert(a)的结果就是undefined。
~~~
61、分析结果
~~~
console.log(a); // a is not defined
a = 1;
解析顺序：
1，整个代码片段一看没有var，没有函数，没有参数，所以以上代码预解析完成后仓库里面什么都没有
2，仓库里面什么都没有的情况下再逐行解读代码就会出现a is not defined
~~~
62、分析结果
~~~
// 示例： 逐行解读代码
alert(a); // function a() {alert(4)}
var a = 1;
alert(a); // 1
function a() {
alert(2);
};
alert(a); // 1
var a = 3;
alert(a); // 3
function a() {
alert(4);
};
alert(a); // 3
// 解析过程
1，预解析：var function 参数
仓库中的值：
a = undefined
a = function a() {alert(2)}
注意：在预解析的过程中，如果遇到重名的只会留下一个，一个是a = undefined另一个是a = function a(0 {alert(2)}，这个和上下文没有关系，主要是看有没有值，所以现在仓库中的值发生了变化。
仓库中的值：
a = function a() {alert(2)}
var a = 3；这行的时候又会把a提取出来a = undefined，没有值所以：
仓库中的值：
a = function a() {alert(2)}
function a() {alert(4)}；这行的时候会把a = function a(){alert(4)}提取出来，这个时候仓库中的值为：
a = function a() {alert(2)}
a = function a() {alert(4)}
这两个PK才会遵循上下文的顺序
仓库中的值：
a = function a() {alert(4)}
预解析完成！！！
仓库中的值为：
a = function a() {alert(4)}
2，逐行解读代码：
表达式：=+-\*/%++--!，表达式可以修改预解析的值
第一个alert结果：function a() {alert(4)}
表达式是可以修改仓库中的值所以
第二个alert结果：1
函数声明不能修改预解析的值所以
第三个alert结果：1
第四个alert结果：3
第五个alert结果：3
扩展：如果我在本实例最下面添加a();结果是什么？
// 示例： 逐行解读代码
alert(a); // function a() {alert(4)}
var a = 1;
alert(a); // 1
function a() {
alert(2);
};
alert(a); // 1
var a = 3;
alert(a); // 3
function a() {
alert(4);
};
alert(a); // 3
a()； //a is not defined
解答：
alert(typeof a) //number
因为a这时候等于3，相当于3()；JS 中有这样的语法吗？没有所以报错了
~~~
63、分析结果
~~~
var a = 1;
function fn() {
alert(a); // undefined
var a = 2;
}
fn();
alert(a); // 1
1，预解析：
a = undefined
fn = function fn() {alert(a);var a = 2;}
2，逐行解读代码：
第一行：var a = 1;由于是表达式可以改变值，所以a得值变为了：
a = 1;
第二行：function fn() {alert(a);var a = 2;}，由于这是函数声明不会改变值，所以不做任何修改，继续往下走
第三行：fn()；这个时候遇到了函数调用，那么就会往这个函数里面走，函数呢也是一个域，所以就会执行预解析、逐行解读代码：
1，fn()函数局部预解析：
由于遇到了var a = 2;所以预解析的结果为：a = undefined
2，fn()含数局部逐行解析代码：
第一行：alert(a)；由于预解析a = undefined此时和外面的a没有半毛钱关系，所以结果就是undefined
第二行：var a = 2;由于是表达式所以会改变函数作用于中a的值 所以a = 2
fn()函数调用已走完
第四行：alert(a)；这里会查找全局a = 1;所以结果就是1
~~~
64、分析结果
~~~
var a = 1;
function fn() {
alert(a);
a = 2;
}
fn();
alert(a);
// 解析过程
1，预解析：
a = undefined
fn = function fn () {alert(a); a = 2;}
2，逐行解读代码：
a = 1；
function fn () {alert(a); a = 2;}，函数声明不做修改
fn(); 函数调用，掉头执行function fn () {alert(a); a = 2;}，函数作用于执行：
1，预解析：
没有找到var function 参数
2，逐行解读代码：
alert(a)内部没又找到，查找外层a = 1（作用域链）;所以alert(a)结果就是：1
a = 2;
第二个：alert(a)； // 2
~~~
65、解析过程
~~~
var a = 1;
function fn(a) {
alert(a);
a = 2;
}
fn();
alert(a);
// 解析过程
1，预解析：
a = undefined
fn = function fn(a) {alert(a); a = 2}
2，逐行解读代码
a = 1;
fn()函数调用开始新的作用域：
1，预解析：
没有var，没有function，找到了参数a，参数本质上就是局部变量
a = undefined；
2，逐行解读代码：
第一个alert(a)： undefined
a = 2;（修改的是局部的a，并非全局的a）
第二个alert(a)： 1
~~~
66、解析过程
~~~
var a = 1;
function fn(a) {
alert(a);
a = 2;
}
fn(a);
alert(a);
// 解析过程
1，预解析：
a = undefined
fn = function fn (a) {aler(a); a= 2};
2，逐行解读代码
a = 1;
fn(a) 函数调用：
1，预解析（var、function、参数）：
a = undefined
2，逐行解读代码：
传递了实参：a = 1
alert(a) //1
a = 2;
alert(a)（全局的a） // 1
~~~
- 公告
- HTML
- 1、什么是盒模型
- 2、行内、块元素、空元素分别举例
- 3、src和href的区别
- 4、html5为什么只需要写<!
- 5、link和@import的区别
- 6、Doctype作用，标准模式与兼容模式有什么区别
- 7、至少用两种方法写两列布局，左列定宽200px，右侧自适应
- 8、写出HTML5新增的语义化标签
- 9、前端页面由那三层构成，分别是什么，作用是什么
- 10、请描述一下cookies，sessionStorage和localStorage的区别
- 11、Sass 、S LESS 是什么？大家为什么要使用他们
- 12、css 优先级算法如何计算？
- 13、javascript的 typeof 返回哪些数据类型
- 14、例举 3 种强制类型转换和 2 种隐式类型转换
- 15、数组方法 pop() push() unshift() shift()
- 16、window.onload 和 document ready 的区别
- 17、”==”和“===”的不同
- 18、iframe的作用
- 19、png、jpg、gif 这些图片格式解释一下，分别什么时候用。有没有了解过webp？
- 20、style标签写在body后与body前有什么区别
- 21、在网页中的应该使用奇数还是偶数的字体？为什么呢
- CSS
- 1、未知宽高垂直水平居中
- 2、都知道哪些CSS Hack
- 3、简述优雅降级和渐进增强
- 4、box-sizing常用的属性及分别有什么用
- 5、postion有几种取值？每种取值相对于谁来进行定位
- 6、CSS选择器有哪些？哪些属性可以继承？
- 7、移动端分辨率适配
- 8、PC常见兼容问题
- 9、display:none和visibility:hidden的区别
- 10、浏览器中的回流和重绘是什么，分别在什么情况下触发
- 11、分析代码结果
- 12、px、em、rem的区别
- 13、清除浮动的方式有哪些，比较好的是哪种
- 14、简述 readyonly 与 disabled 的区别
- 15、有下面这样一段 HTML 结构，使用 css 实现这样的效果
- 16、你做的页面在哪些流览器测试过？这些浏览器的内核分别是什么?
- 17、为什么要初始化样式
- 18、Doctype 的作用？严格模式与混杂模式的区别？
- 19、浏览器的内核分别是什么?经常遇到的浏览器的兼容性有哪些？原因，解决 方法是什么，常用 hack 的技巧 ？
- 20、哪些 css 属性可以继承
- 21、css 优先级算法如何计算？
- 22、CSS3 有哪些新特性？
- 23、html5 有哪些新特性、移除了那些元素？如何处理 HTML5 新标签的浏览器兼 容问题？如何区分 HTML 和 HTML5？
- 24、CSS3 新增伪类有那些？
- 25、rgba()和opacity的透明效果有什么区别
- 26、知道css有个content属性吗？有什么用？有什么应用？
- 27、页面导入样式时，使用link和@import有什么区别
- 28、介绍以下你对浏览器内核的理解
- 29、CSS3新增的特性
- 30、解释css sprites,如何使用？
- 31、用纯css创建一个三角形的原理是什么？
- 32、一个满屏品字布局如何设计
- 33、CSS属性overflow属性定义溢出元素内容区的内容会如何处理
- 34、请解释一下CSS3的flexbox（弹性盒布局模型）,以及适用场景
- 35、浏览器是怎样解析CSS选择器的
- 36、PC常见兼容问题汇总
- JS
- 1、getAttribute
- css
- 1、IE6双倍边距bug
- 2、IE6中图片链接的下方有间隙
- 3、IE6下空元素的高度BUG
- 4、不同浏览器的标签默认的margin和padding不一样
- 5、渐进识别的方式
- 37、绝对定位和相对定位区别
- 38、position跟display、overflow、float这些特性相互叠加后会怎么样？
- 39、上下margin重合的问题
- 40、设置元素浮动后，该元素的display值是多少
- 41、::before 和 :after中双冒号和单冒号有什么区别？解释一下这2个伪元素的作用
- 42、 li与li之间有看不见的空白间隔是什么原因引起的？有什么解决办法？
- 43、实现三栏布局
- 44、rem原理
- JavaScript1.0
- 1、简述同步和异步的区别
- javascript异步的几种实现方式
- 2、怎样添加、移除、复制、创建、查找节点
- 3、实现一个函数clone
- 4、数组去重
- 5、在JavaScript中什么是伪数组？如何将伪数组转化为标准数组
- 6、JavaScript中callee和caller的作用
- 7、简述cookie、sessionStorage、localStorage的区别
- 8、jQuery的事件委托on、live、delegate之间有什么区别
- 9、如何理解闭包，有何作用，使用场景
- 10、跨域请求资源的方式有哪些
- 11、谈谈垃圾回收机制
- 12、描述一次完整的http请求过程
- 13、http状态码有哪些
- 14、如何优化图像，图像格式的区别
- 15、浏览器是如何渲染页面的
- 16、写一个function，清除字符串前后的空格
- 17、正则
- 验证邮箱
- 按照规则编写正则
- 《正则》写出正确的正则表达式匹配固话号，区号 3-4 位，第一位为 0，中 横线，7-8 位数字，中横线，3-4 位分机号格式的固话号
- 最短 6 位数，最长 20 位，阿拉伯数和英文字母 （不区分大小写）组成
- 18、改变this的方式有哪些，实现一个bind
- 19、移动端点击事件延迟300ms，原因是什么，如何解决
- 20、运行题 ※
- 21、选择题 ※
- 22、封装一个函数，参数是定时器的时间，.then执行回调函数
- 23、请尽可能详尽的解释ajax的工作原理，以及跨域
- 24、alert(undefined == null)弹出什么
- 25、typeof和instanceof相同点与不同点
- 26、JavaScript中如何检测一个变量是String类型，写出具体实现函数
- 27、JavaScript实现二分法查找
- 28、"aaaasdserdsfssa"中出现次数最多的字符及个数
- 29、谈谈你所了解的Web攻击技术
- 30、描述DOM事件代理（委托）的原理
- 31、使用代码实现，原型继承
- 32、写出五个以上常用JavaScript modules（库或包）
- 33、思考中奖概率问题如何用代码实现，A中奖概率10%，B中奖概率20%，C中奖概率30%
- 34、JS的继承相关
- 35、如何解决回调地狱
- 36、移动端常见问题
- 37、IOS和安卓常见兼容问题
- 38、一个长度不超5位的正整数转换成对应的中文字符串，例如：20876 返回 “两万零八百七十六”（JS编写）
- 39、第一个人10岁，第二个比第一个大2岁，依次递推，请用递归编写一个方法，可以计算出第8个人多大？（JS编写）
- 40、JavaScript获取网页传输过来的参数name和sex的值（http://www.wyunfei.com?name=小四&sex=男）
- 41、Common、AMD、CMD的区别
- 42、正则，把一个字符串转为驼峰
- 43、call、apply、bind方法的作用分别是什么？有什么区别？
- 44、JavaScript数据类型
- 45、线程与进程的区别
- 46、哪些常见操作会造成内存泄漏
- 47、你知道哪些项目优化方法
- 48、json的了解
- 49、new操作符具体干了什么
- 50、null和undefined的区别
- 51、eval是做什么的
- 52、构造函数Fn原型对象、实例对象、三者之间的区别
- 53、浏览器的同源策略
- 54、JavaScript 是一门什么样的语言，它有哪些特点
- 55、编程算法题※
- 56、window.location.search() 返回的是什么
- 57、window.location.reload() 作用
- 58、例举 3 种强制类型转换和 2 种隐式类型转换
- 59、列举浏览器对象模型 BOM 里常用的至少 4 个对象，并列举 window 对象的常 用方法至少 5 个
- 60、简述创建函数的几种方式
- 61、iframe 的优缺点
- 62、请你谈谈 Cookie 的弊端
- 63、哪些操作会造成内存泄漏
- 64、事件委托是什么
- 65、解释 jsonp 的原理，以及为什么不是真正的 ajax
- 66、为什么不能定义 1px 左右的 div 容器
- 67、bind(), live(), delegate()的区别
- 68、你如何优化自己的代码
- 69、请尽可能详尽的解释 ajax 的工作原理
- 70、什么是三元表达式？“三元”表示什么意思？
- 71、JavaScript 的循环语句有哪些
- 72、列出 3 条以上 ff 和 IE 的脚本兼容问题
- 73、写一个函数可以计算 sum(5,0,-5);输出 0; sum(1,2,3,4);输出 10;
- 74、JQuery 一个对象可以同时绑定多个事件，这是如何实现的？
- 75、原生 JS 的 window.onload 与 Jquery 的$(document).ready(function(){}) 有什么不同？如何用原生 JS 实现 Jq 的 ready 方法？
- 76、请实现如下功能
- 77、eval 是做什么的？
- 78、javascript 代码中的"use strict";是什么意思 ? 使用它区别是什么？
- 79、如何判断一个对象是否属于某个类？
- 80、new 操作符具体干了什么呢
- 81、视差滚动效果
- 82、谈谈模块化开发
- 83、如何合并两个对象
- 84、页面初始化的时候，需要连续调用多个接口，该怎么办？
- 85、深拷贝浅拷贝
- 86、什么是防抖和节流？有什么区别？如何实现？
- 87、函数柯里化
- 88、作用域链
- 89、原型链的继承机制
- 90、$(window).load和$(window).ready的区别
- 91、微任务和宏任务
- 92、EventLoop
- 93、原型
- 94、JS单线程该多线程
- 95、this指向
- ECMAScript6
- 1、var、let、const区别
- 2、解构赋值
- 3、Promise 详解
- 浏览器
- 输入url敲回车发生了什么
- 浏览器渲染机制、渲染引擎及JS引擎
- 浏览器缓存机制
- 兼容问题 - PC
- ajax
- 1、Ajax 是什么? 如何创建一个 Ajax？
- 2、同步和异步的区别?
- 3、如何解决跨域问题?
- 4、页面编码和被请求的资源编码如果不一致如何处理？
- 5、简述 ajax 的过程
- 6、阐述一下异步加载
- 7、GET 和 POST 的区别，何时使用 POST？
- 8、ajax 是什么?ajax 的交互模型?同步和异步的区别?如何解决跨域问题?
- 9、Ajax 的最大的特点是什么
- 10、ajax 的缺点
- 11、ajax 请求的时候 get 和 post 方式的区别
- 12、解释 jsonp 的原理，以及为什么不是真正的 ajax
- 13、什么是 Ajax 和 JSON，它们的优缺点
- 14、http 常见的状态码有那些？分别代表是什么意思？
- 15、axios
- Vue
- 1、对MVC 、MVVM、MVP的理解
- 2、v-if、v-show区别
- 3、组件通信
- 4、组件生命周期
- 5、分别简述computed和watch的使用场景
- 6、项目构建中，如何提取公共资源
- 7、简述Vuex工作流程
- 8、Vue-router传参及区别
- 9、v-on可以监听多个方法吗
- 10、$nextTick的使用
- 11、vue组件中data为什么必须是一个函数
- 12、vue事件对象的使用
- 13、vue-router响应路由参数的变化
- 14、vue-router导航守卫（钩子函数）
- 15、vue-router传参
- 16、vue-router的两种模式
- 17、vue-router路由模式为history，导致的问题
- 18、keep-alive组件的作用
- 19、渐进式框架的理解
- 20、详述虚拟DOM中的diff算法
- 21、Vue中双向数据绑定是如何实现的
- 22、Vuex中如何异步修改状态
- 23、单页面应用和多页面应用区别及优缺点
- 24、vue中过滤器有什么作用
- 25、v-if和v-for的优先级
- 26、vue中key值得作用
- 27、vue提供了几种脚手架模板
- 28、assets和static的区别
- 29、常见的几种MVVM的实现方式
- 30、组件样式属性 scoped 问题及解决方法
- 31、列举常用的指令
- 32、vue常用的修饰符
- 33、vue事件中如何使用event对象？
- 34、数组更新检测
- 35、对象更新检测
- 36、自定义指令详解
- 37、自定义过滤器详解
- 38、$route和$router的区别
- 39、Vue两个核心点
- 40、Vue计算属性computed
- 41、computed和methods区别
- 42、watch监听详解
- 43、computed和watch区别
- 44、vue和jQuery的区别
- 45、组件第一次加载会触发那几个钩子（生命周期函数）
- 46、vue-loader是什么？用途有哪些？
- 47、Vuex中actions和mutations的区别
- 48、v-model是什么
- 49、ajax请求应该写在组件的created中还是vuex的actions中
- 50、vue.cli项目中src目录每个文件夹和文件的用法
- 51、active-class 是哪个组件的属性？嵌套路由怎么定义
- 52、vue-router 是什么?它有哪些组件
- 53、不用 vuex 会带来什么问题
- 54、hash模式和history模式的实现
- 55、引入组件的步骤
- 56、Vue-cli打包命令是什么？打包后悔导致路径问题，应该在哪里修改
- 57、开发中遇到的问题
- 58、三大框架的对比
- 59、简述Vue响应式原理
- 60、跨组件双向数据绑定
- 61、delete和Vue.delete删除数组的区别
- 62、SPA首屏加载慢如何解决
- 63、Vue-router跳转和location.href有什么区别
- 64、SPA改为MPA
- 65、Vue中的slot是什么
- 66、你们vue项目是打包了一个js文件，一个css文件，还是有多个文件
- 67、vue的双向绑定的原理，和angular的对比
- 68、Vue2中注册在router-link上事件无效解决方法
- 69、<router-link>在IE与火狐上点击失效（路由不跳转）问题
- 70、Vue中跨域
- 71、axios post请求问题
- 72、SPA 路由history模式上线后刷新404
- 73、Vue路由的实现原理
- 74、swiper获取数据、css都没有问题，但是图片不动
- 75、Vue-router懒加载
- 76、子组件能不能修改父组件传递过来的数据
- 人力资源
- 1、对前端工程师你是如何理解的
- 2、你怎样看待加班
- 3、离职原因
- 4、说说你的职业规划
- 5、你对我们公司了解多少
- 6、你为什么选择我们公司
- 7、你能为我们公司带来什么
- 8、认为自己的最大的优缺点是什么
- 9、谈谈你对跳槽的看法
- 10、怎么理解你应聘的岗位
- 11、你找工作首要考虑的因素是什么
- 12、上家公司的组织架构
- 13、谈谈你对薪资的要求
- 14、你经常逛的博客及公众号等
- 15、你的业余爱好
- 16、你有什么要问我的吗
- 17、如果你未被我们录用，你怎么打算
- 18、最能概括你自己的三个词是什么
- 19、说说你对行业、技术发展趋势的看法
- 20、就你申请的这个职位，你认为你还欠缺什么
- 21、你怎样对待自己的失敗
- 22、什么会让你有成就感
- 23、你和别人发生过争执吗？你是怎样解决的
- 24、家庭情况介绍
- 25、你在上家单位主要负责什么
- 26、你愿意接受背景调查吗
- 27、你朋友对你的评价
- 28、如果通过这次面试我们单位录用了你，但工作一段时间却发现你根本不适合这个职位，你怎么办
- 29、在完成某项工作时，你认为领导要求的方式不是最好的，自己还有更好的方法，你应该怎么做
- 30、如果你的工作出现失误，给本公司造成经济损失，你认为该怎么办
- 31、如果你做的一项工作受到上级领导的表扬，但你主管领导却说是他做的，你该怎样
- 32、工作中你难以和同事、上司相处，你该怎么办
- 33、假设你在某单位工作，成绩比较突出，得到领导的肯定。但同时你发现同事们越来越孤立你，你怎么看这个问题？你准备怎么办
- 34、为什么喜欢前端？
- 35、请你自我介绍
- 36、你新到一个部门,一天一个客户来找你解决问题,你努力想让他满意，可是始终达不到群众得满意,他投诉你们部门工作效率低,你这个时候怎么作
- 37、在工作中遇到的问题及解决方案
- 38、何时可以到岗
- 39、谈谈你对工作的期望与目标
- 40、你更喜欢和哪种性格的人共事
- 41、如果你是老板，最不喜欢哪种类型的员工
- 42、怎样和上级沟通
- 43、面试中，大脑出现短路怎么办
- 44、近期和长期的规划是什么
- 项目实战
- B2C商城API
- 后台
- 用户接口
- 管路员登录
- 用户列表
- 退出
- 订单接口
- 订单列表
- 订单详情
- 订单查询
- 分类接口
- 分类列表
- 分类添加
- 分类编辑
- 统计接口
- 产品接口
- 产品列表
- 产品搜索
- 产品上下架
- 添加商品
- 图片上传
- 富文本图片上传
- 富文本编辑器
- 商品详情
- 产品保存&更新
- 前台
- 产品
- 产品列表&排序
- 产品详情
- 用户
- 大众点评
- 商铺列表
- 商铺详情
- 添加收藏
- 收藏列表
- 删除收藏
- 检测是否收藏
- 登录
- Vue
- 开发前必读
- 主题
- 收藏
- 用户相关
- 评论
- 消息
- 其它功能
- 公司中的那些事儿
- 工作流程
- 上线流程
- 知识点解析
- 第一节：布局
- 第二节：盒模型&BFC
- 第三节：DOM事件
- 第四节：HTTP协议
- 第五节：原型链
- 第六节：继承
- 移动端
- 1、点透
- 2、1px问题
- 3、图片在安卓上，有些设备会模糊
- 4、防止手机中页面放大和缩小
- 5、上下拉动滚动条时卡顿、慢
- 6、iphone及ipad下输入框默认内阴影
- 7、webkit mask兼容处理
- 8、click的300ms延迟问题
- 9、移动端和PC端有什么区别？
- 10、固定定位布局 键盘挡住输入框内容
- 11、移动端是如何调试的
- hybird
- 历届面试真题
- 1807
- 面试题解
- webSocket
- 微信支付流程详解及源码 - 前端
- 微信分享流程详解及源码 - 前端
- 前后端协作及综合问题
- 1、跨域
- 2、前后端交互 - 传参
- 面向对象
- 1、普通方法
- 2、工厂方式
- 3、构造函数
- 4、原型
- 5、通过原型实现customPush方法
- 6、原型链
- 7、面试题
- 1、构造函数（废弃）
- 2、原型（废弃）
- 3、原型链 - 面试题链接
- 8、继承 - ES5
- 9、继承 - ES6
- 前端安全
- 1、XSS攻击
- 2、CSRF
- 3、HTTP和HTTPs
- 后台管理系统介绍及权限管理
- webpack
- 1、首屏加速 - CDN
- 2、首屏加速 - 懒加载
- 3、首屏加速 - 按需加载
- 4、搭建测试(test)&预发(pre)环境
- 项目中的鉴权是如何实现的？
- 前端优化
- 1、你的前端性能还能再抢救一下
- 2、解读雅虎35条军规（上）
- 3、解读雅虎35条军规（下）
- 4、你要不要看这些优化指标？
- 5、性能优化百宝箱（上）
- 6、性能优化百宝箱（下）
- 7、聊聊 DNS Prefetch
- 8、Webpack 性能优化两三事
- 9、图片加载优化（上）
- 10、图片加载优化（下）
- 安卓、IOS兼容性
- 真机调试
- 随堂笔记
- 1902B
- Vue2.0 - 课堂笔记&源码
- 实训
- 周考题
- 面试题
- 前端面试体系核心攻略
- 1. 前端面试的知识体系