TypeScript Object.extend方法代碼示例

function testObserver() {
    Ember.Object.extend({
        valueObserver: Ember.observer('value', function() {
            // Executes whenever the "value" property changes
        })
    });
}

function testOn() {
    let Job = Ember.Object.extend({
        logCompleted: Ember.on('completed', function() {
            console.log('Job completed!');
        })
    });

    let job = Job.create();

    Ember.sendEvent(job, 'completed'); // Logs 'Job completed!'
}

function testEvented() {
    let Person = Ember.Object.extend(Ember.Evented, {
        greet() {
            this.trigger('greet');
        }
    });

    let person = Person.create();

    person.on('greet', function() {
        console.log('Our person has greeted');
    });

    person.on('greet', function() {
        console.log('Our person has greeted');
    }).one('greet', function() {
        console.log('Offer one-time special');
    }).off('event', {}, function() {});

    person.greet();
}

(() => {
    /** typeOf */
    Ember.typeOf();                       // $ExpectType "undefined"
    Ember.typeOf(null);                   // $ExpectType "null"
    Ember.typeOf(undefined);              // $ExpectType "undefined"
    Ember.typeOf('michael');              // $ExpectType "string"
    // tslint:disable-next-line:no-construct
    Ember.typeOf(new String('michael'));  // $ExpectType "string"
    Ember.typeOf(101);                    // $ExpectType "number"
    // tslint:disable-next-line:no-construct
    Ember.typeOf(new Number(101));        // $ExpectType "number"
    Ember.typeOf(true);                   // $ExpectType "boolean"
    // tslint:disable-next-line:no-construct
    Ember.typeOf(new Boolean(true));      // $ExpectType "boolean"
    Ember.typeOf(() => 4);                // $ExpectType "function"
    Ember.typeOf([1, 2, 90]);             // $ExpectType "array"
    Ember.typeOf(/abc/);                  // $ExpectType "regexp"
    Ember.typeOf(new Date());             // $ExpectType "date"
    Ember.typeOf(({} as any) as FileList);  // $ExpectType "filelist"
    Ember.typeOf(Ember.Object.extend());   // $ExpectType "class"
    Ember.typeOf(Ember.Object.create());   // $ExpectType "instance"
    Ember.typeOf(new Error('teamocil'));  // $ExpectType "error"
    Ember.typeOf((new Date()) as RegExp | Date); // "regexp" | "date"
})();

import Ember from 'ember';
import { assertType } from "./lib/assert";

let App = Ember.Application.create({
    customEvents: {
        paste: 'paste'
    }
});

App.initializer({
    name: 'my-initializer',
    initialize(app) {
        app.register('foo:bar', Ember.Object.extend({ foo: 'bar' }));
    }
});

App.instanceInitializer({
    name: 'my-instance-initializer',
    initialize(app) {
        app.lookup('foo:bar').get('foo');
    }
});

let App2 = Ember.Application.create({
    customEvents: {
        mouseenter: null,
        mouseleave: null
    }
});

    firstName: 'Barack',
    lastName: 'Obama',
    fullName: Ember.computed(function() {
        return `${this.get('firstName')} ${this.get('lastName')}`;
    }),
});
App.president.get('fullName');

declare class MyPerson extends Ember.Object {
    static createMan(): MyPerson;
}
MyPerson.createMan();

const Person1 = Ember.Object.extend({
    say: (thing: string) => {
        alert(thing);
    },
});

declare class MyPerson2 extends Ember.Object {
    helloWorld(): void;
}
MyPerson2.create().helloWorld();

const tom = Person1.create({
    name: 'Tom Dale',
    helloWorld() {
        this.say('Hi my name is ' + this.get('name'));
    },
});
tom.helloWorld();

import Ember from 'ember';
import { assertType } from './lib/assert';

const ExtendClass = Ember.Object.extend({
    foo: 'hello'
});

class ES6Class extends Ember.Object {
    bar: string;
}

let TestClass = Ember.Object;

if (ExtendClass.detect(TestClass)) {
    assertType<string>(TestClass.create().foo);
}

if (ES6Class.detect(TestClass)) {
    assertType<string>(TestClass.create().bar);
}

const Person = Ember.Object.extend({
    firstName: '',
    lastName: '',
    age: 0,

    noArgs: Ember.computed<string>(() => 'test'),

    fullName: Ember.computed<string>('firstName', 'lastName', function() {
        return `${this.get('firstName')} ${this.get('lastName')}`;
    }),

    fullNameReadonly: Ember.computed<string>('fullName', function() {
        return this.get('fullName');
    }).readOnly(),

    fullNameWritable: Ember.computed<string>('firstName', 'lastName', {
        get() {
            return this.get('fullName');
        },
        set(key, value) {
            const [first, last] = value.split(' ');
            this.set('firstName', first);
            this.set('lastName', last);
            return value;
        }
    }),

    fullNameGetOnly: Ember.computed<string>('fullName', {
        get() {
            return this.get('fullName');
        }
    }),

    fullNameSetOnly: Ember.computed<string>('firstName', 'lastName', {
        set(key, value) {
            const [first, last] = value.split(' ');
            this.set('firstName', first);
            this.set('lastName', last);
            return value;
        }
    }),

    combinators: Ember.computed<string>(function() {
        return this.get('firstName');
    }).property('firstName')
      .meta({ foo: 'bar' })
      .volatile()
      .readOnly(),

    explicitlyDeclared: alias('fullName') as Computed<string>,
});

            this.edit();
        }
    }
});

const comment = EditableComment.create({
    postId: 42
});

comment.edit();
comment.canEdit();
comment.tryEdit();
assertType<boolean>(comment.isEditing);
assertType<number>(comment.postId);

const LiteralMixins = Ember.Object.extend({ a: 1 }, { b: 2 }, { c: 3 });
const obj = LiteralMixins.create();
assertType<number>(obj.a);
assertType<number>(obj.b);
assertType<number>(obj.c);

/* Test composition of mixins */
const EditableAndCancelableMixin = Ember.Mixin.create(EditableMixin, {
    cancelled: false,
});

const EditableAndCancelableComment = Ember.Route.extend(EditableAndCancelableMixin);

const editableAndCancelable = EditableAndCancelableComment.create();
assertType<boolean>(editableAndCancelable.isEditing);
assertType<boolean>(editableAndCancelable.cancelled);

import Ember from 'ember';
import { assertType } from './lib/assert';

type Person = typeof Person.prototype;
const Person = Ember.Object.extend({
    name: '',
    isHappy: false
});

const people = Ember.A([
    Person.create({ name: 'Yehuda', isHappy: true }),
    Person.create({ name: 'Majd', isHappy: false }),
]);

assertType<number>(people.get('length'));
assertType<Person>(people.get('lastObject'));
assertType<boolean>(people.isAny('isHappy'));
assertType<boolean>(people.isAny('isHappy', 'false'));
assertType<Ember.Enumerable<Person>>(people.filterBy('isHappy'));
assertType<Ember.Enumerable<Person>>(people.rejectBy('isHappy'));
assertType<Ember.Enumerable<Person>>(people.filter((person) => person.get('name') === 'Yehuda'));
assertType<typeof people>(people.get('[]'));
assertType<Person>(people.get('[]').get('firstObject'));

assertType<Ember.Array<boolean>>(people.mapBy('isHappy'));
assertType<any[]>(people.mapBy('name.length'));

const last = people.get('lastObject');
if (last) {
    assertType<string>(last.get('name'));
}