Mengira offset relatif dengan cekap dalam susunan gelung

Artikel ini memperincikan bagaimana untuk mengira secara efisien mengimbangi indeks sewenang -wenangnya berbanding indeks semasa dalam array gelung dan menentukan sama ada ia berada dalam jarak tertentu (contohnya, 3 kedudukan). Dengan menggunakan fungsi ringkas yang dioptimumkan oleh operasi Modulo, bukan sahaja menyelesaikan masalah kod berlebihan, tetapi juga memastikan bahawa dalam struktur gelung, sama ada ke hadapan atau ke belakang, offset dapat diperoleh dengan tepat dan indeks di luar julat dapat diapit dengan baik. Ini penting untuk perkembangan komponen UI seperti gambarajah karusel.

1. Keperluan pengiraan untuk offset relatif dalam susunan gelung

Apabila membina komponen antara muka pengguna seperti karusel, sering kali perlu menangani ciri -ciri gelung array. Ini bermakna bahawa akhir array disambungkan ke permulaan. Keperluan yang sama adalah untuk mengira "jarak" atau "mengimbangi" mana -mana elemen dalam array berbanding dengan elemen yang dipilih sekarang (CurrentIndex), dan jarak ini adalah gelung. Sebagai contoh, dalam array dengan 10 elemen, jika CurrentIndex adalah 0, maka Indeks 9 sebenarnya adalah elemen sebelumnya 0, dan offset relatifnya harus -1.

Di samping itu, kita juga mungkin perlu mengehadkan nilai mutlak maksimum offset ini. Sebagai contoh, hanya prihatin dengan unsur -unsur yang tidak lebih daripada kedudukan N dari CurrentIndex. Untuk unsur -unsur di luar julat ini, offset mereka boleh ditetapkan secara seragam ke N (atau -N). Pengiraan ini berguna untuk menentukan lokasi atau penglihatan elemen pada skrin.

2. Cabaran kaedah asal

Pelaksanaan awal mungkin cenderung menggunakan beberapa pernyataan IF-ELSE untuk mengendalikan ke hadapan, terbalik, dan keluar dari situasi skop. Walaupun pendekatan ini secara logik boleh dilaksanakan, ia sering membawa kepada kod verbose, kebolehbacaan yang lemah, dan sukar untuk dikekalkan. Sebagai contoh, untuk senario di mana indeks perlu ditentukan dalam 3 lokasi CurrentIndex, pelaksanaan asal mungkin kelihatan seperti ini:

 fungsi getOffset (currentIndex: nombor, indeks: nombor, panjang: nombor): nombor {
  const diff = index - currentIndex;

  jika (diff === 0) {
    kembali 0;
  } else if (diff  3) {// lebih daripada langsung ke hadapan 3 bit // pengiraan gelung: sebagai contoh, currentIndex = 9, index = 1, panjang = 10, 
      // diff = -8, tetapi sebenarnya mengira 2 bit dari 9 ke kanan // di sini math.max (diff -panjang, -3) logik mungkin memerlukan lebih banyak pelarasan halus kembali math.min (diff, 3); // langsung ke hadapan, terhad kepada 3
    } else {
      kembali math.min (diff, 3); // langsung ke hadapan, terhad kepada 3
    }
  }
}

Kod ini cuba mengendalikan pelbagai situasi, tetapi logik dalamannya, terutamanya apabila berurusan dengan sempadan gelung dan mengepung maksimum mengimbangi, nampaknya rumit dan rawan kesilapan.

3. Mengoptimumkan penyelesaian mudah

Untuk menyelesaikan masalah di atas, kita boleh menggunakan ciri -ciri operasi modulo (%) untuk memudahkan pengiraan jarak dalam array gelung. Idea teras adalah untuk mengira jarak kitaran "ke hadapan" indeks relatif kepada CurrentIndex, dan kemudian menilai offset sebenar berdasarkan jarak ini.

Katakan kami ingin menetapkan offset indeks di luar julat yang ditentukan (contohnya, 3 kedudukan) hingga 3 (atau -3). Fungsi getoffset yang dioptimumkan adalah seperti berikut:

 /**
 * Kirakan pengimbang relatif indeks dalam array gelung dan mengikatnya dalam jarak yang ditentukan.
 * @param {Number} CurrentIndex Index Rujukan Semasa.
 * @param {Number} Indeks Indeks Indeks.
 * @param {Number} Panjang Panjang jumlah array.
 * @returns {Number} Offset indeks sasaran berbanding dengan indeks semasa, nombor positif mewakili ke hadapan, nombor negatif mewakili ke belakang,
 * Offset di luar jarak yang ditentukan akan diapit hingga 3 atau -3.
 */
fungsi getOffset (currentIndex: nombor, indeks: nombor, panjang: nombor): nombor {
  // 1. Kirakan perbezaan asal antara kedua -dua indeks dan pastikan hasilnya positif. // (Indeks - Panjang CurrentIndex) Pastikan hasilnya positif.
  // % Panjang memastikan hasilnya berada dalam julat [0, panjang -1], yang mewakili jarak dari currentIndex ke indeks const diff = (indeks - currentIndex panjang) panjang;

  // 2. Menilai offset sebenar berdasarkan jarak siklik ke hadapan yang dikira // menganggap bahawa jarak maksimum mengimbangi yang kita sayang ialah 3
  const maxOffsetDistance = 3; 

  jika (diff  kembali 1
    // Contohnya: CurrentIndex = 0, indeks = 3, diff = 3 -> kembali 3
    kembali diff;
  } else if (diff> = length - maxOffsetDistance) {
    // Jika jarak ke hadapan lebih besar daripada atau sama dengan (panjang - maxoffsetdistance),
    // Ini bermakna indeksnya sangat dekat dengan "kiri" semasa CurrentIndex.
    // Contohnya: CurrentIndex = 0, indeks = 9, panjang = 10, maxOffsetDistance = 3
    // diff = 9. Panjang - maxOffsetDistance = 10 - 3 = 7. 9> = 7 adalah benar.
    // Pada masa ini, 9 sebenarnya adalah mengimbangi -1.
    // Diff - panjang untuk mendapatkan offset negatif.
    kembali diff - panjang;
  } else {
    // Jika tidak, ini bermakna bahawa indeks terletak "jauh" currentIndex dan bukannya mengimbangi negatif dari jarak dekat.
    // Menurut keperluan, semua indeks di luar julat langsung disetkan secara seragam ke maxOffsetDistance (iaitu 3).
    // Contohnya: CurrentIndex = 0, indeks = 4, panjang = 10, maxOffsetDistance = 3
    // diff = 4. 4  = 7 adalah palsu.
    // Masukkan cawangan ini dan kembalikan 3.
    kembali maxoffsetdistance;
  }
}

4. Kod parsing dan contoh

Mari kita faham secara mendalam bagaimana fungsi getoffset yang dioptimumkan berfungsi:

1. const diff = (index - currentIndex panjang) Panjang %;

   • Indeks - CurrentIndex: Mengira perbezaan langsung antara dua indeks.
   • Panjang: Pastikan hasilnya tidak negatif. Sebagai contoh, jika indeks = 0, currentIndex = 1, panjang = 10, maka 0 - 1 = -1. Tambah panjang hingga 9.
   • Panjang %: Ambil modulus hasil dan hadkan nilai ke julat [0, panjang-1]. Nilai diff ini kini mewakili jarak terpendek dari CurrentIndex ke indeks mengikut arah jam (atau kanan).

2. jika (diff

   • Jika jarak jauh yang dikira mengikut jam adalah kurang daripada atau sama dengan jarak mengimbangi maksimum yang kami tetapkan (contohnya, 3), maka indeks itu berada di sebelah kanan CurrentIndex. Pulangan diff secara langsung sebagai offset ke hadapan.
   • Contoh : GetOffset (0, 1, 10) (MaxOffsetDistance = 3)
     • diff = (1 - 0 10) % 10 = 1
     • 1

3. lain jika (diff> = panjang - maxOffsetDistance)

   • Jika diff adalah besar, dekat dengan panjang, ini bermakna indeks sebenarnya berhampiran sebelah kiri CurrentIndex.
   • Panjang - MaxOffsetDistance mengira jarak mengikut arah jam yang boleh dicapai dengan mengira langkah MaxOffsetDistance lawan jam (atau kiri) dari CurrentIndex.
   • Contoh : GetOffset (0, 9, 10) (MaxOffsetDistance = 3)
     • diff = (9 - 0 10) % 10 = 9
     • 9
     • Panjang - MaxOffsetDistance = 10 - 3 = 7.
     • 9> = 7 adalah benar, menunjukkan bahawa indeks = 9 sangat dekat dengan currentIndex = 0 lawan jam.
     • Pulangan Diff - Panjang = 9 - 10 = -1.

4. lain

   • Sekiranya indeks itu tidak berada dalam jarak dekat CurrentIndex atau dalam jarak dekat kiri, maka ia adalah unsur "jauh". Mengikut keperluan, mengimbangi unsur -unsur ini secara seragam ditetapkan kepada MaxOffsetDistance (iaitu, 3).
   • Contoh : GetOffset (0, 6, 10) (MaxOffsetDistance = 3)
     • diff = (6 - 0 10) % 10 = 6
     • 6
     • Panjang - MaxOffsetDistance = 7.
     • 6> = 7 adalah palsu.
     • Masukkan cawangan lain dan kembalikan 3.

5. Permohonan dan langkah berjaga -jaga praktikal

• Parameterisasi MaxOffsetDistance : Dalam aplikasi praktikal, MaxOffsetDistance (3 dalam kes ini) harus diluluskan ke dalam fungsi sebagai parameter yang boleh dikonfigurasikan untuk meningkatkan fleksibiliti fungsi.
• Komponen UI : Fungsi ini amat sesuai untuk komponen seperti karusel, pager, galeri, dan lain -lain yang perlu menentukan status paparan dan kedudukan item lain berdasarkan pemilihan semasa.
• Prestasi : Operasi modul dan penghakiman bersyarat mudah mempunyai kecekapan yang sangat tinggi dan sesuai untuk panggilan yang kerap.
• Keadaan sempadan : Fungsi ini dapat mengendalikan keadaan dengan betul di mana CurrentIndex dan indeks berada di kedua -dua hujung array, serta keadaan yang sama di mana indeks dan currentIndex adalah (pulangan 0).

Melalui pengoptimuman ini, kami memperoleh fungsi pengiraan offset relatif gelung yang sama -sama ringkas dan lengkap, yang sangat meningkatkan kebolehbacaan dan pemeliharaan kod.

Atas ialah kandungan terperinci Mengira offset relatif dengan cekap dalam susunan gelung. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!