Byte daily practice (OC)

Byte daily practice side （ has OC）

4.13. evening 7 spot （1 One and a half hours ）

Most of their companies are react frame + Self encapsulation hooks

1. Self introduction. + Project introduction
2. Ask how the micro front-end application is related to the parent application and the core implementation of the micro front-end
3. Several ways to judge the type
4. Handwriting instanceof The implementation of the

// Iterative implementation 
function instanceOf(obj,constructor){
    
	// take constructor The prototype of the 
	let prototype = constructor.prototype;
	// take obj The prototype of the 
	obj = obj.__proto__;
	while(true){
    
		if(obj === prototype)
			return true;
		obj = obj.__proto__;
		if(obj === null)
			return false;
	}
}

1. typeof The shortcomings of
2. Deep clone shallow clone

Deep copy implementation ：

Method 1： Use the blending method ：

var obj = {
    a:1,b:2}
var newObj = Object.assign({
    },obj)

Method 2： Using recursion

1. Box model , Use scenarios

2. for in and for of The difference between

3. position Properties of

4. ts The difference between enumeration type and object

5. vue and react The difference between

6. Make a fan

   ... Just remember so much

10. Byte daily practice two sides

4.14. Afternoon 4 spot （1 Hours ）

Self introduction. + Project introduction

1. In the project, when logging in , How does the server know which user logged in (token)
2. token What is it?
3. session What is it? , and cookie、sessionStorage The difference between
4. CDN What is it?
5. Browser cache
6. tcp and udp The difference between
7. http and https The difference between
8. 

//  Note that the chess board is 7 * 7, Then each day of chess jump 
// let count = 0
function solution(x0, y0, xn, yn, n) {
    
    //  Recursive export 
    if (n == 0) {
    
        if (x0 == xn && y0 == yn) {
    
            // count++
            return 1
        }
        return 0
    }

    let arr = getNextSteps(x0, y0)
    let sum = 0
    console.log(arr);
    for (let i = 0; i < arr.length; i++) {
    
        sum += solution(arr[i][0], arr[i][1], xn, yn, n - 1)
    }
    return sum

}
let c = solution(0, 0, 5, 6, 5)
// console.log(count);
console.log(c);

//  Used to judge its next jump , In the middle, there are 8 There are two jumping situations 
function getNextSteps(x, y) {
    
    let arr = []
    //  Jump to the first quadrant  
    if (x <= 4 && y >= 1) {
    
        arr.push([x + 2, y - 1])
    }
    if (x <= 5 && y >= 2) {
    
        arr.push([x + 1, y - 2])
    }

    //  Jump to the second quadrant  
    if (x >= 2 && y >= 1) {
    
        arr.push([x - 2, y - 1])
    }
    if (x >= 1 && y >= 2) {
    
        arr.push([x - 1, y - 2])
    }

    //  Jump to the third quadrant  
    if (x >= 2 && y <= 5) {
    
        arr.push([x - 2, y + 1])
    }
    if (x >= 1 && y <= 4) {
    
        arr.push([x - 1, y + 2])
    }

    //  Jump to the fourth quadrant  
    if (x <= 4 && y <= 5) {
    
        arr.push([x + 2, y + 1])
    }
    if (x <= 5 && y <= 4) {
    
        arr.push([x + 1, y + 2])
    }
    return arr
}
// let arr = getNextSteps(0, 0)
// console.log(arr);

9. Write about the dfs Find the sum of all nodes of the tree

class Tree {
    
    constructor(val, left, right) {
    
        this.left = left == undefined ? null : left
        this.right = right == undefined ? null : right
        this.val = val == undefined ? 0 : val
    }
}


//  Subsequent traversal to find the sum of nodes 
function treeNode(root) {
    
    if (!root) {
    
        return 0
    }
    // console.log(root.val);
    let left = treeNode(root.left)  // Go all the way to the leaf node of the left subtree , Because the leaf node has no left node , That is, its left node is null It's over , So it's going back to 0
    let right = treeNode(root.right) //  return 0
    let sum = left + right + root.val // Get the sum of the tree with the current node as the root 
    console.log(sum);
    return sum
}

let tree = new Tree(1, new Tree(2, new Tree(4), new Tree(5)), new Tree(3))
console.log(treeNode(tree));

11. Byte daily practice on three sides

Didn't ask what . Mainly write code .

1. Re write down the horse vaulting that failed to pass the code question on the second side 、 There are follow-up traversal and sequence traversal to find the sum of all nodes .

2. Use binary search to find the inflection point index of an array that increases first and then decreases .[1, 2, 3, 2, 1] => 2