20180802总结

1. 数据的排序算法

　　参考https://www.cnblogs.com/real-me/p/7103375.html

2. 遍历对象的键：

　　Object.keys(obj).forEach(function(key,i,v){console.log(key)}

　　i => 索引；v => 对象本身

3. mysql和mongoose区别：

　　1. MySQL是传统的关系型数据库，MongoDB则是非关系型数据库，也叫文档型数据库

　　2.海量存储下，redis与mongodb的读写速度确实比Mysql有着很明显的优势

　　3.mysql支持事务，mongoodb不支持

　　其他参考：https://blog.csdn.net/yamaxifeng_132/article/details/53490827

4.什么是mysql事务：

　　MySQL 事务主要用于处理操作量大，复杂度高的数据。比如说，在人员管理系统中，你删除一个人员，你即需要删除人员的基本资料，也要删除和该人员相关的信息，如信箱，文章等等，这样，这些数据库操作语句就构成一个事务！

　　具体参考：http://www.runoob.com/mysql/mysql-transaction.html

5.node的数据类型：

　　Number（数字类型），String（字符串类型），Boolean（不布尔类型：真假类型），Null（空元素类型），Undefined（未定义类型），以及ES6新添加的Symbol（对象，象征）

6.什么是闭包：

　　闭包就是能够读取其他函数内部变量的函数。

function a(){
    var i=0;
    function b(){
        alert(++i);
    }
    return b;
}
var c=a();
c();

这段代码有两个特点：

1、函数b嵌套在函数a内部；

2、函数a返回函数b。

这样在执行完var c=a( )后，变量c实际上是指向了函数b，再执行c( )后就会弹出一个窗口显示i的值（第一次为1）。这段代码其实就创建了一个闭包，这是因为函数a外的变量c引用了函数a内的函数b。也就是说，当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。

7.闭包的作用：

　　简而言之，闭包的作用就是在a执行完并返回后，闭包使得Javascript的垃圾回收机制不会收回a所占用的资源，因为a的内部函数b的执行需要依赖a中的变量。

在上面的例子中，由于闭包的存在使得函数a返回后，a中的i始终存在，这样每次执行c()，i都是自加1后alert出i的值。

　　那么我们来想象另一种情况，如果a返回的不是函数b，情况就完全不同了。因为a执行完后，b没有被返回给a的外界，只是被a所引用，而此时a也只会被b引 用，因此函数a和b互相引用但又不被外界打扰（被外界引用），函数a和b就会被回收。

8.常用的npm命令：

　　参考：https://www.cnblogs.com/itlkNote/p/6830682.html

 

9.深拷贝和浅拷贝的区别

　　浅拷贝是将原始对象中的数据型字段拷贝到新对象中去，将引用型字段的“引用”复制到新对象中去，不把“引用的对象”复制进去，所以原始对象和新对象引用同一对象，新对象中的引用型字段发生变化会导致原始对象中的对应字段也发生变化。

　　深拷贝是在引用方面不同，深拷贝就是创建一个新的和原始字段的内容相同的字段，是两个一样大的数据段，所以两者的引用是不同的，之后的新对象中的引用型字段发生改变，不会引起原始对象中的字段发生改变。

10.如何实现深拷贝

　　深拷贝：

　　1)JSON.stringify与JSON.parse

function deepClone(obj){
    let _obj = JSON.stringify(obj),
        objClone = JSON.parse(_obj);
    return objClone
}    
let a=[0,1,[2,3],4],
    b=deepClone(a);

　　2)递归复制所有层级属性

function deepClone(obj){
    let objClone = Array.isArray(obj)?[]:{};
    if(obj && typeof obj==="object"){
        for(key in obj){
            if(obj.hasOwnProperty(key)){
                //判断ojb子元素是否为对象，如果是，递归复制
                if(obj[key]&&typeof obj[key] ==="object"){
                    objClone[key] = deepClone(obj[key]);
                }else{
                    //如果不是，简单复制
                    objClone[key] = obj[key];
                }
            }
        }
    }
    return objClone;
}    
let a=[1,2,3,4],
    b=deepClone(a);

　　3)JQ的extend方法:

　　$.extend( [deep ], target, object1 [, objectN ] )

　　deep表示是否深拷贝，为true为深拷贝，为false，则为浅拷贝

　　target Object类型 目标对象，其他对象的成员属性将被附加到该对象上

　　object1  objectN可选。 Object类型 第一个以及第N个被合并的对象。 

let a=[0,1,[2,3],4],
    b=$.extend(true,[],a);

 

　　4)lodash的cloneDeep

var objects = [{ 'a': 1 }, { 'b': 2 }];
 
var deep = _.cloneDeep(objects);
console.log(deep[0] === objects[0]);
// => false

　　具体参考：https://www.cnblogs.com/echolun/p/7889848.html

11.数据排序算法

　　参考：https://segmentfault.com/a/1190000009911526

//1.冒泡排序
var exchange = function (a, i, j)        // 交换A[i]和A[j]
{
  var temp = a[i];
  a[i] = a[j];
  a[j] = temp;
}

var sort = function (a) {
  var n = a.length;
  for (var j = 0; j < n - 1; j++)            // 每次最大元素就像气泡一样"浮"到数组的最后
  {
    for (var i = 0; i < n - 1 - j; i++)    // 依次比较相邻的两个元素,使较大的那个向后移
    {
      if (a[i] > a[i + 1])            // 如果条件改成A[i] >= A[i + 1],则变为不稳定的排序算法
      {
        exchange(a, i, i + 1);
      }
    }
  }

  return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4];    // 从小到大排序
// console.log(sort(a))


//------------2.选择排序------------
var exchange = function (a, i, j)        // 交换A[i]和A[j]
{
  var temp = a[i];
  a[i] = a[j];
  a[j] = temp;
}

var selectSort = function (a) {
  var n = a.length;
  var i, j, min;
  for (i = 0; i <= n - 2; i++)                // 已排序序列的末尾
  {
    min = i;
    for (j = i + 1; j <= n - 1; j++) {  // 未排序序列
      if (a[j] < a[min])// 依次找出未排序序列中的最小值,存放到已排序序列的末尾
      {
        min = j;
      }
    }
    if (min != i) {
      exchange(a, min, i);    // 该操作很有可能把稳定性打乱,所以选择排序是不稳定的排序算法
    }
  }
  return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4];    // 从小到大排序
console.log(selectSort(a))


//-----------3.插入排序------------

var insertSort = function (a) {
  var n = a.length;
  var i, j, get;
  for (i = 1; i < n; i++)             // 类似抓扑克牌排序
  {
    get = a[i];                     // 右手抓到一张扑克牌
    j = i - 1;                      // 拿在左手上的牌总是排序好的
    while (j >= 0 && a[j] > get)    // 将抓到的牌与手牌从右向左进行比较
    {
      a[j + 1] = a[j];            // 如果该手牌比抓到的牌大,就将其右移
      j--;
    }
    a[j + 1] = get;// 直到该手牌比抓到的牌小(或二者相等),将抓到的牌插入到该手牌右边(相等元素的相对次序未变,所以插入排序是稳定的)
  }
  return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4];    // 从小到大排序
console.log(insertSort(a))


//-----------4.shell排序------------

var shellSort = function (a) {
  var n = a.length;
  var i, j, get;
  var h = 0;
  while (h <= n)                          // 生成初始增量
  {
    h = 3 * h + 1;
  }
  while (h >= 1) {
    for (i = h; i < n; i++) {
      j = i - h;
      get = a[i];
      while ((j >= 0) && (a[j] > get)) {
        a[j + h] = a[j];
        j = j - h;
      }
      a[j + h] = get;
    }
    h = (h - 1) / 3;                    // 递减增量
  }
  return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4];    // 从小到大排序
console.log(shellSort(a))


//-----------5.快速排序----------------
var exchange = function (a, i, j)        // 交换A[i]和A[j]
{
  var temp = a[i];
  a[i] = a[j];
  a[j] = temp;
}

var partition = function (a, left, right)  // 划分函数
{
  var pivot = a[right];                    // 选择最后一个元素作为基准
  var tail = left - 1;                     // tail为小于基准的子数组最后一个元素的索引
  for (var i = left; i < right; i++)       // 遍历基准以外的其他元素
  {
    if (a[i] <= pivot)                   // 把小于等于基准的元素放到前一个子数组中
    {
      tail++;
      exchange(a, tail, i);
    }
  }
  exchange(a, tail + 1, right);            // 最后把基准放到前一个子数组的后边,剩下的子数组既是大于基准的子数组
  // 该操作很有可能把后面元素的稳定性打乱,所以快速排序是不稳定的排序算法
  return tail + 1;                         // 返回基准的索引
}

var quicksort = function (a, left, right) {
  var pivot_index;                        // 基准的索引
  if (left < right) {
    pivot_index = partition(a, left, right);
    quicksort(a, left, pivot_index - 1);
    quicksort(a, pivot_index + 1, right);
  }
  return a;
}
var a = [6, 5, 3, 1, 8, 7, 2, 4];    // 从小到大排序
console.log(quicksort(a, 0, a.length - 1))

12. node的异步实例

　　1)setimmediat

　　2)promise

13.node内存机制

14.node是多线程还是单线程