代码记录

鼠标特效：

.li-img:hover{
              transform:scale(1.1,1.1);
              -webkit-transition: all 0.5s linear;
              -moz-transition: all 0.5s linear;
              -o-transition: all 0.5s linear;
              transition: all 0.5s linear;
            }

new 的实现原理
function Person(name,age,sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}

function newObj(Fn,args) {
  let re = {};
  if(Fn.prototype !== null){
    Object.setPrototypeOf(re,Fn.prototype);
    // re = Object.create(Fn.prototype);
  }
  const result = Fn.call(re,...args);
  if ((typeof result === "object" || typeof result === "function") && result !== null) {
    return result;
  }
  return re;
}

let person = newObj(Person,['zhuhong','24','man']);
console.log(person.prototype);

function New(Fn,...args) {
  const obj = {};
  if(Fn.prototype !== null){
    Object.setPrototypeOf(obj,Fn.prototype);
    // obj = Object.create(Fn.prototype);
  }
  const obj1 = Fn.apply(obj,args);
  if((typeof obj1 === 'object' || typeof obj1 === 'function') && obj1 !== null){
    return obj1;
  }
  return obj;
}

function Person(name) {
  this.name = name;
}

const person = New(Person,'朱宏');
console.log(person);
console.log(person);

Function.prototype.Bind=function () {
  const out = Array.from(arguments);
  const ctx = out.shift();
  const self = this;
  return function (ctx) {
    const inner = Array.from(arguments);
  }
}

const myPromise = new Promise((resolve, reject)=>{
  console.log('hahah');
  // resolve();
  reject();
}).then(()=>{
  console.log('then');
}).catch(()=>{
  console.log('catch')
}).finally(()=>{
  console.log('finally');
})

const a = new Promise((resolve, reject)=>{
  resolve(100);
})
const b = new Promise((resolve, reject)=>{
  reject(1);
}).catch((res)=>{
  console.log(res)
})
const c = new Promise((resolve, reject)=>{
  resolve(25);
})
Promise.race([a,b,c]).then((res)=>{
  console.log(res)
})

const f = () => console.log('now');
// Promise.resolve().then(f);
(async ()=>f())();
console.log('next');

js实现单例模式
function Universe() {
  if(typeof Universe.instance === 'object'){
    return Universe.instance;
  }
  Universe.instance = this;
  return this;
}
function Universe() {
  return function () {
    if(typeof Universe.instance === 'object'){
      return Universe.instance;
    }
    Universe.instance = this;
    return this;
  }();
}

let a = new Universe();
let b = new Universe();
console.log(a===b);
console.log(Universe.instance)

let a = 1;
function f(a) {
  a = 2;
}
f(a)
console.log(a);//a = 1

let a = {a:1}
function f(c){
  c.a = 2;
}
f(a)
console.log(a)//{ a: 2 }
/*
js有原始类型和引用（共享）类型，上述前者属于原始类型，不存在引用（指针）传递，也就是没有深浅拷贝之分，直接是独立变量。
所以函数中的a属于局部变量，改变不了全局变量的值。

后者属于引用(指针)传递，也就是指针指向物理地址是一个，属于浅拷贝，故能改变该对象的值。
*/

'use strict';
let a = 1;
let obj = {
  a: 2,
  b:function () {
    console.log(a)
  },
  print:function () {
    console.log(this.a);
  }
}
obj.b();//a = 1
obj.print();//a = 2
let p = obj.print;
p();//undefined
/*
浏览器严格模式下this全局指向为undefined,对象this指向自己本身
 */

//两个有序数组A和B，判断B是否是A的子序？要求不可以转化数据格式，不可以使用api
let A = [1,2,3,4,5,6,7,8,9,10];
let B = [1,8,9]
// let B = [8,8.5,9]
//使用api
console.log(Array.from(new Set([...A,...B])).length === A.length)
//不使用api
function isChild(A,B){
  if(B.length === 0){
    return true;
  }
  let flag = 0;
  for (let i=0; i<B.length; i++){
    let index = false;
    for (let j=flag; j<A.length; j++){
      if(!index && j === A.length - 1){
        return false;
      }
      if(B[i] === A[j]){
        flag = j;
        index = true;
        break;
      }
    }
  }
  return true;
}
console.log(isChild(A,B));

// 给定长度为N(1≤N≤2000)的字符串S，要构造一个长度为N的字符串T。期初，T是一个空串，随后反复进行下列任意操作。
// ·从S的头部删除一个字符，加到T的尾部
// ·从S的尾部删除一个字符，加到T的尾部
// 目标是要构造字典序尽可能小的字符串
input: acdbcb
output: abcbcd
const input = 'acdbcb';
const output = 'abcbcd';
const strArr = input.split('');
let result = '';

while (strArr.length > 1){
  let left = strArr[0];
  let right = strArr[strArr.length-1];
  if(left < right){
    let head = strArr.shift();
    result = result + head;
  }
  if(left > right){
    let foot = strArr.pop();
    result = result + foot;
  }
  if (left === right){
    result = result +getMin(left,right,strArr);
  }
}

console.log(result+strArr[0])

function getMin(left,right,arr) {
  let h='',f='';
  while(left === right && arr.length > 1){
    h = h + arr.shift();
    f = f + arr.pop();
    left = arr[0];
    right = arr[arr.length-1];
  }
  if(h < f){
    arr.push(f);
    return h;
  } else {
    arr.unshift(h);
    return f;
  }
}

Function.prototype.a = () => console.log(1)
Object.prototype.b = () => console.log(2)
function A(){}
A.prototype.c = () => console.log(3)
var a = new A()
console.log(Object.getPrototypeOf(A.prototype))//Object.prototype
console.log(Object.getPrototypeOf(Function) === Function.prototype)//true
console.log(Object.getPrototypeOf(Array) === Function.prototype)//true
console.log(Object.getPrototypeOf(Object) === Object.prototype)//false
console.log(Object.getPrototypeOf(A) === A.prototype)//false
// a.a() // 报错
a.b() // 2

//输出1该怎么办？
Function.a();
A.a();
A.prototype.c();
a.c();
a.constructor.a();
console.log(a.constructor)
/*
本题检测js原型链的基本知识，a是实例，a的constructor是A，没有prototype。继承A.prototype。
所以a.a()在A.prototype中并没有a()这个方法。那么继续沿着原型链网上找，a.__proto__.__proto__,
也就是A.prototype.__proto__ = Object.prototype,只有b没有a，所以报错a.a is not a function。
此处注意A的__proto__指向Function.prototype，A.prototype指向Object.prototype,a.constructor就是a的构造函数。切记
 */

console.log(a)//undefined
var a = 1
console.log(b)//Cannot access 'b' before initialization
let b = 2
console.log(c)//c(){}
function c(){}

var x = 20
function a(y){
  var x = 10
  return get(y)
}
function get(y){
  return x+y
}
console.log(a(10))//30

// 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
// 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
// 注意： 给定 n 是一个正整数。

//尾递归优化
function num(n,t1=0,t2=1) {
  if(n === 0)return t2;
  return num(n-1,t2,t2 + t1);
}
let start = new Date().getTime();
console.log(num(0));
let end = new Date().getTime();
console.log('递归耗时：',end-start);

num(4,0,1);
num(3,1,1);
num(2,1,2);
num(1,2,3);
num(0,3,5);

function num1(n) {
  if(n < 1){
    return 0;
  }
  if(n === 1){
    return 1;
  }
  let a = 1;
  let b = 2;
  let total = 0;
for(let i=3;i<=n;i++){
  total = a + b;
  a = b;
  b = total;
}
return total;
}
let start1 = new Date().getTime();
console.log(num1(0));
let end1 = new Date().getTime();
console.log('循环耗时：',end1-start1);

const arr = [50,32,5,73,8,6,5,4,8,5,66,88,56,4,3,4,554,45,54,4]
//插入排序
function f(arr){
  let flag = 1;
  for(let i=flag; i<arr.length; i++){
    let num = arr[i];
    for(let j=flag-1; j>=0; j--){
      if(num < arr[j]){
        arr[j+1] = arr[j];
      } else {
        arr[j+1] = num;
        break;
      }
    }
    flag++;
  }
  return arr;
}
console.log(f(arr));

//冒泡排序
function f1(arr) {
  let flag = false;
  while (!flag){
    flag = false;
    for(let i=0; i<arr.length; i++){
      if(arr[i] > arr[i+1]){
        flag = true;
        let temp = arr[i];
        arr[i] = arr[i+1];
        arr[i+1] = temp;
      }
    }
    if(!flag){
      return arr;
    }
  }
}
console.log(f1(arr));

快速排序
function f2(arr,l,r) {
  if(l < r){
  let i = l;
  let j = r;
  let X = arr[i];
  let index = l;
  while (i < j){
    for(j;j>0;j--){
      if(arr[j] < X){
        arr[i] = arr[j];
        index = j;
        break;
      }
    }
    for(i;i<j;i++){
      if(arr[i] > X){
        arr[index] = arr[i];
        index = i;
        break;
      }
    }
  }
  arr[i] = X;
  f2(arr,l,i-1);
  f2(arr,i+1,r);
  }
}
f2(arr,0,arr.length-1)
console.log(arr)