经常使用前端知识积累

j1、s规范：

1.

不要在代码中留大段注释掉的代码

2.

适当地换行

适当的添加注释，但不要疯狂的添加注释

3.

将相似行为、命名的代码归类在一块儿

在不破坏语义性的状况下，'能省则省'

// bad
arr.map(a => {
  return add(a)
})
setTimeout(() => {
  doSomething()
}, 1000)
// good
arr.map(add)
setTimeout(doSomething, 1000)

　　

// bad
const a = (v) => {
  return v + 1
}
// good
const a = v => v + 1
// bad
const b = (v, i) => {
  return {
    v,
    i
  }
}
// good
const b = (v, i) => ({v, i})
// bad
const c = () => {
  return (dispatch) => {
    // doSomething
  }
}
// good
const c = () => dispatch => {
  // doSomething
}

　　4.

合理使用各类表达式

// bad
if (cb) {
  cb()
}
// good
cb && cb()
// bad
if (a) {
  return b
} else {
  return c
}
// good
return a ? b : c
// bad
if (a) {
  c = a
} else {
  c = 'default'
}
// good
c = a || 'default'

　　5.

链式调用写法

// bad
fetch(url).then(res => {
  return res.json()
}).then(() => {
  // doSomething
}).catch(e => {
})
// good
fetch(url)
  .then(res => {
    return res.json()
  })
  .then(() => {
    // doSomething
  })
  .catch(e => {
  })

　二.概念理解

闭包的理解

使用闭包主要是为了设计私有的方法和变量。 优势是能够避免全局变量的污染， 缺点是闭包会常驻内存，会增大内存使用量，使用不当很容易形成内存泄露

 

Cookie

第一：每一个特定的域名下最多生成20个cookie

1. IE6或更低版本最多20个cookie

2. IE7和以后的版本最后能够有50个cookie。

3. Firefox最多50个cookie

4. chrome和Safari没有作硬性限制

第二：cookie的最大大约为4096字节，为了兼容性，通常不能超过4095字节

优势:极高的扩展性和可用性

1. 经过良好的编程，控制保存在cookie中的session对象的大小。

2. 经过加密和安全传输技术（SSL），减小cookie被破解的可能性。

3. 只在cookie中存放不敏感数据，即便被盗也不会有重大损失。

4. 控制cookie的生命期，使之不会永远有效。偷盗者极可能拿到一个过时的cookie。

缺点:

1. Cookie数量和长度的限制。每一个domain最多只能有20条cookie，每一个cookie长度不能超过4KB，不然会被截掉。

2. 安全性问题。若是cookie被人拦截了，那人就能够取得全部的session信息。即便加密也与事无补，由于拦截者并不须要知道cookie的意义，他只要原样转发cookie就能够达到目的了。

3. 有些状态不可能保存在客户端。例如，为了防止重复提交表单，咱们须要在服务器端保存一个计数器。若是咱们把这个计数器保存在客户端，那么它起不到任何做用。

    

浏览器本地存储

sessionStorage

本地存储一个会话（session）中的数据，这些数据只有在同一个会话中的页面才能访问而且当会话结束后数据也随之销毁。 所以sessionStorage不是一种持久化的本地存储，仅仅是会话级别的存储

localStorage

用于持久化的本地存储，除非主动删除数据，不然数据是永远不会过时的

web storage和cookie的区别

Cookie的大小是受限的，而且每次你请求一个新的页面的时候Cookie都会被发送过去，这样无形中浪费了带宽，另外cookie还须要指定做用域，不能够跨域调用 cookie须要前端开发者本身封装setCookie，getCookie

 

link 和@import 的区别是

1. link属于HTML标签，而@import是CSS提供的;

2. 页面被加载的时，link会同时被加载，而@import引用的CSS会等到页面被加载完再加载;

3. import只在IE5以上才能识别，而link是HTML标签，无兼容问题;

4. link方式的样式的权重 高于@import的权重.

    

box-sizing属性

box-sizing属性主要用来控制元素的盒模型的解析模式。默认值是content-box

• content-box：让元素维持W3C的标准盒模型。元素的宽度/高度由border + padding + content的宽度/高度决定，设置width/height属性指的是content部分的宽/高

• border-box：让元素维持IE传统盒模型（IE6如下版本和IE6~7的怪异模式）。设置width/height属性指的是border + padding + content

   

BFC规范的理解

级格式化上下文，是CSS中的一个渲染机制，BFC就至关于一个盒子，内部的元素与外界的元素互不干扰。它不会影响外部的布局，外部的布局也不会影响到它.

建立BFC

• float的值不是none

• position 的值不是static或者relative

• display的值是inline-block,table-cell,flex,table-caption或者inline-flex

• overflow的值不是visible

BFC的特性

• 内部的BOX会在垂直方向上一个接一个的放置

• 于同一个BFC的俩个相邻的BOX的margin会发生重叠，与方向无关。

• 每一个元素的左外边距与包含块的左边界相接触（从左到右），即便浮动元素也是如此

• BFC的区域不会与float的元素区域重叠

• 计算BFC的高度时，浮动子元素也参与计算

• BFC就是页面上的一个隔离的独立容器，容器里面的子元素不会影响到外面的元素，反之亦然

BFC在布局中的应用

要阻止margin重叠，只要将俩个元素别放在一个BFC中便可

使得父元素包含子元素，常见的方式是为父元素设置overflow：hidden或者浮动父元素。根本缘由在于建立BFC的元素，子浮动元素也会参与其高度计算，即不会产生高度塌陷问题

与浮动元素相邻的已生成BFC的元素不能与浮动元素互相覆盖。利用该特性能够做为多栏布局的一种实现方式. 特色在于左右俩栏的宽度固定，中间栏能够根据浏览器宽度自适应

 

null和undefined的区别

undefined

undefined是一个表示"无"的原始值，转为数值时为NaN

• 变量被声明了，但没有赋值时，就等于undefined

• 调用函数时，应该提供的参数没有提供，该参数等于undefined

• 对象没有赋值的属性，该属性的值为undefined

• 函数没有返回值时，默认返回undefined

null

null是一个表示"无"的对象，转为数值时为0

• 做为函数的参数，表示该函数的参数不是对象

• 做为对象原型链的终点

   

documen.write和 innerHTML的区别

document.write只能重绘整个页面 innerHTML能够重绘页面的一部分

 

HTML5的离线存储

原理

HTML5的离线存储是基于一个新建的.appcache文件的缓存机制(不是存储技术)，经过这个文件上的解析清单离线存储资源，这些资源就会像cookie同样被存储了下来。以后当网络在处于离线状态下时，浏览器会经过被离线存储的数据进行页面展现

使用

• 在文档的 html 标签设置 manifest 属性，如 manifest="/offline.appcache"

• 在项目中新建 manifest 文件，manifest 文件的命名建议：xxx.appcache

• 在 web 服务器配置正确的 MIME-type，即 text/cache-manifest

   

css各类居中

水平居中

1. .parent{

2.    text-align: center;

3. }

4. .child{

5.    display: inline-block;

6. }

1. .child{

2.    display:table;

3.    margin: 0 auto;

4. }

1. .parent{

2.    position:relative;

3. }

4. .child{

5.    position:absolute;

6.    left:50%;

7.    transform: translateX(-50%);

8. }

垂直居中

• table-cell配合vertical-align

1. .parent{

2.    display: table-cell;

3.    vertical-align:middle;

4. }

absolute配合tranform

1. .parent{

2.    position:relative;

3. }

4. .child{

5.    position:absolute;

6.    top: 50%;

7.    transform: translateY(-50%);

8. }

水平+垂直居中

• inline-block配合text-align加上table-cell配合vertical-align

1. .parent{

2.    display: table-cell;

3.    vertical-align:middle;

4.    text-align:center;

5. }

6. .child{

7.    display: inline-block;

8. }

1. .parent{

2.    position: relative;

3. }

4. .child{

5.    position: absolute;

6.    left: 50%;

7.    top: 50%;

8.    transform: translate(-50%,-50%);

9. }

全能的flex

1. .parent{

2.    display: flex;

3.    justify-content: center;

4. }

1. .parent{

2.    display: flex;

3.    align-items: center;

4. }

1. .parent{

2.    display: flex;

3.    justify-content: center;

4.    align-items: center;

5. }

6.  

 

 

　

1.js的基本数据类型：数字，字符串，布尔，数组，对象，null,undefined

2.js对象设置属性的两种方式：

　　var person = {};

　　person.name = 'sss';//只能取对象自身的属性

　　person[age] ;//age能够是变量

 　  var nameA = 'name';

　　var nameB = 'name111';

　　console.log(person[nameA]);//sss

　　console.log(person[nameB]);//undefined

//删除属性

　　delete o.name;

　　delete o[age];

//检测属性 

// 1 in 运算符

var o ={};

o.name = 'xxx';

console.log( 'name' in o) ;//true

console.log( name in o) ;//false

//2 hasOwnProperty()

console.log(o.hasOwnProperty('name')) ; // true

 = 赋值== 判断值相等 === 对类型和值进行判断

//3.属性遍历 枚举

// for in 

var o = {x:1,y:2,z:3};

for(a in o){

console.log(a);// x  y  z

console.log(o[a]); //1 2 3  

}

var arr =[{x:1},{y:2},{z:3}];

for ( a in arr){

console.log(a);// 0 1 2 输出的是index

console.log(arr[a]);// {x:1}  {y:2}   {z:3}

}

//同步

for(var a =0;a<arr.length;a++){

console.log(arr[a]) ;

}

//异步 若是变量是从其余接口来，在循环中使用，建议用for 循环

$.each(arr,function(index,item)){

console.log(item);

}

 

//序列化

var o2 = {x:1,y:2,z:3};

console.log(JSON.stringify(o2));//{"x":1,"y":2,"z":3}

console.log(typeof(JSON.stringify(o2));//string

var str = JSON.stringify(o2);

console.log(JSON.parse(str));//{x: 1, y: 2, z: 3}

//深拷贝和浅拷贝 深拷贝就至关于双胞胎，各自互不影响。浅拷贝至关于人和影子，引用关系，互相影响

var o3 = {x:1,y:2,z:3};

var p =o3; 

4 this 关键字 表明函数的拥有者 

1.函数中引用 2.对象调用 3.构造函数调用 4.this指向

call(this,name,age)和apply(this,[]) 在一个对象中调用另外一个对象

var a = '111';

function test(){

　　return this.a;

};

var o = {};

o.a = 1;

o.b = test;

console.log(o.b.call()); //111

console.log(o.b.call(o)); //1 

console.log(o.b.apply()); //111

console.log(o.b.apply(o)); //1 

//继承

Function.apply(obj,args)方法能接收两个参数 obj：这个对象将代替Function类里this对象 args：这个是数组，它将做为参数传给Function（args-->arguments）

Function.call(obj,[param1[,param2[,…[,paramN]]]]) obj：这个对象将代替Function类里this对象 params：这个是一个参数列表

//构造函数 this指向这个实例化新对象

function Fun(name,age){

　　this.name = name;

　　this,age = age;

};

var fun = new Fun('lili',22);

var fun2 = new Fun('qq',23);

console.log(fun2.name);//qq

 

var number = 1;

var obj = { 

　　number : 2,

　　showNumber:function(){

　　　　this.number = 3;

　　　　(function(){

　　　　　　console.log(this.number); //1 闭包函数自调函数，函数自执行，this是指向window.this

　　　　})();

　　　　console.log(this.number);// 3 对象中this指向对象

　　}

};

obj.showNumber();