Hoppa till huvudinnehållet

API

Inofficiell Beta-översättning

Denna sida har översatts av PageTurner AI (beta). Inte officiellt godkänd av projektet. Hittade du ett fel? Rapportera problem →

Om du vill köra Prettier programmatiskt, kolla in den här sidan.

import * as prettier from "prettier";

Våra publika API:er är alla asynkrona. Om du av någon anledning måste använda en synkron version kan du prova @prettier/sync.

prettier.format(source, options)​

format används för att formatera text med Prettier. options.parser måste anges enligt det språk du formaterar (se listan över tillgängliga parsers). Alternativt kan options.filepath anges så att Prettier kan härleda parsern från filtillägget. Andra alternativ kan anges för att åsidosätta standardvärdena.

await prettier.format("foo ( );", { semi: false, parser: "babel" });
// -> 'foo()\n'

prettier.check(source [, options])​

check kontrollerar om filen är formaterad enligt angivna alternativ och returnerar ett Promise<boolean>. Detta liknar parametrarna --check eller --list-different i CLI:n och är användbart för att köra Prettier i CI-scenarion.

prettier.formatWithCursor(source [, options])​

formatWithCursor formaterar både koden och översätter en markörposition från oformaterad till formaterad kod. Detta är användbart för redigerarintegrationer för att förhindra att markören flyttas när koden formateras.

Alternativet cursorOffset bör anges för att specificera var markören befinner sig.

await prettier.formatWithCursor(" 1", { cursorOffset: 2, parser: "babel" });
// -> { formatted: '1;\n', cursorOffset: 1 }

prettier.resolveConfig(fileUrlOrPath [, options])​

resolveConfig används för att lösa konfiguration för en given källfil genom att skicka dess sökväg eller URL som första argument. Konfigurationssökningen börjar i filens katalog och fortsätter uppåt i katalogstrukturen. Du kan också direkt ange sökvägen till konfigurationsfilen som options.config om du inte vill söka efter den. Ett löfte returneras som kommer att lösas till:

  • Ett alternativsobjekt, om en konfigurationsfil hittades.

  • null om ingen fil hittades.

Löftet kommer att avvisas om det uppstod ett fel vid tolknigen av konfigurationsfilen.

Om options.useCache är false kommer all cachelagring att kringgås.

const text = await fs.readFile(filePath, "utf8");
const options = await prettier.resolveConfig(filePath);
const formatted = await prettier.format(text, {
  ...options,
  filepath: filePath,
});

Om options.editorconfig är true och en .editorconfig-fil finns i ditt projekt kommer Prettier att tolka den och konvertera dess egenskaper till motsvarande Prettier-konfiguration. Denna konfiguration kommer att åsidosättas av .prettierrc, etc. För närvarande stöds följande EditorConfig-egenskaper:

  • end_of_line

  • indent_style

  • indent_size/tab_width

  • max_line_length

prettier.resolveConfigFile([fileUrlOrPath])​

resolveConfigFile används för att hitta sökvägen till Prettier-konfigurationsfilen som kommer att användas vid konfigurationslösning (dvs. när resolveConfig anropas). Ett löfte returneras som kommer att lösas till:

  • Sökvägen till konfigurationsfilen.

  • null om ingen fil hittades.

Löftet kommer att avvisas om det uppstod ett fel vid tolknigen av konfigurationsfilen.

Sökningen börjar vid process.cwd(), eller i katalogen för fileUrlOrPath om den anges.

const configFile = await prettier.resolveConfigFile(filePath);
// you got the path of the configuration file

prettier.clearConfigCache()​

När Prettier laddar konfigurationsfiler och pluginmoduler cachelagras filsystemets struktur för prestanda. Denna funktion rensar cachen. Generellt sett behövs detta endast för redigerarintegrationer som vet att filsystemet har ändrats sedan senaste formateringen.

prettier.getFileInfo(fileUrlOrPath [, options])​

getFileInfo kan användas av redigerartillägg för att avgöra om en specifik fil behöver formateras. Metoden returnerar ett löfte (promise) som löser till ett objekt med följande egenskaper:

{
  ignored: boolean;
  inferredParser: string | null;
}

Löftet kommer att avvisas om typen av fileUrlOrPath inte är string eller URL.

Inställningen av options.ignorePath (string | URL | (string | URL)[]) och options.withNodeModules (boolean) påverkar värdet av ignored (false som standard).

Om den angivna fileUrlOrPath ignoreras är inferredParser alltid null.

Att ange tilläggs-sökvägar i options.plugins ((string | URL | Plugin)[]) hjälper till att extrahera inferredParser för filer som inte stöds av Prettier-kärnan.

När options.resolveConfig (boolean, standard true) sätts till false kommer Prettier inte att söka efter konfigurationsfiler. Detta kan vara användbart om funktionen endast används för att kontrollera om en fil ignoreras.

prettier.getSupportInfo()​

Returnerar ett löfte som löser till ett objekt som representerar de alternativ, parsrar, språk och filtyper som Prettier stöder.

Stödinformationen ser ut så här:

{
  languages: Array<{
    name: string;
    parsers: string[];
    group?: string;
    tmScope?: string;
    aceMode?: string;
    codemirrorMode?: string;
    codemirrorMimeType?: string;
    aliases?: string[];
    extensions?: string[];
    filenames?: string[];
    linguistLanguageId?: number;
    vscodeLanguageIds?: string[];
    isSupported?(options: { filepath: string }): boolean;
  }>;
}

Prettier kan inte garantera att filepath finns på disken.
Vid användning från API:er (t.ex. prettier.format()) kan Prettier heller inte garantera att det är en giltig sökväg.

Anpassat parsergränssnitt (borttaget)​

Borttaget i v3.0.0 (ersatt av Tilläggsgränssnittet)

Innan tillägg fanns hade Prettier en liknande men mer begränsad funktion kallad anpassade parsrar. Den har tagits bort i v3.0.0 eftersom dess funktionalitet var en delmängd av vad Tilläggsgränssnittet erbjuder. Om du använde det, se exemplet nedan för migrering.

❌ Anpassat parsergränssnitt (borttaget):

import { format } from "prettier";

format("lodash ( )", {
  parser(text, { babel }) {
    const ast = babel(text);
    ast.program.body[0].expression.callee.name = "_";
    return ast;
  },
});
// -> "_();\n"

✔️ Tilläggsgränssnitt:

import { format } from "prettier";
import * as prettierPluginBabel from "prettier/plugins/babel";

const myCustomPlugin = {
  parsers: {
    "my-custom-parser": {
      async parse(text) {
        const ast = await prettierPluginBabel.parsers.babel.parse(text);
        ast.program.body[0].expression.callee.name = "_";
        return ast;
      },
      astFormat: "estree",
    },
  },
};

await format("lodash ( )", {
  parser: "my-custom-parser",
  plugins: [myCustomPlugin],
});
// -> "_();\n"

Generellt rekommenderas inte den här typen av kodmodifieringar. Prettier använder platsinformation från AST-noder för att bevara tomma rader och kommentarer. När AST:n modifieras efter parsning kan platsinformationen bli inkonsekvent, vilket kan ge oförutsägbara resultat. Överväg att använda jscodeshift för kodmodifieringar.

Som del av det borttagna anpassade parsergränssnittet gick det tidigare att skicka en sökväg till en modul som exporterar en parse-funktion via --parser-flaggan. Använd --plugin-CLI-flaggan eller plugins-API-alternativet istället för att läsa in tillägg.