[JAVA] Créez un plugin VSCode.

en premier

Pour le fichier de configuration (fichier de propriétés) de Java9 et des applications antérieures, le japonais (code à 2 octets) ne pouvait pas être utilisé tel quel, et il était nécessaire de le remplacer par un code commençant par '\ u'. J'étais en mesure de maintenir des applications avant Java9, et c'était une tâche fastidieuse et fastidieuse de faire native2ascii chaque fois que j'utilisais VSCode.

Par conséquent, j'ai décidé de créer une fonction équivalente à native2ascii avec le plug-in VScode.

Tout d'abord, créez un environnement pour développer des plugins VS Code. Comment créer un environnement est «Développement de l'extension Visual Studio Code First» de @rma. Veuillez vous référer au.

politique

Pour autant que je puisse voir, je ne pouvais pas lancer la commande sur VSCode ou sélectionner l'événement "lire le fichier de propriétés" (veuillez me donner quelques informations), j'ai donc utilisé la commande VSCode manuellement. Nous avons procédé à la politique de conversion (caractère → codage) et inverse (code → caractère) avec.

Codé

Le codage des caractères → a été réalisé avec le sentiment suivant.

1. Récupérez la chaîne de fichier du document.
2. Répétez ligne par ligne pour obtenir le japonais sous forme d'expression régulière et créez un tableau.
3. Créez un code à partir de la séquence créée en 2. et créez une séquence associative de japonais et de code.
4. Remplacez par la méthode de remplacement sur la ligne d'origine.
5. Créez un nouveau document en collectant les chaînes remplacées.
6. Documents dans l'éditeur 5. Remplacez-le par le document créé dans.

De plus, il ne correspond pas à des caractères de substitution.

function ascii(e: vscode.TextEditor, d: vscode.TextDocument, sel: vscode.Selection[]) {
    console.log(d.getText());
    let text = d.getText();
    let newTest = text.split("\n");
    let replaced = "";
    newTest.forEach(val => {
        let reg = val.match(/([^\x01-\x7E])/g);
        if (reg) {
            let t = reg.map(code => {
                let unicode = code.charCodeAt(0).toString(16);
                return {code, value:`\\u${unicode}`};
            }).reduce( (v,obj) => {
                let {code, value} = obj;
                let reg = new RegExp(code);
                return v.replace(reg, value);
            }, val);
            replaced = `${replaced}${t}\n`; 
        } else {
            replaced = `${replaced}${val}\n`; 
        }
    });
    e.edit((builder)=>{
        if (e) {
            let startPos = e.document.positionAt(0);
            let endPos = e.document.positionAt(text.length);
            let allRange = new vscode.Range(startPos,endPos);
            builder.replace(allRange,replaced);
        }
    });
}

inverser

Ce n'est pas très différent de celui codé. Je crée des personnages à partir d'Unicode.

function reverse(e: vscode.TextEditor, d: vscode.TextDocument, sel: vscode.Selection[]) {
        console.log(d.getText());
        let text = d.getText();
        let newTest = text.split("\n");
        let replaced = "";
        newTest.forEach(val => {
            let reg = val.match(/(\\u[0-9|a-f]{4})/g);
            if (reg) {
                let t = reg.map(unicode => {
                    let codeStrs = unicode.split("\\u");
                    let codePoints = parseInt(codeStrs[1], 16);
                    return {code:`\\${unicode}`, value:String.fromCharCode(codePoints)};
                }).reduce( (v,obj) => {
                    let {code, value} = obj;
                    let reg = new RegExp(code);
                    return v.replace(reg, value);
                }, val);
                replaced = `${replaced}${t}\n`; 
            } else {
                replaced = `${replaced}${val}\n`; 
            }
        });
        e.edit((builder)=>{
            if (e) {
                let startPos = e.document.positionAt(0);
                let endPos = e.document.positionAt(text.length);
                let allRange = new vscode.Range(startPos,endPos);
                builder.replace(allRange,replaced);
            }
        });
}

native2ascii J'ai créé les fonctions suivantes et les ai résumées afin que les fonctions créées ci-dessus puissent être appelées par des commandes. Appelez cette fonction avec registerCommand et vous avez terminé.

function native2ascii() {
    if (!vscode.window.activeTextEditor) {
		vscode.window.showInformationMessage('Open a file first to manipulate text selections');
		return;
    }   
    var items: vscode.QuickPickItem[] = [];

	items.push({ label: "ascii", description: "Conversion de caractère en Unicode" });
    items.push({ label: "reverse", description: "Conversion d'Unicode en caractères" });
    
    Window.showQuickPick(items).then((selection) => {
		if (!selection) {
			return;
		}
        let e = Window.activeTextEditor;
        if (e) {
            let d = e.document;
            let sel = e.selections;
            switch (selection.label) {
                case "ascii":
                    ascii(e, d, sel);
                    break;
                case "reverse":
                    reverse(e, d, sel);
                    break;
                default:
		   console.log("hum this should not have happend - no selection")
		   break;
            }
        }
    });
}

Créez un fichier VSIX avec VSCE.

Empaquetez le plugin créé. J'ai utilisé VSCE. Je l'ai installé avec la commande suivante.

npm install -g vsce

Après l'installation, conditionnez-le avec la commande suivante. Si vous ne réécrivez pas README.md, l'empaquetage échouera.

vsce package

Le code source est enregistré dans GitHub.

Résumé

L'environnement pour créer des plug-ins était substantiel et il n'y avait pas de place pour se faire prendre (grâce à @rma). C'était la première fois que j'utilisais du texte dactylographié, mais depuis que je touchais ES2015, je n'ai ressenti aucune gêne. Au contraire, VScode a une bonne prise en charge de la langue et je voulais vraiment utiliser du dactylographie.