SE6

object

closure

closure=inner function+external function variable

1
function f1() {
2
    let i=0
3
    function f2() {
4
        i++
5
        console.log(i)
6
    }
7
    return f2
8
}
9
const f=f1()

construct object

1
function Pig(name,age,gender){
2
    this.name = name
3
    this.age = age
4
    this.gender = gender
5
    }
6
const pappe = new Pig('佩奇',6,'女')

Instance members: methods and properties on property objects

Static members: static properties and methods

convention

1. can only start with a capital letter
2. can only be executed using the ‘new’ operator

prototype

1
function Pig(name,age){
2
    this.name = name
3
    this.age = age
4
    }
5
Pig.prototype.sing=function(){}
6
const pappe = new Pig('佩奇',6)

1. each cpmstructor has a prototype property
2. This object mounting function will not create functions on the prototype multiple times during object instantiation, saving memory

constructor

1. Refers back to the constructor created

object prototype

​__proto__​ =[[proto]]​

inherit

1
function Person(){
2
        this.gender=1
3
}
4
function A(uname,age){
5
       this.uname = uname;
6
       this.age = age;
7
}
8
A.prototype=new Person()
9
A.prototype.constructor=A

Prototype Chain

Inheritance based on prototype objects associates different constructor objects together

instanceof

You can use instanceof​ to check if the prototype property of the constructor appears on the prototype chain of an instance object

function

parmeter

• dynamics parmeter

  1
  arguments

  The paseudo array includes all the parameters passed in

• remaining parameters

  1
  function f(...<parameter name>){
  2
      <parameter name> //array
  3
  }

Arrow function

1
const <function name> = () =>{}

rule

1. If the function has only one line, it can be written on one line, {} can be omitted, and there is no need to write a return to have a return value. If the return dictionary needs to be written, () needs to be added
2. if there is only parameter,()can beomitted

this

the arrow function does not have this,it wil only use this from the higer-level scope chain

deconstruction

1
{name:newname,age:newage}={name:lsy;age:19}

1. The variable names for deconstruction need to be consistent with those in the object
2. Rename: The previous name is the opposite name, followed by the new name that needs to be changed. If not changed, do not use write

multistage

1
obj={
2
    a:1
3
    b:{
4
        b1:2
5
        b2:3
6
        }
7
    c:4
8
}
9
{a,b:{b1,b2},c}=obj

array

Expand operator

1
...<array>

deconstruction array

1
[a,b]=[1,2]

1. Assign the variables on the left to the variables on the right in sequence
2. Support multidimensional arrays

copy

shallow copy

If it is a complex data type, only copy the address

1. object

   1
   Object.assign(<new>,<old>)

2. array

   1
   Array.prototype.concat()

deep copy

1. recursion
2. json
3. Library functions

performance optimization