堆栈内存、this绑定、js event loop、class语法、斐波那契数列、动态规划

1.堆栈内存

栈内存主要用于存储各种基本类型（Boolean、Number、String、undefined、null以及对象变量的指针）的变量。
堆内存存储object。

2.this指针

new绑定的优先级大于bind绑定

3.js event loop以及宏任务和微任务；

//定时器任务属于宏任务，需要在任务队列等待
setTimeout(() => console.log('a'));
//promise是异步微任务，在本轮同步任务结束之前执行
Promise.resolve().then(
   () => console.log('b’);
 ).then(
 //箭头函数的resolve传递的参数作为这个then的参数
   () => Promise.resolve('2').then(
     (data) => {
     //定时器任务放入任务队列中等待，放在第一个定时器之后
       setTimeout(() => console.log('d'));
       console.log('f');
       //返回值作为下一个then的参数
       return data*2;
     }
   )
 ).then(data => console.log(data));
 //输出：bf4ad

4.class语法

ES5

function Point(name){
    this.name = name;
}
Point.prototype.getName = function(){
    return 'my name is'+this.name
}
Point.prototype.archer = function(time){
    var self = this;
    setTimeout(function(){
        console.log('my name is'+self.name)
    },time)
}

ES6

class Point{
    constructor(name){
        this.name = name;
    }
    getName(){
        return 'my name is ${this.name}';
    }
    archer(time){
        setTimeout(()=>{
            console.log('my name is ${this.name}')
        },time);    
    }
}

5.斐波那契数列

0，1，1，2，3，5，8，13…

//递归 
//O(2^n)
var fib = function(N) {
    if(N == 0|| N == 1){
        return N; 
    }
     return fib(N - 1)+fib(N - 2);
};

//循环一个一个的算 
//O（n）
var fib = function(N) {
    var pre = 1,prepre = 0,newpre = 1
    if(N == 0|| N == 1) return N;
    for(let i = 2;i <= N;i++){
        newpre = pre + prepre;  
        prepre = pre;
        pre = newpre;
    }
    return newpre;
}

6.零钱兑换 (动态规划）

动态规划的问题涉及选与不选两种情况

var coinChange = function(coins, amount) {
//数组中每一项都事先设为正无穷便于和最小值比较
let dp = Array(amount + 1).fill(Infinity);
dp[0]=0
for(let i = 1; i <= amount; i++){
//每次外层for循环时，内部的for...of循环来判断是否可用现有的金币组合来组成amount金币量
    for(let coin of coins){
        if(i-coin >= 0){
        //1 不选这枚硬币 dp[i] 
        //2 选这枚硬币 剩下的钱是i-coin 兑换的硬币数为db[i-coin]+1 
            dp[i] = Math.min(dp[i],dp[i-coin]+1)
        }
    }
}
return dp[amount] === Infinity ? -1:dp[amount]
};

动态规划具有无后效性和最优子结构的基本特征。
无后效性：下一时刻的状态只与当前状态有关，与当前状态之前的状态无关，当前状态是对以往决策的总结。
关键在于正确地写出基本的递推关系式和恰当的边界条件。
1递归关系式
2子问题重叠
3最优子结构

来源：CSDN

作者：保护我方甜茶

链接：https://blog.csdn.net/s4459/article/details/104796874