바벨 컴파일 : 클래스 상속

 

컴파일하기 전에

 

// 父类
클래스 과일 { 
    정적 영양 = "비타민" 
    정적 공장 () { 
        을 console.log ( '种果树' ); 
    } 
    이름; 
    생성자 (명) { 
        이 .name을 = 이름; 
    } 
    안녕하세요 () { 
        CONSOLE.LOG ( 이 .name을); 
    } 
} 

// 子类
클래스 몽고가 확장 과일 { 
    생성자 (이름, 레벨) { 
        슈퍼 (이름); 
        이 .level = 단계; 
    } 
    {) (식사 
        (super.name을 console.log를 이 .name을)를; 
    }
}

 

컴파일

 

"엄격한 사용" ; 

//이 유형 가져 오기 
기능 _typeof (OBJ를) {
     // 운영 환경은 기본적으로 기호 지원 
    IF ( 대해서 typeof 기호 === "기능"&& 대해서 typeof Symbol.iterator === "기호" ) { 
        _typeof = 기능 _typeof를 ( OBJ) {
             반환  대해서 typeof (OBJ); 
        } 
    } 
    // 아날로그 구현 심볼 
    다른 { 
        _typeof = 함수 _typeof (OBJ) {
             반환 OBJ &&
                 대해서 typeof 심볼 === "기능"&&
                obj.constructor === 기호 && 
                OBJ ==! Symbol.prototype
                 "기호"? 
                : 대해서 typeof OBJ,이 
        }; 
    } 
    반환 ; _typeof (obj) 등 
} 

/ * * 
 * 부모 클래스 생성자가 생성 된 것을 반환 호출 할 수 있습니다 
 * @param {오브젝트} 자기 - 컨텍스트 
 파라미터 : {오브젝트} 전화 - 거래를 만들기 위해 부모 생성자를 호출 (객체 / 기능) 
 * / 
기능 _possibleConstructorReturn (자체, 전화) {
     // 구문 규칙 : new 연산자를 사용하여 생성자 운영자 호출은 객체 / 함수를 반환 할 때 
    IF ((_typeof (호출) === "객체"|| && 호출 과 typeof 전화 === "기능" {))
         반환전화; 
    } 
    반환 _assertThisInitialized (자기를); 
} 

// 주장 컨텍스트가 초기화 된 
기능 _assertThisInitialized (셀프) {
     // 슈퍼 초기 컨텍스트를 호출하지 않는 예외 
    IF (자기 === 무효 0 ) {
         던져  새로운 새로운 ReferenceError가 (
             "는이 hasn를 "슈퍼 ()를 호출하지되었습니다 - '는 T가 초기화 된 
        ) 
    } 
    반환 , 자기가 
} 

// 속성 읽기 
기능 {) _GET (목표, 재산, 수신기
     // [반사 지원 
    IF ( 대해서 typeof "정의되지 않은! 반사] == " &&Reflect.get) { 
        _GET = Reflect.get; 
    } 
    // 模拟Relect 
    다른 { 
        _GET = 함수 _GET (타겟 속성, 수신기) {
             VAR의 베이스 = _superPropBase (목표 특성);
            만약 (! 기본) 반환 ;
            VAR의 DESC = Object.getOwnPropertyDescriptor (베이스 특성);
            경우 (desc.get)는 {
                 반환 desc.get.call (수신기); 
            } 
            반환 desc.value을; 
        }; 
    } 
    반환_GET (타겟 속성, 수신기 || 대상) 
} 

// 이 제 프로토 타입 객체가 (즉, 속성을 상속하여 얻어진 생략) 특성 갖는다 찾을 때까지, 원형 따라 체인을 조회 
기능 _superPropBase (오브젝트, 프로퍼티) {
     while 회를 ( ! Object.prototype.hasOwnProperty.call (개체 속성)) { 
        오브젝트 = _getPrototypeOf (객체);
         IF (객체 === 널 ) BREAK ; 
    } 
    반환 , 개체 
} 

// __proto__의 읽기 
기능 _getPrototypeOf (O) { 
    _getPrototypeOf를 = Object.setPrototypeOf
         ? Object.getPrototypeOf
        : 기능 _getPrototypeOf (O)가 {
             반환 O .__ proto__ || Object.getPrototypeOf (O) 
        }; 
    반환 _getPrototypeOf (O)를; 
} 

// 유전 
함수 _inherits (서브 클래스, 수퍼 클래스) {
     IF ( 대해서 typeof ! 슈퍼 클래스 == "기능" ! && 슈퍼 클래스 == null이 ) {
         던져  새로운 새로운 형식 오류는 ( "슈퍼 표현이 (가) 널 (null) 또는 함수이어야합니다" ); 
    } 
    // 상속 된 멤버 방법 : 프로토 타입 서브 생성자는 부모 생성자 프로토 타입 상속 
    subClass.prototype = 개체입니다. 만들기 (슈퍼 클래스 && superClass.prototype, {
        생성자 {값 : 서브 클래스 쓰기 가능한 : 참으로 , 구성 : 진실 } 
    }); 
    // 상속 정적 속성 정적 방법 : __proto__ 서브 생성자 상위 생성자 
    IF (수퍼) _setPrototypeOf (서브 클래스, 수퍼 클래스); 
} 

// __proto__ 집합 
함수 _setPrototypeOf (O, P) { 
    _setPrototypeOf = 
        Object.setPrototypeOf ||
         함수 _setPrototypeOf (O, P) { 
            O .__ proto__ = ; P
             복귀 O 단계; 
        } 
    리턴 ; _setPrototypeOf (O, P) 
} 

함수_instanceof (왼쪽, 오른쪽) {
     경우 ( 
        오른쪽 ! = null의 &&
         대해서 typeof 심볼! == "미등록"&& 
        오른쪽 [Symbol.hasInstance] 
    ) { 
        창 ! 오른쪽 [Symbol.hasInstance (왼쪽); 
    } 다른 {
         반환 왼쪽 instanceof를 잘; 
    } 
} 

기능 _classCallCheck (예, 생성자) {
     경우 (! {_instanceof (예, 생성자))
         던져  새로운 ( "함수로 클래스를 호출 할 수 없습니다"형식 오류를 ); 
    } 
}

함수 _defineProperties (목표 소품) {
     대 ( VAR은 I = 0; I는를 <props.length; 내가 ++ ) {
         VAR의 기술자 = 소품 [I]을; 
        descriptor.enumerable = descriptor.enumerable || 거짓 ; 
        descriptor.configurable = 진정한 ;
        경우 ( "값" 에 descriptor.writable 디스크립터) = 참 ; 
        Object.defineProperty (목표 descriptor.key, 기술자); 
    } 
} 

함수 _createClass (생성자, protoProps, staticProps) {
     만약(protoProps) _defineProperties (Constructor.prototype, protoProps);
    경우 (staticProps) _defineProperties (생성자, staticProps);
    반환 생성자; 
} 

함수 _defineProperty (OBJ, 키 값) {
     경우 (키 에 OBJ) { 
        Object.defineProperty (OBJ 키 { 
            값 : 값 
            열거 : 사실 , 
            구성 : 사실 , 
            쓰기 : 참 
        }); 
    } 다른 { 
        OBJ [키] = 값; 
    } 
    반환OBJ; 
} 

VAR의 과일 =
     / * #__PURE__ * / 
    ( 함수 () { 
        _createClass (과일, 널 , [ 
            { 
                키 "시스템" , 
                값 : 함수 식물 () { 
                    CONSOLE.LOG ( "种果树' ); 
                } 
            } 
        ]) ; 

        함수 과일 (명) { 
            _classCallCheck ( 이 , 과일) 

            _defineProperty ( 이 "이름", 무효 0 );

            이 .name을 = 이름; 
        } 

        _createClass (과일, [ 
            { 
                키 에 "Hello" , 
                값 : 함수 안녕하세요 () { 
                    CONSOLE.LOG ( 이 .name을) 
                } 
            } 
        ]); 

        반환 과일; 
    }) (); 

_defineProperty (과일, "영양", "비타민" ); 

VAR 몽고 =
     / * #__PURE__ * / 
    ( 함수 (_Fruit) { 
        _inherits (몽고, _Fruit) 

        기능몽고 (이름, 레벨) {
             var에 _this; 

            _classCallCheck ( 이 , 몽고); 

            _this = _possibleConstructorReturn (
                 이 , 
                _getPrototypeOf (몽고) .call ( 이 이름) 
            ); 
            _this.level = 레벨;
            반환 _this을; 
        } 

        _createClass (몽고는 [ 
            { 
                키「먹는다」, 
                값 : 함수 먹는다 () { 
                    CONSOLE.LOG를 (
                        _GET (_getPrototypeOf (Mongo.prototype), "이름" 이 )
                         이 .name을 
                    ); 
                } 
            } 
        ]); 

        반환 몽고을; 
    })(과일);