டைப் பாதுகாப்பில் தேர்ச்சி: டைப் காவலர்கள் மற்றும் டைப் உறுதிமொழிகளுக்கான ஒரு விரிவான வழிகாட்டி

மென்பொருள் மேம்பாட்டுத் துறையில், குறிப்பாக ஜாவாஸ்கிரிப்ட் போன்ற டைனமிக் முறையில் டைப் செய்யப்படும் மொழிகளுடன் பணிபுரியும் போது, டைப் பாதுகாப்பைப் பராமரிப்பது ஒரு குறிப்பிடத்தக்க சவாலாக இருக்கலாம். டைப்ஸ்கிரிப்ட், ஜாவாஸ்கிரிப்டின் ஒரு சூப்பர்செட், நிலையான டைப்பிங்கை அறிமுகப்படுத்துவதன் மூலம் இந்தக் கவலையை நிவர்த்தி செய்கிறது. இருப்பினும், டைப்ஸ்கிரிப்டின் டைப் அமைப்புடன் கூட, ஒரு மாறியின் சரியான வகையை அனுமானிப்பதில் கம்பைலருக்கு உதவி தேவைப்படும் சூழ்நிலைகள் எழுகின்றன. இங்குதான் டைப் காவலர்கள் மற்றும் டைப் உறுதிமொழிகள் devreye giriyor. இந்த விரிவான வழிகாட்டி இந்த சக்திவாய்ந்த அம்சங்களை ஆராய்ந்து, உங்கள் குறியீட்டின் நம்பகத்தன்மை மற்றும் பராமரிப்பை மேம்படுத்துவதற்கான நடைமுறை எடுத்துக்காட்டுகள் மற்றும் சிறந்த நடைமுறைகளை வழங்கும்.

டைப் காவலர்கள் என்றால் என்ன?

டைப் காவலர்கள் என்பது ஒரு குறிப்பிட்ட எல்லைக்குள் ஒரு மாறியின் வகையைச் சுருக்கும் டைப்ஸ்கிரிப்ட் கோவைகள் ஆகும். அவை கம்பைலர் ஆரம்பத்தில் அனுமானித்ததை விட ஒரு மாறியின் வகையை மிகவும் துல்லியமாகப் புரிந்துகொள்ள உதவுகின்றன. யூனியன் வகைகளைக் கையாளும் போது அல்லது ஒரு மாறியின் வகை இயக்க நேர நிலைமைகளைப் பொறுத்து இருக்கும்போது இது குறிப்பாக பயனுள்ளதாக இருக்கும். டைப் காவலர்களைப் பயன்படுத்துவதன் மூலம், இயக்க நேரப் பிழைகளைத் தவிர்த்து, மேலும் வலுவான குறியீட்டை எழுதலாம்.

பொதுவான டைப் காவலர் நுட்பங்கள்

டைப்ஸ்கிரிப்ட் டைப் காவலர்களை உருவாக்க பல உள்ளமைக்கப்பட்ட வழிமுறைகளை வழங்குகிறது:

• typeof ஆபரேட்டர்: ஒரு மாறியின் பழமையான வகையைச் சரிபார்க்கிறது (எ.கா., "string", "number", "boolean", "undefined", "object", "function", "symbol", "bigint").
• instanceof ஆபரேட்டர்: ஒரு பொருள் ஒரு குறிப்பிட்ட வகுப்பின் நிகழ்வா என்பதைச் சரிபார்க்கிறது.
• in ஆபரேட்டர்: ஒரு பொருளுக்கு ஒரு குறிப்பிட்ட பண்பு உள்ளதா என்பதைச் சரிபார்க்கிறது.
• தனிப்பயன் டைப் காவலர் செயல்பாடுகள்: ஒரு டைப் предиகேட்டை வழங்கும் செயல்பாடுகள், இது டைப்ஸ்கிரிப்ட் வகைகளைச் சுருக்கப் பயன்படுத்தும் ஒரு சிறப்பு வகையான பூலியன் கோவையாகும்.

typeof பயன்படுத்துதல்

typeof ஆபரேட்டர் ஒரு மாறியின் பழமையான வகையைச் சரிபார்க்க ஒரு நேரடியான வழியாகும். இது வகையைக் குறிக்கும் ஒரு ஸ்டிரிங்கை வழங்குகிறது.

function printValue(value: string | number) {
  if (typeof value === "string") {
    console.log(value.toUpperCase()); // இங்கே 'value' ஒரு ஸ்டிரிங் என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  } else {
    console.log(value.toFixed(2)); // இங்கே 'value' ஒரு எண் என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  }
}

printValue("hello"); // வெளியீடு: HELLO
printValue(3.14159); // வெளியீடு: 3.14

instanceof பயன்படுத்துதல்

instanceof ஆபரேட்டர் ஒரு பொருள் ஒரு குறிப்பிட்ட வகுப்பின் நிகழ்வா என்பதைச் சரிபார்க்கிறது. இது மரபுரிமையுடன் பணிபுரியும் போது குறிப்பாக பயனுள்ளதாக இருக்கும்.

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

class Dog extends Animal {
  bark() {
    console.log("Woof!");
  }
}

function makeSound(animal: Animal) {
  if (animal instanceof Dog) {
    animal.bark(); // இங்கே 'animal' ஒரு Dog என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  } else {
    console.log("Generic animal sound");
  }
}

const myDog = new Dog("Buddy");
const myAnimal = new Animal("Generic Animal");

makeSound(myDog); // வெளியீடு: Woof!
makeSound(myAnimal); // வெளியீடு: Generic animal sound

in பயன்படுத்துதல்

in ஆபரேட்டர் ஒரு பொருளுக்கு ஒரு குறிப்பிட்ட பண்பு உள்ளதா என்பதைச் சரிபார்க்கிறது. இது அவற்றின் வகையைப் பொறுத்து வெவ்வேறு பண்புகளைக் கொண்டிருக்கக்கூடிய பொருட்களுடன் கையாளும் போது பயனுள்ளதாக இருக்கும்.

interface Bird {
  fly(): void;
  layEggs(): void;
}

interface Fish {
  swim(): void;
  layEggs(): void;
}

function move(animal: Bird | Fish) {
  if ("fly" in animal) {
    animal.fly(); // இங்கே 'animal' ஒரு Bird என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  } else {
    animal.swim(); // இங்கே 'animal' ஒரு Fish என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  }
}

const myBird: Bird = { fly: () => console.log("Flying"), layEggs: () => console.log("Laying eggs") };
const myFish: Fish = { swim: () => console.log("Swimming"), layEggs: () => console.log("Laying eggs") };

move(myBird); // வெளியீடு: Flying
move(myFish); // வெளியீடு: Swimming

தனிப்பயன் டைப் காவலர் செயல்பாடுகள்

மேலும் சிக்கலான சூழ்நிலைகளுக்கு, உங்கள் சொந்த டைப் காவலர் செயல்பாடுகளை வரையறுக்கலாம். இந்த செயல்பாடுகள் ஒரு டைப் предиகேட்டை வழங்குகின்றன, இது ஒரு மாறியின் வகையைச் சுருக்க டைப்ஸ்கிரிப்ட் பயன்படுத்தும் ஒரு பூலியன் கோவையாகும். ஒரு டைப் предиকেট variable is Type என்ற வடிவத்தை எடுக்கும்.

interface Square {
  kind: "square";
  size: number;
}

interface Circle {
  kind: "circle";
  radius: number;
}

type Shape = Square | Circle;

function isSquare(shape: Shape): shape is Square {
  return shape.kind === "square";
}

function getArea(shape: Shape) {
  if (isSquare(shape)) {
    return shape.size * shape.size; // இங்கே 'shape' ஒரு Square என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  } else {
    return Math.PI * shape.radius * shape.radius; // இங்கே 'shape' ஒரு Circle என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  }
}

const mySquare: Square = { kind: "square", size: 5 };
const myCircle: Circle = { kind: "circle", radius: 3 };

console.log(getArea(mySquare)); // வெளியீடு: 25
console.log(getArea(myCircle)); // வெளியீடு: 28.274333882308138

டைப் உறுதிமொழிகள் என்றால் என்ன?

டைப் உறுதிமொழிகள் என்பது, டைப்ஸ்கிரிப்ட் கம்பைலரிடம் ஒரு மாறியின் வகையைப் பற்றி அது தற்போது புரிந்துகொள்வதை விட உங்களுக்கு அதிகம் தெரியும் என்று கூறுவதற்கான ஒரு வழியாகும். அவை டைப்ஸ்கிரிப்டின் டைப் அனுமானத்தை மீறி, ஒரு மதிப்பின் வகையை வெளிப்படையாகக் குறிப்பிடுவதற்கான ஒரு வழியாகும். இருப்பினும், டைப் உறுதிமொழிகளை எச்சரிக்கையுடன் பயன்படுத்துவது முக்கியம், ஏனெனில் அவை டைப்ஸ்கிரிப்டின் டைப் சரிபார்ப்பைத் தவிர்த்து, தவறாகப் பயன்படுத்தப்பட்டால் இயக்க நேரப் பிழைகளுக்கு வழிவகுக்கும்.

டைப் உறுதிமொழிகள் இரண்டு வடிவங்களைக் கொண்டுள்ளன:

• கோண அடைப்புக்குறி தொடரியல்: <Type>value
• as முக்கியச்சொல்: value as Type

as முக்கியச்சொல் பொதுவாக விரும்பப்படுகிறது, ஏனெனில் இது JSX உடன் மிகவும் இணக்கமானது.

டைப் உறுதிமொழிகளை எப்போது பயன்படுத்துவது

டைப் உறுதிமொழிகள் பொதுவாக பின்வரும் சூழ்நிலைகளில் பயன்படுத்தப்படுகின்றன:

• டைப்ஸ்கிரிப்ட்டால் அனுமானிக்க முடியாத ஒரு மாறியின் வகையைப் பற்றி நீங்கள் உறுதியாக இருக்கும்போது.
• முழுமையாக டைப் செய்யப்படாத ஜாவாஸ்கிரிப்ட் நூலகங்களுடன் தொடர்பு கொள்ளும் குறியீட்டுடன் பணிபுரியும் போது.
• ஒரு மதிப்பை மேலும் ஒரு குறிப்பிட்ட வகைக்கு மாற்ற வேண்டியிருக்கும் போது.

டைப் உறுதிமொழிகளின் எடுத்துக்காட்டுகள்

வெளிப்படையான டைப் உறுதிமொழி

இந்த எடுத்துக்காட்டில், document.getElementById அழைப்பு ஒரு HTMLCanvasElement ஐ வழங்கும் என்று நாங்கள் உறுதியளிக்கிறோம். உறுதிமொழி இல்லாமல், டைப்ஸ்கிரிப்ட் HTMLElement | null என்ற பொதுவான வகையை அனுமானிக்கும்.

const canvas = document.getElementById("myCanvas") as HTMLCanvasElement;
const ctx = canvas.getContext("2d"); // இங்கே 'canvas' ஒரு HTMLCanvasElement என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்

if (ctx) {
  ctx.fillStyle = "#FF0000";
  ctx.fillRect(0, 0, 150, 75);
}

தெரியாத வகைகளுடன் வேலை செய்தல்

ஒரு API போன்ற வெளிப்புற மூலத்திலிருந்து தரவுகளுடன் பணிபுரியும் போது, நீங்கள் அறியப்படாத வகையுடன் தரவைப் பெறலாம். தரவை எவ்வாறு கையாள்வது என்பதை டைப்ஸ்கிரிப்டுக்குச் சொல்ல ஒரு டைப் உறுதிமொழியைப் பயன்படுத்தலாம்.

interface User {
  id: number;
  name: string;
  email: string;
}

async function fetchUser(id: number): Promise<User> {
  const response = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
  const data = await response.json();
  return data as User; // தரவு ஒரு User என்று உறுதிப்படுத்துங்கள்
}

fetchUser(1)
  .then(user => {
    console.log(user.name); // இங்கே 'user' ஒரு User என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  })
  .catch(error => {
    console.error("Error fetching user:", error);
  });

டைப் உறுதிமொழிகளைப் பயன்படுத்தும்போது எச்சரிக்கைகள்

டைப் உறுதிமொழிகள் குறைவாகவும் எச்சரிக்கையுடனும் பயன்படுத்தப்பட வேண்டும். டைப் உறுதிமொழிகளை அதிகமாகப் பயன்படுத்துவது அடிப்படை டைப் பிழைகளை மறைத்து, இயக்க நேரச் சிக்கல்களுக்கு வழிவகுக்கும். இங்கே சில முக்கியக் கருத்தாய்வுகள்:

• கட்டாய உறுதிமொழிகளைத் தவிர்க்கவும்: ஒரு மதிப்பை அது தெளிவாக இல்லாத ஒரு வகைக்குள் கட்டாயப்படுத்த டைப் உறுதிமொழிகளைப் பயன்படுத்த வேண்டாம். இது டைப்ஸ்கிரிப்டின் டைப் சரிபார்ப்பைத் தவிர்த்து, எதிர்பாராத நடத்தைக்கு வழிவகுக்கும்.
• டைப் காவலர்களை விரும்புங்கள்: முடிந்தவரை, டைப் உறுதிமொழிகளுக்குப் பதிலாக டைப் காவலர்களைப் பயன்படுத்தவும். டைப் காவலர்கள் வகைகளைச் சுருக்குவதற்கு ஒரு பாதுகாப்பான மற்றும் நம்பகமான வழியை வழங்குகின்றன.
• தரவைச் சரிபார்க்கவும்: வெளிப்புற மூலத்திலிருந்து வரும் தரவின் வகையை நீங்கள் உறுதிப்படுத்தினால், அது எதிர்பார்க்கப்படும் வகையுடன் பொருந்துகிறதா என்பதை உறுதிப்படுத்த ஒரு திட்டத்திற்கு எதிராக தரவைச் சரிபார்ப்பதைக் கருத்தில் கொள்ளுங்கள்.

டைப் சுருக்கல்

டைப் காவலர்கள் டைப் சுருக்கல் என்ற கருத்துடன் உள்ளார்ந்த रूप से जुड़े हुए हैं. டைப் சுருக்கல் என்பது இயக்க நேர நிலைமைகள் அல்லது சோதனைகளின் அடிப்படையில் ஒரு மாறியின் வகையை மேலும் ஒரு குறிப்பிட்ட வகைக்குச் செம்மைப்படுத்தும் செயல்முறையாகும். டைப் சுருக்கத்தை அடைய நாம் பயன்படுத்தும் கருவிகள்தான் டைப் காவலர்கள்.

டைப்ஸ்கிரிப்ட் கட்டுப்பாட்டு ஓட்டப் பகுப்பாய்வைப் பயன்படுத்தி, குறியீட்டின் வெவ்வேறு கிளைகளில் ஒரு மாறியின் வகை எவ்வாறு மாறுகிறது என்பதைப் புரிந்துகொள்கிறது. ஒரு டைப் காவலர் பயன்படுத்தப்படும்போது, டைப்ஸ்கிரிப்ட் மாறியின் வகை பற்றிய அதன் உள் புரிதலைப் புதுப்பிக்கிறது, அந்த வகைக்கு குறிப்பிட்ட முறைகள் மற்றும் பண்புகளைப் பாதுகாப்பாகப் பயன்படுத்த உங்களை அனுமதிக்கிறது.

டைப் சுருக்கத்தின் எடுத்துக்காட்டு

function processValue(value: string | number | null) {
  if (value === null) {
    console.log("Value is null");
  } else if (typeof value === "string") {
    console.log(value.toUpperCase()); // இங்கே 'value' ஒரு ஸ்டிரிங் என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  } else {
    console.log(value.toFixed(2)); // இங்கே 'value' ஒரு எண் என்று டைப்ஸ்கிரிப்டுக்குத் தெரியும்
  }
}

processValue("test"); // வெளியீடு: TEST
processValue(123.456); // வெளியீடு: 123.46
processValue(null); // வெளியீடு: Value is null

சிறந்த நடைமுறைகள்

உங்கள் டைப்ஸ்கிரிப்ட் திட்டங்களில் டைப் காவலர்கள் மற்றும் டைப் உறுதிமொழிகளை திறம்படப் பயன்படுத்த, பின்வரும் சிறந்த நடைமுறைகளைக் கருத்தில் கொள்ளுங்கள்:

• டைப் உறுதிமொழிகளை விட டைப் காவலர்களை விரும்புங்கள்: டைப் காவலர்கள் வகைகளைச் சுருக்குவதற்கு ஒரு பாதுகாப்பான மற்றும் நம்பகமான வழியை வழங்குகின்றன. தேவையான போது மற்றும் எச்சரிக்கையுடன் மட்டுமே டைப் உறுதிமொழிகளைப் பயன்படுத்தவும்.
• சிக்கலான சூழ்நிலைகளுக்கு தனிப்பயன் டைப் காவலர்களைப் பயன்படுத்தவும்: சிக்கலான டைப் உறவுகள் அல்லது தனிப்பயன் தரவு கட்டமைப்புகளைக் கையாளும் போது, குறியீட்டுத் தெளிவு மற்றும் பராமரிப்பை மேம்படுத்த உங்கள் சொந்த டைப் காவலர் செயல்பாடுகளை வரையறுக்கவும்.
• டைப் உறுதிமொழிகளை ஆவணப்படுத்தவும்: நீங்கள் டைப் உறுதிமொழிகளைப் பயன்படுத்தினால், அவற்றை ஏன் பயன்படுத்துகிறீர்கள் மற்றும் உறுதிமொழி ஏன் பாதுகாப்பானது என்று நீங்கள் நம்புகிறீர்கள் என்பதை விளக்க கருத்துகளைச் சேர்க்கவும்.
• வெளிப்புறத் தரவைச் சரிபார்க்கவும்: வெளிப்புற மூலங்களிலிருந்து வரும் தரவுகளுடன் பணிபுரியும் போது, அது எதிர்பார்க்கப்படும் வகையுடன் பொருந்துகிறதா என்பதை உறுதிப்படுத்த ஒரு திட்டத்திற்கு எதிராக தரவைச் சரிபார்க்கவும். இதற்காக zod அல்லது yup போன்ற நூலகங்கள் உதவியாக இருக்கும்.
• டைப் வரையறைகளைத் துல்லியமாக வைத்திருங்கள்: உங்கள் டைப் வரையறைகள் உங்கள் தரவின் கட்டமைப்பைத் துல்லியமாகப் பிரதிபலிக்கின்றன என்பதை உறுதிப்படுத்தவும். தவறான டைப் வரையறைகள் தவறான டைப் அனுமானங்கள் மற்றும் இயக்க நேரப் பிழைகளுக்கு வழிவகுக்கும்.
• கடுமையான பயன்முறையை இயக்கு: கடுமையான டைப் சரிபார்ப்பை இயக்க மற்றும் சாத்தியமான பிழைகளை முன்கூட்டியே கண்டறிய டைப்ஸ்கிரிப்டின் கடுமையான பயன்முறையை (tsconfig.json இல் strict: true) பயன்படுத்தவும்.

சர்வதேசப் பரிசீலனைகள்

உலகளாவிய பார்வையாளர்களுக்காக பயன்பாடுகளை உருவாக்கும்போது, டைப் காவலர்கள் மற்றும் டைப் உறுதிமொழிகள் உள்ளூர்மயமாக்கல் மற்றும் சர்வதேசமயமாக்கல் (i18n) முயற்சிகளை எவ்வாறு பாதிக்கலாம் என்பதை மனதில் கொள்ளுங்கள். குறிப்பாக, கருத்தில் கொள்ளுங்கள்:

• தரவு வடிவமைப்பு: எண் மற்றும் தேதி வடிவங்கள் வெவ்வேறு இடங்களுக்கு ஏற்ப கணிசமாக வேறுபடுகின்றன. எண் அல்லது தேதி மதிப்புகளில் டைப் சோதனைகள் அல்லது உறுதிமொழிகளைச் செய்யும்போது, நீங்கள் உள்ளூர் சார்ந்த வடிவமைப்பு மற்றும் பாகுபடுத்தல் செயல்பாடுகளைப் பயன்படுத்துகிறீர்கள் என்பதை உறுதிப்படுத்தவும். உதாரணமாக, பயனரின் இடத்திற்கு ஏற்ப எண்கள் மற்றும் தேதிகளை வடிவமைக்க மற்றும் பாகுபடுத்த Intl.NumberFormat மற்றும் Intl.DateTimeFormat போன்ற நூலகங்களைப் பயன்படுத்தவும். ஒரு குறிப்பிட்ட வடிவமைப்பை (எ.கா., அமெரிக்க தேதி வடிவம் MM/DD/YYYY) தவறாகக் கருதுவது மற்ற இடங்களில் பிழைகளுக்கு வழிவகுக்கும்.
• நாணயக் கையாளுதல்: நாணய சின்னங்கள் மற்றும் வடிவமைப்பும் உலகளவில் வேறுபடுகின்றன. பண மதிப்புகளைக் கையாளும்போது, நாணய வடிவமைப்பு மற்றும் மாற்றத்தை ஆதரிக்கும் நூலகங்களைப் பயன்படுத்தவும், மேலும் நாணய சின்னங்களை ஹார்ட்கோடிங் செய்வதைத் தவிர்க்கவும். உங்கள் டைப் காவலர்கள் வெவ்வேறு நாணய வகைகளைச் சரியாகக் கையாளுகின்றன மற்றும் நாணயங்களின் தற்செயலான கலப்பைத் தடுக்கின்றன என்பதை உறுதிப்படுத்தவும்.
• எழுத்துக் குறியாக்கம்: எழுத்துக் குறியாக்கச் சிக்கல்கள் குறித்து எச்சரிக்கையாக இருங்கள், குறிப்பாக ஸ்டிரிங்களுடன் பணிபுரியும் போது. உங்கள் குறியீடு யூனிகோட் எழுத்துக்களைச் சரியாகக் கையாளுகிறது மற்றும் எழுத்துத் தொகுப்புகள் பற்றிய அனுமானங்களைத் தவிர்க்கிறது என்பதை உறுதிப்படுத்தவும். யூனிகோட்-சார்ந்த ஸ்டிரிங் கையாளுதல் செயல்பாடுகளை வழங்கும் நூலகங்களைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள்.
• வலமிருந்து இடமாக (RTL) எழுதப்படும் மொழிகள்: உங்கள் பயன்பாடு அரபு அல்லது ஹீப்ரு போன்ற RTL மொழிகளை ஆதரித்தால், உங்கள் டைப் காவலர்கள் மற்றும் உறுதிமொழிகள் உரை திசையைச் சரியாகக் கையாளுகின்றன என்பதை உறுதிப்படுத்தவும். RTL உரை ஸ்டிரிங் ஒப்பீடுகள் மற்றும் சரிபார்ப்புகளை எவ்வாறு பாதிக்கலாம் என்பதில் கவனம் செலுத்துங்கள்.

முடிவுரை

டைப் காவலர்கள் மற்றும் டைப் உறுதிமொழிகள் டைப் பாதுகாப்பை மேம்படுத்துவதற்கும் மேலும் வலுவான டைப்ஸ்கிரிப்ட் குறியீட்டை எழுதுவதற்கும் அத்தியாவசியக் கருவிகளாகும். இந்த அம்சங்களை எவ்வாறு திறம்படப் பயன்படுத்துவது என்பதைப் புரிந்துகொள்வதன் மூலம், இயக்க நேரப் பிழைகளைத் தடுக்கலாம், குறியீட்டுப் பராமரிப்பை மேம்படுத்தலாம் மற்றும் மேலும் நம்பகமான பயன்பாடுகளை உருவாக்கலாம். முடிந்தவரை டைப் உறுதிமொழிகளுக்குப் பதிலாக டைப் காவலர்களை விரும்புவதை நினைவில் கொள்ளுங்கள், உங்கள் டைப் உறுதிமொழிகளை ஆவணப்படுத்துங்கள், மற்றும் உங்கள் டைப் தகவலின் துல்லியத்தை உறுதிப்படுத்த வெளிப்புறத் தரவைச் சரிபார்க்கவும். இந்தக் கொள்கைகளைப் பயன்படுத்துவது, உலகளவில் வரிசைப்படுத்தலுக்கு ஏற்ற, மேலும் நிலையான மற்றும் கணிக்கக்கூடிய மென்பொருளை உருவாக்க உங்களை அனுமதிக்கும்.