node.js - Typescript å kjøre toString på en funksjon resulterer i merkelige tegn (path_1, (0, promises.writeFile))

Jeg prøver å konvertere en funksjon til en streng for å sende den til en arbeidstråd og kjøre den der. Men strengen inneholder merkelige tegn når importert kode brukes.

import { HttpStatus } from '@nestjs/common';
import { access, constants, writeFile } from 'fs/promises';
import path from 'path';
import { Error as CustomError } from 'src/util/Error';
import { AbstractTask } from 'src/util/queue/AbstractTask';

export class CreateFileTask extends AbstractTask<boolean> {
    private path: string;

    private buffer: Buffer;

    constructor(path: string, buffer: Buffer) {
        super();

        this.path = path;
        this.buffer = buffer;
    }

    public async execute(): Promise<boolean> {
        return new Promise(async (resolve, reject) => {
            let resolvedPath = path.resolve(this.path);

            try {
                await access(resolvedPath, constants.F_OK);
            } catch (e) {
                reject(new CustomError(`file at ${this.path} already exists`, HttpStatus.CONFLICT));
            }

            try {
                await writeFile(resolvedPath, this.buffer);
            } catch (e) {
                if (e instanceof Error) {
                    reject(new CustomError(e.message, HttpStatus.INTERNAL_SERVER_ERROR));
                } else {
                    reject(new CustomError(e as string, HttpStatus.INTERNAL_SERVER_ERROR));
                }
            }

            resolve(true);
        });
    }
}

Å kalle new CreateFileTask(...).execute.toString() resulterer i merkelige tegn:

execute() {
    return new Promise(async (resolve, reject) => {
        let resolvedPath = path.resolve(this.path);
        try {
            await (0, promises_1.access)(resolvedPath, promises_1.constants.F_OK);
        }
        catch (e) {
            reject(new Error_1.Error(`file at ${this.path} already exists`, common_1.HttpStatus.CONFLICT));
        }
        try {
            await (0, promises_1.writeFile)(resolvedPath, this.buffer);
        }
        catch (e) {
            if (e instanceof Error) {
                reject(new Error_1.Error(e.message, common_1.HttpStatus.INTERNAL_SERVER_ERROR));
            }
            else {
                reject(new Error_1.Error(e, common_1.HttpStatus.INTERNAL_SERVER_ERROR));
            }
        }
        resolve(true);
    });
}

Å bruke import * as path from "path" ser ut til å fikse det for path-modulen. Hvorfor er det slik? Finnes det noen annen løsning i stedet for å bruke import * as ... from ... altså importere alt selv om det ikke trengs?

Svar #1

De «rare tegnene» er den kompilerte versjonen av koden din som er output fra bundleren din, og det som faktisk kjører. Men det er ikke det egentlige problemet her.

Jeg prøver å konvertere en funksjon til en streng for å sende den til en arbeidstråd og kjøre den der.

Du kan ikke konvertere en funksjon til en streng og forvente at den kan kjøres på den andre siden. Så ikke prøv å kode funksjoner og sende dem som strenger.

For at du skal kunne sende en funksjon for å utføre, må du sende alle verdier som brukes i den funksjonen fra omfanget til den funksjonen. Og det er egentlig ikke praktisk.

For eksempel:

const foo = 123
function logFoo() { console.log(foo) }
console.log(logFoo.toString()) // "function logFoo() { console.log(foo) }"

Her blir logFoo konvertert til en streng helt fint, men den refererer til en lokal variabel foo som ikke er inkludert i utdata-strengen. Så dette vil sannsynligvis krasje hvis du prøver å eval og kjøre den.

Dette problemet er mye verre hvis du har importerte filer fra andre filer, eller en klassereferanse som this.something.

Så denne tilnærmingen kommer bare ikke til å fungere. Ikke gjør dette.

Last i stedet koden din inn i arbeideren, og send deretter meldinger til den som inneholder dataene selv.

Relaterte artikler