Wat doet ‘declareren’ in ‘export declareren class Actions’?

Waarom hebben we de declarein de verklaring nodig?

export declare class Actions {
    ...
}

Antwoord 1, autoriteit 100%

vond wat ik zocht:

Declareren vs. var

varmaakt een nieuwe variabele aan. declarewordt gebruikt om TypeScript te laten weten dat de variabele ergens anders is gemaakt. Als u declaregebruikt, wordt er niets toegevoegd aan het JavaScript dat wordt gegenereerd – het is gewoon een hint voor de compiler.

Als u bijvoorbeeld een extern script gebruikt dat var externalModuledefinieert, gebruikt u declare var externalModuleom de TypeScript-compiler te laten weten dat externalModuleis al ingesteld

Antwoord 2, autoriteit 45%

Om dit te begrijpen, moet u eerst het trefwoord “declare” begrijpen.

Hier is een goede uitleg van Gil Fink’s Blog:

Het trefwoord TypeScript declare wordt gebruikt om variabelen te declareren die mogelijk niet afkomstig zijn uit een TypeScript-bestand.

Stel je bijvoorbeeld voor dat we een bibliotheek hebben met de naam myLibrary die geen TypeScript-declaratiebestand heeft en een naamruimte met de naam myLibrary in de globale naamruimte. Als u die bibliotheek in uw TypeScript-code wilt gebruiken, kunt u de volgende code gebruiken:

declare var myLibrary;

Het type dat de TypeScript-runtime aan de myLibrary-variabele zal geven, is het willekeurig type. Het probleem hier is dat je geen Intellisense voor die variabele hebt in de ontwerptijd, maar je kunt de bibliotheek in je code gebruiken. Een andere optie om hetzelfde gedrag te vertonen zonder het trefwoord declare te gebruiken, is door gewoon een variabele met het type any te gebruiken:

var myLibrary: any;

Beide codevoorbeelden resulteren in dezelfde JavaScript-uitvoer, maar het declaratievoorbeeld is beter leesbaar en drukt een ambientverklaring uit.

Dus nadat u het trefwoord “declare” heeft begrepen, gaat u terug naar de plaats waar u de

export declare class Action{
...
}

De echte implementatie van de klasse bevindt zich waarschijnlijk ergens anders, misschien een .js-bestand.

Antwoord 3, autoriteit 21%

declarein typoscript:

Het trefwoord declarein typoscript is handig om de typoscript-compiler te vertellen dat een declaratieergens anders is gedefinieerd (ergens geschreven in een extern javascript-bestand of in een deel van de runtime-omgeving ).

Stel dat we ergens anders een variabele genaamd foo hebben gedeclareerd. Wanneer we vervolgens proberen te verwijzen naar de variabele, zal de typoscript-compiler een foutmelding geven:

foo = 'random'; // Error: 'foo' is not defined

We kunnen dit probleem oplossen met het trefwoord declare:

declare var foo: string;
foo = 'random';  // no error anymore

Dit heeft de volgende gevolgen:

• Als fooeigenlijk nergens anders wordt gedeclareerd, en we proberen de variabele te gebruiken, kan er een runtime-fout optreden. Gebruik dus alleen het trefwoord declareals u weet dat de variabele op dit moment beschikbaar is.
• Omdat we de typen kennen, krijgen we (mogelijk) toegang tot onze IDE Intellisense.
• Omdat we de typen kennen, kan de typoscript-compiler de typen tijdens het compileren controlerenen kan hij ons waarschuwen als we in bepaalde scenario’s de verkeerde typen gebruiken.

Antwoord 4, autoriteit 9%

Het trefwoord declarein dit specifieke geval:

export declare class Actions {
    ...
}

… is blijkbaar nutteloos en ik denk dat TypeScript zou moeten overwegen om dit een fout te maken (ik weet niet of er een verborgen reden is). Als u een klasse declareert, hoeft u deze nooit te importeren. Als u een klasse exporteert en verwacht dat iemand deze importeert, hoeft u deze niet te declareren. En omdat u deze klasse declareert, moet deze klasse per definitie bruikbaar zijn zonder dat u deze hoeft te importeren. Maar dit is niet waar wanneer u een klasse exporteert declareert. Je moethet importeren om het te kunnen gebruiken.

TL;DR

export declare class Actions {
    ...
}

is hetzelfde als

declare class Actions {
    ...
}

Antwoord 5, autoriteit 5%

declare– zonder enige import- of exportsleutelwoorden – definieert aangiftebestanden die automatisch worden gekozen door TypeScript, wat een handige functie is om typen toe te voegen aan oudere modules (npm geïnstalleerde pakketten zonder TypeScript-definities).

import/ exportis de juiste manier om modules te gebruiken, en alles moet handmatig (en dat vind ik een beetje vervelend) geïmporteerd worden, of het is logisch, of het is definities.

Als praktisch gebruiksvoorbeeld, kunt u met export declarevoorkomen dat u alle subelementen exporteert, bijvoorbeeld:

export declare namespace Redux {
    namespace Store {
        interface Definition { ... }
    }
}

Wat misschien makkelijker te lezen is dan:

export namespace Redux {
    export namespace Store {
        export interface Definition { ... }
    }
}

De externe import is in beide gevallen hetzelfde (bijv. import { Redux } from 'definitions/redux';), waarvan ik niet weet of het een goede gewoonte is of niet, maar ik vind het netjes! ^^

Het is belangrijk om te onthouden dat het toevoegen van een importof exportaan uw bestand het tot een module zal promoveren, daarom de declarescope zal niet meer op mondiaal niveau zijn.

PS, er is een fout opgetreden (probleem 16671): als u const enumin uw declaratie (ik doe dat voor het type redux-acties) en u specificeerde de transpileOnly-vlag (create-react-app-typescriptpakket doet , daarom weet ik het), wordt de opsomming niet inline gezet! Je kunt erin rennen, misschien niet, maar het is handig om het van tevoren te weten!