state-of-the-art-shitcode/README.ka-GE.md

უვარგისი კოდის წერის თანამედროვე პრინციპები

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

წინამდებარე დოკუმენტი ასევე ხელმისაწვდომია შემდეგ ენებზე: English, 简体中文, 한국어

ემბლემა დამსახურებისამებრ

თუკი თქვენს საცავში (repository-ში) მკაცრად არის დაცული უვარგისი კოდის წერის პრინციპები, შეგიძლიათ ეს მიღწევა შემდეგი ემბლემის გამოყენებით აღნიშნოთ:

მოცემული ემბლემის გამოსახვისათვის საჭირო კოდი (Markdown):

[![State-of-the-art Shitcode](https://img.shields.io/static/v1?label=State-of-the-art&message=Shitcode&color=7B5804)](https://github.com/trekhleb/state-of-the-art-shitcode)

პრინციპები

💩 ცვლადებისათვის სახელები ისე შეარჩიეთ, რომ თქვენი კოდი ბუნდოვანი გახდეს

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

კარგია 👍🏻

let a = 42;

ცუდია 👎🏻

let age = 42;

💩 ერთმანეთში აურიეთ ცვლადებისა და ფუნქციების სახელდების სტილი

დიდება მრავალფეროვნებას!

კარგია 👍🏻

let wWidth = 640;
let w_height = 480;

ცუდია 👎🏻

let windowWidth = 640;
let windowHeight = 480;

💩 არასოდეს დაწეროთ კომენტარები

თქვენი კოდის წაკითხვას მაინც არავინ აპირებს.

კარგია 👍🏻

const cdr = 700;

ცუდია 👎🏻

კომენტარები უმეტესწილად უნდა შეიცავდეს „რატომ“-ს და არა „რა“-ს. თუ კოდში „რა“ ბუნდოვანია, მაშასადამე, კოდი მეტისმეტად მოუწესრიგებელია.

// The number of 700ms has been calculated empirically based on UX A/B test results.
// @see: <link to experiment or to related JIRA task or to something that explains number 700 in details>
const callbackDebounceRate = 700;

💩 კომენტარები ყოველთვის წერეთ თქვენს მშობლიურ ენაზე

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

კარგია 👍🏻

// Закриваємо модальне віконечко при виникненні помилки.
toggleModal(false);

ცუდია 👎🏻

// Hide modal window on error.
toggleModal(false);

💩 შეძლებისდაგვარად მაქსიმალურად მოახდინეთ ფორმატირების სტილთა არევ-დარევა

დიდება მრავალფეროვნებას!

კარგია 👍🏻

let i = ['tomato', 'onion', 'mushrooms'];
let d = [ "ketchup", "mayonnaise" ];

ცუდია 👎🏻

let ingredients = ['tomato', 'onion', 'mushrooms'];
let dressings = ['ketchup', 'mayonnaise'];

💩 განათავსეთ რაც შეიძლება მეტი კოდი ერთ ხაზზე

კარგია 👍🏻

document.location.search.replace(/(^\?)/,'').split('&').reduce(function(o,n){n=n.split('=');o[n[0]]=n[1];return o},{})

ცუდია 👎🏻

document.location.search
  .replace(/(^\?)/, '')
  .split('&')
  .reduce((searchParams, keyValuePair) => {
    keyValuePair = keyValuePair.split('=');
    searchParams[keyValuePair[0]] = keyValuePair[1];
    return searchParams;
  },
  {}
)

💩 კრახი უჩუმრად განიცადეთ

როდესაც რაიმე შეცდომას აღმოაჩენთ, არ არის საჭირო, ამის შესახებ ვინმემ რამე იცოდეს. არანაირი აღრიცხვა, არანაირი შეტყობინებები შეცდომის შესახებ, მოდუნდით.

კარგია 👍🏻

try {
  // რაღაც არაპროგნოზირებადი.
} catch (error) {
  // ჩშშ... 🤫
}

ცუდია 👎🏻

try {
  // რაღაც არაპროგნოზირებადი.
} catch (error) {
  setErrorMessage(error.message);
  // ან/და
  logError(error);
}

💩 ფართოდ გამოიყენეთ გლობალური ცვლადები

გლობალიზაციის პრინციპი.

კარგია 👍🏻

let x = 5;

function square() {
  x = x ** 2;
}

square(); // ახლა x არის 25.

ცუდია 👎🏻

let x = 5;

function square(num) {
  return num ** 2;
}

x = square(x); // ახლა x არის 25.

💩 შექმენით ცვლადები, რომელთა გამოიყენებასაც არ აპირებთ

ყოველი შემთხვევისთვის.

კარგია 👍🏻

function sum(a, b, c) {
  const timeout = 1300;
  const result = a + b;
  return a + b;
}

ცუდია 👎🏻

function sum(a, b) {
  return a + b;
}

💩 შეძლებისდაგვარად მოერიდეთ ტიპების განსაზღვრას ან/და ტიპების შემოწმებას იმ ენებში, სადაც ამის საშუალება გაქვთ

კარგია 👍🏻

function sum(a, b) {
  return a + b;
}

// ისიამოვნეთ უტიპებოდ.
const guessWhat = sum([], {}); // -> "[object Object]"
const guessWhatAgain = sum({}, []); // -> 0

ცუდია 👎🏻

function sum(a: number, b: number): ?number {
  // აშუქებს შემთხვევას, როცა ჩვენ არ ვახდენთ ტრანსპილაციას ან/და Flow-ს გამოყენებით ტიპების შემოწმებას JS-ში.
  if (typeof a !== 'number' && typeof b !== 'number') {
    return undefined;
  }
  return a + b;
}

// ამან მარცხი უნდა განიცადოს ტრანსპილაციის/კომპილაციის პროცესში.
const guessWhat = sum([], {}); // -> undefined

💩 უნდა გაგაჩნდეთ კოდის მიუწვდომელი ნაწილები

ეს არის თქვენი „გეგმა B“.

კარგია 👍🏻

function square(num) {
  if (typeof num === 'undefined') {
    return undefined;
  }
  else {
    return num ** 2;
  }
  return null; // ეს არის ჩემი „გეგმა B“..
}

ცუდია 👎🏻

function square(num) {
  if (typeof num === 'undefined') {
    return undefined;
  }
  return num ** 2;
}

💩 სამკუთხედის პრინციპი

მიბაძეთ ჩიტებს — დაიბუდეთ, დაიბუდეთ, დაიბუდეთ.

კარგია 👍🏻

function someFunction() {
  if (condition1) {
    if (condition2) {
      asyncFunction(params, (result) => {
        if (result) {
          for (;;) {
            if (condition3) {
            }
          }
        }
      })
    }
  }
}

ცუდია 👎🏻

async function someFunction() {
  if (!condition1 || !condition2) {
    return;
  }
  
  const result = await asyncFunction(params);
  if (!result) {
    return;
  }
  
  for (;;) {
    if (condition3) {
    }
  }
}

💩 აურ-დაურიეთ აბზაცები

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

კარგია 👍🏻

const fruits = ['apple',
  'orange', 'grape', 'pineapple'];
  const toppings = ['syrup', 'cream', 
                    'jam', 
                    'chocolate'];
const desserts = [];
fruits.forEach(fruit => {
toppings.forEach(topping => {
    desserts.push([
fruit,topping]);
    });})

ცუდია 👎🏻

const fruits = ['apple', 'orange', 'grape', 'pineapple'];
const toppings = ['syrup', 'cream', 'jam', 'chocolate'];
const desserts = [];

fruits.forEach(fruit => {
  toppings.forEach(topping => {
    desserts.push([fruit, topping]); 
  });
})

💩 ნუ დალუქავთ დაქვემდებარებებს (dependencies)

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

კარგია 👍🏻

$ ls -la

package.json

ცუდია 👎🏻

$ ls -la

package.json
package-lock.json

💩 ლოგიკური მნიშვნელობის მქონე ცვლადებს ყოველთვის დაარქვით flag

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

კარგია 👍🏻

let flag = true;

ცუდია 👎🏻

let isDone = false;
let isEmpty = false;

💩 გრძლად დაწერილი ფუნქციები უკეთესია, ვიდრე მოკლედ დაწერილი

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

• 10000 ხაზისაგან შემდგარი კოდის ერთ ფაილში განთავსება ჩვეულებრივი ამბავია.
• ფუნქციის ტანის 1000 ხაზისაგან შედგენა ჩვეულებრივი ამბავია.
• მუშაობთ რამდენიმე სერვისთან (მე-3 მხარის მიერ უზრუნველყოფილთან თუ შიდასთან, ასევე, გაქვთ რამდენიმე დამხმარე ფუნქცია, ნულიდან დაწერილი მონაცემთა ბაზის ORM-ი და jQuery-ის „სლაიდერი“) ერთადერთ service.js-ში? არაფერია, ჩვეულებრივი ამბავია.

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

ეს არის ზედმეტი და არასაჭიროდ გაწეული შრომა.

💩 რამდენადაც შესაძლებელია ეცადეთ მოერიდოთ კოდის linter-ებს

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

💩 წამოიწყეთ პროექტი README ფაილის გარეშე

და ჯერჯერობით ასე დატოვეთ.

💩 უნდა გაგაჩნდეთ არასაჭირო კოდი

არ წაშალოთ კოდი, რომელსაც თქვენი აპლიკაცია არ იყენებს. დიდი-დიდი, დააკომენტარეთ.