Kas yra VS Code failų šablonai ir kodo fragmentai?

Dirbant prie programinės įrangos kūrimo projektų, nuoseklumo ir efektyvumo palaikymas kodavimo praktikoje yra labai svarbus. Štai čia į pagalbą ateina VS Code failų šablonai ir kodo fragmentai. Jie padeda programuotojams efektyviai struktūrizuoti kodą, sumažindami rankinį darbą ir klaidas.

Failų šablonai

Failų šablonai – tai iš anksto apibrėžti modeliai naujiems failams kurti su struktūrizuotu turiniu. Jie padeda programuotojams:

• palaikyti nuoseklias failų struktūras visuose projektuose;
• automatizuoti pasikartojančias failų konfigūravimo užduotis;
• pagerinti naujų komandos narių įvedimą į darbą, standartizuojant failų formatus.

Kodo fragmentai (snippets)

Kodo fragmentai – tai pakartotinai naudojami kodo gabaliukai, kuriuos galima įterpti į esamus failus. Jie padeda programuotojams:

• pagreitinti kodavimą, sumažinant pasikartojantį rašymą;
• sumažinti sintaksės klaidas, naudojant iš anksto apibrėžtas, patikrintas kodo struktūras;
• užtikrinti vienodus kodavimo šablonus visame projekte.

Naudojant kartu šablonus ir kodo fragmentus, programuotojai gali dirbti efektyviau, užtikrindami švarų, gerai struktūrizuotą kodą visuose projektuose.

Failų šablonų konfigūravimas Progress OpenEdge VS Code aplinkoje

VS Code failų šablonų konfigūravimas yra paprastas procesas, padedantis programuotojams sumažinti laiką, skirtą pasikartojančiam failų struktūrizavimui, ir užtikrinti atitiktį projekto standartams.

Naudojau File Templates plėtinį, sukurtą rioj7, kad supaprastinčiau failų struktūros konfigūravimą ir automatizuočiau pasikartojančias užduotis. Žemiau pateikiamas žingsnis po žingsnio vadovas, kaip sukonfigūruoti ir naudoti failų šablonus.

1 žingsnis: konfigūruokite šablonų saugojimo vietas

VS Code palaiko failų šablonų saugojimą skirtinguose lygmenyse, priklausomai nuo jūsų naudojimo poreikių. Kiekvienas lygmuo turi skirtingą taikymo apimtį:

Naudotojo lygmuo

Ką tai daro? Šiame lygmenyje saugomi šablonai yra prieinami visuose projektuose.

Kaip sukonfigūruoti? Atidarykite VS Code nustatymus, ieškokite „File Templates“ ir nustatykite „Templates: Folder“ į norimą kelią.

Daugiašaknio darbo aplanko („multi-root workspace“) lygmuo

Ką tai daro? Galite apibrėžti bendrą šablonų katalogą naudotojams, dirbantiems su keliais projektais viename darbo aplanke („workspace“).

Kaip sukonfigūruoti? Nurodykite kelią Workspace nustatymuose, savo .code-workspace konfigūracijos faile. Čia nustatyti šablonai bus prieinami visiems projektams daugiašaknio darbo aplanke.

{ 
'folders': [ 
        { 
        'path': 'projectOne' 
        }, 
        { 
        'path': 'projectTwo' 
        } 
    ], 
    'settings': { 
        'templates.folder': 'C:/Path/To/Templates' 
    }, 
    'extensions': { 
        'recommendations': [ 
            'rioj7.vscode-file-templates' 
        ] 
    } 
} 

Darbo aplanko/aplanko („workspace/folder“) lygmuo

Ką tai daro? Šio lygmens šablonai yra specifiniai konkrečiam atidarytam darbo aplankui ar aplankui.

Kaip sukonfigūruoti? Įdėkite savo šablonus į projekto .vscode/templates katalogą. Tai idealiai tinka kontekstui specifiniams šablonams, taikomiems tik tam konkrečiam projektui.

2 žingsnis: naujo failo šablono kūrimas

Atidarykite naują failą savo šablonų vietoje

Sukurkite naują failą aplanke, kuriame saugote savo šablonus (pavyzdžiui, <homedir>/.vscode/templates).

Pridėkite turinį su dinaminiais laukais

Savo šablono faile įtraukite tekstą ir dinaminius laukus, kurie bus pakeisti kuriant naują failą. Galimos šios galimybės:

Baziniai kintamieji:

• ${input}: paragina įvesti reikšmę failo kūrimo metu.
• $author: įterpia autoriaus vardą, nurodytą jūsų nustatymuose.

• ${dateTimeFormat}: įterpia dabartinę datą. Tai galite dar labiau pritaikyti, nurodydami savo formato savybes (pvz., ${dateTimeFormat#template=${year}-${month}-${day}#}).

Failų ir darbo aplanko kintamieji:

• ${relativeFile}: įterpia šiuo metu atidaryto failo kelią, santykinį darbo aplanko atžvilgiu.
• ${fileBasename}: įterpia dabartinio failo pavadinimą (su plėtiniu).
• ${fileBasenameNoExtension}: įterpia dabartinio failo pavadinimą be plėtinio.

Daugiau pažangių parinkčių ir išsamių pavyzdžių rasite plėtinio dokumentacijoje.

Išsaugokite šabloną

Pridėję norimą turinį ir vietos rezervavimo ženklus (placeholders), išsaugokite failą. Kai kursite naują failą naudodami šį šabloną, vietos rezervavimo ženklai bus automatiškai pakeisti pagal nustatytas konfigūracijas ir transformacijas.

3 žingsnis: naudokite šablonus naujiems failams kurti

Naują failą iš šablono galite sukurti naudodami Command Palette arba File Explorer kontekstinį meniu.

Per Command Palette:

• Atidarykite Command Palette (Ctrl + Shift + P);
• Įveskite „Files: New File from Template“ ir pasirinkite šią komandą.

Per File Explorer kontekstinį meniu:

• Spustelėkite dešiniuoju pelės klavišu norimą katalogą Explorer skydelyje;
• Pasirinkite „New File from Template“.

Abiem atvejais pasirinksite šabloną, įvesite norimą failo pavadinimą ir užpildysite visus reikalingus vietos rezervavimo ženklų laukus.

‍

Renkantis šabloną, VS Code parodo kiekvieno šablono saugojimo lygmenį. Jei keli šablonai turi tą patį pavadinimą, rodomas tik aukščiausio prioriteto šablonas.

Ko galima tikėtis iš failų šablonų?

Dinaminių kintamųjų supratimas ir konfigūravimas iš pradžių gali būti sudėtingas, reikalaujantis tam tikro mokymosi ir derinimo, kad jie veiktų efektyviai.

Failų šablonų įgyvendinimas padeda programuotojams pasiekti keletą pagrindinių privalumų:

• Didesnis efektyvumas. Automatizuoja failų kūrimą, taupydamas laiką ir pastangas.
• ‍Nuoseklūs standartai. Užtikrina vienodą struktūrą, gerinant skaitomumą ir priežiūrą.
• ‍Plečiamumas. Supaprastinti procesai palengvina naujų darbuotojų įvedimą į darbą, projektui augant.

Įtraukdamos failų šablonus, komandos gali dirbti efektyviau, palaikyti nuoseklumą ir lengvai plėsti savo kūrimo procesus.

Šablonų pavyzdžiai VS Code File Templates plėtiniui (rioj7)

Klasės šablono pavyzdys

‍

/*------------------------------------------------------------------------ 
    File        : ${fileBasenameNoExtension}.cls 
    Purpose     : ${input#Class purpose#} 
    Syntax      : 
    Description : ${input#Description of this class#} 
    Author(s)   : ${author} 
    Created     : ${dateTimeFormat#options={'year':'numeric','month':'2-digit','day':'2-digit'}#template=${year}-${month}-${day}#} 
    Notes       : 
  ----------------------------------------------------------------------*/ 

block-level on error undo, throw. 

using Example.* from propath. 

class ${fileBasenameNoExtension}: 

    /*-------------------------------------------------------------------------- 
        Purpose     : Default constructor for ${fileBasenameNoExtension} 
        Notes       : ${input#Additional notes for constructor#} 
     --------------------------------------------------------------------------*/ 
    constructor public ${fileBasenameNoExtension} (): 
        /* Constructor code here */ 
        ${cursor} 
    end constructor. 

    /*-------------------------------------------------------------------------- 
        Purpose     : Destructor for ${fileBasenameNoExtension} 
        Notes       : Clean up resources, if any 
    --------------------------------------------------------------------------*/ 
    destructor public ${fileBasenameNoExtension} (): 
        /* Cleanup code here */ 
    end destructor. 

end class. 

‍

Vienetų testo šablono pavyzdys

/*------------------------------------------------------------------------ 
    File        : ${fileBasenameNoExtension}.cls 
    Purpose     : ${input#Class purpose#} 
    Syntax      : 
    Description : 
    Author(s)   : ${author} 
    Created     : ${dateTimeFormat#options={'year':'numeric','month':'2-digit','day':'2-digit'}#template=${year}-${month}-${day}#} 
    Notes       : 
  ----------------------------------------------------------------------*/ 

block-level on error undo, throw. 

using ExampleOne.* from propath. 
using Assertion.*  from propath.  

@Test. 
class ${fileBasenameNoExtension}: 

    @Test. 
    method public void TestMethod1(): 
        ${cursor} 
    end method. 

end class. 

Enum šablono pavyzdys

/*------------------------------------------------------------------------ 
    File        : ${fileBasenameNoExtension} 
    Purpose     : ${input#Enter the purpose of this enum#} 
    Syntax      : 
    Description : ${input#Provide a brief description of this enum#} 
    Author(s)   : ${author} 
    Created     : ${dateTimeFormat#options={'year':'numeric','month':'2-digit','day':'2-digit'}#template=${year}-${month}-${day}#} 
    Notes       : 
  ----------------------------------------------------------------------*/ 
enum ${fileBasenameNoExtension}: 

    define enum ${cursor} . 

end enum. 

Interfeiso šablono pavyzdys

/*------------------------------------------------------------------------ 
    File        : ${fileBasenameNoExtension} 
    Purpose     : ${input#Enter the purpose of this interface#} 
    Syntax      : 
    Description : ${input#Enter a brief description of this interface#} 
    Author(s)   : ${author} 
    Created     : ${dateTimeFormat#options={'year':'numeric','month':'2-digit','day':'2-digit'}#template=${year}-${month}-${day}#} 
    Notes       : 
  ----------------------------------------------------------------------*/ 
interface ${fileBasenameNoExtension}: 

    ${cursor} 

end interface. 

Procedūros šablono pavyzdys

/*------------------------------------------------------------------------ 
    File        : ${fileBasenameNoExtension}.p 
    Purpose     : ${input#Enter the purpose of this procedure#} 
    Syntax      : 
    Description : ${input#Provide a brief description of this procedure#} 
    Author(s)   : ${author} 
    Created     : ${dateTimeFormat#options={'year':'numeric','month':'2-digit','day':'2-digit'}#template=${year}-${month}-${day}#} 
    Notes       : ${input#Optional notes or additional context#} 
  ----------------------------------------------------------------------*/ 
block-level on error undo, throw. 

DEFINE VARIABLE Example AS CHARACTER NO-UNDO. 

${cursor} 

Daugiau plėtinių failų šablonams kurti:

• VS Code File Template Extension (Thinker) ‍
• VZ File templates for Visual Studio Code ‍
• VS Code File Templates Extension (rioj7)

VS Code kodo fragmentų (snippets) kūrimas ir naudojimas Progress OpenEdge aplinkoje

Be failų šablonų, VS Code kodo fragmentai (snippets) leidžia programuotojams greitai įterpti dažnai naudojamus kodo gabaliukus, mažinant klaidas ir gerinant efektyvumą. Kodo fragmentų konfigūravimas Progress OpenEdge kūrime gali žymiai pagreitinti darbo eigą.

Šiam tikslui pasiekti naudojau VS Code naudotojo kodo fragmentus (user snippets). Žemiau pateikiamas žingsnis po žingsnio vadovas, kaip kurti pasirinktinius fragmentus, pritaikytus jūsų konkrečiam projektui.

1 žingsnis: pasirinktinių kodo fragmentų kūrimas ir išsaugojimas

Atidarykite naudotojo kodo fragmentus

• Atidarykite VS Code;
• Atidarykite Command Palette (Ctrl + Shift + P);
• Pasirinkite „Configure User Snippets“;
• Pasirinkite abl.json failą, kad atidarytumėte (ar sukurtumėte) ABL kodo fragmentų failą.

Apibrėžkite savo kodo fragmentą

abl.json faile pridėkite naują kodo fragmento įrašą su šiais komponentais:

• Prefix: trigerio žodis, kurį įvedate, kad suaktyvintumėte kodo fragmentą.
• ‍Body: kodo šablonas, kuris bus įterptas, įskaitant vietos rezervavimo ženklus pritaikomoms reikšmėms. ‍
• Description: trumpas paaiškinimas, ką šis kodo fragmentas atlieka.

Pavyzdys: CATCH bloko kodo fragmentas

'Catch Block': { 
    'prefix': 'catch', 
    'body': [ 
        'CATCH ${1:Error} AS ${2:Progress.Lang.Error}:', 
        '    MESSAGE ${1:Error}:GetMessage(1).', 
        'END CATCH.', 
        '$0' 
    ], 
    'description': 'Creates a CATCH block for handling errors in ABL.'
} 

Paaiškinimas

Prefix ("catch"): įvedus catch ir paspaudus Tab (⇥), suaktyvinamas šis kodo fragmentas.

Body:

• ${1:Error} yra vietos rezervavimo ženklas klaidos kintamojo pavadinimui.
• ${2:Progress.Lang.Error} yra vietos rezervavimo ženklas išimties klasei.
• $0 nurodo, kur bus pozicionuotas žymeklis po kodo fragmento išskleidimo.

Description: suteikia paaiškinimą (tooltip) VS Code aplinkoje, padedantį greitai identifikuoti kodo fragmento paskirtį.

Pridėję kodo fragmentą į abl.json failą, jį išsaugokite. Jūsų pasirinktinis kodo fragmentas dabar prieinamas pakartotiniam naudojimui visuose jūsų ABL projektuose.

2 žingsnis: kodo fragmentų naudojimas

Apibrėžus kodo fragmentus, juos naudoti yra paprasta:

Suaktyvinkite kodo fragmentą

Atidarykite failą VS Code aplinkoje, tuomet įveskite kodo fragmento trigerį (pvz., catch). Galite arba:

• Paspausti Tab (⇥): tai iškart išskleidžia kodo fragmentą.
• ‍Pasirinkti iš rekomendacijų: VS Code IntelliSense pasiūlys kodo fragmentą, kurį galėsite pasirinkti iš sąrašo.

Pavyzdžiui, įvedus catch ir paspaudus Tab, gaunama:

Catch blokas

CATCH Error AS Progress.Lang.Error: 
    MESSAGE Error:GetMessage(1). 
END CATCH

‍

Užpildykite vietos rezervavimo ženklus

Po išskleidimo kodo fragmentas turi vietos rezervavimo ženklus (pvz., ${1:Error} ir ${2:Progress.Lang.Error}).

Naudokite Tab (⇥) klavišą navigacijai tarp vietos rezervavimo ženklų.

Pakeiskite kiekvieną vietos rezervavimo ženklą tinkamomis reikšmėmis, pritaikydami įterptą kodą savo poreikiams.

OpenEdge ABL Snippets plėtinys

Egzistuoja VS Code plėtinys, vadinamas OpenEdge ABL Snippets, kuris jau pateikia platų iš anksto apibrėžtų kodo fragmentų rinkinį, skirtą dažniausiai naudojamoms ABL konstrukcijoms. Pavyzdžiui, jis apima kodo fragmentus:

• kintamųjų apibrėžimui;
• įvesties, išvesties ir įvesties-išvesties parametrams;
• standartiniams kodo blokams, tokiems kaip procedūros, funkcijos, ciklai ir t.t.

Jei iš anksto apibrėžti kodo fragmentai atitinka jūsų poreikius, galite juos naudoti tokius, kokie yra. Tačiau jei norite juos pritaikyti, turite dvi galimybes: modifikuoti snippets.json failą OpenEdge ABL Snippets plėtinio aplanke arba nukopijuoti šiuos kodo fragmentus į savo naudotojo kodo fragmentų failą abl.json ir juos pritaikyti pagal poreikį. Atminkite, kad plėtinio atnaujinimai gali perrašyti pakeitimus, padarytus tiesiogiai plėtinio aplanke.

Kokie iššūkiai naudojant iš anksto apibrėžtus kodo fragmentus?

Naudojant kelis plėtinius, kodo fragmentai kartais gali konfliktuoti, todėl sunku, kad norimas kodo fragmentas pasirodytų kaip pagrindinis pasiūlymas. Be to, DI pagrindu veikiantys plėtiniai gali generuoti konkuruojančius kodo pasiūlymus, kurie gali trukdyti naudoti Tab klavišą navigacijai tarp kodo fragmento vietos rezervavimo ženklų.

Kodo fragmentų taikymas Progress OpenEdge kūrime suteikia keletą privalumų:

• Didesnis efektyvumas. Taupo laiką, eliminuojant pasikartojantį kodavimą.
• ‍Sumažintos klaidos. Standartizuoti, iš anksto patikrinti kodo fragmentai padeda sumažinti klaidas.
• ‍Pagerintas nuoseklumas. Vienodas kodas palengvina priežiūrą ir naujų darbuotojų įvedimą į darbą.

Integruodamos kodo fragmentus į kūrimo procesą, komandos gali dirbti greičiau, sumažinti klaidas ir palaikyti aukštos kokybės, nuoseklų kodą visuose projektuose.

Daugiau šaltinių kodo fragmentų pavyzdžiams:

• Snippets In VS Code
• Code snippets for OpenEdge ABL development in VS Code

Žemiau pateikiami papildomi pasirinktinių kodo fragmentų pavyzdžiai ABL kodui, kuriuos galite pridėti į savo abl.json failą.

Catch blokas

'Catch Block': { 
'prefix': 'catch', 
'body': [ 
'CATCH ${1:Error} AS ${2:Progress.Lang.Error}:', 
'    MESSAGE ${1:Error}:GetMessage(1).', 
'END CATCH.', 
'$0' 
], 
'description': 'Creates a CATCH block for handling errors in ABL.' 
} 

Case blokas

'Case Block': { 
    'prefix': 'case', 
    'body': [ 
        'CASE ${1:variable}:', 
        '    WHEN ${2:value1} THEN', 
        '        /* Code for case 1 */', 
        '    WHEN ${3:value2} THEN', 
        '        /* Code for case 2 */', 
        '    OTHERWISE', 
        '        /* Default case */', 
        'END CASE.' 
    ], 
    'description': 'Creates a CASE statement with multiple options.' 
} 

FIND su prieinamumo patikrinimu 

'FIND with Availability Check': { 
    'prefix': 'findavail', 
    'body': [ 
        'FIND FIRST ${1:tableName} WHERE ${2:condition} NO-LOCK NO-ERROR.', 
        'IF NOT AVAILABLE ${1:tableName} THEN DO:', 
        '    /* Handle not found case */', 
        'END.' 
    ], 
    'description': 'Finds a record with NO-LOCK and NO-ERROR.' 
} 

Message

'Message': { 
    'prefix': 'msg', 
    'body': [ 
        'MESSAGE ${1:\'Message\'} VIEW-AS ALERT-BOX.' 
    ], 
    'description': 'Creates a MESSAGE alert box.' 
} 

Pagrindinė nauda naudojant VS Code šablonus ir kodo fragmentus Progress OpenEdge aplinkoje

VS Code šablonų ir kodo fragmentų naudojimas jūsų Progress OpenEdge darbo eigoje pagerina efektyvumą ir palaiko kodo nuoseklumą. Šie įrankiai supaprastina kūrimą, mažindami pasikartojančias užduotis ir užtikrindami standartizuotas struktūras.

• Didesnis efektyvumas. Automatizuojant failų kūrimą ir įprastus kodo šablonus, pagreitinamas kūrimo procesas. Naudojant failų šablonus, programuotojams nebereikia rankiniu būdu struktūrizuoti kiekvieno failo, o kodo fragmentai padeda greitai įterpti iš anksto apibrėžtus kodo blokus, sumažinant laiką, skiriamą pasikartojančioms užduotims.
• ‍Sumažintos klaidos. Iš anksto apibrėžtos struktūros eliminuoja sintaksės klaidas. Naudojant šablonus ir kodo fragmentus, programuotojai išvengia dažnų žmogiškų klaidų, kylančių dėl nenuoseklaus formatavimo ar trūkstamų elementų, taip užtikrinant aukštesnę kodo kokybę.
• ‍Nuoseklumas visuose projektuose. Standartizuoti šablonai ir kodo fragmentai įgyvendina geriausias praktikas, gerina skaitomumą ir palaikomumą. Tai ypač naudinga didesnėse komandose, kur vienodos kodo struktūros palaikymas yra būtinas sklandžiam bendradarbiavimui.
• ‍Pagerintas plečiamumas. Naudojant gerai apibrėžtus šablonus ir kodo fragmentus, organizacijos gali lengvai įvesti į darbą naujus programuotojus. Standartizuoti procesai reiškia, kad nauji komandos nariai gali greitai prisitaikyti prie kodavimo standartų be ilgo mokymo.
• ‍Geresnis palaikomumas. Projektus, sukurtus su nuosekliomis failų struktūromis ir standartizuotais kodo fragmentais, lengviau palaikyti. Derinimas (debugging), refaktoringas ir kodo plėtimas tampa lengviau valdomi, kai visi failai ir kodo šablonai laikosi struktūruoto požiūrio.

Įgyvendinant šiuos įrankius, komandos gali dirbti efektyviau, palaikyti aukštą kodo kokybę ir supaprastinti bendradarbiavimą Progress OpenEdge projektuose.

VS Code failų šablonų ir kodo fragmentų integravimas į jūsų Progress OpenEdge darbo eigą pagreitina kūrimą, sumažina klaidas ir palaiko kodą gerai sutvarkytą. Šie įrankiai supaprastina failų kūrimą ir supaprastina pasikartojančias kodavimo užduotis, leisdami programuotojams sutelkti dėmesį į sudėtingesnių problemų sprendimą.

Jei turite klausimų ar reikia papildomos pagalbos, mūsų Progress OpenEdge komanda pasiruošusi padėti. Susisiekite su mumis dėl ekspertų patarimų, kaip optimizuoti savo kūrimo procesus.

Dažniausiai užduodami klausimai

Kuo skiriasi VS Code failų šablonai nuo kodo fragmentų?

Failų šablonai – tai iš anksto apibrėžti modeliai, skirti naujiems failams kurti su struktūrizuotu turiniu, o kodo fragmentai (snippets) – tai pakartotinai naudojami kodo gabaliukai, įterpiami į jau esamus failus. Abu įrankiai padeda mažinti pasikartojantį darbą, bet skirtingais kūrimo etapais.

Ar reikia papildomo plėtinio, norint naudoti failų šablonus VS Code aplinkoje?

Taip, VS Code natūviai nepalaiko pasirinktinių failų šablonų, todėl reikalingas plėtinys, pvz., File Templates Extension by rioj7, leidžiantis konfigūruoti šablonų saugojimo vietas ir dinaminius laukus.

Kur galima saugoti VS Code failų šablonus?

Šablonus galima saugoti trimis lygmenimis: naudotojo lygmeniu (prieinami visuose projektuose), „multi-root workspace“ lygmeniu (bendri keliems projektams viename darbo aplanke) arba darbo aplanko/aplanko lygmeniu (specifiniai konkrečiam projektui).

Ar OpenEdge ABL Snippets plėtinys pakeičia poreikį kurti pasirinktinius kodo fragmentus?

Ne visada. Plėtinys jau pateikia platų iš anksto apibrėžtų kodo fragmentų rinkinį dažniausiems ABL konstruktams, tačiau pasirinktiniai kodo fragmentai vis tiek naudingi projekto specifiniams šablonams ar individualioms kodavimo praktikoms.