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 pertama kaedah substr() ialah nilai positif yang diperoleh dengan menambah nilai negatif ditambah panjang rentetan dan parameter kedua ditetapkan kepada sifar.

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)

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)

 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]

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

 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;
  }
}