Perbincangan ringkas tentang teknik Array.prototype.slice.call_javascript javascript

Sebelum menulis

Dalam js, kita sering melihat kaedah penulisan Array.prototype.slice.call(arguments,0 Sudah tentu, semua orang mungkin memahami peranan kaedah ini, iaitu menukar objek seperti tatasusunan kepada tatasusunan sebenar . Mengenai kaedah ini, izinkan saya bercakap tentang pemahaman saya.

Ini melibatkan kaedah slice() dan kaedah call(), jadi mari kita bincangkan secara ringkas tentang kedua-dua kaedah ini dahulu.

kaedah slice()

Array dan rentetan kedua-duanya mempunyai kaedah hirisan ini Fungsi kaedah ini adalah untuk memintas sekeping data. Ia menerima dua parameter Parameter pertama ialah indeks kedudukan yang akan dipintas. Dalam tatasusunan, nilai pulangan kaedah ini ialah tatasusunan yang mengandungi unsur terpintas Dalam rentetan, nilai pulangan kaedah ini ialah rentetan yang mengandungi rentetan terpintas.

Kaedah ini juga boleh menghantar nilai negatif Apabila parameter ialah nombor negatif, nombor positif yang diperoleh dengan menambah parameter dan panjang tatasusunan atau rentetan digunakan sebagai parameter sebenar.

adalah seperti berikut:

[1,2,3,4,5,6].slice(2,4);

[1,2,3,4,5,6].slice(-4,-2);

Nilai pulangan adalah semua [3,4], iaitu tatasusunan.

'everything'.slice(2,4);

'everything'.slice(-4,-2);

Nilai pulangan masing-masing ialah 'er' dan 'hi', iaitu rentetan.

Jika parameter dimasukkan, semua elemen dari kedudukan mula ke kedudukan akhir akan dikeluarkan. Tiada lagi contoh.

Kaedah lain yang serupa untuk rentetan

Dalam rentetan, terdapat dua kaedah lain bagi jenis slice():

kaedah substring() dan substr().

Antaranya, kaedah substring() bermaksud mengembalikan rentetan dari kedudukan mula ke kedudukan akhir substr() menerima dua parameter Parameter pertama menunjukkan kedudukan permulaan, dan parameter kedua menunjukkan bilangan aksara dipintas, dan Dua kaedah pertama adalah sedikit berbeza.

Apabila parameter yang dimasukkan ke dalam kaedah adalah nombor negatif, ketiga-tiga kaedah ini berbeza sedikit.

Apabila parameter dimasukkan ke dalam kaedah ialah nombor negatif:

slice(), seperti yang dinyatakan di atas, menambah nombor negatif pada panjang rentetan untuk mendapatkan nilai positif yang sepadan;

Parameter kaedah subrentetan() semuanya ditetapkan kepada sifar;

Parameter pertama kaedah substr() ialah nilai positif yang diperoleh dengan menambah nilai negatif ditambah panjang rentetan dan parameter kedua ditetapkan kepada sifar.

panggil() dan gunakan() kaedah

Kaedah call() dan apply() digunakan terutamanya untuk mengembangkan skop fungsi.

Kaedah call() dan apply() menerima dua parameter:

apply(): Parameter pertama ialah skop, dan yang kedua ialah tatasusunan parameter Parameter kedua boleh menjadi contoh tatasusunan atau objek argumen.

Kaedah panggilan() juga menerima dua parameter, tetapi kaedah menghantar parameter adalah berbeza daripada apply(): parameter fungsi yang diluluskan mesti ditulis satu demi satu.

Memandangkan ini bukan fokus, saya tidak akan menerangkan butiran di sini.

Array.prototype.slice.call(arguments,0)

Dalam Array.prototype.slice.call(arguments,0), ​​​​Array.prototype.slice memanggil kaedah prototaip Array Untuk tatasusunan sebenar, terdapat kaedah slice(), tetapi untuk perkara seperti argumen atau diri -defined Walaupun sesetengah objek seperti tatasusunan mempunyai beberapa atribut seperti panjang, ia tidak mempunyai kaedah slice() Oleh itu, untuk objek seperti tatasusunan, anda perlu menggunakan kaedah prototaip untuk menggunakan kaedah slice() itu ialah, Array.prototype.slice (jika dalam penyesuaian Kaedah slice() disesuaikan dalam objek seperti tatasusunan, jadi ia boleh dipanggil terus).

Jadi, maksud Array.prototype.slice.call(arguments,0) boleh difahami seperti ini: untuk tatasusunan kelas argumen, kami memanggil kaedah prototaip Array.prototype.slice dan menggunakan kaedah call() untuk hadkan skop kepada Dalam argumen, Array.prototype di sini boleh difahami sebagai argumen, dan parameter 0 ialah parameter pertama kaedah slice(), iaitu indeks kedudukan permulaan. Dengan cara ini, tatasusunan kelas argumen ditukar kepada tatasusunan sebenar.

Sudah tentu, anda juga boleh menggunakan traversal untuk menukar argumen kepada tatasusunan, jadi kod secara semula jadi akan lebih banyak dan tidak cukup langsung.

Kami tahu bahawa Array.prototype.slice.call(arguments) boleh menukar objek dengan atribut panjang kepada tatasusunan, kecuali untuk koleksi nod di bawah IE (kerana objek DOM di bawah IE dilaksanakan dalam bentuk objek com, js Objek dan objek COM tidak boleh ditukar)

Seperti:

 var a={length:2,0:'first',1:'second'};
 Array.prototype.slice.call(a);// ["first", "second"]
 var a={length:2};
 Array.prototype.slice.call(a);// [undefined, undefined]

Mungkin mereka yang baru mula belajar js tidak begitu faham mengapa ayat ini boleh mencapai fungsi sedemikian. Sebagai contoh, saya seorang, jadi mari kita terokainya.

Pertama sekali, slice mempunyai dua kegunaan, satu ialah String.slice dan satu lagi ialah Array.slice Yang pertama mengembalikan rentetan, dan yang kedua mengembalikan tatasusunan.

Array.prototype.slice.call(arguments) boleh menukar argumen kepada array, maka ia adalah arguments.toArray().slice(); ) Prosesnya adalah untuk menukar parameter pertama yang dihantar ke tatasusunan dan kemudian memanggil keping?

Mari lihat penggunaan panggilan sekali lagi, seperti yang ditunjukkan dalam contoh berikut

可以看出，call了后，就把当前函数推入所传参数的作用域中去了，不知道这样说对不对，但反正this就指向了所传进去的对象就肯定的了。
到这里，基本就差不多了，我们可以大胆猜一下slice的内部实现，如下

 Array.prototype.slice = function(start,end){
   var result = new Array();
   start = start || 0;
   end = end || this.length; //this指向调用的对象，当用了call后，能够改变this的指向，也就是指向传进来的对象，这是关键
   for(var i = start; i < end; i++){
      result.push(this[i]);
   }
   return result;
 }

大概就是这样吧，理解就行，不深究。

最后，附个转成数组的通用函数

var toArray = function(s){
  try{
    return Array.prototype.slice.call(s);
  } catch(e){
      var arr = [];
      for(var i = 0,len = s.length; i < len; i++){
        //arr.push(s[i]);
        arr[i] = s[i]; //据说这样比push快
      }
       return arr;
  }
}