def decorator(f):
 print "my decorator"
 return f
@decorator
def myfunc():
 print "my function"
myfunc()
# my decorator
# my function

def decorator(f):
 def wrapper():
 print "my decorator"
 return f()
 return wrapper
def myfunc():
 print "my function"
myfunc = decorator(myfuc)

Object.defineProperty(obj, prop, descriptor)

@testable
class MyTestableClass {
 // ...
}
function testable(target) {
 target.isTestable = true;
}
MyTestableClass.isTestable // true

@decorator
class A {}
// 等同于
class A {}
A = decorator(A) || A;

function testable(isTestable) {
 return function(target) {
 target.isTestable = isTestable;
 }
}
@testable(true)
class MyTestableClass {}
MyTestableClass.isTestable // true
@testable(false)
class MyClass {}
MyClass.isTestable // false

// mixins.js
export function mixins(...list) {
 return function (target) {
 Object.assign(target.prototype, ...list)
 }
}
// main.js
import { mixins } from './mixins'
const Foo = {
 foo() { console.log('foo') }
};
@mixins(Foo)
class MyClass {}
let obj = new MyClass();
obj.foo() // 'foo'

class Person {
 @readonly
 name() { return `${this.first} ${this.last}` }
}

function readonly(target, name, descriptor){
 // descriptor對象原來的值如下
 // {
 // value: specifiedFunction,
 // enumerable: false,
 // configurable: true,
 // writable: true
 // };
 descriptor.writable = false;
 return descriptor;
}
readonly(Person.prototype, 'name', descriptor);
// 類似于
Object.defineProperty(Person.prototype, 'name', descriptor);

function doSomething(name) {
 console.log('Hello, ' + name);
}
function loggingDecorator(wrapped) {
 return function() {
 console.log('Starting');
 const result = wrapped.apply(this, arguments);
 console.log('Finished');
 return result;
 }
}
const wrapped = loggingDecorator(doSomething);

import { override } from 'core-decorators';
class Parent {
 speak(first, second) {}
}
class Child extends Parent {
 @override
 speak() {}
 // SyntaxError: Child#speak() does not properly override Parent#speak(first, second)
}
// or
class Child extends Parent {
 @override
 speaks() {}
 // SyntaxError: No descriptor matching Child#speaks() was found on the prototype chain.
 //
 // Did you mean "speak"?
}

import { deprecate } from 'core-decorators';
class Person {
 @deprecate
 facepalm() {}
 @deprecate('We stopped facepalming')
 facepalmHard() {}
 @deprecate('We stopped facepalming', { url: 'http://knowyourmeme.com/memes/facepalm' })
 facepalmHarder() {}
}
let person = new Person();
person.facepalm();
// DEPRECATION Person#facepalm: This function will be removed in future versions.
person.facepalmHard();
// DEPRECATION Person#facepalmHard: We stopped facepalming
person.facepalmHarder();
// DEPRECATION Person#facepalmHarder: We stopped facepalming
//
// See http://knowyourmeme.com/memes/facepalm for more details.
//

@testable
class Person {
 @readonly
 @nonenumerable
 name() { return `${this.first} ${this.last}` }
}

@connect(mapStateToProps, mapDispatchToProps)
export default class MyReactComponent extends React.Component {}

/**
 * @description 在點(diǎn)擊時，如果有新功能提醒，則彈窗顯示
 * @param code 新功能的code
 * @returns {function(*, *, *)}
 */
 const checkRecommandFunc = (code) => (target, property, descriptor) => {
 let desF = descriptor.value; 
 descriptor.value = function (...args) {
 let recommandFuncModalData = SYSTEM.recommandFuncCodeMap[code];
 if (recommandFuncModalData && recommandFuncModalData.id) {
 setTimeout(() => {
 this.props.dispatch({type: 'global/setRecommandFuncModalData', recommandFuncModalData});
 }, 1000);
 }
 desF.apply(this, args);
 };
 return descriptor;
 };

@autobind
@loadingWrap(true)
async handleSelect(params) {
 await this.props.dispatch({
 type: 'product_list/setQuerypParams',
 querypParams: params
 });
}

export function loadingWrap(needHide) {
 const defaultLoading = (
 <p className="toast-loading">
 <Loading className="loading-icon"/>
 <p>加載中...</p>
 </p>
 );
 return function (target, property, descriptor) {
 const raw = descriptor.value;
 
 descriptor.value = function (...args) {
 Toast.info(text || defaultLoading, 0, null, true);
 const res = raw.apply(this, args);
 
 if (needHide) {
 if (get('finally')(res)) {
 res.finally(() => {
 Toast.hide();
 });
 } else {
 Toast.hide();
 }
 }
 };
 return descriptor;
 };
}