JavaScript 深拷贝/数组去重/......

1.JavaScript深拷贝

 function clone(obj) {
        var copy;

        // 处理3个简单的类型, null 或者 undefined
        if (obj === null || typeof obj !== 'object') {
            return obj;
        }

        if (obj instanceof Date) {
            copy = new Date();
            copy.setTime(obj.getTime());
            return copy;
        }

        if (obj instanceof Array) {
            var copy = [];
            for (var i = 0, len = obj.length; i < len; i++) {
                copy[i] = clone(obj[i]);
            }
            return copy;
        }

        if (obj instanceof Object) {
            var copy = {};
            for (var attr in obj) {
                if (obj.hasOwnProperty(attr)) {
                    copy[attr] = clone(obj[attr]);
                }
            }
            return copy;
        }

        throw new Error("Unable to copy obj! Its type isn't supported.");
    }

---

2.数组去重

Array.prototype.unique1 = function()
{
    var n = []; //一个新的临时数组
    for(var i = 0; i < this.length; i++) //遍历当前数组
    {
        //如果当前数组的第i已经保存进了临时数组，那么跳过，
        //否则把当前项push到临时数组里面
        if (n.indexOf(this[i]) == -1) n.push(this[i]);
    }
    return n;
}

Array.prototype.unique2 = function()
{
    var n = {},r=[]; //n为hash表，r为临时数组
    for(var i = 0; i < this.length; i++) //遍历当前数组
    {
        if (!n[this[i]]) //如果hash表中没有当前项
        {
            n[this[i]] = true; //存入hash表
            r.push(this[i]); //把当前数组的当前项push到临时数组里面
        }
    }
    return r;
}

Array.prototype.unique3 = function()
{
    var n = [this[0]]; //结果数组
    for(var i = 1; i < this.length; i++) //从第二项开始遍历
    {
        //如果当前数组的第i项在当前数组中第一次出现的位置不是i，
        //那么表示第i项是重复的，忽略掉。否则存入结果数组
        if (this.indexOf(this[i]) == i) n.push(this[i]);
    }
    return n;
}

其中第1种和第3种方法都用到了数组的indexOf方法。

• 此方法的目的是寻找存入参数在数组中第一次出现的位置。很显 然，js引擎在实现这个方法的时候会遍历数组直到找到目标为止。所 以此函数会浪费掉很多时间。
  而第2中方法用的是hash表。把已经出现过的通过下标的形式存入一个object内。下标的引用要比用indexOf搜索数组快的多。

Array.prototype.unique4 = function()
{
    this.sort();
    var re=[this[0]];
    for(var i = 1; i < this.length; i++)
    {
        if( this[i] !== re[re.length-1])
        {
            re.push(this[i]);
        }
    }
    return re;
}

 * 这个方法的思路是先把数组排序，然后比较相邻的两个值。 
 * 排序的时候用的JS原生的sort方法，JS引擎内部应该是用的快速排序吧。
 * 最终测试的结果是此方法运行时间平均是第二种方法的三倍左右，不过比第一种和第三种方法快了不少。

---

3.Vue/React组件声明周期

beforecreate : 举个栗子：可以在这加个loading事件
created ：在这结束loading，还做一些初始化，实现函数自执行
mounted： 在这发起后端请求，拿回数据，配合路由钩子做一些事情

beforeDestory： 你确认删除XX吗？ destoryed ：当前组件已被删除，清空相关内容
当然，还有更多，继续探索中……

原文

4.CSS垂直居中

水平垂直居中一

 如果确定容器的宽高 宽500 高 300  
 利用 负margin
 设置层的外边距

 div {
    position: relative;     /* 相对定位或绝对定位均可 */
    width:500px;
    height:300px;
    top: 50%;
    left: 50%;
    margin: -150px 0 0 -250px;      /* 外边距为自身宽高的一半 */

  }

水平垂直居中二

 未知容器的宽高，利用 `transform` 属性

 div {
    position: absolute;     /* 相对定位或绝对定位均可 */
    width:500px;
    height:300px;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);
    background-color: pink;     /* 方便看效果 */

 }

水平垂直居中三
      利用 flex 布局
      实际使用时应考虑兼容性


 .container {
    display: flex;
    align-items: center;        /* 垂直居中 */
    justify-content: center;    /* 水平居中 */

 }
 .container div {
    width: 100px;
    height: 100px;
    background-color: pink;     /* 方便看效果 */
 }  

5.JavaScript 排序算法

冒泡排序

    //自己写
    var bubble = function(array) {
        for (var j = 0; j < array.length; j++) {
            for (var i = 0; i < array.length; i++) {
                if (array[i] > array[i + 1]) {
                    var temp = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = temp;
                }
            }
        }
        return array;
    }
    //网上示例
    var bubbleSort=function(arr){
        for(var i=0;iarr[j]){//如果前面的数据比后面的大就交换
                    var temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        return arr;
    }
//    console.log("The result is:"+bubbleSort(arr));

插入排序

var quickSort=function(arr){   
        //如果数组长度小于等于1无需判断直接返回即可  
        if(arr.length<=1){  
            return arr;  
        }  
        
        var midIndex=Math.floor(arr.length/2);//取基准点  
        var midIndexVal=arr.splice(midIndex,1);//取基准点的值,splice(index,1)函数可以返回数组中被删除的那个数arr[index+1]  
        var left=[];//存放比基准点小的数组  
        var right=[];//存放比基准点大的数组  
        //遍历数组，进行判断分配  
        for(var i=0;i

5. v-if和v-show

关于条件渲染

• 所谓条件渲染，就是根据不同的条件，使用不同的模板来生成 html。 在 Vue.js 中，使用 v-if 和 v-show 指令来控制条件渲染。

区别

   v-show 会在app初始化的时候编译并且渲染，并且在之后一直存在。
当切换v-show模块时，只是简单的更改css。
   v-if 当切换v-if模块时，Vue.js 有一个局部编译/卸载过程，因为 v-if 之中的模板也可能包括
数据绑定或子组件。v-if 是真实的条件渲染，因为它会确保条件块在切换当中合适地销毁与重建条件
块内的事件监听器和子组件。 v-if 是惰性的，如果为false，则什么也不错-不编译，不渲染。 
  当第一次条件为真时，才开始编译。

建议

v-show的切换消耗比较低，但是不会重新渲染子组件，所以最好用于静态的内容或者不需要重新构建结构的组件。
  而 v-if 比较适合不太频繁的切换状态的组件。所以项目设计的时候，不要对复杂的业务设计模块太频繁的视图切换。尽量将静态内容和动态内容分离到不同的模块中。

在切换 v-if 块时，Vue.js 有一个局部编译/卸载过程，因为 v-if 之中的模板也可能包括数据绑定或子组件。
  v-if 是真实的条件渲染，因为它会确保条件块在切换当中合适地销毁与重建条件块内的事件监听器和子组件。
v-if 也是惰性的：如果在初始渲染时条件为假，则什么也不做——在条件第一次变为真时才开始局部编译（编译会被缓存起来）。
相比之下，v-show 简单得多——元素始终被编译并保留，只是简单地基于 CSS 切换。
一般来说，v-if 有更高的切换消耗而 v-show 有更高的初始渲染消耗。因此，如果需要频繁切换 v-show 较好，如果在运行时条件不大可能改变 v-if 较好

---

闭包

闭包就是函数能够记住并访问它的词法作用域，即使当这个函数在它的词法作用域之外执行时。

---

一个页面从输入 URL 到页面加载显示完成，这个过程中都发生了什么？

1.浏览器会开启一个新的线程来处理这个请求，对 URL 分析判断如果是 http 协议就按照 Web 方式来处理;
2.通过 DNS 解析获取网址的IP地址，设置 UA 等信息发出第二个GET请求;
3.进行 HTTP 协议会话，客户端发送报头(请求报头);
4.进入到 web 服务器上的 Web Server，如 Apache、Tomcat、Node.JS 等服务器;
5.进入部署好的后端应用，如 PHP、Java、JavaScript、Python 等，找到对应的请求处理;
6.处理结束回馈报头，和资源，如果是浏览器访问过的资源，浏览器缓存上有对应的，会与服务器最后修改时间对比，一致则返回304;
7.如果 html 没缓存，则浏览器开始下载 html 文档(响应报头，状态码200)，同时使用缓存;
8.html 一边下载一边解析 html，根据标签建立文档树 DOM
9.其中根据标记下载所需css、js、图片文件，其中 css 是异步下载，同步执行(By default CSS is treated as a render blocking resource, html 也是)并会阻塞式的建立 CSSOM, 然后这俩一起会 render 成完整的 render 树（最后我们看到的样子），然后再因为假如把 css 放到底部,可能页面会出现白屏(阻塞 render)，或者布局混乱样式很丑直到CSS加载完成闪跳(rerender)的感觉。所以写到顶部确保用户至少能早一点看到界面。
10.js 在现代浏览器里面是异步下载，同步执行的，最好放到底部。因为对于在 js 后面的内容（html），html 的逐步呈现会被阻塞。
11.当 js 运行完成，页面加载完成。