Məzmuna keçin
  • Kateqoriyalar
  • Ən yeni
  • Teqlər
  • Populyar
Yığmaq
Brend loqosu
Elvin HuseynovE

Elvin Huseynov

@Elvin Huseynov
Haqqında
Yazı
5
Mövzu
5
Paylaşımlar
0
Qruplar
0
İzləyicilər
0
İzləyir
0

Yazı

Ən yeni

  • JavaScript-də asinxronluq
    Elvin HuseynovE Elvin Huseynov

    JavaScript tək axınlı (single-threaded) bir dildir, yəni eyni anda yalnız bir əməliyyatı icra edə bilər. Lakin bu, JavaScript-in eyni anda bir neçə işi yerinə yetirə bilməməsi anlamına gəlmir. Asinxron proqramlaşdırma məhz bu problemi həll etmək üçün mövcuddur.


    Asinxronluq nədir?

    Asinxron proqramlaşdırma kodun bloklanmamasına və digər əməliyyatların davam etməsinə imkan yaradır. Yəni, bir əməliyyat icra olunarkən, digər əməliyyatlar da eyni vaxtda icra olunmağa davam edə bilər.

    Sinxron (synchronous) kod nümunəsi:

    console.log("1");
    console.log("2");
    console.log("3");
    

    Bu kodu icra etdikdə konsolda ardıcıl olaraq 1, 2, 3 çap olunacaq. Burada hər sətir əvvəlkinin tamamlanmasını gözləyir.

    Asinxron (asynchronous) kod nümunəsi:

    console.log("1");
    setTimeout(() => console.log("2"), 1000);
    console.log("3");
    

    Bu zaman konsolda 1, 3, sonra isə bir saniyə gecikmə ilə 2 çap olunacaq. setTimeout funksiyası ikinci əməliyyatı gözləməyə məcbur etmir və digər əməliyyatlar davam edir.


    Asinxron əməliyyatların idarə olunması

    JavaScript-də asinxron əməliyyatları idarə etmək üçün bir neçə üsul mövcuddur:

    1. Callback funksiyalar

    Callback, bir funksiyanın başqa bir funksiyaya arqument kimi ötürülməsi və müəyyən bir hadisə baş verdikdə çağırılmasıdır.

    function fetchData(callback) {
      setTimeout(() => {
        callback("Məlumat gəldi!");
      }, 2000);
    }
    
    fetchData(function (data) {
      console.log(data);
    });
    

    Burada fetchData funksiyası iki saniyə sonra callback funksiyanı çağırır və nəticəni ötürür.

    Problemi: Callback-lər iç-içə istifadə edildikdə “Callback Hell” adlı mürəkkəb və çətin idarə olunan kod yaranır.

    function step1(callback) {
      setTimeout(() => {
        console.log("Addım 1");
        callback();
      }, 1000);
    }
    
    function step2(callback) {
      setTimeout(() => {
        console.log("Addım 2");
        callback();
      }, 1000);
    }
    
    step1(() => {
      step2(() => {
        console.log("Bütün addımlar tamamlandı!");
      });
    });
    

    Bu tip kodları daha səliqəli və oxunaqlı etmək üçün Promise və async/await metodları istifadə olunur.


    2. Promise

    Promise, asinxron əməliyyatların daha rahat idarə olunmasını təmin edir.

    Promise yaratmaq:

    const myPromise = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve("Məlumat uğurla alındı!");
      }, 2000);
    });
    

    Promise istifadə etmək:

    myPromise.then((data) => {
      console.log(data);
    });
    

    Promise zəncirləmək (chaining):

    fetch("https://jsonplaceholder.typicode.com/todos/1")
      .then((response) => response.json())
      .then((data) => console.log(data))
      .catch((error) => console.error("Xəta baş verdi", error));
    

    Burada .then() ardıcıl olaraq icra edilir, .catch() isə xətanı tutur.


    3. Async/Await

    Async/Await, Promise-ləri daha oxunaqlı etmək üçün istifadə olunur. async açar sözü funksiyanı asinxron edir, await isə Promise-in nəticəsini gözləməyə imkan yaradır.

    Async/Await nümunəsi:

    async function fetchData() {
      try {
        let response = await fetch("https://jsonplaceholder.typicode.com/todos/1");
        let data = await response.json();
        console.log(data);
      } catch (error) {
        console.error("Xəta baş verdi", error);
      }
    }
    
    fetchData();
    

    Burada await əməliyyatı bitənə qədər gözləyir və kod daha oxunaqlı olur.


    Nəticə

    Asinxron proqramlaşdırma, JavaScript-in güclü xüsusiyyətlərindən biridir və daha sürətli və effektiv tətbiqlər yaratmağa imkan verir. Callback-lər, Promise-lər və Async/Await metodları asinxron əməliyyatları idarə etməyə kömək edir.

    Xülasə:

    • Callback-lər – sadə və asan, amma “Callback Hell” problemini yaradır.
    • Promise-lər – daha yaxşı idarə olunur, zəncirlənə bilər.
    • Async/Await – kodu daha oxunaqlı edir və Promise-lər üzərində qurulur.

    Call Stack və Event Loop

    JavaScript mühərriki kodu icra edərkən Call Stack adlı bir strukturdan istifadə edir. Call Stack funksiyaların icra qaydasını idarə edir və onlar icra olunub bitdikdən sonra yaddaşdan silinir.

    Event Loop isə Call Stack və asinxron əməliyyatlar arasında əlaqə yaradan bir mexanizmdir. O, Call Stack boşaldıqda Task Queue və ya Microtask Queue-da olan tapşırıqları icraya göndərir.

    Makro və Mikro tapşırıqlar

    JavaScript-də asinxron əməliyyatlar Makro tapşırıqlar (Macro Tasks) və Mikro tapşırıqlar (Micro Tasks) olmaqla iki əsas kateqoriyaya bölünür:

    • Makro tapşırıqlar: setTimeout, setInterval, setImmediate (Node.js-də), I/O əməliyyatları və MessageChannel daxildir.
    • Mikro tapşırıqlar: Promise.then, MutationObserver və queueMicrotask kimi metodlardan istifadə olunur.

    Mikro tapşırıqlar makro tapşırıqlardan əvvəl icra olunur. Yəni, setTimeout ilə təyin edilmiş bir tapşırıqdan əvvəl, eyni dövrədə (event loop iterasiyasında) yaranmış bütün mikro tapşırıqlar icra ediləcək.


    Bonus olaraq Lydia xanımdan bu prosesin necə işlədiyinin əyani olaraq izahını izləyə bilərsiniz.

    JavaScript asinxron eventloop callstack promise

  • JavaScript-də Promis
    Elvin HuseynovE Elvin Huseynov

    Promis (Promise) — JavaScript-də asinxron kodun yazılması və işlənməsi üçün istifadə olunan xüsusi bir obyektdir. Asinxron funksiyalar, nəticə olaraq bir Promise obyekti qaytarır. Bu obyektin içində, ya artıq icra olunmuş, ya da gələcəkdə icra olunacaq bir əməliyyatın nəticəsi saxlanılır.

    Promis üç əsas vəziyyətdə ola bilər:

    1. Pending (Gözləyən) — Başlanğıc vəziyyəti, əməliyyat başlanıb.
    2. Fulfilled (Tamamlanmış) — Nəticə əldə edilib.
    3. Rejected (İmtina edilmiş) — Xəta baş verib.

    Promisin vəziyyəti yalnız bir dəfə dəyişə bilər; yəni, pending vəziyyətindən yalnız ya fulfilled, ya da rejected vəziyyətinə keçə bilər.

    promise.png


    Promis necə yaradılır?

    Promis, konstruktor vasitəsilə yaradılır. Konstruktor daxilində bir “executor” funksiyası verilir. Bu funksiya, promis yaradıldıqdan dərhal sonra işə düşür və asinxron əməliyyatı yerinə yetirir. Hədəf, əməliyyatın nəticəsini fulfilled (uğurlu) və ya rejected (xəta) vəziyyətinə gətirməkdir.

    const promise = new Promise(function (resolve, reject) {
      // Asinxron əməliyyat:
      navigator.geolocation.getCurrentPosition(function (data) {
        resolve(data);  // Tamamlanmış nəticə
      });
    });
    
    const errorPromise = new Promise(function (resolve, reject) {
      reject(new Error('Xəta'));  // Xəta baş verdi
    });
    
    • resolve: Promisi fulfilled vəziyyətinə gətirən funksiya.
    • reject: Promisi rejected vəziyyətinə gətirən funksiya.

    Promis ilə işləmə

    then(), catch() və finally() metodları, promisin vəziyyətinin dəyişməsi ilə əlaqəli kodu icra etmək üçün istifadə olunur.

    • then() metodu asinxron əməliyyatın uğurlu nəticəsi ilə işləmək üçün istifadə edilir.
    fetch(`https://swapi.dev/api/films/${id}/`)
      .then(function (movies) {
        renderList(movies);
      })
    
    • catch() metodu əməliyyat zamanı xətalarla işləmək üçün istifadə edilir.
    fetch(`https://swapi.dev/api/films/${id}/`)
      .catch(function (error) {
        renderErrorMessage(error);
      });
    
    • finally() metodu isə asinxron əməliyyatın tamamlanmasından sonra, istənilən halda işləyəcək kodu icra edir.
    let isLoading = true;
    fetch(`https://swapi.dev/api/films/${id}/`)
      .finally(function () {
        isLoading = false;
      });
    

    Metodların zəncirlənməsi

    then(), catch() və finally() metodları zəncirlənərək istifadə edilə bilər, beləliklə asinxron əməliyyatların ardıcıl yerinə yetirilməsi təmin edilir.

    fetch(`https://swapi.dev/api/films/${id}/`)
      .then(function (movies) {
        renderList(movies);
      })
      .catch(function (err) {
        renderErrorMessage(err);
      })
      .finally(function () {
        isLoading = false;
      });
    

    Zəncirlənmiş metodlar asinxron əməliyyatların nəticələrinə uyğun hərəkət etməyə imkan verir, məsələn, bir filmi göstərmək və sonra onun əsas qəhrəmanını əldə etmək.


    Digər Promis metodları

    Bəzən mövcud bir nəticəni Promis-ə çevirmək lazımdır. Bu zaman Promise.resolve() metodundan istifadə olunur.

    const happyDog = Promise.resolve('🐶');
    happyDog.then(function (dog) {
      console.log(dog); // 🐶
    });
    

    Promise.reject() metodu, bir xətanı Promis obyektinə çevirmək üçün istifadə olunur.

    const sadDog = Promise.reject('🐶');
    sadDog.catch(function (dog) {
      console.log(dog); // 🐶
    })
      .then(function () {
        console.log('ok');
      });
    

    Asinxron funksiyalar və Promis

    Promis həmçinin asinxron funksiyaları yaratmaq üçün istifadə edilir. Aşağıdakı kimi bir funksiya ilə asinxron əməliyyatlar icra edilə bilər:

    function earnAllMoney() {
      return new Promise(function (resolve, reject) {
        const result = tryEarnAllMoney();
        if (result.ok) {
          resolve(result);
        } else {
          reject(new Error(result));
        }
      });
    }
    

    Sxemli Promislər

    Bir promis, başqa bir promisi “içinə alarsa”, onlar birləşəcək və sadəcə bir promis olacaq.

    const promise = Promise.resolve(Promise.resolve(Promise.resolve('🐶')));
    promise.then(console.log); // 🐶
    

    Nəticə

    Promis, JavaScript-də asinxron əməliyyatların daha rahat və oxunaqlı idarə olunmasını təmin edir. then(), catch(), finally() metodları ilə biz asinxron əməliyyatları idarə edə bilərik. Bu metodlar birləşdirilərək mürəkkəb asinxron əməliyyatlar üçün uyğun həllər yaradır.

    P.S. Ümumiyyətlə, Promis olduqça geniş mövzudur. Burada sadəcə kiçik giriş olaraq paylaşdığım yazını aşağıdakı formadan istifadə edib genişləndirə bilərsiz.

    JavaScript promise asinxron then catch finally

  • Yüksək səviyyəli funksiyalar (Higher Order Functions)
    Elvin HuseynovE Elvin Huseynov

    JavaScript proqramlaşdırma dilində yüksək səviyyəli funksiyalar (Higher Order Functions - HOF) böyük əhəmiyyətə malikdir. Bu funksiyalar başqa funksiyaları arqument kimi qəbul edə və ya nəticə olaraq yeni bir funksiya qaytara bilərlər. Bu yanaşma kodun çevikliyini artırır, abstraksiyaları qurmağa və funksional proqramlaşdırma prinsiplərini tətbiq etməyə imkan verir.

    Bu məqalədə yüksək səviyyəli funksiyaların işləmə prinsipini başa düşmək üçün bir neçə nümunəyə baxacağıq.


    1. setTimeout() – Yüksək səviyyəli funksiya

    JavaScript-in qlobal setTimeout() funksiyası yüksək səviyyəli funksiyalara aid edilir, çünki o, bir funksiyanı arqument kimi qəbul edir və müəyyən müddət keçdikdən sonra icra edir.

    Aşağıdakı nümunədə setTimeout() funksiyası 5 saniyə sonra ekrana mesaj çıxarır:

    setTimeout(
      () => {console.log('Bax, mən buradayam!')},
      5000
    )
    

    Burada setTimeout() callback funksiyasını arqument kimi qəbul edir və müəyyən müddətdən sonra onu işlədir.


    2. map() – Massivlərdə yüksək səviyyəli funksiya

    JavaScript-də bir çox massiv metodları da yüksək səviyyəli funksiyalara aiddir. Bunlar sırasına .map(), .filter(), .reduce() və digər metodlar daxildir.

    Məsələn, .map() funksiyası bir callback funksiyasını arqument kimi qəbul edərək, massivdəki hər elementi dəyişdirən yeni bir massiv qaytarır:

    const years = [1970, 1990, 1995];
    
    const objects = years.map(item => {
      return { year: item };
    });
    
    console.log(objects);
    // [ { year: 1970 }, { year: 1990 }, { year: 1995 } ]
    

    Burada .map() funksiyası item dəyişənini arqument kimi qəbul edir və hər birini obyekt formatına çevirən yeni bir massiv qaytarır.


    3. Çoxistifadəli funksiyaların rahat qurulması

    Yüksək səviyyəli funksiyalar “funksiyanı qismən tətbiq etmə” (Partial Application) prinsipindən istifadə etməyə imkan verir.

    Bu yanaşmada bir funksiya bütün arqumentlərini dərhal qəbul etmək əvəzinə, əvvəlcə bir hissəsini qəbul edir və yeni bir funksiya qaytarır. Bu yeni funksiya qalan arqumentləri qəbul etdikdən sonra tam işləyir.

    Gəlin bunu bir nümunə üzərində izah edək. Aşağıda məlumatların mənbəyini (source) göstərən sadə bir log funksiyası yaradaq:

    const log = (sourceName, message) => {
      console.log(sourceName, ':', message);
    };
    

    Bu funksiyanı işlədərkən hər dəfə mənbənin adını yazmaq lazımdır, bu isə qeyri-effektivdir:

    log('Modul A', 'Başladı');
    // Modul A: Başladı
    
    log('Modul A', 'Torpağın test edilməsi tamamlandı');
    // Modul A: Torpağın test edilməsi tamamlandı
    

    Hər dəfə "Modul A" yazmaq əvəzinə onu yadda saxlayan yeni bir funksiya yarada bilərik.

    Əgər bir funksiyanı elə yazsaq ki, o, əvvəlcə mənbə adını qəbul edib yeni bir funksiya qaytarsın, onda onu daha rahat istifadə edə bilərik:

    // Yüksək səviyyəli funksiya - currying tətbiqi
    const log = sourceName => message => {
      console.log(sourceName, ':', message);
    };
    

    İndi log() funksiyası birinci çağırışda mənbəni yadda saxlayır və ikinci çağırışda mesajı qəbul edərək nəticəni qaytarır:

    const logAppolo = log('Appolo 13');
    
    logAppolo('Huston…');
    // Appolo 13: Huston…
    
    logAppolo('Huston, problemimiz var');
    // Appolo 13: Huston, problemimiz var
    

    Bu yanaşma “currying” adlanır və funksional proqramlaşdırmada geniş istifadə edilir.


    Nəticə

    Yüksək səviyyəli funksiyalar JavaScript-də funksiyaları arqument kimi qəbul etmək və ya nəticə olaraq funksiyalar qaytarmaq imkanı verir. Bu, kodun modulyarlığını, çevikliyini və yenidən istifadə edilə bilməsini artırır.

    Əsas üstünlükləri:
    ✔ Callback funksiyaları ilə işləmək imkanı
    ✔ Kodun təkrar istifadəsini artırır
    ✔ Modulyar və daha rahat istifadə edilə bilən kod yazmağa kömək edir
    ✔ Funksional proqramlaşdırma prinsiplərini tətbiq etməyə imkan yaradır

    Əgər siz daha təmiz və funksional kod yazmaq istəyirsinizsə, yüksək səviyyəli funksiyalardan istifadə etməyi öyrənmək çox vacibdir! 🚀

    JavaScript hof currying functions callback

  • JavaScript-də scope-lar
    Elvin HuseynovE Elvin Huseynov

    JavaScript-də dəyişənlər müvəqqəti dəyərləri saxlamaq üçün istifadə olunur və ehtiyac olduqda onlara müraciət edirik. Lakin bütün dəyişənlər eyni səviyyədə əlçatan deyil. Dəyişənin hansı hissələrdə mövcud olduğunu və ona necə çatmaq mümkün olduğunu scope-lar - “görünürlük sahələri” müəyyən edir.

    Görünürlük sahəsi nədir?

    Görünürlük sahəsi, proqram daxilində bir dəyişənə, funksiyaya və ya obyektə haradan müraciət edə biləcəyimizi müəyyənləşdirən proqram hissəsidir. Bu sahə funksiyalar, bloklar və ya elə bütün proqram ola bilər. Yəni, biz həmişə ən azı bir görünürlük sahəsinin içində oluruq.

    Görünürlük sahələrini iç-içə olan qutular kimi təsəvvür edə bilərik. Bir qutunun içindəki dəyişənlər bir-biriləri ilə əlaqə qura bilər. Həmçinin, daxili qutular yuxarı səviyyədəki qutuların dəyişənlərinə çata bilər.

    carbon.jpg

    Görünürlük sahələri kodun təşkilini asanlaşdırır, dəyişənlərin qorunmasını təmin edir və kodun müxtəlif hissələri arasında təsadüfi müdaxilələrin qarşısını alır.


    Görünürlük sahələrinin növləri

    1. Qlobal görünürlük sahəsi

    Qlobal görünürlük sahəsi, bütün proqram daxilində əlçatan olan ən geniş sahədir. Əgər bir dəyişən funksiya və ya modul xaricində elan edilərsə, bu dəyişən qlobal sahəyə düşür və proqramın istənilən yerindən ona müraciət etmək mümkündür.

    const a = 42;
    
    console.log(a); // 42
    
    function wrap() {
      console.log(a); // 42
    }
    
    const obj = {
      value: a, // 42
    };
    

    Brauzer mühitində bütün qlobal dəyişənlər window obyektinin içində saxlanır:

    console.log(window.a); // 42
    

    Ancaq let və const ilə elan olunan dəyişənlər window obyektinin içərisinə əlavə olunmur.


    2. Modul görünürlük sahəsi

    ES6 modulları istifadə etdikdə, dəyişənlər yalnız onları elan etdiyimiz modullarda mövcud olur. Yəni, bir modulda elan olunan dəyişən başqa bir modul tərəfindən avtomatik olaraq istifadə edilə bilməz.

    module1.js

    const a = 42;
    

    module2.js

    console.log(a); 
    // ReferenceError: a is not defined
    

    Əgər moduldakı bir dəyişənə başqa bir moduldakı kodun daxil olması lazımdırsa, onu export və import vasitəsilə ötürməliyik.


    3. Blok görünürlük sahəsi

    Blok görünürlük sahəsi {} ilə müəyyən olunur. let və const dəyişənləri yalnız həmin blok daxilində mövcud olur.

    if (true) {
      let b = 43;
      console.log(b); // 43
    }
    
    console.log(b); 
    // ReferenceError: b is not defined
    

    Bloklar switch daxilində də istifadə oluna bilər:

    switch (animalType) {
      case 'dog': {
        const legs = 4;
        break;
      }
      case 'fish': {
        const legs = 0;
        break;
      }
    }
    
    console.log(legs); 
    // ReferenceError: legs is not defined
    

    4. Funksional görünürlük sahəsi

    Funksiyalar özlərinə məxsus görünürlük sahəsi yaradır və onların daxilində elan olunan dəyişənlər yalnız həmin funksiyanın içində mövcud olur.

    function scoped() {
      const b = 43;
    }
    
    console.log(b); 
    // ReferenceError: b is not defined
    

    Hər bir funksiya öz görünürlük sahəsinə malikdir və bu sahə digər funksiyalarla qarışmır.

    function scope1() {
      const a = 42;
    }
    
    function scope2() {
      const a = 43;
    }
    
    console.log(a); 
    // ReferenceError: a is not defined
    

    Lakin iç-içə funksiyalar olduqda, daxili funksiyalar xarici funksiyanın dəyişənlərinə çata bilir:

    function outer() {
      const a = 42;
    
      function inner() {
        console.log(a); // 42
      }
    
      inner();
    }
    
    outer();
    

    Bu xüsusiyyətə “leksik görünürlük sahəsi” deyilir.


    IIFE (Immediately Invoked Function Expression)

    IIFE dərhal çağırılan funksiya ifadəsidir. Bu metoddan istifadə edərək kodu təcrid edə və digər kod hissələri ilə qarışmasının qarşısını ala bilərik.

    (function() {
      const a = 42;
      console.log(a); // 42
    })();
    

    Bu üsul kodu modullara bölmək və qlobal dəyişənlərdən asılılığı azaltmaq üçün faydalıdır.


    Funksiyalar və Bağlılıq (Closures)

    JavaScript-də closure (bağlılıq), bir funksiyanın xarici funksiyadakı dəyişənlərə daxil ola bilməsi anlamına gəlir.

    function counter() {
      let state = 0;
    
      function increase() {
        state++;
      }
    
      function decrease() {
        state--;
      }
    
      function valueOf() {
        console.log(state);
      }
    
      return { increase, decrease, valueOf };
    }
    
    const tick = counter();
    tick.increase();
    tick.valueOf(); // 1
    tick.decrease();
    tick.valueOf(); // 0
    

    Burada state dəyişəninə xaricdən birbaşa müdaxilə etmək mümkün deyil. Ancaq increase() və decrease() vasitəsilə onu idarə edə bilərik. Bu üsul məlumatları qorumaq və təhlükəsizliyi artırmaq üçün istifadə olunur.


    Hoisting (Yuxarı Qaldırma)

    var ilə elan olunan dəyişənlər və funksiyalar avtomatik olaraq kodun yuxarısına “qaldırılır” və əvvəl elan olunmuş kimi qəbul edilir.

    console.log(hello); // undefined
    var hello = "Hello";
    

    Əslində bu kod belə işləyir:

    var hello;
    console.log(hello); // undefined
    hello = "Hello";
    

    Ancaq let və const ilə elan olunan dəyişənlərdə hoisting baş vermir:

    console.log(bye); 
    // ReferenceError: Cannot access 'bye' before initialization
    let bye = "Bye";
    

    Bu, kodun daha ardıcıl və gözlənilən kimi işləməsini təmin edir.


    Nəticə

    Görünürlük sahələri JavaScript kodunun təhlükəsiz və ardıcıl işləməsinə kömək edir. Onları düzgün istifadə edərək kodu daha yaxşı strukturlaşdıra, səhvlərin qarşısını ala və məlumatları qorumaq üçün lazımi məhdudiyyətlər tətbiq edə bilərik.

    JavaScript scope closure iife hoisting

  • CSS-də spesifiklik və selektorların çəki sistemi
    Elvin HuseynovE Elvin Huseynov

    Spesifiklik nədir?
    Spesifiklik, brauzerin hansı CSS qaydalarının bir elementə tətbiq olunacağını müəyyənləşdirmək üçün istifadə etdiyi bir alqoritmdir. Əgər bir element bir neçə fərqli selektorla uyğun gəlirsə, brauzer daha yüksək spesifikliyə malik olan stil qaydasını tətbiq edir. Bu prinsip bəzən kaskad qaydasını poza bilər.

    Selektorların Çəkisi

    Brauzer CSS selektorlarının spesifikliyini aşağıdakı qaydada hesablayır:

    1. ID selektorları → Ən yüksək çəkiyə malikdir.
    2. Class, atribut və psevdoklass selektorları → Orta səviyyəli çəkiyə malikdir.
    3. Tag və psevdoselektorlar → Ən aşağı çəkiyə malikdir.

    Bəzi xüsusi selektorlar isə çəkiyə təsir etmir:

    • * (universal selektor)
    • Combinator-lar (+, >, ~)
    • :where() psevdoklassı

    Psevdoklasslar :is(), :has() və :not() isə içindəki ən spesifik selektorun çəkisini qəbul edir.

    Spesifiklik hesablama sistemi

    Spesifikliyi hesablamaq üçün selektoru üç hissəyə ayıraq: ID, class/atribut, və tag selektorları. Bu hissələri 0.0.0 formatında göstərə bilərik.

    • ID selektorları → İlk rəqəmi artırır.
    • Class, atribut və psevdoklass selektorları → İkinci rəqəmi artırır.
    • Tag və psevdoselektorlar → Üçüncü rəqəmi artırır.

    Məsələn:

    Selektor Spesifiklik (çəkisi)
    #block section > .list a 1.1.2
    div#some 1.0.1
    #some 1.0.0
    * .list a 0.1.1
    .class 0.1.0
    section h1 0.0.2
    section 0.0.1

    style atributunun çəkisi

    HTML-də bir elementin style atributunda yazılan CSS qaydaları, xarici CSS fayllarında və <style> teqində yazılmış qaydalardan daha üstün olur. Bu, style atributunun ən yüksək spesifikliyə malik olması deməkdir.

    Məsələn:

    <div class="element" id="this" style="color: purple; border: none">
      Some smart text
    </div>
    
    div.element#this {
      color: green;
      border: 10px solid red;
    }
    

    Burada selektorun spesifikliyi 1.1.1 olsa da, style atributunda yazılmış color: purple üstün tutulur və çərçivə (border) tamamilə yox olur. style atributunun çəkisi 1.0.0.0 olaraq qəbul edilir.

    !important – Mütləq Üstünlük

    !important açar sözü CSS-in bütün qaydalarını pozaraq yazıldığı xüsusiyyəti məcburi şəkildə tətbiq edir. Spesifiklikdən və selektorun çəkisindən asılı olmayaraq, !important həmişə üstün sayılır.

    Lakin bu açar söz ehtiyatla istifadə edilməlidir!

    • Kodun idarə olunmasını çətinləşdirə bilər.
    • CSS spesifiklik və kaskad qaydalarını poza bilər.

    Nəticə

    Spesifiklik CSS-də ən vacib anlayışlardan biridir və düzgün başa düşmək, stil qaydalarının gözlənilməz şəkildə işləməsinin qarşısını almağa kömək edir. Selektorların çəki dərəcəsini nəzərə alaraq, style atributu və !important kimi güclü təsirli metodlardan ehtiyatla istifadə etmək lazımdır.

    CSS/SASS css specificity selectors style
  • 1 / 1
  • Daxil ol

  • Sizin hesabınız yoxdur? Qeydiyyatdan keç

  • Axtarış etmək üçün daxil olun və ya qeydiyyatdan keçin.
  • İlk yazı
    Son yazı
0
  • Kateqoriyalar
  • Ən yeni
  • Teqlər
  • Populyar