Ինտերպրետատորները(թարգմանիչ) և կոմպիլյատորները(կազմող) պատասխանատու են ծրագրավորման լեզուն կամ սցենարը (բարձր մակարդակի լեզուն) մեքենայական կոդի վերածելու համար: Բայց եթե երկու ծրագրերն էլ նույնն են անում, ինչո՞վ են դրանք տարբերվում: Եկե՛ք պարզենք:
Կոմպիլյատոր
Կոմպիլյատորը (անգլ.՝ compiler) ծրագիր է, որը փոխակերպում է ծրագրավորման լեզվով գրված սկզբանական կոդը ( անգլ.՝ source code) այլ ծրագրային լեզվով(ելքային լեզվի, անգլ.՝ target language) կոդի, որը հիմնականում ունի բինար տեսք և հայտնի է օբյեկտային կոդ (անգլ.՝ object code) անվանմամբ։ Սկզբնական կոդի փոխակերպման ամենատարածված պատճառը այն է որ ստեղծվի կատարվող ծրագիր (անգլ.՝ executable program): Այն կարող է կատարել բոլոր նշված օպերացիաները՝
- լեքսիկական վերլուծություն ( անգլ.՝ lexical analysis) – Այս փուլում սկզբնական ֆայլի սիմվոլների հաջորդականությունը փոխակերպվում է թոքենների հաջորդականության։
- սինտակտիկական (քերականական) անալիզ (անգլ.՝ Parsing) – թոքենների հաջորդականությունը փոխակերպվում է վերլուծության ծառի (parse tree):
- սեմանտիկական (իմաստային) անալիզ (անգլ.՝ semantic analysis) – վերլուծության ծառը մշակվում է իմաստը հաստատելու նմատակով։ Օրինակ՝ իդենտիֆիկատորների կապը դրանց հայտարարմանը, տիպերին, համատեղելիության ստուգումը և այլն։ Արդյունքը հիմնականում կոչվում է կոդի միրջանկյալ ներկայացում (անգլ.՝ intermediate representation) և կարող է լինել վերլուծության ծառի լրացում, նոր ծառ, աբստրակտ հրամանների խումբ կամ այլ բան՝ հարմար հետագա աշխատանքին։
- կոդի օպտիմիզացիա ( անգլ.՝ code optimization) – կատարվում է ավելորդ կոնստրուկցիաների հեռացում և կոդի պարզեցում՝ իմաստը պահպանելով։
- կոդի գեներացիա (անգլ.՝ code generation) – միջանկյալ ներկայացումից առաջանում է ելքային կոդ (անգլ.՝ target code)։
Այսպիսով, կոմպիլյատորը վերցնում է ծրագիրն ամբողջությամբ և փոխակերպում այն գործարկվող համակարգչային կոդի: Սա պահանջում է մի ամբողջ ծրագիր, քանի որ համակարգիչը հասկանում է միայն երկուական կոդ: Ուստի կոմպիլյատորի խնդիրն է գործարկվող ծրագիրը վերածել մեքենայի կոդի, որը ճանաչվում է համակարգչի կողմից:
Կոմպիլյացնող ծրագրավորման լեզուների օրինակներ են C, C++, Java-ն:
Ինտերպրետատոր
Ինտերպրետատորը (անգլ.՝ interpreter) ծրագիր է, որն ուղղակիորեն կատարում է ծրագրավորման կամ սկրիպտավորման լեզուներով գրված հրամաններ, առանց դրանք նախապես կոմպիլյացնելով մեքենայական լեզվի ծրագրի։ Ինտերպրետատորը ծրագրի կատարման համար հիմնականում օգտագործում է հետևյալ ստրատեգիաներից մեկը՝
- վերլուծել (անգլ.՝ parse) սկզբնական կոդը և ուղղակիորեն կատարել,
- թարգմանել սկզբնական կոդը, ինչ որ միջանկյալ տեսքի և իրականացնել այն,
- հստակ իրականացնել պահպանված նախակոմպիլյացված (անգլ.՝ precompiled) կոդը՝ կոմպիլյատորի կողմից կազմված, որը հանդիսանում է ինտերպրետատորի համակարգի մի մաս։
Այսինքն ինտերպրետատորը մեքենայական ծրագիր է, որն ուղղակիորեն կատարում է մի շարք հրահանգներ՝ առանց դրանք նախապես կոմպիլյացնելու: Ինտերպրետացվող լեզուների օրինակներ են Perl-ը, Python-ը, Matlab-ը, Javascript-ը, PHP-ն:
Որպես վերը նշվածների կարճ ամփոփում՝ կարելի է նշել, որ թե՛ կոմպիլյատորը և թե՛ ինտերպրետատորը կատարում են նույն գործառույթը՝ բարձր մակարդակի ծրագրավորման լեզուն փոխակերպելով մեքենայական կոդի: Այնուամենայնիվ, կոմպիլյատորը սկզբնական կոդը փոխակերպում է մեքենայի կոդի՝ ծրագիրը գործարկելուց առաջ: Ինտերպրետատորը կատարում է այս ֆունկցիան, երբ այն գործարկվում է, գործարկման հետ միաժամանակ:
Ինչպե՞ս է այս ամենն աշխատում
Կոմպիլյատորը նախ ստեղծում է ծրագիր: Այն վերլուծում է լեզվի բոլոր օպերատորներին` ստուգելու, թե դրանք ճիշտ են, թե՝ ոչ: Եթե կոմպիլյատորը որևէ սխալ գտնի, այն համապատասխան հաղորդագրություն կտա և կդադարեցնի կոմպիլյացման պրոցեսը: Հակառակ դեպքում այն սկզբնաղբյուրը կոդը փոխակերպում է մեքենայական կոդի: Կոմպիլյատորը տարբեր կոդային ֆայլեր է կապում այն ծրագրերի հետ, որոնք կարող եք գործարկվել(օրինակ .exe ֆորմատով): Դրանից հետո ծրագիրը մեկնարկվում է:
Ինտերպրետատորը նույնպես, առաջին հերթին ստեղծում է ծրագիր: Այն չի կապում ֆայլերը կամ չի ստեղծում մեքենայական կոդ. պարզապես ծրագրի կատարման ընթացքումտեղի է ունենում մուտքային օպերատորների կատարում՝ տող առ տող:
Առավելություններ և թերություններ
Կոմպիլյատորի առավելությունները
- Ծրագրային կոդը բերվում է մեքենայական կոդի, ինչի իրականացման համար շատ ավելի քիչ ժամանակ է պահանջվում
- .exe ֆայլերն աշխատում են ավելի արագ, քան սկզբաղբյուր կոդը: Օբյեկտային ծրագրերը պահպանվում են և կարող են գործարկվել ցանկացած պահի
- Օբյեկտային ծրագրեը երրորդ կողմից ավելի են պաշտպանված: Օգտագործողն այն ավելի դժվարությամբ կարող է փոփոխել, քան սկզբնաղբյուր կոդը
- Կոմպիլյատորը սինտաքսային սխալների առկայությունը ստուգում է կոմպիլյացման ընթացքում, ինչը բացառում է գործարկումից հետո սինտաքսային սխալի առաջացումը
Կոմպիլյատորի թերությունները
- Քանզի թարգմանվում է ծրագիրն ամբողջությամբ, օգտագործվում է շատ ավելի մեծ մեքենայական հիշողության ռեսուրս
- Յուրաքանչյուր փոփոխության համար պետք է փոխել սկզբնաղբյուր կոդը և կրկնել կոմպիլյացիայի պրոցեսը
- Նախքան վերջնական կատարվող ֆայլի ստեղծումը անհրաժեշտ է ստեղծել նաև օբյեկտային ծրագիր, ինչը ևս ժամանակատար պրոցես է
- Սկզբնաղբյուր կոդը պետք է լինի 100% ճիշտ կատարվող ֆայլ ստեղծելու համար
Ինտերպրետատորի առավելությունները
- Ինտերպրետատորը զգալիորեն թեթևացնում է սկզբնաղբյուր կոդի հետ աշխատանքը
- Այն միաժամանակ թարգմանում է մեկ հրահանգ, ուստի օգտագործում է նվազագույն քանակությամբ հիշողություն
- Ինտերպրետատորը կարող է սխալների մասին հաղորդագրությունները կապել կատարվող հրահանգների հետ, որը կարող է օգտակար լինել վրիպազերծման (դեբագի) ժամանակ:
Ինտերպրետատորի թերությունները
- Ամեն անգամ, երբ ծրագիրը կատարվում է, զգալի ժամանակ է վատնվում ինտերպրետացիայի վրա, ինչի հետևանքով ձգձգում է կատարման ժամանակը:
- Ինտերպրետացվող ծրագրերը կարող են գործարկվել միայն այն համակարգիչների վրա, որոնք ունեն համապատասխան ինտերպրետատորները:
Տարբերություններ
Եզրափակենք կամպիլյատորի և ինտերպրետատորի տարբերությունները աղյուսակի միջոցով.
Կամպիլյատոր | Ինտերպրետատոր |
---|---|
Կամպիլյատորը լեզվական պրոցեսսոր է, որը փոխարկում է բարձր մակարդակի լեզուն ցածրի, և հակառակը | Ինտերպրետատորը լեզվական պրոցեսսոր է, որը փոխարկում է բարձր մակարդակի լեզուն ցածրի, և հակառակը |
Մշակման է վերցնում ծրագիրն ամբողջությամբ | Մշակման է վերցնում ծրագրի հերթական տողը կամ ինստրուկցիան |
Գեներացնում է միջանկյալ օբյեկտային ծրագիր | Չի գեներացնում միջանկյալ օբյեկտային ծրագիր |
Կամպիլյացիան իրականացվում է կատարումից առաջ | Կամպիլյացիան և կատարումը տեղի են ունենում միաժամանակ |
Համեմատաբար բարձր արագագործություն | Ցածր արագագործություն |
Օբյեկտային ծրագիր ստեղծելու պատճառով առավել շատ հիշողություն է պահանջում | Առավել քիչ հիշողություն է պահանջում, քանի որ օբյեկտային ծրագիր չի ստեղծում |
Սխալների մասին զգուշացումներն անում են միանգամից և կամպիլյացիայի ավարտից հետո | Յուրաքանչյուր սխալի հանդիպելուց անմիջապես կատարվում է զգուշացում |
Սխալների հայտնաբերումը խրթին է | Հեշտորեն հայտնաբերվում են սխալները |
Առավել էֆեկտիվ | Պակաս էֆեկտիվ |
C, C++, C#, Scala, Typescript-ն օգտագործում են կամպիլյատոր | PHP, Perl, Python, Ruby-ն օգտագործում են ինտերպրետատոր |
Սկզբնաղբյուր՝ Compiler Vs Interpreter
Կարդացեք նաև