你真的知道js的语法吗

{
    a = 1;
    function a() { };
    a = 2;
    console.log(a); // 输出：2
}
console.log(a); // 输出：1

function test() {
    b();
    console.log('我是函数');
    var num = 1;

    function b() {
        console.log('我是内嵌函数b,num:', num);
    }
}
test(); // 输出：1.我是内嵌函数b,num:undefined  2.我是函数 

// 解释器解释代码之后会变成如下这个样子

function test() {
    var num = undefined;
    var b = function () { // function提升的同时，方法实现也定义了出来
        console.log('我是内嵌函数b,num:', num);
    }
    b();
    console.log('我是函数');
    num = 1;
}
test();

var a = 1;
{
    let a = 2;
    function test() {
        console.log(a);
    }
}
test();
    
// 按照上面的函数和变量的提升思路，那么这就是解释器解释后的代码样子
var a = undefined;
var test = function () {
    console.log(a);
}
a = 1;
{
    let a = 2;
}
test();

var a = 1;
{
    let a = 2;
    function test() {
        console.log(a);
    }
}
test();
    
// 解释器解释后的代码的样子

var a = undefined; // 变量提升
var test = undefined; // 块内的函数提升，舍弃方法体的定义
a = 1;
{
    let new_test = function () { // 块内的函数，用let以及新的变量名定义，并在此定义出函数实现体
        console.log(a);
    }
    let a = 2;
    var test = new_test; // 用var把原有的变量名声明一下，执行完该代码块时，函数也可以在外部访问
}
test();

{
    a = 1;
    function a() { };
    a = 2;
    console.log(a); // 输出：2
}
console.log(a); // 输出：1

// 解释器解释之后的代码

var a = undefined; // 函数和变量提升至前，不给其函数实现的定义，以免块内污染块外  
{
    let new_a = function () { }; // 新变量名称用let进行修饰，并给出原有函数体的定义，使其函数在块内生效，在这个块中，涉及到原有变量名的都用新的变量名'new_a'
    new_a = 1;
    var a = new_a; // 执行到原有代码时，需要把函数用原有的名称用'var'重新修饰一下，使其块外能访问到
    new_a = 2;
    console.log(new_a); // 输出：2
}
console.log(a); // 输出：1

a = 1;
{
    function a() { };
    a = 2;
    console.log(a); // 输出：2
}
console.log(a); // 输出：function

// 解释器解释之后的代码

var a = undefined;  // 变量提升
a = 1;
{
    let new_a = function () { }; // 块内的方法用'let'以及新的变量名修饰， 在这个块中，涉及到原有变量名的都用新的变量名'new_a'
    var a = new_a; // 执行到原有代码时，用var把原有的函数重新修饰，使其块外能访问到
    new_a = 2;
    console.log(new_a); // 输出：2
}
console.log(a); // 输出：function

function Fun1(value){
    this.value = value;
}
Fun1.prototype.toString = function () {
    console.log(`value:${this.value}`)
};

f1 = new Fun1(1);
f1.toString()// 此时会输出1

// 如果换个对象调用输出值就变了
toString = f1.toString;
value=2 // 默认给window对象定义value属性，值为2
toString() // 输出2，因为window调用，此时window的value为2，所以输出2

function test(arg1, arg2) {
   this.arg1 = arg1;
   this.arg2 = arg2;
   arg3 = arguments;
   // 本方法名称
   this.functionName = arguments.callee.name;
   this.caller = arguments.callee.caller; // 本方法的调用者，为空为window，不为空则为某个函数本身，注意：caller为动态的，出栈则此属性值会变
}


var o = new test(1, 2); // 对象创建
console.log(o.arg1); // 输出：1
console.log(window.arg1); // 输出：undefined

test(3, 4); // 方法调用
console.log(window.arg2); // 输出：4
console.log(window.arg3); // 输出：[3,4]

// 一句话描述this，谁调用的我，这个this就是谁的

function Person(name, age){
    this.name = name;
    this.age = age;
}
san = new Person('张三', 13);
si = new Person('李四', 24);

Person.prototype.toString = function () {
    console.log(`你好，我叫${this.name},我${this.age}岁了`)
};
san.toString();
si.toString();

function PersonSex(name, age, sex){
    Person.call(this, name, age); // 如果不需要父类的属性删掉即可
    this.sex = sex;
}
PersonSex.prototype.__proto__ = Person.prototype; // 通过原型链方式继承
new PersonSex('张三', 13, '男')

let Person = {}
Object.defineProperty(Person, 'name', {
    value: 'jack',
    writable: true,  // 是否可写，默认是false
    get() {
        return '张三';
    },// 获取 Person.name 时会触发本方法 
    set(arg) {
        
    },// Person.name='张三' 时会调用
    enumerable: true, // 是否可列举( for .. in | Object.keys)，默认为false
    configurable: true // 是否可以删除此属性，是否可以从新配置（二次调用defineProperty从新配置此属性），默认为false
});

Object.defineProperty(Person, 'age', {
    value: '26',
});
// 等价于
Object.defineProperty(Person, 'age', {
    value: '26',
    writable: false,
    enumerable: false,
    configurable: false,
});

Person.gender = '男'
//等价于
Object.defineProperty(Person, 'gender', {
    value: '男',
    writable: true,
    enumerable: true,
    configurable: true
});

Person = {
    _name: "李四",
    get name() {
        return "我叫" + this._name;
    }
}
// 等价于
Person = Object.defineProperty({_name: "李四"}, 'name', {
    get(){
        return "我叫" + this._name;
    },
    enumerable: true,
    configurable: true
});

var obj = [];
obj = new Proxy(obj, {
    get(target, prop, receiver){
        let value = Reflect.get(...arguments);// 它保证将正确的 this 传递给 getter(如果有的话)
        return typeof value == 'function' ? value.bind(target) : value; // 任何方法都要用target，bind一下。否则就是代理对象调用方法，this会变
    },
    set(target, prop, value, receiver){
      return Reflect.set(...arguments);// 保证将正确的 this 传递给 setter
    },
    deleteProperty(target, prop) { // 拦截属性删除
       return Reflect.deleteProperty(...arguments)
    },
    ownKeys(target) { // 拦截读取属性列表
      return Reflect.ownKeys(target)
    }
})
obj.push(1);  
// 先读取push=function，在读取length=0(默认)  
// push内部操作为：  
// 1：先set key=0,       value=1  
// 2：在set key=length,  value=1

class Animals{
    name;
    constructor(name) {
        this.name = name;
    }

    get name() {
        return '我叫:' + this.name
    }
}

class Dog extends Animals {
    sex = '未知';
    #age;
    constructor(name, sex, age = -1) {
        super(name)
        this.sex = sex;
        this.#age = age;
    }

    get str() {
        return super.name + "。我的性别是" + this.sex + ",悄悄的告诉你，我" + this.#age + "岁了，不能透露给其他人哦(私有属性)";
    }
}

console.log(new Dog('哈士奇','男', 18).str)
// 我叫:哈士奇。我的性别是男,悄悄的告诉你，我18岁了，不能透露给其他人哦(私有属性)
console.log(Dog.prototype.__proto__ == Animals.prototype)
// true

new Promise(function (resolve, reject) { 
    // 成功
    resolve('data');
    // 失败
    reject('errorMessage');
    // 以上两者不能同时调用
}).then(function (value) { 
    console.log('成功了')
}).catch(function (reason) { 
    console.log('失败了')
}).finally(function () { 
    console.log('执行完啦')
})

setTimeout(function () {
    console.log('1秒后执行');
}, 1000);

setTimeout(function () {
    console.log('执行完这个js整体文件之后才执行');
}, 0)

var interval = setInterval(function () {
    console.log('我是周期性执行，每1秒执行一次')
},1000)

// 清空周期性执行代码
clearInterval(interval);