三菱数控M80系统信誉到期解锁解密

三菱数控M80系统信誉到期解锁解密另外小姐姐最近在看机会 base 北京，邮箱已经附在 GitHub 上了。欢迎有坑位的同学进行推荐。
一、算法
1.全排列
微信公众号：世界上有意思的事

function permutate(str) {
var array = str.split(’’);
function loop(array, pre = []) {
if (array.length == 1) {
return [pre.concat(array).join(’’)];
}
let res = [];
for (let index = 0; index < array.length; index++) {
var first = array.pop();
res = res.concat(loop(array, […pre, first]));
array.unshift(first);
}
return res;
}
return Array.from(new Set(loop(array)))
}

复制代码2.二分搜索
微信公众号：世界上有意思的事

function BinarySearch1 (arr, target) {
return search(arr, target, 0, arr.length - 1)
function search (arr, target, from, to) {
if (from > to) {
return -1
}
const mid = Math.floor((from + to)/2)
if (arr[mid] > target) {
return search(arr, target, from, mid - 1)
} else if (arr[mid] < target) {
return search(arr, target, mid + 1, to)
} else {
return mid
}
}
}

function BinarySearch2 (arr, target) {
let from = 0
let to = arr.length - 1
let mid = Math.floor((from + to)/2)
while (from <= to) {
mid = Math.floor((from + to)/2)
if (arr[mid] > target) {
to = mid - 1
} else if (arr[mid] < target) {
from = mid + 1
} else {
return mid
}
}

return -1

}
复制代码3.排序
(1).冒泡排序
微信公众号：世界上有意思的事

/*
第1次循环确定最大的
第n次循环确定第n大的
*/
function BubbleSort (arr) {
const length = arr.length

for (let i = 0; i < length; i++) {
    for (let j = 1; j < length-i; j++) {
        if (arr[j] < arr[j - 1]) {
            const temp = arr[j]
            arr[j] = arr[j - 1]
            arr[j - 1] = temp
        }
    }
}

return arr

}
复制代码(2).快速排序
微信公众号：世界上有意思的事

/*
在左边找大数，在右边找小数
交换
*/
function QuickSort(arr, low, high) {
let left = low
let right = high
let basic = arr[low]
while (left < right) {
while (left < right && arr[right] > basic) {
right–
}
while (left < right && arr[left] <= basic) {
left++
}

    if (left < right) {
        const temp = arr[left]
        arr[left] = arr[right]
        arr[right] = temp
    } else {
        const temp = arr[low]
        arr[low] = arr[left]
        arr[left] = temp

        QuickSort(arr, low, left - 1)
        QuickSort(arr, right + 1, high)
    }
}

return arr

}
复制代码(3).选择排序
微信公众号：世界上有意思的事

/*
寻找第i小的数的位置，放到i位置上
*/
function SelectionSort (arr) {
const length = arr.length
for (let i = 0; i < length; i++ ) {
let minIndex= i
for (let j = i + 1; j < length; j++) {
minIndex = arr[minIndex] <= arr[j] ? minIndex : j
}
if (minIndex !== i) {
const temp = arr[i]
arr[i] = arr[minIndex]
arr[minIndex] = temp

    }
}
return arr

}
复制代码(4).插入排序
微信公众号：世界上有意思的事

function InsertionSort (arr) {
const length = arr.length
for (let i = 1; i < length; i++) {
const temp = arr[i]
let j
for (j = i - 1; j >= 0 && temp < arr[j]; j–) {
arr[j+1] = arr[j]
}
arr[j+1] = temp
}
return arr
}
复制代码(5).希尔排序
插入排序的改进版。对间隔 gap 为一组的数进行插入排序
微信公众号：世界上有意思的事

function ShellSort (arr) {
const length = arr.length
let gap = Math.floor(length)
while (gap) {
for (let i = gap; i < length; i++) {
const temp = arr[i]
let j
for (j = i - gap; j >= 0 && temp < arr[j]; j = j - gap) {
arr[j + gap] = arr[j]
}
arr[j + gap] = temp
}
gap = Math.floor(gap / 2)
}
return arr
}
复制代码(6).归并排序
微信公众号：世界上有意思的事

function MergeSort (arr, low, high) {
const length = arr.length
if (low === high) {
return arr[low]
}
const mid = Math.floor((low + high)/2)
MergeSort(arr, low, mid)
MergeSort(arr, mid + 1, high)
merge(arr, low, high)
return arr

}

function merge (arr, low, high) {
const mid = Math.floor((low + high)/2)
let left = low
let right = mid + 1
const result = []
while (left <= mid && right <= high) {
if (arr[left] <= arr[right]) {
result.push(arr[left++])
} else {
result.push(arr[right++])
}
}
while (left <= mid) {
result.push(arr[left++])
}
while (right <= high) {
result.push(arr[right++])
}

arr.splice(low, high-low+1, ...result)

}

const test = [2, 34, 452,3,5, 785, 32, 345, 567, 322,5]

console.log(MergeSort(test, 0, test.length - 1))
复制代码(7).堆排序
微信公众号：世界上有意思的事

function HeapSort (arr) {
const length = arr.length

// 调整初始堆，调整完其实也确定了最大值
// 但此时最大值是在 arr[0] 中
for (let i = Math.floor(length/2) - 1; i >= 0; i--) {
    adjustHeap(arr, i, length)
}

// 把 arr[0](最大值)换到后面
for (let i = length - 1; i >=0; i--) {
    const temp = arr[0]
    arr[0] = arr[i]
    arr[i] = temp
    adjustHeap(arr, 0, i)
}

return arr

}

// size 是还需要调整的堆的大小
// 随着一个个最大值的确定，size 会越来越小
function adjustHeap (arr, position, size) {
const left = position * 2 + 1
const right = left + 1
let maxIndex = position
if (left < size && arr[left] > arr[maxIndex]) {
maxIndex = left
}
if (right < size && arr[right] > arr[maxIndex]) {
maxIndex = right
}
if (maxIndex !== position) {
const temp = arr[position]
arr[position] = arr[maxIndex]
arr[maxIndex] = temp
adjustHeap(arr, maxIndex, size)
}
return arr
}
复制代码二、JS基础
1.继承

1、原型链继承，将父类的实例作为子类的原型，他的特点是实例是子类的实例也是父类的实例，父类新增的原型方法/属性，子类都能够访问，并且原型链继承简单易于实现，缺点是来自原型对象的所有属性被所有实例共享，无法实现多继承，无法向父类构造函数传参。

2、构造继承，使用父类的构造函数来增强子类实例，即复制父类的实例属性给子类，构造继承可以向父类传递参数，可以实现多继承，通过call多个父类对象。但是构造继承只能继承父类的实例属性和方法，不能继承原型属性和方法，无法实现函数服用，每个子类都有父类实例函数的副本，影响性能

3、实例继承，为父类实例添加新特性，作为子类实例返回，实例继承的特点是不限制调用方法，不管是new 子类（）还是子类（）返回的对象具有相同的效果，缺点是实例是父类的实例，不是子类的实例，不支持多继承

4、拷贝继承：特点：支持多继承，缺点：效率较低，内存占用高（因为要拷贝父类的属性）无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）

5、组合继承：通过调用父类构造，继承父类的属性并保留传参的优点，然后通过将父类实例作为子类原型，实现函数复用

6、寄生组合继承：通过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点

2.this指向
(1).this 指向有哪几种

1.默认绑定：全局环境中，this默认绑定到window。

2.隐式绑定：一般地，被直接对象所包含的函数调用时，也称为方法调用，this隐式绑定到该直接对象。

3.隐式丢失：隐式丢失是指被隐式绑定的函数丢失绑定对象，从而默认绑定到window。显式绑定：通过call()、apply()、bind()方法把对象绑定到this上，叫做显式绑定。

4.new绑定：如果函数或者方法调用之前带有关键字new，它就构成构造函数调用。对于this绑定来说，称为new绑定。

构造函数通常不使用return关键字，它们通常初始化新对象，当构造函数的函数体执行完毕时，它会显式返回。在这种情况下，构造函数调用表达式的计算结果就是这个新对象的值。
如果构造函数使用return语句但没有指定返回值，或者返回一个原始值，那么这时将忽略返回值，同时使用这个新对象作为调用结果。
如果构造函数显式地使用return语句返回一个对象，那么调用表达式的值就是这个对象。

(2).改变函数内部 this 指针的指向函数（bind，apply，call的区别）

1.apply：调用一个对象的一个方法，用另一个对象替换当前对象。例如：B.apply(A, arguments);即A对象应用B对象的方法。

2.call：调用一个对象的一个方法，用另一个对象替换当前对象。例如：B.call(A, args1,args2);即A对象调用B对象的方法。

3.bind除了返回是函数以外，它的参数和call一样。

(3).箭头函数

1.箭头函数没有this，所以需要通过查找作用域链来确定this的值，这就意味着如果箭头函数被非箭头函数包含，this绑定的就是最近一层非箭头函数的this，
2.箭头函数没有自己的arguments对象，但是可以访问外围函数的arguments对象
3.不能通过new关键字调用，同样也没有new.target值和原型

3.数据类型
(1).基本数据类型
Undefined、Null、Boolean、Number 、String、Symbol
(2).symbol

1.语法：
// 不能用 new
let s = Symbol()

// 可以接受一个字符串作为参数，表示对 Symbol 实例的描述，主要是为了在控制台显示，或者转为字符串时，比较容易区分。
let s1 = Symbol(‘foo’);
let s2 = Symbol(‘bar’);

s1 // Symbol(foo)
s2 // Symbol(bar)

s1.toString() // “Symbol(foo)”
s2.toString() // “Symbol(bar)”
复制代码

2.作用：定义一个独一无二的值

1.用作对象的属性名

1.不会出现在for…in、for…of循环中，也不会被Object.keys()、Object.getOwnPropertyNames()、JSON.stringify()返回。
2.Object.getOwnPropertySymbols()方法，可以获取指定对象的所有 Symbol 属性名。该方法返回一个数组，成员是当前对象的所有用作属性名的 Symbol 值。
3.Reflect.ownKeys()方法可以返回所有类型的键名，包括常规键名和 Symbol 键名。

2.用于定义一组常量
log.levels = {
DEBUG: Symbol(‘debug’),
INFO: Symbol(‘info’),
WARN: Symbol(‘warn’)
};
复制代码

3.类型转换：

1.转成字符串
String(sym) // ‘Symbol(My symbol)’
sym.toString() // ‘Symbol(My symbol)’
复制代码

2.转成布尔值
Boolean(sym)
!sym
复制代码

3.不能转成数字

4.不能与其他类型的值进行运算
let sym = Symbol(‘My symbol’);

"your symbol is " + sym
// TypeError: can’t convert symbol to string
your symbol is ${sym}
// TypeError: can’t convert symbol to string
复制代码

4.属性：Symbol.prototype.description

5.Symbol.for()，Symbol.keyFor()

1.在全局环境中登记 Symbol 值。之后不会再重复生成

(3).如何判断类型
typeof()，instanceof，Object.prototype.toString.call()

1.typeof操作符

1.“undefined”——如果这个值未定义;
2.“boolean”——如果这个值是布尔值;
3.“string”——如果这个值是字符串;
4.“number”——如果这个值是数值;
5.“object”——如果这个值是对象或 null;
6.“function”——如果这个值是函数。
7.“symbol”——es6新增的symbol类型

2.instanceof：用来判断对象是不是某个构造函数的实例。会沿着原型链找的

3.Object.prototype.toString.call()
var toString = Object.prototype.toString;

toString.call(new Date); // [object Date]
toString.call(new String); // [object String]
toString.call(Math); // [object Math]
toString.call([]); // [Object Array]
toString.call(new Number) // [object Number]
toString.call(true) // [object Boolean]
toString.call(function(){}) // [object Function]
toString.call({}) // [object Object]
toString.call(new Promise(() => {})) // [object Promise]

toString.call(new Map) // [object Map]
toString.call(new RegExp) // [object RegExp]
toString.call(Symbol()) // [object Symbol]
toString.call(function *a(){}) // [object GeneratorFunction]
toString.call(new DOMException()) // [object DOMException]
toString.call(new Error) // [object Error]

toString.call(undefined); // [object Undefined]
toString.call(null); // [object Null]

// 还有 WeakMap、 WeakSet、Proxy 等
复制代码

(4).判断是否是数组

1.Array.isArray(arr)
2.Object.prototype.toString.call(arr) === ‘[Object Array]’
3.arr instanceof Array
4.array.constructor === Array

(5).字符串转数字
parseInt(string, radix)
4.CallBack Hell
大脑对于事情的计划方式是线性的、阻塞的、单线程的语义，但是回调表达异步流 程的方式是非线性的、非顺序的，这使得正确推导这样的代码难度很大。难于理解的代码 是坏代码，会导致坏 bug。我们需要一种更同步、更顺序、更阻塞的的方式来表达异步，就像我们的大脑一样。
也是更重要的一点，回调会受到控制反转的影响，因为回调暗中把控制权交给第三 方(通常是不受你控制的第三方工具!)来调用你代码中的 continuation。可以发明一些特定逻辑来解决这些信任问题，但是其难度高于应有的水平，可能会产生更 笨重、更难维护的代码，并且缺少足够的保护，其中的损害要直到你受到 bug 的影响才会 被发现。
我们需要一个通用的方案来解决这些信任问题。不管我们创建多少回调，这一方案都应可 以复用，且没有重复代码的开销。
(1).Promise 为什么以及如何用于解决控制反转信任问题
Promise 的实现可以看这里
Promise 这种模式通过可信任的语义把回调作为参数传递，使得这种行为更可靠更合理。 通过把回调的控制反转反转回来，我们把控制权放在了一个可信任的系统(Promise)中， 这种系统的设计目的就是为了使异步编码更清晰。Promise 并没有摈弃回调，只是把回调的安排转交给了一个位于我们和其他工具之间的可信任 的中介机制。

调用回调过早;

这个问题主要就是担心代码是否会引入类似 Zalgo 这样的副作用(参见第 2 章)。在这类问 题中，一个任务有时同步完成，有时异步完成，这可能会导致竞态条件。
根据定义，Promise 就不必担心这种问题，因为即使是立即完成的 Promise(类似于 new Promise(function(resolve){ resolve(42); }))也无法被同步观察到。
也就是说，对一个 Promise 调用 then(…) 的时候，即使这个 Promise 已经决议，提供给 then(…) 的回调也总会被异步调用(对此的更多讨论，请参见 1.5 节)。

调用回调过晚(或不被调用);

和前面一点类似，Promise 创建对象调用 resolve(…) 或 reject(…) 时，这个 Promise 的 then(…) 注册的观察回调就会被自动调度。可以确信，这些被调度的回调在下一个异步事 件点上一定会被触发(参见 1.5 节)。

回调未调用

首先，没有任何东西(甚至 JavaScript 错误)能阻止 Promise 向你通知它的决议(如果它 决议了的话)。如果你对一个 Promise 注册了一个完成回调和一个拒绝回调，那么 Promise 在决议时总是会调用其中的一个。
但是，如果 Promise 本身永远不被决议呢?即使这样，Promise 也提供了解决方案，其使用 了一种称为竞态的高级抽象机制:

调用回调次数过多;

Promise 的定义方式使得它只能被决议一次。如果出于某种 原因，Promise 创建代码试图调用 resolve(…) 或 reject(…) 多次，或者试图两者都调用， 那么这个 Promise 将只会接受第一次决议，并默默地忽略任何后续调用。
由于 Promise 只能被决议一次，所以任何通过 then(…) 注册的(每个)回调就只会被调 用一次。

未能传递所需的环境和参数;

Promise 至多只能有一个决议值(完成或拒绝)。
如果你没有用任何值显式决议，那么这个值就是 undefined，这是 JavaScript 常见的处理方 式。但不管这个值是什么，无论当前或未来，它都会被传给所有注册的(且适当的完成或 拒绝)回调。

吞掉可能出现的错误和异常。

如果拒绝一个 Promise 并给出一个理由(也就是一个出错消息)，这个值就会被传给拒绝回调