Construiește un obiect funcție cu proprietăți dactilografiat

Actualizare: Acest răspuns a fost cea mai bună soluție în versiunile anterioare dactilografiate, dar există opțiuni mai bune disponibile în versiuni mai noi (a se vedea alte răspunsuri).

Răspunsul acceptat funcționează și ar putea fi necesare în anumite situații, dar au dezavantajul de a oferi nici o siguranță de tip pentru construirea obiectului. Aceasta tehnica va arunca cel puțin o eroare de tip dacă încercați să adăugați o proprietate nedefinită.

interface F { (): any; someValue: number; }

var f = <F>function () { }
f.someValue = 3

// type error
f.notDeclard = 3

Typescript este proiectat să se ocupe de acest caz , prin declarație contopire :

ar putea fi, de asemenea, familiarizat cu practica JavaScript de a crea o funcție și apoi se extinde funcția prin adăugarea de proprietăți pe funcția. Typescript folosește declarația fuzionare pentru a construi definiții ca acest lucru într-un mod de tip în condiții de siguranță.

Declarația fuzionare ne permite să spunem că ceva este în același timp o funcție și un spațiu de nume (modul intern):

function f() { }
namespace f {
    export var someValue = 3;
}

Acest lucru păstrează dactilografiere și ne permite să scrie atât f()și f.someValue. Când scrieți un .d.tsfișier de cod JavaScript existent, utilizați declare:

declare function f(): void;
declare namespace f {
    export var someValue: number;
}

Adăugarea de proprietăți la funcții este de multe ori un model confuz sau neașteptate dactilografiat, așa că încercați să-l evite, dar poate fi necesară atunci când se utilizează sau o conversie mai vechi cod de JS. Aceasta este una dintre singurele momente în care ar fi oportun să se amestece module interne () cu spații de nume externe.

Acest lucru este ușor de realizat acum (dactilografiat 2.x), cu Object.assign(target, source)

exemplu:

Magia aici este că Object.assign<T, U>(...)este tastat să returneze o intersecție tip de T & U.

Aplicarea că aceasta rezolvă într-o interfață de cunoscut este, de asemenea, drept înainte:

interface Foo {
  (a: number, b: string): string[];
  foo: string;
}

let method: Foo = Object.assign(
  (a: number, b: string) => { return a * a; },
  { foo: 10 }
); 

Eroare: foo: număr nu repartizabile foo: string
Eroare: număr nu repartizabile string [] (tip de retur)

caveat: poate fi necesar să polyfill Object.assign dacă țintirea browsere mai vechi.

Nu pot spune că este foarte simplu, dar este posibil, cu siguranta:

interface Optional {
  <T>(value?: T): OptionalMonad<T>;
  empty(): OptionalMonad<any>;
}

const Optional = (<T>(value?: T) => OptionalCreator(value)) as Optional;
Optional.empty = () => OptionalCreator();

dacă ai curios acest lucru este de la GIST de- al meu cu versiunea typescript / JavaScript deOptional

Un răspuns actualizat: întrucât adăugarea de tipuri de intersecție , prin intermediul &, este posibil să se „fuzioneze“ două tipuri deduse pe zbor.

Iată un ajutor general , care citește proprietățile unui obiect fromși să le copii de peste un obiect onto. Ea se întoarce același obiect , ontodar cu un nou tip , care include ambele seturi de proprietăți, care descrie în mod corect comportamentul de rulare:

function merge<T1, T2>(onto: T1, from: T2): T1 & T2 {
    Object.keys(from).forEach(key => onto[key] = from[key]);
    return onto as T1 & T2;
}

Acest ajutor de nivel scăzut încă nu efectuează o afirmație de tip, dar este de tip sigur prin design. Cu acest ajutor, în loc, avem un operator pe care o putem folosi pentru a rezolva problema PO cu siguranță de tip complet:

interface Foo {
    (message: string): void;
    bar(count: number): void;
}

const foo: Foo = merge(
    (message: string) => console.log(`message is ${message}`), {
        bar(count: number) {
            console.log(`bar was passed ${count}`)
        }
    }
);

Click aici pentru a încerca în typescript Playground . Rețineți că am constrânsă foosă fie de tip Foo, astfel încât rezultatul mergetrebuie să fie completă Foo. Deci , dacă redenumiți barsă badatunci veți obține o eroare de tip.

NB Există încă o gaură tip aici, cu toate acestea. Typescript nu oferă o modalitate de a constrânge un parametru de tip să fie „nu este o funcție“. Deci , ai putea obține confuz și să treacă funcția ta ca al doilea argument merge, și că nu ar funcționa. Deci , până când acest lucru poate fi declarată, trebuie să - l prindem în timpul rulării:

function merge<T1, T2>(onto: T1, from: T2): T1 & T2 {
    if (typeof from !== "object" || from instanceof Array) {
        throw new Error("merge: 'from' must be an ordinary object");
    }
    Object.keys(from).forEach(key => onto[key] = from[key]);
    return onto as T1 & T2;
}

Ca o comandă rapidă, puteți atribui în mod dinamic valoarea obiectului folosind [ „proprietate“] accessor:

var f = function() { }
f['someValue'] = 3;

Aceasta ocolește verificarea de tip. Cu toate acestea, este destul de sigur că aveți pentru a avea acces în mod intenționat proprietatea în același mod:

var val = f.someValue; // This won't work
var val = f['someValue']; // Yeah, I meant to do that

Cu toate acestea, dacă doriți cu adevărat tipul de verificare pentru valoarea proprietății, acest lucru nu va funcționa.

Vechea întrebare, dar pentru versiunile dactilografiate incepand cu 3.1, puteți face pur și simplu atribuirea proprietății așa cum ați face în simplu JS, atâta timp cât utilizați o declarație funcție sau constcuvântul cheie pentru variabila:

function f () {}
f.someValue = 3; // fine
const g = function () {};
g.someValue = 3; // also fine
var h = function () {};
h.someValue = 3; // Error: "Property 'someValue' does not exist on type '() => void'"

De referință și de exemplu on - line .

Acest lucru se îndepărtează de la tastare puternică, dar poți să faci

var f: any = function() { }
f.someValue = 3;

dacă încercarea de a obține tastarea puternic în jurul opresive ca am fost atunci când am găsit această întrebare. Din păcate acest lucru este un caz nu typescript JavaScript perfect validă, astfel că trebuie să-ți spun typescript să renunțe.

„Tu JavaScript este perfect valabil typescript“ evaluează la fals. (Notă: folosind 0,95)