TypeScript => Importera externa bibliotek

Syntax

import {component} from 'libName'; // Will import the class "component"
import {component as c} from 'libName'; // Will import the class "component" into a "c" object
import component from 'libname'; // Will import the default export from libName
import * as lib from 'libName'; // Will import everything from libName into a "lib" object
import lib = require('libName'); // Will import everything from libName into a "lib" object
const lib: any = require('libName'); // Will import everything from libName into a "lib" object
import 'libName'; // Will import libName module for its side effects only

Anmärkningar

Det kan verka som syntaxen

import * as lib from 'libName';

och

import lib = require('libName');

är samma sak, men de är inte!

Låt oss anser att vi vill importera en klass Person exporteras med skrivmaskin specifika export = syntax:

class Person {
...
}
export = Person;

I det här fallet är det inte möjligt att importera det med syntaks es6 (vi skulle få ett fel vid kompileringstid), TypeScript-specifik import = syntax måste användas.

import * as Person from 'Person';  //compile error
import Person = require('Person');  //OK

Konversationen är sant: klassiska moduler kan importeras med den andra syntaxen, så på ett sätt är den sista syntaxen kraftigare eftersom den kan importera all export.

För mer information se den officiella dokumentationen .

Importera en modul från npm

Om du har en typdefinitionsfil (d.ts) för modulen kan du använda ett import .

import _ = require('lodash');

Om du inte har en definitionsfil för modulen kommer TypeScript att kasta ett fel vid sammanställningen eftersom den inte kan hitta den modul du försöker importera.

I det här fallet kan du importera modulen med den normala funktionen för körning require . Detta returnerar det dock som any typ.

// The _ variable is of type any, so TypeScript will not perform any type checking.
const _: any = require('lodash');

Från TypeScript 2.0 kan du också använda en kortfattad omgivande moduldeklaration för att berätta för TypeScript att en modul finns när du inte har en typdefinitionsfil för modulen. TypScript kan dock inte tillhandahålla någon meningsfull typkontroll i det här fallet.

declare module "lodash";

// you can now import from lodash in any way you wish:
import { flatten } from "lodash";
import * as _ from "lodash";

Från TypeScript 2.1 har reglerna avspännats ytterligare. Så länge en modul finns i din node_modules katalog, låter TypeScript dig importera den, även utan moduldeklaration någonstans. (Observera att om du använder kompilatoralternativet --noImplicitAny , kommer nedanstående fortfarande att generera en varning.)

// Will work if `node_modules/someModule/index.js` exists, or if `node_modules/someModule/package.json` has a valid "main" entry point
import { foo } from "someModule";

Hitta definitionfiler

för typskript 2.x:

definitioner från DefinitelyTyped finns tillgängliga via @types npm- paketet

npm i --save lodash
npm i --save-dev @types/lodash

men om du vill använda typer från andra repor kan de användas på gamla sätt:

för typskript 1.x:

Typings är ett npm-paket som automatiskt kan installera typdefinitionsfiler i ett lokalt projekt. Jag rekommenderar att du läser snabbstart .

npm install -global typings

Nu har vi tillgång till typ Cli.

Det första steget är att söka efter det paket som används av projektet

typings search lodash
NAME              SOURCE HOMEPAGE                                        DESCRIPTION VERSIONS UPDATED
lodash            dt     http://lodash.com/                                          2        2016-07-20T00:13:09.000Z
lodash            global                                                             1        2016-07-01T20:51:07.000Z
lodash            npm    https://www.npmjs.com/package/lodash                        1        2016-07-01T20:51:07.000Z

Bestäm sedan vilken källa du ska installera från. Jag använder dt som står för DefinitelyTyped en GitHub-repo där gemenskapen kan redigera typsnitt, det är också normalt det senast uppdaterade.

Installera typfilerna

 typings install dt~lodash --global --save

Låt oss bryta ner det sista kommandot. Vi installerar DefinitelyTyped-versionen av lodash som en global typfil i vårt projekt och sparar den som ett beroende i typings.json . Oavsett var vi importerar lodash, laddar typsnittet lodash-typfilen.

Om vi vill installera typsnitt som endast kommer att användas för utvecklingsmiljö kan vi tillhandahålla --save-dev :
```
 typings install chai --save-dev
```

Använda globala externa bibliotek utan typsnitt

Även moduler är ideal, om biblioteket som du använder refereras av en global variabel (som $ eller _), eftersom det var lastad med en script -tagg kan du skapa en omgivande deklaration för att hänvisa till det:

declare const _: any;

Hitta definitionsfiler med typskript 2.x

Med 2.x-versionerna av typskriptet finns nu typsnitt tillgängliga från npm @types-arkivet . Dessa upplöses automatiskt av typskriptkompileraren och är mycket enklare att använda.

För att installera en typdefinition installerar du den helt enkelt som ett beroende i ditt projekt package.json

t.ex

npm i -S lodash
npm i -D @types/lodash

efter installationen använder du helt enkelt modulen som tidigare

import * as _ from 'lodash'

Modified text is an extract of the original Stack Overflow Documentation

Licensierat under CC BY-SA 3.0

Inte anslutet till Stack Overflow

TypeScript
Importera externa bibliotek

Sök…