Perbincangan ringkas tentang mengapa rentetan dalam JavaScript mempunyai kemahiran method

Perbincangan ringkas tentang mengapa rentetan dalam JavaScript mempunyai kemahiran method_javascript

WBOY

Lepaskan： 2016-05-16 15:41:59

asal

1204 orang telah melayarinya

Pengenalan

Kita semua tahu bahawa jenis data JavaScript dibahagikan kepada dua kategori, jenis asas (atau jenis primitif) dan jenis rujukan.

Nilai jenis asas ialah segmen data ringkas yang disimpan dalam memori tindanan, dan ia diakses mengikut nilai. Terdapat lima jenis asas dalam JS: Undefined, Null, Boolean, Number dan String.

Nilai jenis rujukan ialah objek yang disimpan dalam memori timbunan dan nilainya diakses melalui rujukan. Jenis rujukan terutamanya termasuk Objek, Tatasusunan, Fungsi, RegExp dan Tarikh.

Objek mempunyai sifat dan kaedah, jadi tidak menghairankan sama sekali kita melihat kod berikut.

var favs=['鸡蛋','莲蓬'];
favs.push('秋葵');
console.log(favs);//["鸡蛋", "莲蓬", "秋葵"]
console.log(favs.length);//3

Salin selepas log masuk

Array adalah jenis rujukan, jadi ia secara semula jadi boleh mempunyai sifat (panjang) dan kaedah (tolak Ini adalah semulajadi seperti makan ais krim pada musim panas). Namun, lihat kod di bawah dan fikirkan dengan teliti, adakah ini dan ini sah?

var realMessage="Said I love you but I lied";
var myMessage=realMessage.substring(5,15);
console.log(myMessage); //"I love you"

Salin selepas log masuk

Terdapat seorang gadis yang patah hati yang dengan sengaja melaksanakan kaedah "substring" pada rentetan yang digunakan untuk putus, dan kemudian dengan gembira tertidur menonton versi yang diedit. Tetapi, tetapi, bukankah dikatakan bahawa rentetan adalah jenis asas Mengapa ia boleh mempunyai kaedah? ? Adakah terdapat kaedah diraja, Tuan Qingtian?

Sebenarnya, semua ini adalah kerana sesuatu yang dipanggil "Jenis Pembungkusan Asas". Jenis pembungkusan asas ini sangat tegak, dan merupakan "selesai dan pergi, menyembunyikan kebaikan dan kemasyhuran"!

Jenis pembungkusan asas

Selain jenis rujukan Objek, Tatasusunan dan lain-lain yang dinyatakan pada mulanya, JavaScript juga menyediakan kami dengan tiga jenis rujukan khas: String, Nombor dan Boolean, yang memudahkan kami mengendalikan jenis asas yang sepadan.

Melanjutkan melihat contoh memotong rentetan di atas, adakah anda perasan bahawa walaupun menggunakan kaedah subrentetan, nilai realMessage itu sendiri tidak akan berubah dengan memanggil kaedah ini hanya mengembalikan rentetan baharu.

Inilah yang dilakukan oleh jenis pembungkusan asas. Pada asalnya anda tidak mempunyai kaedah, tetapi apabila anda ingin menggunakan kaedah, laraskan sahaja Jenis pembungkusan asas yang sepadan mempunyai kaedah ini. Sebagai contoh, kaedah subrentetan di atas adalah mustahil untuk rentetan jenis asas mempunyai kaedah ini, tetapi String jenis pembungkusan ada, dan ia akan melaksanakan kaedah dan mengembalikan hasilnya. Apabila melaksanakan kepada:

realMessage.substring(5,15)

Salin selepas log masuk

Banyak yang berlaku dengan baris kod ini.

Pertama, ia membaca nilai RealMessage daripada ingatan. Apabila dalam mod bacaan ini, latar belakang mula berfungsi. Ketinggian JS menerangkan tindakan ini diselesaikan di latar belakang seperti ini:

1. Buat contoh jenis Rentetan; 2. Panggil kaedah yang dinyatakan pada contoh; 3. Musnahkan contoh ini

Contoh di atas boleh digambarkan dengan kod seperti ini:

var _realMessage=new String("Said I love you but I lied");
var myMessage=_realMessage.substring(5,15);
_realMessgae=null; //方法调用后即销毁

Salin selepas log masuk

Jadi, kami faham bahawa bukan rentetan jenis asas yang melaksanakan kaedahnya sendiri, tetapi latar belakang mencipta Rentetan jenis pembungkusan asas yang sepadan untuknya, yang membuat contoh berdasarkan nilai jenis asas, supaya Ini instance memanggil kaedah yang ditentukan dan akhirnya memusnahkan dirinya sendiri, yang menakjubkan.

Beri perhatian kepada ciri "boleh musnah" jenis pembungkusan asas dalam langkah terakhir, yang menentukan bahawa kami tidak boleh menambah sifat dan kaedah tersuai pada nilai jenis asas.

var me="sunjing";
me.age=18;
console.log(me.age);//undefined

Salin selepas log masuk

Saya menambahkan atribut umur pada rentetan "saya" dan menetapkan nilai kepada 18 tahun yang indah Namun, apabila saya melawatnya sekali lagi, tiada kesan atribut ini. Ini kerana:

Apabila penetapan atribut dalam baris kedua kod dilaksanakan, tika jenis pembungkusan asas dibuat di latar belakang Atribut umur memang dilampirkan pada tika, tetapi kemudian tika itu dimusnahkan. Apabila baris ketiga pelaksanaan dilaksanakan, contoh baharu jenis pembungkusan asas dicipta semula, yang secara semula jadi tidak mempunyai atribut umur.

Paparan menggunakan jenis pembungkusan asas

Selain apabila rentetan berada dalam mod bacaan, latar belakang akan membantu kami mencipta tika jenis pembungkusan asas, dan kami juga boleh menciptanya secara eksplisit sendiri.

var str=new String("hello");
var str2=str.toUpperCase();
console.log(str2);//"HELLO:

Salin selepas log masuk

Ini berbeza daripada apa yang disimpan dalam pembolehubah apabila latar belakang membantu kami menciptanya.

var str1=new String("hello");
var str2="hello";
typeof str1 //"object"
typeof str2 //"string"

Salin selepas log masuk

Ringkasan

Terima kasih kepada jenis pembungkusan asas, adalah lebih mudah bagi kami untuk mengendalikan tiga jenis asas rentetan, boolean dan nombor. Apabila ketiga-tiga jenis nilai asas ini dibaca, contoh jenis pembungkusan yang sepadan akan dibuat di latar belakang Contoh ini akan memanggil kaedah yang ditentukan dan akan dimusnahkan selepas panggilan. Kitaran hayat yang singkat ini menentukan bahawa kita tidak boleh menambah sifat dan kaedah tersuai pada jenis asas.

Mari kita lihat kaedah subString() dan kaedah slice() kelas String dalam JavaScript

Baru-baru ini, saya sedang membaca buku "Pengaturcaraan Lanjutan dengan Javascript" dan mendapati beberapa kemahiran praktikal dan mata pengetahuan yang saya tidak pernah temui sebelum ini saya ingin merakamkannya di blog saya untuk mendalami ingatan saya.

Dalam Bahagian 2.8.4 buku, kita bercakap tentang kaedah subString() dan kaedah slice() dalam kelas String Hasil penggunaan dan pengembaliannya pada asasnya adalah sama, seperti yang ditunjukkan dalam contoh berikut:

由以上代码的输出结果可已看出，slice()方法和subString()方调用方法法和输出结果完全一样，这两种方法返回的都是要处理的字符串的子串，都接受一个或两个参数，第一个参数是要获取的子串的起始位置，第二个参数是要获取子串的终止位置，如果第二个参数省略终止位置就默认为字符串的长度，且两个方法都不改变String对象自身的值。

为什么有两个功能完全相同的方法呢？事实上，这两个方法并不完全相同，不过只在参数为负值时，他们处理参数的方式稍有不同。

对于负数参数，slice()方法会用字符串的长度加上参数，subString()方法将其作为0处理，例如：

var strObj = new String("hello world");
alert(strObj.slice(-3));　　　　　　// 输出结果："rld"
alert(strObj.subString(-3));　　　 // 输出结果："hello world"
alert(strObj.slice(3,-4));　　　　 // 输出结果："lo w"
alert(strObj.subString(3,-4))　　 // 输出结果："hel"

Salin selepas log masuk

这样既可看到slice()和subString()方法的主要不同。当只有参数-3时，slice()返回"rld"，subString()则返回"hello world"。这是因为对于字符串"hello world"，slice(-3)将被转换成slice(8)，而subString(-3)则转化成subString(0)。同样，使用3和-4差别也是很明显。slice()方法将被转换成slice(3,7)，与前面的例子相同，返回"lo w"。而subString()方法则将这个两个参数解释为subString(0,3)，实际上是：subString(0,3)，因为subString()总是把较小的参数作为起始位，较大的数字最为终止位。