一、類

class ClassA{
  constructor(o){
    Object.assign(this, o);
  }
  
  foo(){
    console.log(this);
  }

  static bar(){
    console.log("我是一個靜態(tài)方法，不能通過實例化對象調(diào)用，只能通過類本身調(diào)用");
  }
}

let a = new ClassA({
  a : 1,
  b : 2,
  c : 3
});

ClassA.bar();
a.foo();

二、類的繼承

class ClassA{
  constructor(o){
    if(new.target !== ClassA){
      console.log("通過子類調(diào)用的");
    }else{
      console.log("被單獨調(diào)用的");
    }

    Object.assign(this, o);
  }

  foo(){
    console.log("我是classA的foo方法");
  }

  bar(){
    console.log("我是classA的方法");
    console.log(this);
  }
}

class ClassB extends ClassA{
  constructor(o){
    super(o);
  }

  foo(){
    super.foo();

    console.log("我是classB的foo方法");
  }
}

let b = new ClassB({a:1});
//ClassB.prototype -> b.__proto__
//b.foo();

三、模塊與import語法
import() 返回一個promise對象
需要export暴露

let dir = "./export1.js";
if(true){
  import(dir)
    .then((module)=>{
      let {a, foo, ClassA} = module;
      foo();
      console.log(a, foo, ClassA);
      console.log(module.default);
    })
}

(async function(){
  let {c, b, foo} = await import(dir);
  console.log(c, b, foo);
})()

let a = 1;
let b = 2;

function foo(){
  console.log("foo");
}
//as取別名
export {a as c, b, foo}

export let a = 1;
export function foo(){
  console.log("foo");
}
export class ClassA{
  constructor(){}
}

export default class ClassA{
  constructor(){}
}

import第二種用法，瀏覽器可能不支持，微信小程序已經(jīng)支持

//代碼編譯階段執(zhí)行
import {b, foo} from "../../export/export1.js";
console.log(b, foo);

import ClassB from "../../export/export2.js";
new ClassB();

import * as modules from "../../export/export1.js";
console.log(modules);

let a = 1;
let b = 2;
let foo = function(){
  console.log("foo");
}
export {a, b, foo};

export default class ClassA{
  constructor(){
    console.log(this);
  }
}