常用排序算法汇总

发表于 2019-03-13

1. 冒泡排序

思想

循环数组，比较当前元素和下一个元素，如果当前元素比下一个元素大，交换位置，这样最后一个元素就是最大数。

继续重复上面的操作，不循环已经排好的元素。

优化：当一次循环没有冒泡时，说明已经排序好了，可以停止循环。

复杂度

时间复杂度： O(n2)

空间复杂度:O(1)

稳定

代码

function bibbleSort(array){
    for(var j = 0; j<array.length; j++){
        let complete = true; //循环停止标识符
        for(var i = 0; i<array.length - 1 - j; i++){
            //比较相邻元素  (注意array.length要减一)
            if(array[i] > array[i+1]){
                [array[i], array[i+1]] = [array[i+1], array[i]];
                complete = false;
            }
        }
        if(complete){
            break;
        }
    }
    return array
}
bubbleSort([9,10,222,34,5,56,234,2,33,0,456,3,44,5,22,3,44,67,34])
//输出  [0, 2, 3, 3, 5, 5, 9, 10, 22, 33, 34, 34, 44, 44, 56, 67, 222, 234, 456]

2. 快速排序

思想

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据比另一部分的所有数据要小，再按这种方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，使整个数据变成有序序列。
可以看出，快速排序用到了分治的思想（对小问题进行递归）

步骤

选择一个基准元素target（一般选择第一个数）
将比target小的元素移动到数组左边，比target大的元素移动到数组右边
分别对target左侧和右侧的元素进行快速排序

复杂度

时间复杂度：平均O(nlogn)，最坏O(n2)，实际上大多数情况下小于O(nlogn)

空间复杂度: O(logn)（递归调用消耗）

不稳定

代码

写法1：简单、但消耗空间

function quickSort(array){
    if(array.length < 2){
        return array
    }
    //选一个target
    const target = array[0];
    const left = [];
    const right = [];
    for(let i = 1; i < array.length; i++){
        if(array[i] < target){
            left.push(array[i]);
        }
        else right.push(array[i]);
    }
    return quickSort(left).concat([target], quickSort(right));
}
quickSort([9,10,222,34,5,56,234,2,33,0,456,3,44,5,22,3,44,67,34])
//输出  [0, 2, 3, 3, 5, 5, 9, 10, 22, 33, 34, 34, 44, 44, 56, 67, 222, 234, 456]

写法2：节省空间，但稍微复杂

记录一个索引l从数组最左侧开始，记录一个索引r从数组右侧开始

在l<r的条件下，找到右侧小于target的值array[r]，并将其赋值到array[l]

在l<r的条件下，找到左侧大于target的值array[l]，并将其赋值到array[r]

这样让l=r时，左侧的值全部小于target，右侧的值全部小于target，将target放到该位置

这种方法需要先知道数组的长度

function quickSort(array, start, end){
    if(end - start < 1){
        return
    }
    const target = array[start];
    let l = start;
    let r = end;
    while(l < r){
        while(l < r && array[r] >= target){
          r--;
        }
        array[l] = array[r];
        while (l < r && array[l] < target) {
          l++;
        }
        array[r] = array[l];
    }
    array[l] = target;
    quickSort(array, start, l - 1);
    quickSort(array, l + 1, end);
    return array;
}
quickSort([9,10,222,34,5,56,234,2,33,0,456,3,44,5,22,3,44,67,34], 0, 18)
//输出  [0, 2, 3, 3, 5, 5, 9, 10, 22, 33, 34, 34, 44, 44, 56, 67, 222, 234, 456]

3. 插入排序

思想

将左侧序列看成一个有序序列，每次将一个数字插入该有序序列。

插入时，从有序序列最右侧开始比较，若比较的数较大，后移一位。

复杂度

时间复杂度： O(n2)

空间复杂度:O(1)

稳定

代码

function insertSort(array){
    for(let i = 0; i < array.length; i++){
        let target = i;
        for(let j = i-1; j >= 0; j--){
            if(array[j] > array[target]){
                [array[target], array[j]] = [array[j], array[target]];
                //一定要把target的索引交换, 否则会有大量浪费的比较
                target = j;
            }
            else break;
        }
    }
    return array
}
insertSort([9,10,222,34,5,56,234,2,33,0,456,3,44,5,22,3,44,67,34])
//输出  [0, 2, 3, 3, 5, 5, 9, 10, 22, 33, 34, 34, 44, 44, 56, 67, 222, 234, 456]

4. 选择排序

思想

每次循环选取一个最小的数字放到前面的有序序列中。

复杂度

时间复杂度： O(n2)

空间复杂度:O(1)

不稳定

代码

function selectionSort(array){
    for(let i = 0; i < array.length - 1; i++){
        let minIndex = i;
        for(let j = i + 1; j < array.length; j++){
            if(array[j] < array[minIndex]){
                //索引号一定要修改  否则无法真正调换两个元素
                minIndex = j;
            }
        }
        [array[minIndex], array[i]] = [array[i], array[minIndex]];
    }
    return array
}
selectionSort([9,10,222,34,5,56,234,2,33,0,456,3,44,5,22,3,44,67,34])
//输出  [0, 2, 3, 3, 5, 5, 9, 10, 22, 33, 34, 34, 44, 44, 56, 67, 222, 234, 456]

5. 堆排序 (较难)

思想

创建一个大顶堆，大顶堆的堆顶一定是最大的元素。

交换第一个元素和最后一个元素，让剩余的元素继续调整为大顶堆。

从后往前以此和第一个元素交换并重新构建，排序完成。

堆的概念

堆排序是一种树形选择排序，在排序过程中可以把元素看成是一颗完全二叉树。

每个节点都大（小）于它的两个子节点，当每个节点都大于等于它的两个子节点时，就称为大顶堆，也叫堆有序；当每个节点都小于等于它的两个子节点时，就称为小顶堆。

复杂度

时间复杂度： O(nlogn)

空间复杂度:O(1)

不稳定

代码

function heapSort(array){
    //创建大顶堆
    createMaxHeap(array);
    //交换第一个和最后一个元素, 然后重新调整
    for(let i = array.length-1; i > 0; i--){
        [array[i], array[0]] = [array[0], array[i]];
        adjust(array, 0, i);
    }
    return array;
}
//构建大顶端, 从第一个非子叶结点开始下沉操作
function createMaxHeap(array){
    const len = array.length;
    const start = parseInt(len / 2) - 1;
    for(let i = start; i >= 0; i--){
        adjust(array, i, len);
    }
}
//将第target个元素进行下沉，孩子节点有比他大的就下沉
function adjust(array, target, len) {
    for (let i = 2 * target + 1; i < len; i = 2 * i + 1) {
        // 找到孩子节点中最大的
        if (i + 1 < len && array[i + 1] > array[i]) {
            i = i + 1;
        }
        // 下沉
        if (array[i] > array[target]) {
            [array[i], array[target]] = [array[target], array[i]]
            target = i;
        } else {
            break;
        }
    }
}
heapSort([9,10,222,34,5,56,234,2,33,0,456,3,44,5,22,3,44,67,34])
//输出  [0, 2, 3, 3, 5, 5, 9, 10, 22, 33, 34, 34, 44, 44, 56, 67, 222, 234, 456]

6. 归并排序

思想

分治法的一个典型应用。

将已有序的子序列合并，得到完全有序的序列
即先使每个子序列有序，再使子序列段间有序
若将两个有序表合并成一个有序表，称为二路归并

分割:

将数组从中点进行分割，分为左、右两个数组
递归分割左、右数组，直到数组长度小于2

归并:

如果需要合并，那么左右两数组已经有序了。

创建一个临时存储数组temp，比较两数组第一个元素，将较小的元素加入临时数组

若左右数组有一个为空，那么此时另一个数组一定大于temp中的所有元素，直接将其所有元素加入temp

复杂度

时间复杂度： O(nlogn)

空间复杂度: O(n)

稳定

代码

写法1：简单、但消耗空间

function mergeSort(array){
    if(array.length < 2){
        return array
    }
    const mid = Math.floor(array.length / 2);
    const front = array.slice(0, mid);
    const end = array.slice(mid);
    return merge(mergeSort(front), mergeSort(end));
}
function merge(front, end){
    const temp = [];
    while(front.length && end.length){
        if(front[0]<end[0]){
            temp.push(front.shift());
        }
        else temp.push(end.shift());
    }
    while(front.length){
        temp.push(front.shift());
    }
    while(end.length){
        temp.push(end.shift());
    }
    return temp
}
mergeSort([9,10,222,34,5,56,234,2,33,0,456,3,44,5,22,3,44,67,34])
//输出  [0, 2, 3, 3, 5, 5, 9, 10, 22, 33, 34, 34, 44, 44, 56, 67, 222, 234, 456]

写法2：记录数组的索引，使用left、right两个索引来限定当前分割的数组。

function mergeSort(array, left, right, temp) {
    if (left < right) {
    const mid = Math.floor((left + right) / 2);
    mergeSort(array, left, mid, temp)
    mergeSort(array, mid + 1, right, temp)
    merge(array, left, right, temp);
    }
    return array;
}
function merge(array, left, right, temp) {
    const mid = Math.floor((left + right) / 2);
    let leftIndex = left;
    let rightIndex = mid + 1;
    let tempIndex = 0;
    while (leftIndex <= mid && rightIndex <= right) {
    if (array[leftIndex] < array[rightIndex]) {
        temp[tempIndex++] = array[leftIndex++]
    } else {
        temp[tempIndex++] = array[rightIndex++]
    }
    }
    while (leftIndex <= mid) {
    temp[tempIndex++] = array[leftIndex++]
    }
    while (rightIndex <= right) {
    temp[tempIndex++] = array[rightIndex++]
    }
    tempIndex = 0;
    for (let i = left; i <= right; i++) {
    array[i] = temp[tempIndex++];
    }
}
mergeSort([9,10,222,34,5,56,234,2,33,0,456,3,44,5,22,3,44,67,34], 0, 18, [])
//输出  [0, 2, 3, 3, 5, 5, 9, 10, 22, 33, 34, 34, 44, 44, 56, 67, 222, 234, 456]

Python负数的取余计算

发表于 2019-01-16

最近在leetcode上用python做题，由于python不是我工作的主要语言，所以对于一些基础特性搞的并不是很清楚，所以在写的过程中会遇到一些奇怪的问题。

在做数字翻转的题目时，因为要用到python的取余计算，但是测试用例中有很多负数，负数的用例我都没有通过。调试时候发现-123%10在python里得到的结果是7。在学习python的四则运算时并没有考虑这么深入，于是记录一下python中负数的取余计算机制。

在Python中，取余的计算公式与别的语言并没有什么区别：r=a-n*[a//n]

这里r是余数，a是被除数，n是除数。

不过在“a//n”这一步，当a是负数的时候，会向下取整，也就是说向负无穷方向取整。这也就得到：

-123%10 = -123 - 10 * (-123 // 10) = -123 - 10 * (-13) = 7

这里还不得不提的是

print(123%-10)

这个情况，结果为：

-7

vue-cli2和vue-cli3的区别

发表于 2018-10-20

vue-cli升级到3了，整体看了下感觉是封装的更简洁了，而且支持typescript、pwd等新特性。
不过从vue-cli2时代过来的我，还是习惯用2，可以看到整体的配置选项，根据业务需要自己来添加。
现在来大概概括一下2代和3代的区别。

vue-cli脚手架的使用

使用vue-cli可以快速搭建vue的开发环境，和webpack的配置
安装vue脚手架： npm install -g@vue/cli
上面安装的是vue cli3的版本，如果需要想按照vue cli2的方式初始化项目是不可以的，我们必须要拉取2.x的模板，需要安装全局的桥接工具(官方查看)
Vue CLI2 初始化项目 vue init webpack my-project
Vue CLI3 初始化项目 vue create my-project

CLI2的使用

初始化项目：web init webpack mytest（根据这个创建项目文件名），初始化出现配置选项：
 //项目名称
 Project name ...
 //作者的信息，会默认从git中读取信息
 Project description ...
 Author ...
 //vue创建的选项 1.runtime-compiler   2.runtime-only
 vue build ...(一般选runtime-only)
 //是否安装vue-router
 Install vue-router？ ..
 //是否使用ESLint检测代码规范
 use ESLint to link your code
 //是否写单元测试 （一般不使用）
 Set up unit tests
 //是否使用Nightwatch来进行e2e测试 （2代表to  e to e 点对点）
 Setup e2e test with Nightwatch？
 //使用npm或者yarn包管理工具
 use npm
 use yarn

Runtime-Compiler和Runtime-only的区别?

runtime-compiler（v1）(运行过程)): template -> ast -> render -> vdom -> UI
runtime-only(v2 1.性能更高， 2.代码量更少)：render -> vdom -> UI
那.vue文件中的template是由谁处理的呢？是由vue-template-compiler这个开发时工具依赖来处理的，他将.vue文件解析成了render函数，解析之后，是没有tamplate这个东西的

总结

如果在开发中，依然使用template，就需要选择Runtime-Compiler
如果在开发中，使用的是.vue文件夹开发，那么可以选择Runtime-Only

render函数的使用

new Vue({
  el:'#app',
  render:(createElement) =>{
    //使用方式一：
    return createElement('标签','相关数据对象(可以不传)',['内容数组'])
    //1.1render函数的基本使用
    return createElement('div',{class:'box'},['xiaohuang'])
    //1.2嵌套render函数
    return createElement('div',{class:'box'},['小黄',createElement('h2',['标题啊'])])
  }
})

`Runtime-Compiler`和`Runtime-only`在main.js中的不同使用：
  1.`Runtime-Compiler`中
  const cpn =Vue.component('cpn',{
    template:'<div>我是cpn组件 </div>'，
    data(){
      return{
      }
    }
  })
  2.`Runtime-only`中
  new Vue({
    el:'#app'
    render:(createElement)=>{
      //使用方法二：传入一个组件对象
      return createElement(cpn)
    }
  })

cLI3的使用

1.初始化项目：vue create my-project
2.

//选择一个配置方式
 please pick a perset  (一般选最后一个Manually select features（手动选择特性） )
 //选择对于你的工程所需要的特性 （用空格选择）
 check the features needed for your project
 //对应的配置文件单独生成还是放在package.json里
 where do you prefer placing config for babel
 //要不要把刚才自己选择的配置保存下来
 save this as a preset for future projects?

3.pubilc文件相当于CLI2中的static目录
4.配置都去哪里了，可以启动配置服务器 vue ui 查看（全局命令）

手写代码实现call和apply功能

发表于 2018-08-29

call和apply的功能类似, 区别仅仅是传入的参数形式不同。
它们的作用都是使用指定的this值来调用某个函数，用来改变上下文环境。

举例说明：

var foo = {
    value: 1
};
function bar() {
    console.log(this.value);
}
bar.call(foo); //输出1

call把this的指向改成指向foo, 但bar函数依旧执行了。

Step1

调用call的时候, 想当于把foo对象进行了一次改造:

var foo = {
    value: 1,
    bar: function() {
        console.log(this.value)
    }
};
foo.bar(); // 1

等于把bar函数设为了foo对象的一个属性——>执行bar函数——>删除这个属性

按照这个思路,可以写出一个call2模拟函数:

Function.prototype.call2 = function(context){
    //用this获取调用call的函数
    context.fn = this;
    context.fn();
    delete context.fn;
}
//test
var foo = {
    age: 12
}
function bar(){
    console.log(this.age);
}
bar.call2(foo);  //输出12

但是这个模拟没有实现传参功能,所以需要进行改造。

Step2

关于传参, 举个栗子:

var foo = {
    value: 1
};
function bar(name, age) {
    console.log(name)
    console.log(age)
    console.log(this.value);
}
bar.call(foo, 'Snapline', 28);
//输出
//Snapline
//28
//1

call的传参是不定的, 用arguments来获取所有的参数。

改造如下:

Function.prototype.call2 = function(context){
    //用this获取调用call的函数
    context.fn = this;
    //获取参数
    const args = [...arguments].slice(1);
    context.fn(...args);
    delete context.fn;
}
//test
var foo = {
    value: 1
};
function bar(name, age) {
    console.log(name)
    console.log(age)
    console.log(this.value);
}
bar.call2(foo, 'Snapline', 28);
//输出
//Snapline
//28
//1

Step3

基本已经完成了模拟, 有几个小问题需要注意:

1.this参数可以传null, 此时this指向window

var value = 1;
function bar() {
    console.log(this.value);
}
bar.call(null); // 相当于window.value  输出1

2.函数可以有返回值

所以有如下call函数完全体:

Function.prototype.call2 = function(context){
    //传入的必须是函数
    if(typeof this !== 'function'){
        throw new TypeError('Error');
    }
    //传入null的话,this指向window
    context = context || window;
    //用this获取调用call的函数
    context.fn = this;
    //获取参数
    const args = [...arguments].slice(1);
    //创建result用来做返回值
    const result = context.fn(...args);
    //恢复默认的fn
    delete context.fn;
    //返回值
    return result;
}
//test
var value = 2;
var obj = {
    value: 1
}
function bar(name, age) {
    console.log(this.value);
    return {
        value: this.value,
        name: name,
        age: age
    }
}
bar.call2(null); // 2
console.log(bar.call2(obj, 'Snapline', 28));
//输出
//1
//Object {
//     value: 1,
//     name: 'Snapline',
//     age: 28
// }

实现apply

实现了call以后实现apply就非常简单了, 只是参数形式不同。

//实现apply
Function.prototype.apply2 = function(context){
    //传入的必须是函数
    if(typeof this !== 'function'){
        throw new TypeError('Error');
    }
    context = context || window;
    context.fn = this;
    let result;
    if(Array.isArray(arguments[1])) {
        // 通过...运算符将数组转换为用逗号分隔的参数序列
        result = context.fn(...arguments[1])
    } else {
        result = context.fn()
    }
    delete context.fn;
    return result;
}
//test
function test(arg1, arg2) {
  console.log(arg1, arg2)
  console.log(this.a, this.b)
}
test.apply2({
  a: 'a',
  b: 'b'
}, [1, 2])
//(1,2)
//(a,b)

MD5加密的防范方法和crypto模块应用

发表于 2018-06-23

MD5简介

MD5（Message-Digest Algorithm）是计算机安全领域广泛使用的散列函数（又称哈希算法、摘要算法），主要用来确保消息的完整和一致性。常见的应用场景有密码保护、下载文件校验等。

MD5特点

1.运算速度快：对jquery.js求md5值，57254个字符，耗时1.907ms。
2.输出长度固定：输入长度不固定，输出长度固定（128位）。
3.运算不可逆：已知运算结果的情况下，无法通过通过逆运算得到原始字符串。
4.高度离散：输入的微小变化，可导致运算结果差异巨大。
5.弱碰撞性：不同输入的散列值可能相同。

MD5应用场景

1.文件完整性校验：比如从网上下载一个软件，一般网站都会将软件的md5值附在网页上，用户下载完软件后，可对下载到本地的软件进行md5运算，然后跟网站上的md5值进行对比，确保下载的软件是完整的（或正确的）。
2.密码保护：将md5后的密码保存到数据库，而不是保存明文密码，避免拖库等事件发生后，明文密码外泄。
3.防篡改：比如数字证书的防篡改，就用到了摘要算法。（当然还要结合数字签名等手段）。

常用案例：密码保护

密码首先肯定不可能明文保存在数据库里，一旦泄露后果不堪设想。最基础的做法是对密码进行一层MD5加密，最常见的老年人密码“123456”，经过md5加密后，变为：e10adc3949ba59abbe56e057f20f883e。
这么做一来避免明文暴露，二来黑客破解起来需要时间。
但仅仅是一层md5加密是远远不够的，因为md5的加密是确定性的，所以可以建立一个md5密码破解池，通过枚举，把各种排列组合的加密结果保存起来，然后通过md5密码进行查询，反解。尤其是很多用户的密码很简单，大概率会被暴力破解。

防范方法：密码加盐

“加盐”的意思就是在密码特定位置插入特定字符串后，再对修改后的字符串进行md5运算。
这样首先暴力破解的难度会加大，因为利用了“输入的微小变化，可导致运算结果差异巨大”这一特点，哪怕加入3个数字的盐“值”，md5的加密结果则会完全不同。

crypto模块应用

在nodejs中，crypto模块封装了一系列密码学相关的功能，包括摘要运算。基础例子如下，非常简单：

var crypto = require('crypto');
var md5 = crypto.createHash('md5');
var result = md5.update('a').digest('hex');
console.log(result);
// 输出：0cc175b9c0f1b6a831c399e269772661

给密码加盐:

var crypto = require('crypto');
function cryptPwd(password, salt) {
    // 密码“加盐”
    var saltPassword = password + ':' + salt;
    console.log('原始密码：%s', password);
    console.log('加盐后的密码：%s', saltPassword);
    // 加盐密码的md5值
    var md5 = crypto.createHash('md5');
    var result = md5.update(saltPassword).digest('hex');
    console.log('加盐密码的md5值：%s', result);
}
cryptPwd('123456', 'abc');
// 输出：
// 原始密码：123456
// 加盐后的密码：123456:abc
// 加盐密码的md5值：51011af1892f59e74baf61f3d4389092
cryptPwd('123456', 'bcd');
// 输出：
// 原始密码：123456
// 加盐后的密码：123456:bcd
// 加盐密码的md5值：55a95bcb6bfbaef6906dbbd264ab4531

还不够,需要随机盐值

单纯的加盐，依然会有各种问题：

1.盐值过短，暴力破解会很容易。
2.固定盐值，或者盐值已经外泄，那么只要把常用密码+固定盐值的hash值表算出来就可以了，本质上又回到了最初的暴力破解路线。

那么我们要做的就是给每个用户一个“随机盐值”。
示例代码如下。可以看到，密码同样是123456，由于采用了随机盐值，前后运算得出的结果是不同的。这样带来的好处是，多个用户，同样的密码，攻击者需要进行多次运算才能够完全破解。同样是纯数字3位短盐值，随机盐值破解所需的运算量，是固定盐值的1000倍。

var crypto = require('crypto');
function getRandomSalt(){
    return Math.random().toString().slice(2, 5);
}
function cryptPwd(password, salt) {
    // 密码“加盐”
    var saltPassword = password + ':' + salt;
    console.log('原始密码：%s', password);
    console.log('加盐后的密码：%s', saltPassword);
    // 加盐密码的md5值
    var md5 = crypto.createHash('md5');
    var result = md5.update(saltPassword).digest('hex');
    console.log('加盐密码的md5值：%s', result);
}
var password = '123456';
cryptPwd('123456', getRandomSalt());
// 输出：
// 原始密码：123456
// 加盐后的密码：123456:498
// 加盐密码的md5值：af3b7d32cc2a254a6bf1ebdcfd700115
cryptPwd('123456', getRandomSalt());
// 输出：
// 原始密码：123456
// 加盐后的密码：123456:287
// 加盐密码的md5值：65d7dd044c2db64c5e658d947578d759

随机盐值需要注意的问题是：后端也需要用户密码来校验登录，所以需要针对每一个用户设定一个随机盐值并且存储起来，每一次都要使用密码和随机盐值通过约定算法加密做校验。
这样做的话，即使盐值外泄，由于每一个用户的盐值都不同，即便暴力破解，也要破解很久，结果也就是破解了一个用户的密码，时间成本会很大。

最后

当然也可以使用只有开发者知道的加密次数，比如对md5值再次进行md5加密，然后再加密，这样也会很大的提高破解代价。
md5也存在碰撞问题，就是两个不同的字符串会得到相同的结果，这是一个需要注意的点。

便捷地同时使用github和gitlab的方法

发表于 2018-04-16

昨天完成了迁移，迁移时也换了新的gitlab账户，并绑定了新的ssh。更新博文后发现hexo d命令总是错误，原因是github的permission处于denied的状态，猜测一定是ssh的问题。

由于按照网上给出的ssh生成命令进行，一路回车，等于对id_rsa文件的命名采取了默认状态，导致github在获取rsa的时候引起了错乱。

那么优雅的使用github和gitlab的方法就是命名两个不同的rsa文件分别进行绑定，然后用config文件来做配置区分。

步骤一：生成密钥

首先要在~/ssh/目录下操作，直接把文件生成在本文件夹下。

gitlab密钥

ssh-keygen -t rsa -C "gitlab 用户邮箱地址" ←┘
Generating public/private rsa key pair.
Enter file in which to save the key (/Users/user/.ssh/id_rsa): ←┘
Enter passphrase (empty for no passphrase): ←┘
Enter same passphrase again: ←┘

这时候生成的是一对名为id_rsa和id_rsa.pub的公私密钥文件。

github密钥

ssh-keygen -t rsa -C "github 用户邮箱地址" ←┘
Generating public/private rsa key pair.
Enter file in which to save the key (/Users/user/.ssh/id_rsa): id_rsa_github ←┘
Enter passphrase (empty for no passphrase): ←┘
Enter same passphrase again: ←┘

这时候生成的是一对名为id_rsa_github和id_rsa_github.pub的公私密钥文件。

~/.ssh/ 目录下生成以下文件:

- id_rsa
- id_rsa.pub 
- id_rsa_github
- id_rsa_github.pub

分别将 id_rsa.pub 和 id_rsa_github.pub 内容复制到 gitlab 或 github 的 ssh key 中。

新建config文件

Host github.com
    HostName github.com
    IdentityFile ~/.ssh/id_rsa_github
Host gitlab.com
    HostName gitlab.shoukala.com
    IdentityFile ~/.ssh/id_rsa

注意这里Host后面一定要写上 .com，不然hexo d的命令还是会失败。

测试连接

使用ssh -T git@gitlab.com测试gitlab的连接，使用ssh -T git@github.com测试github的链接。

会在 ~/.ssh/ 目录下自动生成 known_hosts 文件。

此时，我们就能分别维护gitlab和github的项目了。

1. 冒泡排序

思想

复杂度

代码

2. 快速排序

思想

步骤

复杂度

代码

3. 插入排序

思想

复杂度

代码

4. 选择排序

思想

复杂度

代码

5. 堆排序 (较难)

思想

堆的概念

复杂度

代码

6. 归并排序

思想

复杂度

代码

vue-cli脚手架的使用

CLI2的使用

cLI3的使用

Step1

Step2

Step3

实现apply

MD5简介

MD5特点

MD5应用场景

常用案例：密码保护

防范方法：密码加盐

crypto模块应用

还不够,需要随机盐值

最后

步骤一： 生成密钥

gitlab密钥

github密钥

~/.ssh/ 目录下生成以下文件:

新建config文件

测试连接

步骤一：生成密钥