Kemahiran penggunaan lanjutan bagi fungsi split dan join dalam kemahiran JavaScript_javascript

Javascript mempunyai dua fungsi yang sangat berkuasa yang disukai oleh pembangun: split dan join, dua fungsi bertentangan. Kedua-dua fungsi ini membenarkan jenis rentetan dan tatasusunan ditukar ganti, iaitu tatasusunan boleh disiri menjadi rentetan dan sebaliknya. Kita boleh menggunakan sepenuhnya kedua-dua fungsi ini. Mari terokai beberapa aplikasi menarik di dalamnya Mula-mula, mari perkenalkan dua fungsi ini:

String.prototype.split(pemisah, had)
pemisah membahagikan rentetan kepada tatasusunan, dan had parameter pilihan mentakrifkan panjang maksimum tatasusunan yang dijana.

"85@@86@@53".split('@@'); //['85','86','53'];
"banana".split(); //["banana"]; //( thanks peter (-: )
"president,senate,house".split(',',2); //["president", "senate"]
Array.prototype.join(separator)

Pemisah parameter pilihan menukar tatasusunan kepada rentetan. Jika tiada pemisah disediakan, koma akan digunakan sebagai nilai parameter (sama seperti fungsi toString tatasusunan).

["slugs","snails","puppy dog's tails"].join(' and '); //"slugs and snails and puppy dog's tails"
['Giants', 4, 'Rangers', 1].join(' '); //"Giants 4 Rangers 1"
[1962,1989,2002,2010].join();

Mari kita lihat apl ini:

ganti Semua
Fungsi ringkas ini, tidak seperti fungsi ganti asli, boleh digunakan sebagai penggantian subrentetan global tanpa menggunakan ungkapan biasa.

String.prototype.replaceAll = function(find, replaceWith) {
  return this.split(find).join(replaceWith); 
}

"the man and the plan".replaceAll('the','a'); //"a man and a plan"

Untuk rentetan kecil, prestasinya lebih lemah daripada fungsi asli penggantian aksara tunggal (di sini merujuk kepada dua fungsi tambahan ungkapan biasa), tetapi di bawah mozilla, jika aksara ini melebihi 2 atau 3 aksara, penggunaan fungsi ini berjalan lebih cepat daripada ungkapan biasa.

kejadian
Fungsi ini boleh mendapatkan bilangan padanan subrentetan. Dan fungsi semacam ini sangat mudah dan tidak memerlukan regularisasi.

String.prototype.occurences = function(find, matchCase) {
  var text = this;
  matchCase || (find = find.toLowerCase(), text = text.toLowerCase());
  return text.split(find).length-1;  
}

document.body.innerHTML.occurences("div"); //google home page has 114
document.body.innerHTML.occurences("/div"); //google home page has 57
"England engages its engineers".occurrences("eng",true); //2
repeat

Fungsi ini dipinjam daripada prototaip.js:

String.prototype.repeat = function(times) {
  return new Array(times+1).join(this);  
}

"go ".repeat(3) + "Giants!"; //"go go go Giants!"

Keindahannya terletak pada penggunaan fungsi join. Tumpuan adalah pada nilai parameter pemisah dan tatasusunan asas hanya mengandungi beberapa nilai yang tidak ditentukan. Untuk menggambarkan perkara ini dengan lebih jelas, mari kita cipta semula contoh di atas:

[undefined,undefined,undefined,undefined].join("go ") + "Giants

Ingat bahawa setiap elemen tatasusunan akan ditukar kepada rentetan (rentetan kosong dalam kes ini) sebelum bergabung. Aplikasi fungsi ulangan ini adalah salah satu daripada beberapa aplikasi yang mentakrifkan tatasusunan melalui literal tatasusunan tidak boleh dilaksanakan.

Gunakan parameter had
Saya jarang menggunakan parameter pilihan had bagi fungsi split Berikut ialah contoh penggunaan had ini:

var getDomain = function(url) {
  return url.split('/',3).join('/');
}

getDomain("http://www.aneventapart.com/2010/seattle/slides/");
//"http://www.aneventapart.com"
getDomain("https://addons.mozilla.org/en-US/firefox/bookmarks/");
//"https://addons.mozilla.org"

Ubah suai ahli berangka
Jika kita mencampurkan ungkapan biasa, bergabung dan memisahkan, kita boleh mengubah suai ahli tatasusunan dengan mudah. Tetapi fungsi ini tidak sesukar yang dibayangkan Fungsi utamanya adalah untuk mengeluarkan rentetan yang dinyatakan di hadapan setiap ahli tatasusunan yang diberikan.

var beheadMembers = function(arr, removeStr) {
  var regex = RegExp("[,]?" + removeStr);
  return arr.join().split(regex).slice(1);
}

//make an array containing only the numeric portion of flight numbers
beheadMembers(["ba015","ba129","ba130"],"ba"); //["015","129","130"]

Malangnya, fungsi ini tidak berfungsi dalam IE kerana ia tersalah mengalih keluar ahli kosong pertama daripada perpecahan. Sekarang mari kita betulkan fungsi ini:

var beheadMembers = function(arr, removeStr) {
  var regex = RegExp("[,]?" + removeStr);
  var result = arr.join().split(regex);
  return result[0] && result || result.slice(1); //IE workaround
}

Mengapa kita harus menggunakan teknik ini dan bukannya fungsi peta tatasusunan dalam Emascript 5?

["ba015","ba129","ba130"].map(function(e) {
  return e.replace('ba','')
}); //["015","129","130"] 

Dalam aplikasi sebenar, apabila boleh dilaksanakan, saya biasanya menggunakan fungsi peta asli (tidak tersedia di bawah IE<9). Contoh berikut hanya digunakan sebagai alat pembelajaran, tetapi perlu diperhatikan bahawa sintaks panggilan join dan split adalah lebih mudah dan lebih langsung. Perkara yang paling menarik ialah ia juga sangat cekap, terutamanya untuk tatasusunan yang sangat kecil, dan ia lebih cekap dalam FF dan Safari. Untuk tatasusunan besar, fungsi peta adalah lebih sesuai. (Dalam semua penyemak imbas), fungsi cantum dan split akan mempunyai lebih sedikit panggilan fungsi.

//test 1 - using join/split
var arr = [], x = 1000;
while (x--) {arr.push("ba" + x);}

var beheadMembers = function(arr, regex) {
  return arr.join().split(regex).slice(1);
}

var regex = RegExp("[,]?" + 'ba');
var timer = +new Date, y = 1000;
while(y--) {beheadMembers(arr,regex);};
+new Date - timer;

//FF 3.6 733ms
//Ch 7  464ms
//Sa 5  701ms
//IE 8 1256ms

//test 2 - using native map function
var arr = [], x = 1000;
while (x--) {arr.push("ba" + x);}

var timer = +new Date, y = 1000;
while(y--) {
  arr.map(function(e) {
    return e.replace('ba','')
  });
}
+new Date - timer;

//FF 3.6 2051ms
//Cr 7  732ms
//Sf 5  1520ms
//IE 8  (Not supported)

Padanan corak
Tatasusunan perlu melakukan pemadanan corak secara berterusan, tetapi rentetan tidak. Ungkapan biasa boleh digunakan pada rentetan, tetapi bukan pada tatasusunan. Kuasa menukar tatasusunan kepada rentetan untuk padanan corak adalah jauh di luar skop artikel ini. Mari kita lihat aplikasi mudahnya.

Andaikan keputusan pertandingan berjalan kaki perlu disimpan dalam susunan. Tujuannya adalah untuk menggantikan peserta dengan masa rekod mereka dalam tatasusunan. Kami boleh menggunakan gabungan dan ungkapan biasa untuk mengesahkan sama ada mod storan ini betul. Kod berikut adalah untuk mengetahui sama ada masa rekod terlepas dengan mencari dua nama berturut-turut.

var results = ['sunil', '23:09', 'bob', '22:09', 'carlos', 'mary', '22:59'];
var badData = results.join(',').match(/[a-zA-Z]+,[a-zA-Z]+/g);
badData; //["carlos,mary"]