ტიპები
ტიპები
Type Inference
ტიპი აღწერს მონაცემის თავისებურებას. ჩვეულებრივ, ტაიპსკრიპტი თავისით ამოიცნობს ტიპებს (type inference) და ჩვენ ყოველთვის არ გვჭირდება ექსპლიციტურად ტიპების განსაზღვრა.
const myStr = "hello"; // string
const anotherStr = "1234"; // string
const myNum = 74; // number
const anotherNum = -12.54; // number
let myBool = true; // boolean
function greet() {
return "Hello there!"; // ტაიპსკრიპტი მიხვდება, რომ ფუნქცია string-ს აბრუნებს
}
myBool = "a string"; // ეს გამოიწვევს ერორს, რადგან boolean ტიპის ცვლადში ვინახავთ string-ს.
რადგან ჩვენ თავიდან myBool
ცვლადი შევქმენით boolean
ტიპით, ტაიპსკრიპტი უფლებას არ გვაძლევს,
რომ ამ ცვლადში შემდგომ სხვა ტიპის მნიშვნელობა შევინახოთ.
იგივე ეხება ობიექტებს:
const user = {
id: 588,
name: "John",
};
user.id = "98"; // გამოიწვევს ერორს, რადგან user.id უნდა იყოს number და არა string
მასივების შემთხვევაში მისი ელემენტების ტიპი ავტომატურად არის any, რაც ნებისმიერ ტიპს ნიშნავს, ამიტომ მათი შეცვლა ერორს არ გამოიწვევს.
ექსპლიციტური ტიპები
ჩვენ ტიპების განსაზღვრა შეგვიძლია დეკლარაციის დროს.
const typescript: string = "cool"; // ცვლადი მხოლოდ string იქნება
let myBool: boolean; // ცვლადი მხოლოდ boolean იქნება
if (typescript === "cool") {
myBool = true; // ვალიდურია
}
let fluidVar: any = "hello";
fluidVar = 99;
fluidVar = false;
fluidVar = { name: "john" };
any
ტიპი გულისხმობს ნებისმიერ ტიპს. ასეთი ტიპის წყალობით ტაიპსკრიპტი არანაირ მნიშვნელობაზე
არ გამოაცხადებს პრეტენზიას.
მასივების შემთხვევაში უნდა მივუთითოთ რა ტიპის ელემენტები იქნება მასში.
const myArr: string[] = ["one"];
myArr.push("two");
myArr.push(3); // გამოიწვევს ერორს
ასე ჩვენ დეკლარაციას ვუკეთებთ მასივს, რომელშიც მხოლოდ სტრინგის ტიპის მნიშვნელობები იქნება.
ფუნქციებში შეგვიძლია განვსაზღვროთ პარამეტრის ტიპები და დაბრუნებული შედეგის ტიპი:
function multiply(a: number, b: number): number {
return a * b;
}
multiply(12, "wrong"); // გამოიწვევს ერორს, რადგან b არგუმენტად არ ვაწვდით number ტიპს
აღსანიშნავია, რომ ფუნქციის დაბრუნებულ ტიპს ტაიპსკრიპტი ისედაც მიხვდება, თუ მას ჩვენ ექსპლიციტურად არ დავუწერთ, მაგრამ ხშირად ჯობია, რომ ტიპები მივუთითოთ.
შეგვიძლია ფუნქციის ტიპები არასავალდებულო გავხადოთ ?
სიმბოლოს გამოყენებით:
function log(text?: number): void {
if (text) {
console.log(text);
} else {
console.log("No text was provided");
}
}
log(); // არ გამოიწვევს ერორს და ამობეჭდავს "No text was provided".
რამდენიმე პარამეტრის შემთხვევაში, არასავალდებულო პარამეტრები აუცილებლად უნდა იყოს ბოლოში.
Union Types
შესაძლებელია ტიპების გაერთიანება |
სიმბოლოთი:
let myVar: string | number | { id: number } = 85;
myVar = { id: 999 }; // ვალიდურია
myVar = { name: "John", lastName: "Doe" }; // გამოიწვევს ერორს
ჩვენ დეკლარაციას ვუკეთებთ ცვლადს, რომელიც შეიძლება იყოს string, number ან ობიექტი, რომლის თვისებაც არის id რიცხვის ტიპით.
Interface
ჩვენ შეგვიძლია ობიექტის სტრუქტურის ექსპლიციტურად აღწერა ინტერფეისის საშუალებით:
interface User {
name: string;
id: number;
email?: string;
}
const someUser: User = {
name: "John",
id: 0,
// email-ის არ არსებობა არ გამოიწვევს ერორს.
};
interface
გასაღებით განვსაზღვრეთ User
ტიპი, რომელიც კონვენციურად
"UpperCamelCase"-ით იწერება, როგორც კლასი. ამ ინტერფეისში შემდგომ
ჩამოწერილია ცალკეული თვისებების ტიპები. ნებისმიერი ცვლადი, რომლის
ტიპიც იქნება User
, ამ სტრუქტურას უნდა დაემორჩილოს. ?
სიმბოლოთი
აღწერილი ტიპები არის არასავალდებული - მათი არ არსებობის შემთხვევაში
ერორი არ მოხდება, ტუმცა მათი შექმნის შემთხვევაში, აუცილებელია, რომ
სწორი ტიპის მნიშვნელობა შევქმნათ.
შესაძლებელია ინტერფეისების (ან კლასების) გავრცობა სხვა ინტერფეისებით,
extends
გასაღების მეშვეობით:
interface User {
name: string;
id: number;
email?: string;
}
interface Admin extends User {
canEdit: boolean;
}
const admin: Admin = {
name: "John",
id: 0,
canEdit: true,
};
Admin
ინტერფეისი User
ინტერფეისისგან მიიღებს თვისებების ტიპებს და თავის მხრივ
ახალი თვისებების ტიპებითაც იხელმძღვაბელებს. მაშასადამე ცვლადს, რომელიც Admin
ტიპის იქნება, დასჭირდება არა მხოლოდ Admin-ის ინტერფეისში არსებული ტიპის თვისებები,
არამედ User
-ში არსებული ტიპის თვისებებიც (არასავალდებულო ტიპების გამოკლებით).
Tuples
თუფლები გამოიყენება მასივებში კონკრეტულ ინდექსებზე არსებული ელემენტების
ტიპის განსაზღვრისთვის. მოცემულ მაგალითში 0 ინდექსზე ყოველთვის იქნება
number
, 1-ზე string
, ხოლო 2-ზე boolean
ტიპის მნიშვნელობები.
let myTuple: [number, string, boolean] = [4, "Tuple this, tuple that", true];
myTuple[1] = false; // გამოიწვევს ერორს, რადგან string-ს ვანაცვლებთ boolean-ით.
როგორც მასივების შემთხვევაშია, შესაძლებელია თუფლების დესტრუქტურიზაციაც. ახალი ცვლადები შესაბამის ტიპებს მიიღებენ.
let myTuple: [number, string, boolean] = [4, "Tuple this, tuple that", true];
const [a, b, c] = myTuple;
a ცვლადი იქნება number, b ცვლადი იქნება string, ხოლო c იქნება boolean.