Nodejs verwendet Readline, um zur Eingabe von Beispielcode für Inhalte aufzufordern

@echo aus
setze curpath=%~dp0
%curpath%nodejs\node.exe %curpath%buildVersion.js
Pause

const readline = erforderlich('readline');
const rl = readline.createInterface({
    Eingabe: process.stdin,
    Ausgabe: process.stdout,
});
rl.question(`Bitte geben Sie die neue Versionsnummer ein: `, (Name) => {

});

// Versionsinformationen abrufen, die im dritten Schritt implementiert werden var versionInfo;
const versionInfoUrl = './src/config/version/version.js';
Funktion getVersion() {
    var BuildVersion = "";
    versuchen {
        versionInfo = erforderlich(versionInfoUrl);
        BuildVersion = Versionsinfo.Version;
    } Fehler abfangen {

    }
    BuildVersion zurückgeben;
}

const chalk = require('chalk'); // Farbbibliothek importieren rl.question(`${chalk.cyan("Aktuelle Versionsnummer: ")}${chalk.bold.red(getVersion())} \nBitte geben Sie die neue Versionsnummer ein: `, (name) => {
    !name && (name=versionInfo?versionInfo.version:"");
    console.log(`${chalk.cyan("Die neue Versionsnummer ist: ")}${chalk.bold.yellow(name)}`);

// Standardwert schreiben rl.write("Version")

// Analysieren Sie die von der Bat-Operation übergebenen Parameter. var minimist = require('minimist');
var argv = minimist(prozess.argv.slice(2), {
    Zeichenfolge: ["Name"]
});

const untergeordneter Prozess = erforderlich('untergeordneter Prozess');
rl.question(`${chalk.cyan("Aktuelle Versionsnummer: ")}${chalk.bold.red(getVersion())} \nBitte geben Sie die neue Versionsnummer ein: `, (name) => {
    !name && (name=versionInfo?versionInfo.version:"");
    console.log(`${chalk.cyan("Die neue Versionsnummer ist: ")}${chalk.bold.yellow(name)}`);
    // Notieren Sie die neue Versionsnummer changeVersion(name);
    
    var buildType = argv.buildType || "build" // Der Befehl wird in Gulp konfiguriert var gulpCmd = `gulp ${buildType} --buildVersion "${name}" --color --f ${__dirname}/gulpfile.js`;
    Konsole.log(gulpCmd);
    let spawnProcess = child_process.spawn(gulpCmd, [], {
        Shell: wahr
    });
    spawnProcess.stdout.on('Daten', (Daten) => {
        Konsole.log(`${data.toString()}`);
    });
    spawnProcess.stderr.on('Daten', (Daten) => {
        console.log(`stderror: ${data}`);
    });
    spawnProcess.on('schließen', (Code) => {
        wenn (Code !== 0) {
            console.log(`schließen: $[code]`);
        }
    });
    spawnProcess.on('beenden', (Code) => {
        // console.log(`exit: ${code.toString()}`);
        console.log(chalk.bold.yellow("----------------- Abgeschlossen --------------------"));
    });
});

Funktion changeVersion(params) {
    if (versionInfo && versionInfo.changeVersion) {
        versionInfo.changeVersion(params);
    }
}

let exec = require('Unterprozess').execSync;
exec('vue-cli-service --mode dev build', {
    stdio: "erben"
});

var VersionInfoJson;
// Da in HTML darauf verwiesen werden kann, wird eine Unterscheidung vorgenommen, wenn (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
    getVersionInfo(true);
} anders {
    wenn (Typ der Definition === 'Funktion' und definieren.amd) {
        getVersionInfo(false);
    } anders {
        getVersionInfoLocal();
    }
}

Funktion getVersionInfo(isModule) {
    versuchen {
        VersionInfoJson = erfordern("./version.json");
    } Fehler abfangen {
        VersionInfoJson = {};
    }
    VersionInfoJson.buildTime = getNowFormatDate();
    VersionInfoJson.changeVersion = Version ändern;

    wenn (istModul) {
        module.exports = VersionInfoJson;
    }anders{
        definieren([], Funktion () {
            VersionInfoJson zurückgeben;
        });
    }
}

asynchrone Funktion getVersionInfoLocal() {
    versuchen {
        VersionInfoJson = warte auf getVersionJson();
    } Fehler abfangen {
        VersionInfoJson = {};
    }
    VersionInfoJson.buildTime = getNowFormatDate();
    Fenster.VersionInfo = VersionInfoJson;
}

Funktion getVersionJson() {
    returniere neues Promise((lösen, ablehnen)=>{
        var request = neue XMLHttpRequest();
        Anfrage.öffnen("get", "config/version/version.json");
        Anfrage.senden(null);
        Anfrage.onload = Funktion () {
            wenn (Anfrage.Status == 200) {
                var json = JSON.parse(Anfrage.AntwortText);
                lösen (json);
            }anders{
                var json = {};
                lösen (json);
            }
        }
    });
}

Funktion changeVersion(version) {
    var KopiereVersion = cloneObj(VersionInfoJson);
    KopiereVersion.version = Version;
    if (Version kopieren.hasOwnProperty("Version ändern")) {
        löschen copyVersion["changeVersion"]
    }
    // console.log(Kopierversion, __Verzeichnisname, __Dateiname)
    lass fs = erfordern('fs');
    fs.writeFile(__dirname + "/version.json", JSON.stringify(copyVersion), (err) => {

    });
}

// 1. Verwenden Sie „new obj.constructor()“, um ein leeres Objekt zu erstellen, anstatt {} oder [] zu verwenden, um die Vererbung der Prototypenkette beizubehalten.
// 2. Verwenden Sie obj.hasOwnProperty(key), um zu bestimmen, ob die Eigenschaft aus der Prototypenkette stammt, da for..in.. auch die aufzählbaren Eigenschaften in seiner Prototypenkette durchläuft.
// 3. Die obige Funktion verwendet einen rekursiven Algorithmus. Wenn die Funktion einen Namen hat und sich dieser Name in Zukunft nicht ändert, gibt es mit dieser Definition kein Problem. Das Problem besteht jedoch darin, dass die Ausführung dieser Funktion eng an den Funktionsnamen Fakultät gekoppelt ist. Um diese enge Kopplung zu beseitigen, verwenden Sie arguments.callee.
Funktion KlonObj(Objekt) {
    wenn (obj === null) return null
    wenn (Typ des Objekts !== 'Objekt') returniere Objekt;
    wenn (Objekt.Konstruktor === Datum) neues Datum(Objekt) zurückgeben;
    wenn (Objekt.Konstruktor === RegExp) neues RegExp(Objekt) zurückgeben;
    var newObj = new obj.constructor(); //behalte die Vererbungskette für (var key in obj) {
        if (obj.hasOwnProperty(key)) { //Die Eigenschaften in der Prototypenkette nicht durchlaufen var val = obj[key];
            newObj[key] = typeof val === 'object' ? arguments.callee(val) : val; // Verwenden Sie arguments.callee, um sich vom Funktionsnamen zu entkoppeln}
    }
    gib neuesObjekt zurück;
}

Funktion getNowFormatDate() {
    var date = neues Datum();
    var seperator1 = "-"; // Jahr-, Monat-, Tagesintervall var seperator2 = ":"; // Stunde-, Minute-, Sekundenintervall var month = date.getMonth() + 1;
    var strDate = date.getDate();
    wenn (Monat >= 1 und Monat <= 9) {
        Monat = "0" + Monat;
    }
    wenn (strDate >= 0 und strDate <= 9) {
        strDate = "0" + strDate;
    }
    var currentdate = date.getFullYear() + seperator1 + monat + seperator1 + strDate +
        " " + date.getHours() + seperator2 + date.getMinutes() +
        seperator2 + date.getSeconds();
    aktuelles Datum zurückgeben;
}

var minimist = erforderlich('minimist');
var argv = minimist(prozess.argv.slice(2), {
    Zeichenfolge: ["Name"]
});

Konsole.log(argv.BuildVersion)