Pythonizing JavaScript

Python mempunyai banyak fungsi utiliti yang berkuasa seperti range, enumerate, zip, dsb., yang dibina pada objek boleh lelar dan protokol lelaran. Digabungkan dengan fungsi penjana, protokol ini telah tersedia dalam semua penyemak imbas Evergreen dan Node.js sejak sekitar 2016, tetapi penggunaannya sangat rendah, pada pendapat saya. Dalam artikel ini, saya akan melaksanakan beberapa fungsi pembantu ini menggunakan TypeScript dengan harapan dapat mengubahnya.

Iterators, iterables dan fungsi penjana

Protokol Iterator

Protokol iterator ialah cara standard untuk menjana jujukan nilai. Untuk objek menjadi lelaran, ia mesti mematuhi protokol lelaran dengan melaksanakan kaedah next, contohnya:

const iterator = {
  i: 0,
  next() {
    return { done: false, value: this.i++ };
  }
};

Kami kemudiannya boleh memanggil kaedah next berulang kali untuk mendapatkan nilai:

console.log(iterator.next().value); // → 0
console.log(iterator.next().value); // → 1
console.log(iterator.next().value); // → 2
console.log(iterator.next().value); // → 3
console.log(iterator.next().value); // → 4

Kaedah

next harus mengembalikan objek yang mengandungi sifat value (mengandungi nilai sebenar) dan sifat done (menentukan sama ada lelaran telah kehabisan, iaitu sama ada ia tidak dapat menghasilkan nilai lagi). Menurut MDN, kedua-dua atribut tidak diperlukan dengan ketat dan jika kedua-duanya tiada, nilai pulangan dianggap sebagai { done: false, value: undefined }.

Protokol objek boleh lelar

Protokol Objek Boleh Lelar membenarkan objek untuk menentukan tingkah laku lelarannya sendiri. Untuk mematuhi protokol Iterable Object, objek mesti menentukan kaedah menggunakan kekunci Symbol.iterator yang mengembalikan iterator. Banyak objek terbina dalam seperti Array, TypedArray, Set dan Map melaksanakan protokol ini supaya ia boleh diulang menggunakan gelung for...of.

Sebagai contoh, untuk tatasusunan, kaedah values ditentukan sebagai kaedah Symbol.iterator tatasusunan:

console.log(Array.prototype.values === Array.prototype[Symbol.iterator]); // → true

Kami boleh menggabungkan protokol lelaran dan objek boleh lelar untuk mencipta lelaran boleh lelar seperti berikut:

const iterable = {
  i: 0,
  [Symbol.iterator]() {
    const iterable = this;
    return {
      next() {
        return { done: false, value: iterable.i++ };
      }
    };
  }
};

Nama kedua-dua protokol ini malangnya hampir sama dan masih mengelirukan saya sehingga hari ini.

Seperti yang anda duga, contoh lelaran dan objek boleh lelar kami adalah tidak terhingga, bermakna ia boleh menjana nilai selama-lamanya. Ini adalah ciri yang sangat berkuasa, tetapi ia juga boleh menjadi perangkap dengan mudah. Sebagai contoh, jika kita menggunakan iterable dalam gelung for...of, gelung akan berterusan selama-lamanya atau sebagai parameter kepada Array.from, JS akhirnya akan membuang RangeError kerana tatasusunan akan menjadi terlalu besar :

// 将无限循环：
for (const value of iterable) {
  console.log(value);
}

// 将抛出 RangeError
const arr = Array.from(iterable);

Sebab iterator dan iterables boleh menjadi tidak terhingga adalah kerana mereka dinilai dengan malas, iaitu mereka hanya menghasilkan nilai apabila digunakan.

Fungsi penjana

Walaupun iterator dan objek boleh lelar merupakan alat yang berharga, ia boleh menjadi agak menyusahkan untuk menulis. Sebagai alternatif, fungsi penjana diperkenalkan.

Fungsi penjana ditentukan menggunakan function* (atau function *, asterisk boleh berada di mana-mana antara kata kunci function dan nama fungsi), membolehkan kami mengganggu pelaksanaan fungsi dan mengembalikan nilai menggunakan yield kata kunci , dan sambung semula pelaksanaan di tempat ia berhenti kemudian, sambil mengekalkan keadaan dalamannya:

const iterator = {
  i: 0,
  next() {
    return { done: false, value: this.i++ };
  }
};

Utiliti Python

Seperti yang dinyatakan dalam pengenalan, Python mempunyai beberapa utiliti terbina dalam yang sangat berguna berdasarkan protokol di atas. JavaScript juga baru-baru ini telah menambah beberapa kaedah pembantu untuk iterator, seperti .drop() dan .filter(), tetapi (mungkin belum lagi) mempunyai beberapa utiliti yang lebih menarik dalam Python.

Jom dapatkan hands-on!

Sekarang bahagian teori sudah tamat, mari kita mula melaksanakan beberapa fungsi Python!

Nota: Tiada satu pun daripada pelaksanaan yang ditunjukkan di sini harus digunakan sebagaimana adanya dalam persekitaran pengeluaran. Mereka tidak mempunyai pengendalian ralat dan pemeriksaan keadaan sempadan.

hitungkan (boleh berulang [,mula])

enumerate dalam Python mengembalikan urutan tupel untuk setiap item dalam urutan input atau boleh lelar, di mana kedudukan pertama mengandungi kiraan dan kedudukan kedua mengandungi item:

console.log(iterator.next().value); // → 0
console.log(iterator.next().value); // → 1
console.log(iterator.next().value); // → 2
console.log(iterator.next().value); // → 3
console.log(iterator.next().value); // → 4

enumerate juga menerima parameter start pilihan yang menunjukkan di mana kaunter harus bermula:

console.log(Array.prototype.values === Array.prototype[Symbol.iterator]); // → true

Mari laksanakan ini dalam TypeScript menggunakan fungsi penjana. Kita boleh menggunakan pelaksanaan yang digariskan dalam dokumentasi python sebagai panduan

const iterable = {
  i: 0,
  [Symbol.iterator]() {
    const iterable = this;
    return {
      next() {
        return { done: false, value: iterable.i++ };
      }
    };
  }
};

Memandangkan rentetan dalam JavaScript melaksanakan protokol Iterable Object, kami hanya boleh menghantar rentetan ke fungsi enumerate kami dan memanggilnya seperti ini:

// 将无限循环：
for (const value of iterable) {
  console.log(value);
}

// 将抛出 RangeError
const arr = Array.from(iterable);

ulang(elem [,n])

repeat ialah sebahagian daripada pustaka itertools terbina dalam, yang mengulang input yang diberikan elem n kali, atau tidak terhingga jika n tidak dinyatakan. Sekali lagi kita boleh menggunakan pelaksanaan dalam dokumentasi python sebagai titik permulaan.

function* sequence() {
  let i = 0;
  while (true) {
    yield i++;
  }
}

const seq = sequence();
console.log(seq.next().value); // → 0;
console.log(seq.next().value); // → 1;
console.log(seq.next().value); // → 2;

// 将无限循环，从 3 开始
for (const value of seq) {
  console.log(value);
}

(Pelaksanaan fungsi cycle dan range diabaikan di sini kerana terlalu panjang, tetapi logiknya sama dengan teks asal, cuma kod itu ditulis semula dalam TypeScript)

Kesimpulan

Ini adalah catatan blog pertama saya, saya harap anda mendapatinya menarik dan mungkin anda akan menggunakan iterator, iterables dan penjana dalam projek akan datang. Jika anda mempunyai sebarang soalan atau memerlukan penjelasan, sila tinggalkan komen dan saya dengan senang hati akan memberikan maklumat lanjut.

Satu perkara yang perlu diambil perhatian ialah prestasi tidak jauh dari gelung for asal menggunakan pembilang. Ini mungkin tidak penting dalam banyak kes, tetapi ia pasti penting dalam senario berprestasi tinggi. Saya menyusahkan apabila mendapati bingkai hilang apabila saya melukis data PCM ke kanvas dan menggunakan iterator dan penjana. Ini mungkin kelihatan jelas di belakang, tetapi tidak bagi saya pada masa itu :D

Sore!

Atas ialah kandungan terperinci Pythonizing JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!