1. რა არის Typescript ?
TypeScript (ტს) არის კორპორაცია Microsoft-ის თანამშრომლის - ანდრეს ჰაილსბერგის მიერ შექმნილი ობიექტზე ორიენტირებული პროგრამირების ენა ღია წყაროთი (Open-source), რომელიც წარმოადგენს ჯავასკრიპტის (ჯს) მკაცრად სინტაქსირებულ გაფართოებას, ჯს-ის ინსტრუმენტების განვრცობილ კომპლექტს (ჰაილსბერგი ასევე არის პროგრამირების შემდეგი ენების ავტორი : Turbo Pascal, Delphi და C#). ჯს-ისა და ტს-ის დამოკიდებულების აღწერებში, ხშირად გამოიყენება ტერმინები - სიმრავლე (superset) და ქვესიმრავლე (subset). ქვესიმრავლე მათემატიკაში ნიშნავს შემდეგს : სიმრავლე A არის სიმრავლე B-ს ქვესიმრავლე თუ სიმრავლე B მოიცავს სიმრავლე A-ს, ანუ A-სიმრავლის ყველა ელემენტი არის B სიმრავლეშიც. თუ ამ განმარტებას უხეშად და პირდაპირი მნიშვნელობით გამოვიყენებთ, შეგვიძლია ვთქვათ, რომ ჯს არის ტს-ის 'ქვესიმრავლე', აქედან გამომდინარე ჯს-ში დაწერილი ნებისმიერი კოდი ხელმისაწვდომია ტს-შიც.





ტს-ში დაწერილი პროგრამა გაშვებისას კომპილირდება უბრალო ჯს-ში.

იმისათვის რათა დაინტერესებულმა პირმა ეს ენა შეისწავლოს საჭიროა ობიექტზე ორიენტირებული პროგრამირების ძირითადი კონცეფციებისა და საბაზისო ჯს-ის ცოდნა.

ტს-ის განსაკუთრებულობები

კომპილაცია

ჯს არის პროგრამირების ინტერპრეტატორული ენა (იხ: კურსი), ეს იმას ნიშნავს, რომ თუ გვსურს გავიგოთ ამ ენაში დაწერილი კოდი ვალიდურია თუ არა საჭიროა ამ კოდის გაშვება.

კომპილაციისას ტს ახდენს სინტაქსური შეცდომების დაფიქსირებას, რაც საშუალებას გვაძლევს აღმოვაჩინოთ ხარვეზები კოდის გაშვებამდე.

მკაცრი ტიპიზაცია

როგორც ვიცით ჯს მკაცრად ტიპიზირებული ენა არ არის. TLS (TypeScript Language Service ანუ TypeScript ენის სერვისი) კი საშუალებას გვაძლევს დავადგინოთ ტიპის გარეშე აღწერილი ცვლადების ტიპები მათივე მნიშვნელობებიდან გამომდინარე.

ოოპ მიდგომა

ტს-ში მხარდაჭერილია ოოპის ძირითადი ცნებები და კონცეფციები : კლასები, ინტერფეისები, მემკვიდრეობითობა და ა.შ

ტს-ის კომპონენტები

  • უშუალოდ ენა - მოიცავს სიტყვა-გასაღებებს, სინტაქსს და ტიპების ანოტაციებს.
  • კომპილატორი - იგივე TSC ანუ TypeScript compiler, რომელსაც TypeScript-ში დაწერილი ინსტრუქციები გადაჰყავს ჯს-ში.
  • TLS - TypeScript Language Service ეს არის კომპილატორის გარშემო არსებული გარსი, რომელიც ასრულებს ერთგავი რედაქტორის როლს : აფიქსირებს გამოსახულებათა და ინსტრუქციათა შესრულება-დასრულების მომენტებს, უზრუნველყოფს კოდის ფორმატირებასა და დახარისხებას და ა.შ





2. სამუშაო გარემოს მოწყობა, რა არის Node.js ?

რა არის Node.js ?

Node ანუ Node.js — არის V8 (ავტ. Google) ძრავზე დაფუძნებული პროგრამული პლატფორმა, რომელიც JavaScript-ს, როგორც სპეციალიზირებულ ენას, გარდაქმნის პროგრამირების სრულფასოვან და საერთო დანიშნულების ენად. ამ პლატფორმაზე დაფუძნებით ჯს შეგვიძლია გამოვიყენოთ სერვერული მხარის სამუშაოებში და დავაგენერიროთ დინამიური ვებ-გვერდების შიგთავსები მანამ სანამ ეს გვერდები გაიგზავნება ბრაუზერში, ასე რომ იმსხვრევა სტერეოტიპი თითქოს ჯს-ს ვერაფერში გამოვიყენებთ თუ არ გვაქვს ბრაუზერი :))

Node.js ინსტალაცია

Node.js ის გადმოწერა შესაძლებელია ოფიციალური ვებ-გვერდიდან. ინსტალაცია მიმდინარეობს სტანდარტულად, ყოველგვარი სირთულეების გარეშე. იმისათვის რათა დავრწმუნდეთ, რომ ინსტალაციამ წარმატებით ჩაიარა, ბრძანებათა ველიდან (CMD) გავუშვათ შემდეგი ბრძანება : node –v

ტს ინსტალაცია

ტს-ის ინსტალაციისათვის უნდა გავუშვათ შემდეგი ბრძანება : npm install -g typescript
  • npm - Node.js Package Manager ანუ Node.js პაკეტების მენეჯერი. პაკეტის მიღმა იგულისხმება იმ ფაილების ნაკრები, რომლებიც გვჭირდება კონკრეტული მოდულის შესაქმნელად, ხოლო თავად მოდული არის ჯს-ის ბიბლიოთეკა, რომლის გამოყენებაც გვსურს პროექტში.
  • -g - ტს სისტემაში დაინსტალირდება, როგორც გლობალური პაკეტი, რაც იმას ნიშნავს, რომ კომპილატორთან წვდომა შეგვიძლია ჩვენი ნებისმიერი პროექტიდან.
იმისათვის რათა გავარკვიოთ ინსტალაციამ წარმატებით ჩაიარა თუ არა, ბრძანებათა ველიდან გავუშვათ შემდეგი ბრძანება : tsc –v
3. საბაზისო სინტაქსი
სინტაქსი არის იმ წესებისა და პირობების ერთობლიობა, რომლებიც უნდა დავიცვათ ამა თუ იმ პროგრამის წერისას, პროგრამირების ნებისმიერ ენას გააჩნია საკუთარი სინტაქსი. ტს პროგრამა შეიძლება შეიცავდეს :
  • მოდულებს
  • ფუნქციებს
  • ცვლადებს
  • გამოსახულებებს
  • კომენტარებს

ჩვენი პირველი ტს კოდი

ახალი ტექნოლოგიის შესწავლისას, ჩვენი პირველი კოდით, ტრადიციულად მივესალმოთ მსოფლიოს :)) შევქმნათ რაიმე საქაღალდე რომელშიც ვიმუშავებთ, დავარქვათ მას მაგალითად ts, შემდეგ ამ საქაღალდეში შევქმნათ ფაილი typescript.ts და მასში შევიტანოთ შემდეგი კოდი : var message:string = "გამარჯობა მსოფლიოვ !";
console.log(message); ამის შემდეგ, ბრძანებათა ველიდან გადავინაცვლოთ ts საქაღალდეში და გავუშვათ შემდეგი ბრძანება : tsc typescript.ts

ამ ყველაფრის შემდეგ დავინახავთ, რომ ts საქაღალდეში ავტომატურად შეიქმნება ახალი ფაილი typescript.js და მას თუ გავხსნით ვიხილავთ სტანდარტულ ჯს-ში კომპილირებულ იმ კოდს, რომელიც typescript.ts ფაილში ჩავწერეთ. ts საქაღალდეში შევქმნათ ფაილი index.html შემდეგი კოდით : 
<!DOCTYPE html>
<html>
    <head>
        <title>Typescript</title>
        <meta charset="UTF-8">
        <script src="typescript.js"></script>
    </head>
    <body>
        
    </body>
</html>
გავხსნათ ეს ფაილი ბრაუზერში და გადავამოწნოთ კონსოლი, ვიხილავთ ტექსტს "გამარჯობა მსოფლიოვ !".

იდენტიფიკატორები

იდენტიფიკატორი არის ნებისნმიერი პროგრამული ელემენტის დასახელება, მაგალითად ცვლადის ფუნქციის და ა.შ. ელემენტების სახელდებისას უნდა გავითვალისწინოთ შემდეგი პირობები :
  • დასახელება შეიძლება შეიცავდეს სიმბოლოებსაც და ციფრებსაც, თუმცა იგი არ შეიძლება დაიწყოს ციფრით.
  • ე.წ სპეცსიმბოლოთაგან, დასახელება შეიძლება შეიცავდეს მხოლოდ ამ ორ მათგანს : '_' და '$'.
  • დაუშვებელია იდენტიფიკატორებად გამოვიყენოთ ტს-ის სიტყვაგასაღებები.
  • 'totalScore' და 'TotalScore' სხვადასხვა ცვლადებია, ანუ მნიშვნელოვანია ასოთა რტეგისტრი.
  • იდენტიფიკატორი არ უნდა შეიცავდეს გამოტოვებულ ადგილს.
სწორია არასწორია
firstName Var
first_name first name
num1 first-name
$result 1number

სიტყვაგასაღებები

პროგრამირების ამა თუ იმ ენაში სიტყვაგასაღები არის სპეც-დანიშნულების მქონე სიტყვა, ტს-ის სიტყვაგასაღებებია :
break as any switch
case if throw else
var number string get
module type instanceof typeof
public private enum export
finally for while void
null super this new
in return true false
any extends static let
package implements interface function
new try yield const
continue do catch

გამოტოვებული ადგილები და ახალი ხაზები

ტს არ ითვალისწინებს გამოტოვებულ ადგილებსა და ახალ ხაზზე გადასვლებს კოდში, ასე რომ თავისუფლად შეგვიძლია ჩვენი კოდი ჩავწეროთ ისე რომ იგი იყოს ადვილად გარჩევადი და წაკითხვადი.

ტს არის ასოთა რეგისტრის მიმართ მგრძნობიარე

ტს არის ასოთა რეგისტრის მიმართ მგრძნობიარე, რაც იმას ნიშნავს, რომ იგი ანსხვავებს მაგალითად ასოთა სხვადასხვა რეგისტრში ჩაწერილ ორ იდენტიფიკატორს, რომლების შეიცავენ ერთნაირ სიმბოლოებსა და ასოებს.

წერტილ-მძიმე

წერტილ-მძიმეების გამოყენება ნებაყოფლობითია, თუმცა თუ ერთ ხაზში რამოდენიმე ჩანაწერი გვაქვს, მაშინ ისინი ერთმანეთისგან უნდა გამოვყოთ წერტილ-მძიმით.

კომენტარები

ისევე, როგორც პროგრამირების სხვა ბევრ ენაში, ტს-შიც გვხვდება ორი სახის კომენტარი :
  • ერთხაზიანი
  • მრავალხაზიანი
// ერთხაზიანი კომენტარი
 
/* 
   მრავალხაზიანი 
   კომენტარი 
*/

ტს და ობიექტზე ორიენტირებული მიდგომა

TypeScript - ეს არის ობიექტზე ორიენტირებული JavaScript. ობიექტზე ორიენტირებული მიდგომა კი არის პროგრამირების სტილი, პარადიგმა, რომელიც ახდენს ცხოვრებისეული, რეალური მაგალითების მოდელირებას. ეს მიდგომა პროგრამას განიხილავს, როგორც იმ ობიექტთა სიმრავლეს, კოლექციას, ერთობლიობას, რომლებიც ერთმანეთზე ზემოქმედებენ ე.წ მეთოდების დახმარებით. 
class Greeting 
{ 
    greet():void 
    { 
        console.log("გამარჯობა მსოფლიოვ !") 
    } 
} 

var obj = new Greeting(); 
obj.greet();
ამ მაგალითში განსაზღვრულია კლასი Greeting, რომელსაც აქვს მეთოდი greet (), მეთოდს კონსოლში გამოაქვს ტექსტი : 'გამარჯობა მსოფლიოვ !'. სიტყვაგასაღებ 'key'-ს მეშვეობით ხდება Greeting კლასის ახალი ეგზემპლიარის ანუ ობიექტის შექმნა, შემდეგ კი მივმართავთ ამ ობიექტის მეთოდს - greet ().

კომპილაციის შემდეგ დაგენერირდება ჯს-ის შემდეგი კოდი: 

var Greeting = /** @class */ (function () {
    function Greeting() {
    }
    Greeting.prototype.greet = function () {
        console.log("გამარჯობა მსოფლიოვ !");
    };
    return Greeting;
}());

var obj = new Greeting();
obj.greet();
აშკარაა, რომ კლასის აღწერა ტს-ში უფრო ლაკონურად, მკაფიოდ და მარტივად მოხდა ვიდრე ჯს-ში.
4. მონაცემთა ტიპები
მონაცემთა ტიპების სისტემა, მოიცავს ტიპთა იმ მნიშვნელობებს, რომელიც მხარდაჭერილია პროგრამირების კონკრეტული ენის მიერ. ეს სისტემა ამოწმებს კორექტულადაა თუ არა განსაზღვრული ამა თუ იმ მნიშვნელობის ტიპი, მანამ სანამ ეს მნიშვნელობა გამოყენებული იქნება პროგრამაში ან შეინახება ოპერატიულ მეხსიერებაში. ეს გარანტიაა იმისა, რომ პროგრამა სწორად იმუშვებს.

ტიპი Any

მონაცემთა ტიპი 'Any' არის ტს-ში არსებული დინამიური სუპერტიპი, რომლის გამოყენებაც ავტომატურად ნიშნავს, რომ სისტემა აღარ მოახდენს ცვლადის ტიპის დადგენას მის გამოყენებამდე.

ჩაშენებული ტიპები

მონაცემთა ტიპი სიტყვაგასარები აღწერა
რიცხვითი number მთელი და ათწილადი რიცხვების ერთობლიობა.
სტრიქონი string Unicode-ს სხვადასხვა სიმბოლოთა ნებისმიერი თანმიმდევრობა.
ლოგიკური boolean ჭეშმარიტი ან მცდარი
ინგ: Void - ძალადაკარგული; ანულირება, სიცარიელე void გამოიყენება ისეთი ფუნქციების დეკლარირებისას, რომლებიც არ აბრუნებენ რაიმე ტიპის კონკრეტულ ინფორმაციას. მაგალითად ეს ფუნქცია არაფერს აბრუნებს, მას უბრალოდ ტექსტი გამოაქვს კონსოლში : 
function greet():void 
{ 
    console.log("გამარჯობა მსოფლიოვ !") 
}
Null null ამ მნიშვნელობას არანაირი კავშირი არ აქვს ზემოთ ჩამოთვლილ ტიპებთან, ეს არის ცალკე ტიპის ერთადერთი შესაძლო მნიშვნელობა, ანუ ეს არის სპეციალური მნიშვნელობა რომლის უკანაც იგულისხმება "არაფერი".
undefined undefined მნიშვნელობა undefined, ისევე როგორც, null არის თავისი საკუთარი ტიპის ერთადერთი მნიშვნელობა. თუ ცვლადი გამოცხადებულია მაგრამ მასში არაფერია ჩაწერილი მაშინ ამ ცვლადის მნიშვნელობა არის UNDEFINED.
5. ცვლადები
ტს-ში, ისევე როგორც ჯს-ში, ცვლადის დეკლარირებისათვის გამოიყენება სიტყვაგასაღები 'var'.
  • გამოვაცხადოთ ცვლადის ტიპიც და მნიშვნელობაც ერთ ჩანაწერში : var [იდენტიფიკატორი] : [ტიპი] = მნიშვნელობა ;
  • გამოვაცხადოთ ცვლადის მხოლოდ ტიპი, ნაგულისხმეობის პრინციპით ასეთ შემთხვებვაში მისი მნიშვნელობა იქნება undefined : var [იდენტიფიკატორი] : [ტიპი] ;
  • გამოვაცხადოთ ცვლადის მხოლოდ მნიშვნელობა, ასეთ შემთხვებვაში ტიპი ავტომატურად განისაზღვრება მინიჭებული მნიშვნელობიდან გამომდინარე : var [იდენტიფიკატორი] = [მნიშვნელობა] ;
  • მოვახდინოთ ცვლადის მხოლოდ დეკლარირება და არ განვსაზღროთ მისი არც ტიპი და არც მნიშვნელობა, ასეთ შემთხვებვაში ტიპი ავტომატურად გახდება any ხოლო მნიშვნელობა undefined var [იდენტიფიკატორი] = [მნიშვნელობა] ;
# ცვლადის დეკლარირება & აღწერა
1.

var name:string = ”mary”

სტრიქონული ტიპის შენახვა ცვლადში
2.

var name:string;

სტრიქონული ტიპის ცვლადი მნიშვნელობით - undefined.
3.

var name = ”mary”

ცვლადის აღწერა მხოლოდ მნიშვნელობით, ამ შემთხვევაში ის იქნება სტრიქონული ტიპის ანუ string.

4.

var name;

ამ შემთხვევაში ცვლადის ტიპია any. მნიშვნელობა კი undefined.

 

var name:string = "John"; 
var score1:number = 50;
var score2:number = 42.50
var sum = score1 + score2 
console.log("name"+name) 
console.log("first score: "+score1) 
console.log("second score: "+score2) 
console.log("sum of the scores: "+sum)
ამ ყველაფრის კომპილაციის შემდეგ დაგენერირდება ჯს კოდი : 
var name = "John";
var score1 = 50;
var score2 = 42.50;
var sum = score1 + score2;
console.log("name" + name);
console.log("first score: " + score1);
console.log("second score: " + score2);
console.log("sum of the scores: " + sum);
იმ შემთხვევაში თუ ცვლადში შევინახავთ ისეთ მნიშვნელობას, რომელიც არ შეესაბამება მის ტიპს, ტს კომპილატორი დააფიქსირებს შეცდომას, რადგან, როგორც ადრე აღვნიშნეთ ტს არის მკაცრად ტიპიზირებული ენა. სწორედ ამიტომ, მაგალითად ამ კოდის კომპილაციისას დაგენერირდება შესაბამისი შეცდომა : var num:number = "hello"

ცვლადთა თვალთახედვის არეები

ცვლადის თვალთახედვის არე განსაზღვრავს თუ სად შეგვიძლია გამოვიყენოთ ეს ცვლადი. ტს-ში ცვლადს შეიძლება გააჩნდეს შემდეგი თვალთახედვის არეები :
  • გლობალური - გლობალური ცვლადების აღწერა ხდება კოდის კონსტრუქციების გარეთ, მათგან დამოუკიდებლად. ასეთ ცვლადებთან წვდომა შეგვიძლია კოდის ნებისმიერი წერტილიდან.
  • კლასსშიდა - ასეთ ცვლადებს ასევე უწოდებენ ხოლმე 'ველებს'. ისინი აღიწერებიან კლასის შიგნით, მაგრამ კლასის მეთოდების გარეთ. ამ ცვლადებთან წვდომა ხდება კლასის ეგზემპლიარი ობიექტებიდან. შეგვიძლია კლასში აღვწეროთ სტატიკური ველებიც, მათთან წვდომა შესაძლებელია პირდაპირ კლასის დასახელების მეშვეობით.
  • ლოკალური - ცვლადების აღწერა ხება კოდის კონკრეტულ კონსტრუქციებში მაგალითად ციკლში, მეთოდში და ა.შ. მათთან წვდომა შესაძლებელია მხოლოდ იმ კონსტრუქციაში სადაც ვქმნით მათ. 
var global_num = 12 // გლობალური ცვლადი

class Numbers 
{ 
    num_val = 13;  // კლასსშიდა ცვლადი ანუ ველი
    static sval = 10; // სტატიკური ველი
   
    storeNum():void 
    { 
        var local_num = 14; // ლოკალური ცვლადი
   } 
} 

console.log("Global num: "+global_num)  
console.log(Numbers.sval) // სტატიკური ცვლადი

var obj = new Numbers(); 
console.log("Global num: "+obj.num_val)
კომპილაციის შედეგი : 
var global_num = 12; // გლობალური ცვლადი

var Numbers = /** @class */ (function () {

    function Numbers() {
        this.num_val = 13; // კლასსშიდა ცვლადი ანუ ველი
    }

    Numbers.prototype.storeNum = function () {
        var local_num = 14; // ლოკალური ცვლადი
    };

    Numbers.sval = 10; // სტატიკური ველი

    return Numbers;
}());

console.log("Global num: " + global_num);
console.log(Numbers.sval); // სტატიკური ცვლადი

var obj = new Numbers();
console.log("Global num: " + obj.num_val);
თუ შევეცდებით მეთოდის გარეთ მივწვდეთ ლოკალურ ცვლადს მაშინ კომპილაციისას დაგენერირდება შესაბამისი შეცდომა : error TS2095: Could not find symbol 'local_num'.
6. ოპერატორები
პროგრამაში ნებისმიერი ქმედება სრულდება ოპერაციების ამა თუ იმ სიმრავლის დახმარებით, ოპერაციები ჩაწერილია გამოსახულებების საშუალებით. გამოსახულება შედგება ოპერანდებისაგან, ოპერაციის ნიშნებისაგან და მრგვალი ფრჩხილებისაგან. მაგალითად a+b-10 გამოსახულებაში სიდიდეები a და b და კონსტანტა 10 არიან ოპერანდები, ხოლო "+" და "-" ოპერაციის ნიშნები . ოპერანდების რაოდენობიდან გამომდინარე Javascript - ში ოპერაცია შეიძლება იყოს
  • უნარული - როდესაც ოპერაციაში მხიოლოდ ერთი ოპერანდია. მაგ: -a
  • ბინარული - როდესაც ოპერაციაში ორი ოპერანდია მაგ: a+b
  • ტერნარული - სამი ოპერანდის კომბინაცია, პირობითი გამოსახულებები, მაგ: "? :" ჩანაწერი
შინაარსობრივი თვალსაზრისით კი ოპერაციები შეიძლება დაიყოს შემდეგ სახეებად :
  • არითმეტიკული ოპერაციები
  • შედარების ოპერაციები
  • სტრიქონული ოპერაციები
  • ლოგიკური ოპერაციები
  • ბიტური ოპერაციები
  • მინიჭების ოპერაციები
  • შერეული ოპერაციები
არითმეტიკულ ოპერაციებში იგულისხმება მიმატება , გამოკლება, გამრავლება, გაყოფა, ნაშთი, უნარული მინუსი



ინკრემენტ და დეკრემენტ ოპერაციები

ინკრემენტ და დეკრემენტ ოპერაციები წარმოადგენენ უნარული ოპერაციების ნიმუშს პირველი უზრუნველყოფს ცვლადის მნიშვნელობის 1 - ით გაზრდას (i++ ან ++i), მეორე კი შემცირებას (i-- ან --i).
უნდა აღინიშნოს რომ i++ da ++i (ისევე როგორც i-- და --i) ტოლფასი ჩანაწერები არ არიან . ცვლადთან მიმართებაში ამ ოპერატორების (++,--) მდებარეობა განსაზღვრავს თავად ოპერაციის (გაზრდა/შემცირება) შესრულების მომენტს შემდეგი კანონზომიერების მიხედვით :
  • თუ ოპერაცია ჩაწერილია ოპერანდის წინ (++a ე.წ ინკრემენტის პრეფიქსული ფორმა), მაშინ გაზრდა მოხდება მიმდინარე გამოსახულების შესრულებამდე. ანუ ცვლადი ჯერ გაიზრდება/შემცირდება და ისე მიიღებს მონაწილეობას გამოსახულების შესრულებაში
  • თუ ოპერაცია ჩაწერილია ოპერანდის შემდეგ (a++ ე.წ ინკრემენტის პოსტფიქსული ფორმა), მაშინ გაზრდა მოხდება მიმდინარე გამოსახულების შესრულების შემდეგ. ანუ ცვლადი გამოსახულებაში მონაწილეწობას მიიღებს გაზრდამდელი/შემცირებამდელი მნიშნელობით და შემდეგ გაიზრდება/შემცირდება
მაგალითად : i = 1;
k = ++i;
ამ შემთხვევაში i - ც და k - ც მიიღებენ მნიშვნელობა 2 - ს i = 1;
k = i++;
ამ შემთხვევაში i გახდება 2 ხოლო k 1
ინკრემენტ და დეკრემენტ ოპერაციებს პრიორიტეტი აქვთ სხვა ნებისმიერ ოპერაციებთან მიმართებაში ფაქტიურად ამა თუ იმ გამოსახულების შესრულებისას პირველ რიგში სრულდება ++/-- ისევ და ისევ იმ პირობით რომ ოპერანდის მიმართ მათ მდებარეობას აქვს გადამწყვეტი მნიშვნელობა .
i = 3;
k = i++*3;
ამ შემთხვევაში k იქნება 9 - ის ტოლი i = 3;
k = ++i*3;
ამ შემთხვევაში k იქნება 12 - ის ტოლი

შედარების ოპერაციები

ამ ოპერაციების საშუალებით ხდება სხვადასხვა ტიპის ცვლადების მნიშვნელობების შედარება. და მიიღება შედეგი true ან false. ტოლობითი ოპერაციები შირად გამოიყენება if და while ოპერატორებთან ერთად.შეიძლება შეგვხვდეს შემთხვევები, როდესაც ერთმანეთს ვადარებთ სხვადასხვა ტიპის ცვლადებს. შედარების ოპერატორიდან გამომდინარე, შესაძლოა, მოხდეს ტიპების გარდაქმნა და შემდეგ შესრულდეს შედარების ოპერაცია.
  • თუ ერთი ოპერანდი რიცხვითი ტიპისაა, მეორე კი - ტექსტური, მაშინ JavaScript შეეცდება ტექსტური ტიპის ოპერანდის რიცხვითში გარდაქმნას. თუ ტექსტური ტიპის ოპერანდი რიცხვითში ვერ გარდაიქმნება, მაშინ შედარების ოპერაციის შედეგი იქნება false.
  • თუ ერთი ოპერანდი ბულის ტიპისაა, მეორე ოპერანდი კი ტექსტურია, JavaScript შეეცდება ორივე ოპერნადის რიცხვით ფორმატში გარდაქმნას და შემდეგ შესრულდება შედარების ოპერაცია. თუ ტექსტური ტიპის ოპერანდი ვერ გარდაიქმნა რიცხვითში, მაშინ შედარების ოპერაციის შედეგი იქნება false.
  • თუ ერთი ოპერანდი რიცხვითი ტიპისაა, მეორე ოპერანდი კი ბულის ცვლადია, მაშინ JavaScript შეეცდება ბულის ტიპის ოპერანდის რიცხვით ფორმატში გარდაქმნას: true მნიშვნელობა გარდაიქმნება 1-ად, ხოლო false - 0-ად და ამის შემდეგ შესრულდება შედარების ოპერაცია.




სტრიქონული ოპერაციები

ძირითადი სტრიქონული ოპერაცია არის კონკატენაცია (ინგ. concatenation ანუ შეერთება) , ეს ოპერაცია ახდენს სტრიქონების გაერთიანებას არითმეტიკული მიმატების ნიშნის (+) საშუალებით. მაგ: "a"+"b" = "ab" ისეთი გამოსახულების შესრულების შედეგად, რომლის ერთი ოპერანდი მაინც ტექსტური ტიპისაა, მიიღება ყოველთვის ტექსტური სტრიქონი, თუმცა არსებობს გამონაკლისებიც:
  • თუ გამოსახულების პირველი ოპერანდი ტექსტური ტიპისაა, მაშინ ყველა დანარჩენი ოპერანდიც გარდაიქმნება ტექსტურ ფორმატში.
  • თუ გამოსახულების პირველი რამდენიმე ოპერანდი რიცხვითი ტიპისაა, ხოლო დანარჩენები ტექსტურია, მაშინ ჯერ შეიკრიბება რიცხვითი ოპერანდები, ხოლო შემდეგ შეიკრიბება ტექსტურ ოპერანდთან და შედეგი მიიღება ტექსტური ტიპის.
var a="6";
var b=7;
var c=8;
var d;
var e;
var f;
var result;
d=a+b+c; // 678
e=b+c+a; // 156
f=c+a+b; // 867
result=d+e+f; // 678 156 867
alert(result);
ტექსტური ოპერანდების შედარების ალგორითმზე ვისაუბრებთ მე-7-ე თავში.

ლოგიკური ოპერაციები

ლოგიკური ოპერაციებია
  • კონიუნქცია - ლოგიკური "და" ანუ AND (&&)
  • დიზუნქცია - ლოგიკური "ან" ანუ OR (||)
  • უარყოფა - ლოგიკური "უარყოფა" არა ანუ NOT (!)



პრიორიტეტების მიხედვით პირველია "!" , შემდეგ "&&" , შემდეგ "||". აგრეთვე უნდა აღინიშნოს რომ დიზუნქცია და კონიუნქცია მარცხნივასოცირებული ოპერაციებია ანუ (a && b && c) ნიშნავს (a && (b && c))

მინიჭების ოპერაციები

მინიჭების ოპერაციებიც (ისევე როგორც ინკიმენტი/დეკრიმენტი) მიეკუთვნებიან უნარული ოპერაციების ტიპს.


სხვა ოპერაციები

პირობითი გამოსახულება "?:"
გამოსახულებაში მონაწილეობს 3 ოპერანდი და ამიტომ ოპერაცია არის ტერნარული. პირველი ოპერანდი ღებულობს true/false მნიშვნელობას, დანარჩენმა ორმა კი ნებისმიერი ტიპის მნიშვნელობა შეიძლება მიიღოს. თუ პირველი ოპერანდის მნიშვნელობაა true, ოპერატორი "?:" დააბრუნებს მეორე ოპერანდიდან გამოთვლილ მნიშვნელობას, თუ არადა მესამე ოპერანდიდან გამოთვლილს.

expression1 ? expression2 : expression3
ფორმულირება1 ? ფორმულირება2 : ფორმულირება3

მაგ : var x = 30;
var y = x > 25 ? x-5 : x+5;
console.log(y);
დაბრუნდება 25, იმიტომ რომ x>25 პირობა სრულდება, ე.ი y უნდა გახდეს x-5.
7. ციკლები
ამა თუ იმ ამოცანის გადასაჭრელად ხშირად საჭირო ხდება ერთი და იგივე გამოთვლების მრავალჯერ ჩატარება. განმეორებად ბრძანებათა ჯგუფს ეწოდება ციკლი.



ტს მხარს უჭერს ციკლის შემდეგ ინსტრუქციებს: (იხ. ფოტო)



ციკლი იტერაციათა განსაზღვრული რაოდენობით

ციკლს, რომლის იტერაციათა რაოდენობაც წინასწარაა განსაზღვრული ანუ ფიქსირებული, ეწოდება განსაზღვრული (უკეთესი თარგმანი ვერ მოვიფიქრე) ციკლი. მაგალითად ასეთი ციკლია for.

ციკლი იტერაციათა განუსაზღვრელი რაოდენობით

ციკლს, რომლის იტერაციათა რაოდენობაც წინასწარ არ არის განსაზღვრული ანუ უცნობია, ეწოდება განუსაზღვრული (უკეთესი თარგმანი ვერ მოვიფიქრე) ციკლი. მაგალითად ასეთი ციკლებია while და do while.

ციკლი for

for ციკლის მეშვეობით ინსტრუქცია ანუ კოდის ბლოკი სრულდება წინასწარ განსაზღვრულ რაოდენობაჯერ.



გამოყენების სინტაქსი ასეთია : 
for (მთვლელის ინიციალიზაცია; შესადარებელი პირობა; ბიჯი) 
{
    // ინსტრუქცია
}
კონკრეტული მაგალითი : 
var num:number = 5; 
var i:number; 
var factorial = 1; 

for(i=num; i>=1; i--) 
{
   factorial *= i;
}

console.log(factorial)
ჯს-ში გენერირებული კოდი : 
var num = 5; 
var factorial = 1; 

while(num >= 1) 
{ 
   factorial = factorial * num; 
   num--; 
} 

console.log(factorial);
ეს პროგრამა თვლის 5-ის ფაქტორიალს და კონსოლში გამოაქვს შედეგი. ციკლი აგენერირებს მთვლელის ცვლილებათა შუალედს 5-დან 1-ის ჩათვლით და ყოველ იტერაციაზე თვლის მთვლელის შესაბამისი მნიშვნელობების ნამრავლს.

ციკლი for in

for in ციკლი არის for ციკლის ნაირსახეობა. მისი მეშვეობით შესაძლებელია, რომ გარკვეული ინსტრუქცია შევასრულოთ მასივის ან კოლექციის თითოეული ელემენტისათვის. გამოყენების სინტაქსი ასეთია : 
for (var val in list) 
{ 
    // ინსტრუქცია 
}
val ცვლადის ტიპი უნდა იყოს string ან any. კონკრეტული მაგალითი : 
var j:any; 
var n:any = "ა ბ გ" 

for(j in n) 
{
   console.log(n[j])  
}
ჯს-ში გენერირებული კოდი : 
var j;
var n = "ა ბ გ";

for (j in n) 
{
   console.log(n[j]);
}

ციკლი while

while ციკლი არის ციკლის, ასე ვთქვათ წინაპირობითი, პრეპირობითი ნაირსახეობა. ანუ ციკლში პირობის შემოწმება ხდება ციკლის გამოძახებამდე, ციკლის ტანის შესრულებამდე გამოითვლება ლოგიკური პირობის მნიშვნელობა, თუ პირობა ჭერშმარიტია მაშინ ციკლიც სრულდება, ამის შემდეგ ისევ მოწმდება პირობა, ციკლი მეორდება მანამ სანამ პირობა არის ჭეშმარიტი. 
while(პირობა) 
{ 
    // ინსტრუქცია იმ შემთხვევისათვის თუ პირობა არის true
}
ანუ 
მანამ სრულდება (პირობა) 
{ 
    // შეასრულე ეს ინსტრუქცია 
}




კონკრეტული მაგალითი : 
var num:number = 5; 
var factorial:number = 1; 

while(num >=1) 
{ 
   factorial = factorial * num; 
   num--; 
} 

console.log(factorial);
ჯს-ში გენერირებული კოდი : 
var num = 5;
var factorial = 1;

while(num >= 1) 
{
   factorial = factorial * num;
   num--;
}

console.log(factorial);

ციკლი do while

do while ციკლი while - ციკლისგან განსხვავეიბით არის პოსტპირობითი ციკლი. ანუ ციკლის გაგრძელების ლოგიკური პირობა იწერება ციკლის ტანის შემდეგ და ციკლის ტანში აღწერილი ინსტრუქცია მინიმუმ ერთხელ მაინც სრულდება, ამის შემდეგ მოწმდება ციკლის გაგრძელების პირობა, თუ იგი ჭეშმარიტია მაშინ ინსტრუქცია კიდევ სრულდება. 
do 
{
    // ინსტრუქცია
} 
while(პირობა)
ანუ 
შეასრულე 
{
    // ეს ინსტრუქცია
} 
მანამ(პირობა ჭეშმარიტია)




კონკრეტული მაგალითი : 
var n:number = 10;

do 
{ 
   console.log(n); 
   n--; 
} 
while(n>=0);
ჯს-ში გენერირებული კოდი : 
var n = 10;

do 
{
   console.log(n);
   n--;
} 
while(n >= 0);

break ჩანაწერი

ციკლის შეწყვეტა შესაძლებელია ოპერატორ break - ის საშუალებით, რომელიც ჩართულია ციკლის ტანში. ის გამოიყენება მაშინ როდესაც ციკლის შესრულებისას დაფიქსირდება რაღაც შეცდომა ან იმ შემთხვევაში როდესაც ცვლადი მიიღებს რაღაც კონკრეტულ მნიშვნელობას და აღარაა საჭირო ციკლის გაგრძელება. როგორც წესი break სრულდება რაიმე წინაპირობასთან ერთად.



კონკრეტული მაგალითი : ვიპოვოთ 5-ის პირველი ჯერადი რიცხვი შუალედში [1-10] 
var i:number = 1 

while(i <= 10) 
{ 
    if (i % 5 == 0) 
    {   
        console.log (i) 
        break // 5-ის პირველი ჯერადი რიცხვი ნაპოვნია და გაგრძელება აღარაა საჭირო
    } 

    i++ 
}
ჯს-ში გენერირებული კოდი : 
var i = 1;

while (i <= 10) 
{
    if (i % 5 == 0)
    {
        console.log(i);
        break; 
    }

    i++;
}

ციკლის კონკრეტული იტერაციის გამოტოვება, continue

დავუშვათ გვინდა არა მთლიანი ციკლის შეჩერება არამედ მისი კონკრეტული იტერაციის გაუქმება. ამ შემთხვევაში გამოიყენება ოპერატორი continue, რომელიც ასევე ციკლის ტანში იწერება.



კონკრეტული მაგალითი : დავთვალოთ რამდენი კენტი რიცხვია [0-20] შუალედში 
var num:number = 0
var count:number = 0;

for(num=0; num<=20; num++) 
{
    if(num % 2 == 0) 
    {
        continue
    }

    count++
}

console.log (count)
ჯს-ში გენერირებული კოდი : 
var num = 0;
var count = 0;

for(num = 0; num <= 20; num++) 
{
    if (num % 2 == 0) 
    {
      continue;
    }

    count++;
}

console.log(count);
8. ფუნქციები
ფუნქცია ეს არის პროგრამის სახელდებული ფრაგმენტი, სხვადასხვა ინსტრუქციების ერთობლიობა, რომლის განსაზღვრაც ხდება ერთხელ მაგრამ გამოძახება შეიძლება მრავალჯერ.

ფუნქციის განსაზღვრა

ფუნქციის განსაზღვრისას უნდა მივუთითოთ მისი დასახელება და აღვწეროთ თუ რომელი კონკრეტული საკითხის გადაჭრას ვაპირებთ და როგორ. უშუალოდ ფუნქციის გამოცხადება ხდება სიტყვაგასღებ 'function'-ის მეშვეობით: 
function  function_name() 
{ 
    // ფუნქციის ტანი
}
                
function () 
{   
    console.log("გილოცავთ ახალ წელს !") 
}

ფუნქციის გამოძახება

იმისათვის რათა შესრულდეს ფუნქციაში აღწერილი ინსტრუქციები, უნდა მოვახდინოთ ამ ფუნქციის გამოძახება. გამოძახების სინტაქსი ასეთია : function_name() კონკრეტული მაგალითი კი ასეთი : 
function test() 
{  
    console.log("გილოცავთ ახალ წელს !"); 
} 

test();

შედეგის დაბრუნება

შესაძებელია, რომ ფუნქციამ დაუბრუნოს კონკრეტული მნიშვნელობა 'გამომძახებელს'.ამ პროცედურის სინტაქსი ასეთია : 
function function_name():return_type 
{ 
    return value; 
}
  • 'return_type' შეიძლება იყოს ინფორმაციის ნებისმიერი ტიპი, რომელიც ტს-შია მიღებული.
  • თუ გვსურს, რომ ფუნქციამ რაიმე მნიშვნელობა დააბრუნოს, მაშინ იგი აუცილებლად უნდა დამთავრდეს 'return' ჩანაწერით.
  • შესაძლებელია მხოლოდ ერთი მნიშვნელობის დაბრუნება.
  • დასაბრუნებელი ინფორმაციის ტიპი უნდა დაემთხვეს ფუნქციის აღწერისას მითითებულ ტიპს (return_type).

კონკრეტული მაგალითი

// ფუნქციის განსაზღვრა, ფუნქცია აბრუნერბს სტრიქონს
function greet():string 
{ 
    return "გილოცავთ ახალ წელს !" 
} 

// ფუნქცია გამომძახებელი
function caller() 
{ 
    var msg = greet() 
    console.log(msg) 
} 

caller()

პარამეტრები

პარამეტრი არის საშუალება შემდეგი გამოყენების მიზნით, ფუნქციას მივამაგროთ, გადავცეთ რაიმე ინფორმაცია. 
function func_name( param1 [:datatype], ( param2 [:datatype]) 
{   
    // ...
}
კონკრეტული მაგალითი : 
function test_param(n1:number,s1:string) 
{ 
   console.log(n1) 
   console.log(s1) 
} 

test_param(123,"გილოცავთ შობას !")
  • აღიწერა ფუნქცია test_param, რომელსაც გადაეცა 2 პარამეტრი : n1, s1.
  • აუცილებელი არ არის განისაზღვროს პარამეტრთა ტიპები, ასეთ შემთხვევაში მათი ტიპი იქნება any.
  • თუ არგუმენტთა აღწერისას მივუთითებთ კონკრეტულ ტიპებს მაშინ აუცილებელია ამ არგუმენტს მივამაგროთ შესაბამისი ტიპის ინფორმაცია, თუ ასე არ ვიზამთ კომპილატორი დააგენერირებს შეცდომას.
ამ კოდის კომპილასციის შემდეგ გაეშვება ჯს შემდეგი კოდი : 
function test_param(n1, s1) 
{
   console.log(n1);
   console.log(s1);
}

test_param(123,"გილოცავთ შობას !")

ნებაყოფლობითი და ნაგულისხმევი პარამეტრები

ტს-ში იგულისხმება, რომ უკლებლივ ყველა აღწერილი არგუმენტი გამოყენებული უნდა იყოს ფუნქციაში. თუმცა ეს არ ნიშნავს იმას, რომ ჩვენ არ შეგვიძლია პარამეტრის მნიშვნელობად მივუთითოთ მაგალითად undefined ან null. რაც შეეხება არგუმენტების რაოდენობას : აუცილებელია, რომ ფუნქციას გამოძახებისას გადაეცეს იმდენივე პარამეტრი რამდენიც გადაეცა ინიციალიზაციისას : 
function buildName(firstName: string, lastName: string) 
{
    return firstName + " " + lastName;
}

let result1 = buildName("ვასო"); // შეცდომაა : აკლია პარამეტრები
let result2 = buildName("ვასო", "ნადირაძე", "ხაშური");  // შეცდომაა : ზედმეტი პარამეტრები
let result3 = buildName("ვასო", "ნადირაძე"); // სწორია
ჯავასკრიპტში ფუნქციის თითოეული პარამეტრის აღწერა არის არასავალდებულო და მომხმარებელს შეუძლია საერთოდ არ განსაზღვროს ზოგიერთი მათგანი, ასეთ შემთხვევაში ამ არგუმენტების მნიშვნელობა არის undefined.

იმისათვის რათა ტაიპსკრიპტში არგუმენტი გავხადოთ არასავალდებულო ამ არგუმენტის დასახელებას უნდა დავურთოთ "?" ნიშანი, მაგალითად გვინდა, რომ გვარი იყოს არასავალდებულო : 

function buildName(firstName: string, lastName?: string) 
{
    if (lastName)
        return firstName + " " + lastName;
    else
        return firstName;
}

let result1 = buildName("ვასო"); // ახლა უკვე სწორია
let result2 = buildName("ვასო", "ნადირაძე", "ხაშური");  // შეცდომაა : ზედმეტი პარამეტრები
let result3 = buildName("ვასო", "ნადირაძე"); // სწორია
არასავალდებულო პარამეტრები უნდა აღიწეროს აუცილებლად სავალდებულო პრამეტრების შემდეგ, დავუშვათ თუ გვსურს, რომ არასავალდებულო ამჯერად გავხადოთ სახელი და არა გვარი, მაშინ პარამეტრებსაც უნდა შევუცვალოთ ადგილი ფუნქციის აღწერისას.

ტაიპსკრიპტში აგრეთვე შესაძლებელია, რომ არგუმენტს განვუსაზღვროთ ნაგულისხმევი მნიშვნელობა, რომელსაც იგი იმ შემთხვევაში მიიღებს თუ ფუნქციის გამოძახებისას მომხმარებელი არ განსაზღვრავს ამ არგუმენტის მნიშვნელობას, ასეთ პარამეტრებს ეწოდება ნაგულსხმევად ინიციალიზირებული პარამეტრები (default-initialized parameters). 

function buildName(firstName: string, lastName = "ნადირაძე") 
{
    return firstName + " " + lastName;
}

let result1 = buildName("ვასო"); // სწორია, დაბრუნდება : ვასო ნადირაძე
let result2 = buildName("ვასო", undefined);  // ახლაც სწორია, დაბრუნდება : ვასო ნადირაძე
let result2 = buildName("ვასო", "ნადირაძე", "ხაშური");  // შეცდომაა : ზედმეტი პარამეტრები
let result3 = buildName("ვასო", "ნადირაძეეე"); // სწორია, ამჯერად უკვე დაბრუნდება ვასო ნადირაძეეე
არასავალდებულო პარამეტრებისაგან განსხვავებით, აუცილებელი არ არის, რომ ნაგულისხმევად ინიციალიზირებული პარამეტრები აღვწეროთ ძირითადი პარამეტრების შემდეგ. სავსებით კორექტულია მაგალითად ეს კოდი : 
function buildName(firstName = 'ვასო', lastName: string) 
{
    return firstName + " " + lastName;
}

Rest პარამეტრები

უკვე გავეცანით სამი ტიპის პარამეტრებს, ესენია :
  • სავალდებულო ანუ ძირითადი პარამეტრები.
  • არასავალდებულო ანუ ნებაყოფლობითი პარამეტრები.
  • ნაგულისხმევად ინიციალიზირებული პარამეტრები.
სამივე ტიპის პარამეტრების უკან მოიაზრება მხოლოდ ერთი მნიშვნელობა, მაგრამ შეიძლება მოხდეს ისე, რომ დაგვჭირდეს პარამეტრთან, როგორც მონაცემთა ნაკრებთან მუშაობა და წინასწარ არ ვიცოდეთ თუ რა რაოდენობის ინფორმაცია შევა ამ ჯგუფში. ტს-ში შესაძლებელია, რომ ამდაგვარი ჯგუფები აღიწეროს ცვლადში და ეს ცვლადი გადაეცეს არგუმენტად ფუნქციას. სხვა სიტყვებით, რომ ვთქვათ 'Rest პარამეტრი'-ს უკან მოიაზრება განუსაზღვრელი რაოდენობის არასავალდებულო არგუმენტთა ნაკრები. 
function addNumbers(...nums:number[]) 
{
    var i;   
    var sum:number = 0; 
   
    for(i = 0; i < nums.length; i++) 
    { 
        sum = sum + nums[i]; 
    } 

    console.log("sum of the numbers",sum) 
} 

addNumbers(1,2,3) 
addNumbers(10,10,10,10,10)
კომპილაციის შემდეგ შესრულდება ეს ჯს კოდი : 
function addNumbers() 
{
    var nums = [];

    for (var _i = 0; _i < arguments.length; _i++) 
    {
        nums[_i - 0] = arguments[_i];
    }

    var i;
    var sum = 0;
	
    for (i = 0; i < nums.length; i++) 
    {
        sum = sum + nums[i];
    }

    console.log("sum of the numbers", sum);
}

addNumbers(1, 2, 3);
addNumbers(10, 10, 10, 10, 10);

ანონიმური ფუნქციები

ფუნქციას, რომელიც არ არის დაკავშირებული კონკრეტულ იდენტიფიკატორთან (სახელთან), ეწოდება ანონიმური ფუნქცია. ასეთი ფუნქციების დეკლარირება ხდება მათი გამოძახებისას. var res = function( [arguments] ) { ... } კონკრეტრული მაგალითი : 
var msg = function() 
{ 
    return "გამარჯობა";  
} 

console.log(msg())
რა თქმა უნდა შესაძლებელია, რომ ანონიმურ ფუნქციას გადაეცეს პარამეტრებიც : 
var res = function(a:number,b:number) 
{ 
    return a*b;  
}; 

console.log(res(12,2))

რეკურსია და ტს ფუნქციები

როგორც ვიცით, რეკურსია არის პროცესი, რომლის დროსაც ფუნქციაში ხდება თავად ამ ფუნქციის გამოძახება მანამ სანამ არ მივიღებთ კონკრეტულ შედეგს. რეკურსიის ყველაზე თვალსაჩინო მაგალითია რიცხვის ფაქტორიალის დასათვლელი ფუნქცია : 
function factorial(number) 
{
    if (number < = 0) 
    {
        return 1; 
    } 
    else 
    {  
        return (number * factorial(number - 1)); // ფუნქცია იძახებს თავისივე თავს
    } 
}; 

console.log(factorial(6));

ანონიმური რეკურსიული ფუნქცია

(function () 
{ 
    var x = "Hello!!";   
    console.log(x)     
})() // ფუნქცია თავისივე თავს იძახებს მრგვალი ფრცილების '()' მეშვეობით

ლამბდა ფუნქციები

ე.წ ლამბდა ფუნქციის უკან მოიაზრება ანონიმური ფუნქციის აღწერის მექანიზმი. ასეთ ფუნქციებს ასევე უწოდებენ 'Arrow ანუ ისარ ფუნქციებს'-აც. ლამბდა ფუნქცია შედგება 3 ნაწილისაგან
  • პარამეტრები - შესაძლოა გააჩნდეს ან არ გააჩნდეს.
  • ლამბდა-ნოტაცია - ჩანაწერი '=>', იგივე ლამბდა ოპერატორი.
  • ინსტრუქციები - ოპერაციათა მიმდევრობა, რომელიც უნდა შესრულდეს ფუნქციის გამოძახებისას.
ლამბდა ფუნქციის აღწერის სინტაქსი ასეთია : ( [პარამეტრი1, პარამეტრი2,…პარამეტრი n] )=>ინსტრუქციები; კონკრეტული მაგალითი : 
var foo = (x:number)=>10 + x 
console.log(foo(100)) // 110
ფუნქცია დააბრუნებს არგუმენტად გადაცემული მნიშვნელობისა და 10-ის ჯამს. კომპილაციის შემდეგ შესრულდება ჯს შემდეგი კოდი : 
var foo = function (x) 
{ 
    return 10 + x; 
};

console.log(foo(100));  // 110

ლამბდა ჩანაწერები

ლამბდა ჩანაწერი არის ანონიმური ფუნქციის დეკლარირების ინსტრუქცია, რომელიც უკავშირდება ბლოკში მოქცეულ კოდის ფრაგმენტს. სინტაქსი ასეთია : 
( [პარამეტრი1, პარამეტრი2,…პარამეტრი n] ) => {
    // ბლოკი სადაც აღწერილია რაიმე კოდი
}
კონკრეტული მაგალითი : 
var foo = (x:number) => {    
   x = 10 + x 
   console.log(x)  
} 

foo(100)
კომპილაციის შემდეგ შესრულდება ჯს შემდეგი კოდი : 
var foo = function (x) 
{
    x = 10 + x;
    console.log(x);
};

foo(100);
9. მუშაობა რიცხვებთან
ტს, ისევე როგორც ჯს, მხარს უჭერს რიცხვით მნიშვნელობებსა და რიცხვითი კლასის - Number-ის ობიექტებს. ეს კლასი საშუალებას გვაძლევს რიცხვით ლიტერალებთან ვიმუშავოთ, როგორც ობიექტებთან. var var_name = new Number(value) თუ Number კლასს არგუმენტად გადავცემთ არარიცხვითი ტიპის მნიშვნელობას, იგი შედეგად დააბრუნებს Nan-ს. ქვემოთ მოყვანილ ცხრილში აღწერილია Number კლასის თვისებები :
# თვისება & აღწერა
1.

MAX_VALUE

შესაძლო მაქსიმალური რიცხვითი მნიშვნელობა ჯავასკრიპტში : 1.7976931348623157E+308.
2.

MIN_VALUE

შესაძლო მაქსიმალური რიცხვითი მნიშვნელობა ჯავასკრიპტში : 5E-324.
3.

NaN

მნიშვნელობა რომლის უკანაც მოიაზრება არარიცხვითი ტიპის მნიშვნელობა.
4.

NEGATIVE_INFINITY

ანუ უარყოფითი უსასრულობა, მნიშვნელობა, რომელიც ნაკლებია MIN_VALUE-ზე.
5.

POSITIVE_INFINITY

ანუ დადებითი უსასრულობა, მნიშვნელობა, რომელიც მეტია MAX_VALUE-ზე.
6.

prototype

Number კლასის ობიექტის სტატიკური თვისება. გამოიყენება მაშინ, როდესაც გვინდა, რომ Number კლასის ობიექტს დავამატოთ ახალი მეთოდები და თვისებები მიმდინარე დოკუმენტში.
მაგალითები : 
console.log("შესაძლო მაქსიმალური რიცხვითი მნიშვნელობა ჯავასკრიპტში : " + Number.MAX_VALUE); 
console.log("შესაძლო მინიმალური რიცხვითი მნიშვნელობა ჯავასკრიპტში  : " + Number.MIN_VALUE); 
console.log("უარყოფითი უსასრულობის მნიშვნელობა : " + Number.NEGATIVE_INFINITY); 
console.log("დადებითი უსასრულობის მნიშვნელობა : " + Number.POSITIVE_INFINITY);
Nan თვისების გამოყენების მაგალითი : 
var month = 0 

if( month <= 0 || month >12) 
{ 
    month = Number.NaN 
    console.log("თვე არის "+ month) 
} 
else 
{ 
    console.log("Value Accepted..") 
}
შედეგი იქნება თვე არის Nan prototype თვისების გამოყენების მაგალითი : 
function employee(id:number,name:string) 
{ 
    this.id = id 
    this.name = name 
} 

var emp = new employee(123,"ვასო") 
employee.prototype.email = "vn@gmail.com" 

console.log("Id: "+emp.id) 
console.log("სახელი: "+emp.name) 
console.log("ელ_ფოსტა: "+emp.email)

toExponential()

მეთოდი გამოიყენება რიცხვის ექსპონენციალური მნიშვნელობის მისაღებად. 
var num1 = 1225.30 
var val = num1.toExponential(); 
console.log(val) // 1.2253e+3

toFixed()

გამოიყენება ათწილადის დასამრგვალებლად მითითებულ სიზუსტემდე. არგუმენტად შეგვიძლია გადავცეთ რიცხვი, რომელიც განსაზღვრავს თუ რა სიზუსტით გვინდა დამრგვალება 
var num3 = 177.234 

console.log(num3.toFixed()) // 177
console.log(num3.toFixed(2)) // 177.23 
console.log(num3.toFixed(6)) // 177.234000
10. მუშაობა სტრიქონებთან
String-კლასის ობიექტების მეშვეობით შესაძლებელია სიმბოლოთა თანმიმდევრობასთან ანუ სტრიქონთან მუშაობა. var var_name = new String(string);

length თვისება

length თვისება გამოიყენება სტრიქონის სიგრძის დასადგენად. 
var uname = new String("გამარჯობა") 
console.log(uname.length) // 9

charAt() მეთოდი

charAt() მეთოდი აბრუნებს არგუმენტად გადაცემული ინდექსის შესაბამის სიმბოლოს სტრიქონიდან. string.charAt(index); 
var str = new String("ეს არის სტრიქონი"); 

console.log(str.charAt(0)); // ე

charCodeAt()

ამ მეთოდის მეშვეობით შესაძლებელია კონკრეტულ ინდექსზე მდგომი რომელიმე სიმბოლოს Unicode ნომრის წაკითხვა. var str = new String("ეს არის სტრიქონი");
console.log(str.charCodeAt(0));

concat

ინგ : Concatenation - ურთიერთკავშირი, შეერთება.

ეს მეთოდი გამოიყენება სტრიქონთა გასაერთიანებლად

გამოყენების სინტაქსი ასეთია : string.concat(string2, string3[, ..., stringN]); კონკრეტული მაგალითი : 
var str1 = new String( "პირველი" ); 
var str2 = new String( " მეორე" ); 
var str3 = str1.concat( str2 ); 

console.log("str1 + str2 : "+str3)

indexOf

ეს ოპერატორი სტრიქონში ეძებს პარამეტრად მითითებულ პირველ შემხვედრ სიმბოლოს ან სიმბოლოთა ჯგუფს და აბრუნებს მის ინდექსს. თუ მითითებული სიმბოლო საერთოდ არ არის ტექსტში მაშინ აბრუნებს -1 - ს 
var str1 = new String("პირველი სტრიქონი"); 
var index = str1.indexOf("სტრიქონი"); 

console.log(index);  // 8

lastIndexOf

ეს ოპერატორი სტრიქონში ეძებს პარამეტრად მითითებულ ბოლო შემხვედრ სიმბოლოს ან სიმბოლოთა ჯგუფს და აბრუნებს მის ინდექსს. 
var str1 = new String("პირველი სტრიქონი ანუ სტრიქონი პირველი"); 
var index = str1.lastIndexOf("სტრიქონი");

console.log(index); // 21
დანარჩენი მეთოდები და თვისებები შეგიძლიათ იხილოთ ჯავასკრიპტის კურსის მე-7-ე თავში ...
11. მასივები

მასივის დეკლარირება და ინიციალიზაცია

ტს-ში მასივის დეკლარირებისა და ინიციალიზაციის სინტაქსი ასეთია : 
var array_name[:datatype]; // დეკლარირება
array_name = [val1,val2,valn..]  // ინიციალიზაცია
თუ დეკლარირებისას არ მივუთითებთ მასივში შესანახი ინფორმაციის ტიპს, მაშინ ეს ტიპი ავტომატურად გახდება any, რომელიც ინიციალიზაციის შემდეგ ჩანაცვლდება მასივში შემავალი პირველი ელემენტის ტიპით.

მასივის დეკლარირება და ინიციალიზაცია შესაძლებელია ერთი ჩანაწერითაც :

var array_name[:data type] = [val1,val2…valn]
კონკრეტული მაგალითი : 
var alphas:string[]; 
alphas = ["1","2","3","4"] 

console.log(alphas[0]);  // 1

Array კლასი

მასივის შექმნა შესაძლებელია Array კლასის მეშვეობითაც, ამ კლასის ობიექტს შექმნისას შეგვიძლია პარამეტრებად გადავცეთ :
  • რიცხვი, რომელიც განსაზღვრავს მასივის სიგრძეს.
  • ერთმანეთისაგან მძიმით გამოყოფილი მნიშვნელობები.
var arr_names:number[] = new Array(4)  

for(var i = 0; i < arr_names.length; ++;) 
{ 
   arr_names[i] = i * 2 
   console.log(arr_names[i]) 
}
კომპილაციის შემდეგ შესრულდება ეს კოდი : 
var arr_names = new Array(4);

for (var i = 0; i < arr_names.length; i++) 
{
    arr_names[i] = i * 2;
    console.log(arr_names[i]);
}
შედეგი კი იქნება : 
0 
2 
4 
6
მძიმით გამოყოფილი მნიშვნელობები მასივის შექმნისას : 
var names:string[] = new Array("გიორგი","დავითი","ანა","ლევანი") 

for(var i = 0; i < names.length; i++) 
{ 
    console.log(names[i]) 
}

მასივებთან სანუშაო მეთოდები

იხ. ჯავასკრიპტის კურსის მე-10-ე თავი ...
12. ინტერფეისები
ინტერფეისი ეს არის სინტაქსური კონტრაქტი, რომელთან წვდომაც შეგვიძლია აპლიკაციის ნებისმიერი ფრაგმენტიდან. ინტერფეისს შეიძლება გააჩნდეს თვისებები, მეთოდები, მოვლენები. ინტერფეისში ხდება თითოეული ამათგანის მხოლოდ დეკლარირება, უშუალოდ განსაზღვრა კი შესაძლებელია იმ გარემოში რომელსაც ვიყენებთ კონკრეტულ ინტერფეისთან სამუშაოდ. ანუ იქმნება ინტერფეისი, მასში ხდება მეთოდებისა და თვისებების დეკლარირება, შემდეგ იქმნება ამ ინტერფეისთან სამუშაო კონკრეტული გარემო (კლასი, ობიექტი ...) და ამ გარემოში ხდება მეთოდებისა და თვისებების უშუალოდ განსაზღვრა.

ინტერფეისის შესაქმნელად გამოიყენება სიტყვაგასაღები interface: 

interface interface_name 
{ 
    // მეთოდებისა და თვისებების დეკლარირება
}
გამოყენების მაგალითი 
interface IPerson 
{ 
    firstName:string, // თვისების დეკლარირება
    lastName:string, // თვისების დეკლარირება
    sayHi: ()=>string // მეთოდის დეკლარირება
} 

var customer:IPerson = 
{ 
    firstName:"ვასო",
    lastName:"ნადირაძე", 
    sayHi: ():string =>{return "გამარჯობა"} 
} 

console.log(customer.firstName) 
console.log(customer.lastName) 
console.log(customer.sayHi())  

var employee:IPerson = 
{ 
    firstName:"გიორგი",
    lastName:"კირვალიძე", 
    sayHi: ():string =>{return "გამარჯობა"} 
} 
  
console.log(employee.firstName);
console.log(employee.lastName);
შეიქმნა ინტერფეისი IPerson, შემდეგ ობიექტი customer რომლის ტიპიც არის IPerson, რაც იმას ნიშნავს, რომ ეს ობიექტი ანუ ინტერფეისთან სამუშაო ერთგვარი გარემო უკვე დაკავშირებულია ინტერფეისთან და მასში უკვე შეგვიძლია ინტერფეისში დეკლარირებული თვისებებისა და მეთოდების განსაზღვრა.

ზემოთ აღწერილი კოდის კომპილირების შემდეგ შესრულდება ჯს შემდეგი კოდი : 

var customer = 
{ 
    firstName: "Tom", 
    lastName: "Hanks",
    sayHi: function () { return "Hi there"; }
};

console.log(customer.firstName);
console.log(customer.lastName);
console.log(customer.sayHi());

var employee = 
{ 
    firstName: "გიორგი", 
    lastName: "კირვალიძე",
    sayHi: function () { return "Hello!!!"; } 
};

console.log(employee.firstName);
console.log(employee.lastName);
როგორც ვხედავთ ინტერფეისის კომპილირება არ მოხდა რადგან ის არის მხოლოდ ტს-ის ნაწილი.

ინტერფეისები და მემკვიდრეობითობა

ტს-ში შესაძლებელია, რომ ერთი ინტერფეისის გაფართოება ანუ განვრცობა მოვახდინოთ მეორე ინტერფეისში, სხვა სიტყვებით თუ ვიტყვით : შესაძლებელია რომელიმე ინტერფეისი გავხადოთ სხვა ერთი ან რამოდენიმე ინტერფეისის მემკვიდრე. ამისათვის გამოიყენება extends სიტყვაგასაღები.

ინგ: Extend - გაშლა, გაფართოება, გაგანიერება; 

Child_interface_name extends super_interface1_name, 
super_interface2_name,…,super_interfaceN_name
კონკრეტული მაგალითები : 
interface Person 
{ 
    age:number 
} 

interface Musician extends Person 
{ 
    instrument:string 
} 

var guitarist = <Musician>{}; 

guitarist.age = 27 
guitarist.instrument = "გიტარა" 

console.log("ასაკი:  "+guitarist.age) 
console.log("ინსტრუმენტი:  "+guitarist.instrument)
კომპილახციის შემდეგ შესრულდება შემდეგი ჯს კოდი : 
var guitarist = {};

guitarist.age = 27;
guitarist.instrument = "გიტარა";

console.log("ასაკი:  " + guitarist.age);
console.log("ინსტრუმენტი:  " + guitarist.instrument);
ახლა რომელიმე ინტერფეისი გავხადოთ რამოდენიმერ ინტერფეისის მემკვიდრე : 
interface IParent1 
{ 
    v1:number 
} 

interface IParent2 
{ 
    v2:number 
} 

interface Child extends IParent1, IParent2 
{
    
} 

var Iobj:Child = { v1:12, v2:23} 

console.log("მნიშვნელობა 1: "+this.v1+" მნიშვნელობა 2: "+this.v2)
კომპილაციის შემდეგ შესრულდება შემდეგი კოდი : 
var Iobj = { v1: 12, v2: 23 };
console.log("მნიშვნელობა 1: "+this.v1+" მნიშვნელობა 2: "+this.v2)
13. კლასები
ტაიპსკრიპტი არის ობიექტზე ორიენტირებული ჯავასკრიპტი. როგორც ადრე ვთქვით იგი მხარს უჭერს ოოპ-ის ისეთ ფუნდამენტურ სტრუქტურებს, როგორებიცაა კლასი, ინტერფეისი და ა.შ. ოოპ-ში კლასი არის სტრუქტურა, რომლის მიხედვითაც ვქმნით ობიექტებს, კლასებში ასევე ხდება მონაცემთა ინკაფსულაცია (ოოპის ძირითადი პრინციპებისა და მიდგომების შესახებ დაწვრილებითი ინფორმაცია შეგიძლიათ იხილოთ ამ ცნობარში).

კლასის შექმნა

კლასის შესაქმნელად გამოიყენება class სიტყვაგასაღები : 
class class_name 
{ 
    // კოდი
}
კლასი შეიძლება შეიცავდეს :
  • ველებს ანუ თვისებებს − კლასში აღწერილი ნებისმიერი ცვლადი.
  • კონსტრუქტორებს − ინსტრუქციათა ნაკრები, რომელიც ავტომატურტად სრულდება კლასის ეგზემპლიარი ობიექტის შექმნისას.
  • ფუნქციებს ანუ მეთოდებს − ინსტრუქციათა ნაკრები, რომელიც იმ შემთხვევაში შესრულდება თუ კლასის ეგზემპლიარი ობიექტის შექმნის შემდეგ გამოვიძახებთ მათ.
განვიხილოთ შემდეგი კლასი : 
class Person 
{
    
}
ამ კოდის კომპილაციის შემდეგ შესრულდება შემდეგი კოდი 
var Person = (function () {

   function Person() 
   {
        
   }

   return Person;

}());
კლასის დეკლარირების მაგალითი : 
class Car 
{ 
    // ველი ანუ თვისება 
    engine:string; 
 
    // კონსტრუქტორი
    constructor(engine:string) 
    { 
        this.engine = engine 
    }  

    // მეთოდი 
    disp():void 
    { 
        console.log(this.engine) 
    } 
}
როგორც ვხედავთ კონსტრუქტორის შესაქმნელად გამოიყენება სიტყვაგასაღები constructor.

სიტყვაგასაღები this კი მიუთითებს მიმდინარე სამუშაო გარემოზე, მიმდინარე კლასსზე.

disp არის ჩვერულებრივი ფუნქცია, კლასის მეთოდი. შევნიშნოთ, რომ მისი შექმნისას არ გამოგვიყენებია function სიტყვაგასაღები.

კომპილაციის შემდეგ შესრულდფება ეს კოდი : 
var Car = (function () {

    // კონსტრუქტორი
    function Car(engine) 
    {
        this.engine = engine;
    }
	
    // მეთოდი
    Car.prototype.disp = function () {
      console.log(this.engine);
    };

    return Car;

}());

ობიექტების შექმნა

ობიექტების შესაქმნელად გამოიყენება new სიტყვაგასაღები : 
var object_name = new class_name([ arguments ])
შევქმნათ ზემოთ აღწერილი კლასის ობიექტი : 
var obj = new Car("Engine 1")

წვდომა მეთოდებთან და თვისებებთან

კლასის მეთოდებთან და თვისებებთან წვდომა შესაძლებელია ამ კლასის საფუძველზე შექმნილი ობიექტების მეშვეობით. 
// თვიზებასთან წვდომას
obj.field_name 

// მეთოდთან წვდომა
obj.function_name()
კონკრეტული მაგალითი : 
class Car 
{ 
    // ატრიბუტი ასნუ თვისება
    engine:string; 
   
    // კონსტრუქტორი
    constructor(engine:string) 
    { 
        this.engine = engine 
    }  
   
    // მეთოდი
    disp():void 
    { 
        console.log("Function displays Engine is  :   "+this.engine) 
    } 
} 

// ობიექტის შექმნა
var obj = new Car("XXSY1")

// თვისებასთან წვდომა
console.log(obj.engine)  

// მეთოდთან წვდომა
obj.disp()
კომპილაციის შემდეგ შესრულდება შემდეგი კოდი : 
var Car = (function () 
{
    // კონსტრუქტორი
    function Car(engine) 
    {
        this.engine = engine;
    }
	
    Car.prototype.disp = function () 
    {
        console.log(this.engine);
    };

    return Car;

}());

/// ობიექტის შექმნა
var obj = new Car("XXSY1");

// თვისებასთან წვდომა
console.log(obj.engine);

// მეთოდთან წვდომა
obj.disp();

მემკვიდრეობითობა კლასებს შორის

მემკვიდრეობითობა - ეს არის შესაძლებლობა უკვე ასრსებული კლასების საფუძველზე შევქმნათ ახალი კლასები.

კლასს, რომლის განვრცობისა და გაფართოების შემდეგაც მიიღება ახალი კლასი, ეწოდება მშობელი ანუ სუპერ კლასი, ახალშექმნილ კლასს კი მემკვიდრე კლასი.

class child_class_name extends parent_class_name 
class Shape 
{ 
    Area:number 
   
    constructor(a:number) 
    { 
      this.Area = a 
    } 
} 

class Circle extends Shape 
{ 
    disp():void 
    { 
        console.log(this.Area) 
    } 
}
  
var obj = new Circle(223); 
obj.disp()
კომპილაციის შემდეგ შესრულდება შემდეგი კოდი : 
var __extends = (this && this.__extends) || function (d, b) 
{
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};

var Shape = (function () {

    function Shape(a) {
        this.Area = a;
    }

    return Shape;

}());

var Circle = (function (_super) {

    __extends(Circle, _super);

    function Circle() {
        _super.apply(this, arguments);
    }
	
    Circle.prototype.disp = function () { 
         console.log("Area of the circle:  " + this.Area); 
    };

    return Circle;

}(Shape));

var obj = new Circle(223);
obj.disp();

მეთოდის ხელახალი განსაზღვრა მემკვიდრე კლასში

ტს-ში შესაძლებელია, რომ მემკვიდრე ანუ შვილობილ კლასში მოვახდინოთ მშობელი კლასის, რომელიმე მეთოდის ხელახალი განსაზღვრა : 
class PrinterClass 
{ 
    doPrint():void 
    {
        console.log("doPrint() მშობლისაგან…") 
    } 
} 

class StringPrinter extends PrinterClass 
{ 
    doPrint():void 
    { 
        super.doPrint() 
        console.log("doPrint() შვილისაგან…") 
    } 
} 

var obj = new StringPrinter() 
obj.doPrint()
სიტყვაგასაღებ super-ის მეშვეობით ხდება მშობელი კლასის მეთოდთან დაკავშირება. ანუ მემკვიდრე კლასის მეთოდში ჯერ გამოვიძახეთ მშობელი კლასის მეთოდი და შემდეგ შევასრულეთ ახალი ინსტრუქცია.

სიტყვაგასაღები static

სიტყვაგასაღები static შეგვიძლია დავურთოთ კლასის ნებისმიერ ინფორმაციულ წევრს (ანუ მეთოდს ან თვისებას). სტატიკური ცვლადის გამოსაყენებლად უნდა მივმართოთ უშუალოდ კლასს : 
class StaticMem 
{  
    static num:number; 
   
    static disp():void 
    { 
        console.log(StaticMem.num) 
    } 
} 

StaticMem.num = 12 // სტატიკური თვისების ინიციალიზაცია
StaticMem.disp() //  სტატიკური თვისების გამოძახება

instanceof ოპერატორი

instanceof ოპერატორი გამოიყენება იმის დასადგენად, მიეკუთვნება თუ არა კონკრეტული ობიექტი კონკრეტულ ტიპს ანუ კლასს. ოპერატორი აბრუნებს ლოგიკური ტიპის პასუხს : true ან false. 
class Person{} 

var obj = new Person() 
var isPerson = obj instanceof Person; 

console.log(isPerson);
კომპილაციის შემდეგ შესრულდება შემდეგი კოდი : 
var Person = (function () 
{
    function Person(){}
    return Person;

}());

var obj = new Person();
var isPerson = obj instanceof Person;

console.log(isPerson);

ინფორმაციის დამალვა ანუ ინკაფსულაცია

უცხო სიტყვათა ლექს: ინკაფსულაცია - უცხო ნივთიერებებისაგან დაცვის მიზნით (უცხო სხეულების, პარაზიტების და მისთ.), ორგანიზმის ირგვლივ შემაერთებელი გარსის (კაფსულის) წარმოქმნა.

შესაძლებელია, რომ კლასში ვმართოთ ნებისმიერი ინფორმაციის ხელმისაწვდომობა, ანუ შევზღუდოთ ამ ინფორმაციების თვალთახედვის არეები. ამ პროცესს ოოპ-ში ეწოდება ინკაფსულაცია. ამ ყველაფრისათვის გამოიყენება ე.წ წვდომის სპეციფიკატორები/მოდიფიკატორები. ეს მოდიფიკატორტები განსაზღვრავენ კლასში აღწერილი ინფორმაციების ხელმისაწვდომობას კლასგარეთ.
# წვდომის სპეციფიკატორი & აღწერა
1.

public

თუ კლასში აღწერილ მეთოდს ან თვისებას წინ ერთვის წვდომის სპეციფიკატორი Public, ეს ნიშნავს რომ მათი გამოყენება შესაძლებელია სკრიპტის ნებისმიერ ადგილას. (ინგლ: Public - საზოაგდოება; საჯარო, აშკარა;) ეს ნიშნავს რომ როდესაც შევქმნით კლასის ეგზემპლიარს, ობიექტს, ჩვენ გვექნება წვდომა ამ ობიექტიდან კლასის ყველა Public მეთოდზე და თვისებაზე.
2.

private

თუ კლასში აღწერილ მეთოდს ან თვისებას წინ ერთვის წვდომის სპეციფიკატორი Private, ეს ნიშნავს რომ მათი გამოყენება შესაძლებელია მხოლოდ და მხოლოდ ამ კლასის შიგნით (ინგლ: Private - კერძო, პირადი; საიდუმლო, ფარული), სხვა სიტყვებით რომ ვთქვათ Private მეთოდები და ფუნქციები დახურულია კლასგარეშე კოდისათვის.
3.

protected

თუ კლასში აღწერილ მეთოდს ან თვისებას წინ ერთვის წვდომის სპეციფიკატორი Protected, ეს ნიშნავს რომ მათი გამოყენება შესაძლებელია მხოლოდ და მხოლოდ ამ კლასის ან მისი მემკვიდრე კლასების შიგნით (ინგლ: Protected - დაცული; პროტექტორატის ქვეშ მყოფი).
თუ კლასში აღწერილ მეთოდებს და თვისებებს არ აქვთ მითითებული წვდომის სპეციფიკატორი, იგულისხმება რომ სპეციფიკატორი არის Public. 
class Encapsulate 
{ 
   str:string = "შემდეგი იქნება Angular !" 
   private str2:string = "Angular" 
}
 
var obj = new Encapsulate() 

console.log(obj.str) // ხელმისაწვდომია
console.log(obj.str2) // შეცდომა კომპილაციისას : str2 არის კერძო თვისება

კლასები და ინტერფეისები

ინგ : Implement - შესრულება, განხორციელება; მოქმედებაში შეყვანა.

შესაძლებელია, რომ კლასებში მოვახდინოთ ინტერფეისების იმპლემენტაცია, ამისათვის გამოიყენება სიტყვაგასაღები implements 
interface ILoan 
{ 
    interest:number 
} 

class AgriLoan implements ILoan 
{ 
    interest:number 
    rebate:number 
   
    constructor(interest:number,rebate:number) 
    { 
        this.interest = interest 
        this.rebate = rebate 
    } 
} 

var obj = new AgriLoan(10,1) 
console.log(obj.interest + ", " +obj.rebate )
კლას AgriLoan-ში მოვახდინეთ ინტერფეის ILoan-ის იმპლემენტაცია, ამის შემდეგ ინტერფეისის თვისება interest უკვე ხელმისაწვდომია ამ კლასსშიც. კომპილაციის შემდეგ შესრულდება შემდეგი კოდი : 
var AgriLoan = (function () {

    function AgriLoan(interest, rebate) 
    {
        this.interest = interest;
        this.rebate = rebate;
    }

    return AgriLoan;

}());

var obj = new AgriLoan(10, 1);
console.log("obj.interest + ", " + obj.rebate);
14. ობიექტები
ობიექტი არის კოდის ფრაგმენტი, ერთგვარი გარემო, რომელშიც ინფორმაცია შეტანილია 'გასაღები : მნიშვნელობა' წყვილების სახით. მნიშვნელობა შეიძლება იყოს სკალარული ინფორმაცია, ფუნქცია ან სხვა ობიექტებისაგან შემდგარი მასივი. 
var object_name = { 
    key1: “მნიშვნელობა1”, // სკალარული მნიშვნელობა
    key2: “მნიშვნელობა12”,  
    key3: function() {
        // ინსტრუქცია 
    }, 
    key4:[“ერთი”, “ორი”] // კოლექცია
};
ლიტერალის სახით ჩაწერილი ობიექტის მაგალითი : 
var person = { 
    firstname:"ვასო", 
    lastname:"ნადირაძე" 
}; 

// ობიექტის მნიშვნელობებთან წვდომა
console.log(person.firstname) 
console.log(person.lastname)
კომპილაციის შემდეგ შესრულდება იგივე კოდი.

ტიპიზაცია და ობიექტები

დავუშვათ ჯავასკრიპტში გვაქვს შემდეგი ობიექტი : 
var person = { 
    firstname:"ვასო", 
    lastname:"ნადირაძე" 
};
იმ შემთხვევაში, თუ გვსურს ობიექტში დავამატოთ რაიმე ახალი ინფორმაცია, ჯს უპრობლემოდ გვაძლევს ამის საშუალებას: person.sayHello = function(){ return "გამარჯობა";} თუ იგივეს გაკეთებას ტაიპსკრიპტში შევეცდებით, კომპილაციისას დაგენერირდება შეცდომა. ეს იმიტომ, რომ ტს-ში კონკრეტული ობიექტი აუცილებლად უნდა მიეკუთვნებოდეს ტიპის კონკრეტულ შაბლონს, სხვა სიტყვებით თუ ვიტყვით : ობიექტი აუცილებლად უნდა იყოს ტიპის კონკრეტული შაბლონის ეგზემპლიარი : 
var person = { 
    firstname:"ვასო", 
    lastname:"ნადირაძე",
    sayHello:function() {  } // ტიპის შაბლონი 
}; 


person.sayHello = function() {  
    console.log("გამარჯობა "+person.firstName)
}  

person.sayHello()

ობიექტები, როგორც ფუნქციის პარამეტრები

var person = { 
    firstname:"ვასო", 
    lastname:"ნადირაძე",
}; 

var invokeperson = function(obj: { firstname:string, lastname :string }) { 
   console.log(obj.firstname) 
   console.log(obj.lastname) 
} 

invokeperson(person)
კომპილაციისას შესრულდება შემდეგი კოდი : 
var person = { 
    firstname:"ვასო", 
    lastname:"ნადირაძე",
}; 

var invokeperson = function (obj) {
   console.log(obj.firstname);
   console.log(obj.lastname);
};

invokeperson(person);
15. სახელსივრცე - namespace (განსავრცობია)
სახელსივრცის უკან შეგვიძლია მოვიაზროთ ერთმანეთთან დაკავშირებული კოდების ლოგიკური დაჯგუფების გზა. სახელსივრცის განსაზღვრა ხდება სიტყვაგასაღებ namespace-ს მეშვეობით : 
namespace SomeNameSpaceName 
{ 
    export interface ISomeInterfaceName {}  
    export class SomeClassName {}  
}
იმ კლასებთან ან ინტერფეისებთან დაკავშირება, რომლებთან მუშაობაც გვსურს კონკრეტულ სახელსივრცეში, ხდება სიტყვაგასაღებ export-ის მეშვეობით. ერთ სახელსივრცეში აღწერილი კლასის მეორე სახელსივრცეში გამოყენების სინტაქსი შემდეგნაირია : SomeNameSpaceName.SomeClassName; თუ პირველი სახელსივრცე წარმოადგენს ტს-ის სხვა ფაილს, მაშინ მასთან წვდომის სინტაქსი შემდეგნაირია : /// <reference path = "SomeFileName.ts" /> სახელსივრცეების გამოყენების კონკრეტული მაგალითი : 
ფაილიდს დასახელება :IShape.ts 
---------- 

namespace Drawing 
{ 
    export interface IShape 
    { 
        draw(); 
    }
}  

ფაილიდს დასახელება :Circle.ts 
---------- 

/// <reference path = "IShape.ts" /> 
namespace Drawing 
{ 
    export class Circle implements IShape 
    { 
        public draw() 
        { 
            console.log("Circle is drawn"); 
        }  
      
        ფაილიდს დასახელება :Triangle.ts 
        ---------- 
        /// <reference path = "IShape.ts" /> 
        namespace Drawing 
        { 
            export class Triangle implements IShape 
            { 
                public draw() 
                {
                    console.log("Triangle is drawn"); 
                } 
            } 
         
            ფაილიდს დასახელება : TestShape.ts 
            /// <reference path = "IShape.ts" />   
            /// <reference path = "Circle.ts" /> 
            /// <reference path = "Triangle.ts" />  
            function drawAllShapes(shape:Drawing.IShape) 
            { 
               shape.draw(); 
            } 

            drawAllShapes(new Drawing.Circle());
            drawAllShapes(new Drawing.Triangle());
        }
   }
}
16. მოდულები (განსავრცობია)
ტაიპსკრიპტში მოდული ეწოდება კონკრეტულ ფაილს, რომელშიც აღწერილია სხვადასხვა კლასები, ფუნქციები, მნიშვნელობები და ა.შ რომლებიც ემსახურებიან კონკრეტული ამოცანის გადაჭრას. სხვა სიტყვებით თუ ვიტყვით მოდული არის ერთგვარი 'მინი- ბიბლიოთეკა', რომლის იმპორტირებაც შესაძლებელია სხვა მოდულებში.

ტაიპსკრიპტის 1.5 ვერსიის გამოსვლამდე მოდულები იყოფოდა ორ კატეგორიად

  • შიდა მოდულები (Internal Modules).
  • გარე მოდულები (External Modules).
მოდულებთან დაკავშირებულ ტერმინოლოგიებში, ტაიპსკრიპტის 1.5 ვერსიაში არის ცვლილებერბი :

'შიდა მოდულს' ახლა უკვე ეწოდება 'სახელსივრცე (namespace)', 'გარე მოდულს' კი უბრალოდ 'მოდული'.

შიდა მოდულები ანუ სახელსივრცეები

შიდა მოდულის შექმნის ძველი სინტაქსი : 
module TutorialPoint 
{ 
    export function add(x, y) 
    {  
        console.log(x+y); 
    } 
}
შიდა მოდულის ანუ ახლა უკვე სახელსივრცის შექმნის ახლანდელი სინტაქსი : 
namespace TutorialPoint 
{ 
    export function add(x, y) 
    { 
        console.log(x + y);
    } 
}
კომპილაციის შემდეგ ორივე შემთხვევაში დაგენერირდება შემდეგი კოდი : 
var TutorialPoint; 

(function (TutorialPoint) { 

    function add(x, y) 
    { 
        console.log(x + y); 
    } 

    TutorialPoint.add = add; 

})(TutorialPoint || (TutorialPoint = {}));

მოდულები(ყოფილი გარე მოდულები)

ტს-ში მოდულები გამოიყენება ჯავასკრიპტის სხვადასხვა გარე ფაილების ჩატვირთვისა და ურთიერთდაკავშირებისათვის (როგორც ვიცით სტანდარტულ ჯს-ში ეს კეთდება <script></script> ტეგის მეშვეობით). გარე მოდულითან დაკავირებისათვის გამოიყენება import და export სიტყვაგასაღებები : 
// ფაილის დასახელება : SomeInterface.ts 
export interface SomeInterface 
{ 
    // კოდი
}
იმისათვის რათა გამოცხადებული მოდული გამოვიყენოთ სხვა ფაილში, ასევე დაგვჭირდება import სიტყვაგასაღები : 
import someInterfaceRef = require(“./SomeInterface”);
ღვნიშნოთ, რომ ფაილის დასახელება (SomeInterface) მითითებულია გაფართოერბის გარეშე.

კონკრეტული მაგალითი : 

// IShape.ts 
export interface IShape 
{ 
    draw(); 
}

// Circle.ts 
import shape = require("./IShape"); 

export class Circle implements shape.IShape 
{ 
    public draw() 
    { 
        console.log("წრე დაიხატა (გარე მოდული"); 
    } 
} 

// Triangle.ts 
import shape = require("./IShape"); 

export class Triangle implements shape.IShape 
{ 
    public draw() 
    { 
        console.log("სამკუთხედი დაიხატა (გარე მოდული)"); 
    } 
}
   
// TestShape.ts 
import shape = require("./IShape"); 
import circle = require("./Circle"); 
import triangle = require("./Triangle");  

function drawAllShapes(shapeToDraw: shape.IShape) 
{
    shapeToDraw.draw(); 
} 

drawAllShapes(new circle.Circle()); 
drawAllShapes(new triangle.Triangle());