Jenis data asas dan jenis pembungkusan kemahiran system_javascript jenis JavaScript

Ditulis di hadapan

Jenis data JavaScript boleh dibahagikan kepada dua jenis: jenis primitif dan jenis rujukan

Jenis primitif juga dipanggil jenis asas atau jenis ringkas kerana ia menduduki ruang tetap dan merupakan segmen data ringkas Untuk meningkatkan kelajuan pertanyaan berubah, ia disimpan dalam timbunan (diakses mengikut nilai). Antaranya, jenis data asas JavaScript termasuk Undefined, Null, Boolean, Number dan String

Oleh kerana saiz nilai jenis rujukan akan berubah, ia tidak boleh disimpan pada timbunan, jika tidak, ia akan mengurangkan kelajuan pertanyaan berubah, jadi ia disimpan dalam timbunan (timbunan) Nilai yang disimpan dalam pembolehubah ialah penunjuk yang menunjuk ke Lokasi memori di mana objek disimpan (akses mengikut alamat)

[Nota] Untuk nilai jenis rujukan, anda boleh menambah atribut dan kaedah padanya, dan anda juga boleh menukar dan memadamkan atribut dan kaedahnya tetapi jenis asas tidak boleh menambah atribut dan kaedah

Tidak ditentukan

Jenis Undefined hanya mempunyai satu nilai, iaitu undefined. Apabila pembolehubah yang diisytiharkan tidak dimulakan, nilai lalai pembolehubah itu tidak ditentukan

var test;//undefined
console.log(test == undefined);//true
var test = undefined;//undefined 

Hanya satu operasi boleh dilakukan pada pembolehubah yang belum diisytiharkan lagi Gunakan operator jenis untuk mengesan jenis datanya, tetapi dalam mod ketat ia akan menyebabkan ralat

jenis(ujian);//undefined

Adegan muncul

　[1]Mengisytiharkan pembolehubah tidak ditetapkan

[2] Dapatkan atribut objek yang tidak wujud

　[3]Hasil pelaksanaan fungsi tanpa nilai pulangan

　[4]Parameter fungsi tidak diluluskan dalam

　[5]kosong(ungkapan)

Penukaran jenis

　　Boolean(undefined):　 false
　　Number(undefined):　 NaN
　　String(undefined):　　'undefined'

Batal

Jenis Null hanya mempunyai satu nilai, iaitu null. Dari sudut pandangan logik, nilai null mewakili penunjuk objek nol Jika pembolehubah yang ditentukan akan digunakan untuk menyimpan objek, adalah lebih baik untuk memulakan pembolehubah kepada null. Malah, nilai yang tidak ditentukan diperoleh daripada nilai nol, jadi tidak ditentukan == null

　[Nota] null ialah penunjuk objek null, [] ialah tatasusunan kosong, {} ialah objek kosong, ketiga-tiganya berbeza

console.log(null == undefined);//true 

Adegan muncul

Apabila objek tidak wujud

Penukaran jenis

Boolean(null): palsu
Nombor(null): 0
Rentetan(null): 'null'

[Nota] Kerana undefined dan null bukan jenis pembina, anda tidak boleh menambah sifat tersuai

Jenis Pembungkusan

Jenis pembalut adalah jenis rujukan khas. Apabila nilai jenis asas dibaca, objek jenis pembalut asas yang sepadan dibuat di latar belakang dan beberapa kaedah boleh dipanggil untuk memanipulasi data. Terdapat tiga jenis pembungkusan: Boolean, Number dan String

var s1 = 'some text';
var s2 = s1.substring(2);
//在上述过程中，实际上发生了三个步骤
var s1 = new String('some text'); //(1)创建String类型的一个实例 
var s2 = s1.substring(2); //(2)在实例上调用指定的方法
s1 = null; //(3)销毁这个实例 

[Nota] Perbezaan utama antara jenis rujukan dan jenis pembalut asas ialah jangka hayat objek. Contoh jenis rujukan yang dibuat menggunakan operator baharu kekal dalam ingatan sehingga aliran pelaksanaan meninggalkan skop semasa. Objek jenis pembungkusan asas yang dibuat secara automatik hanya wujud pada masa apabila baris kod dilaksanakan, dan kemudian dimusnahkan serta-merta. Ini bermakna sifat dan kaedah tidak boleh ditambah pada masa jalan untuk nilai jenis primitif

var s1 = 'some text';
s1.color = 'red';
alert(s1.color);//undefined 

Kaedah penciptaan

Terdapat dua cara untuk mencipta jenis pembungkusan secara eksplisit:

[1] Kaedah objek [tidak disyorkan]

var s = new Object('abc');
var b = new Object(true);
var n = new Object(123); 

[2] Kaedah pembina [tidak disyorkan]

var s = new String('abc');
var b = new Boolean(true);
var n = new Number(123); 

[Nota] Menggunakan baharu untuk memanggil pembina jenis pembungkusan asas adalah berbeza daripada memanggil terus fungsi transformasi dengan nama yang sama

var value = '25';
var number = Number(value);
console.log(typeof number);//number
var obj = new Number(value);
console.log(typeof obj);//object 

Boolean

　　Boolean类型只有两个值：true 和 false。Boolean包装类型是与布尔值对应的引用类型，在布尔表达式中使用Boolean对象容易造成误解

出现场景

　　[1]条件语句导致系统执行的隐士类型转换

　　[2]字面量或变量定义

类型转换

　　Number(true): 1 　　　　|| 　　Number(false) : 0
　　String(true):'true' 　　　 || 　　String(false):'false'

Boolean()

　　Boolean(undefined):false
　   Boolean(null):false

　　Boolean(非空对象包括空数组[]和空对象{}):true

　　Boolean(非0): true || Boolean(0和NaN):false

　　Boolean(非空包括空格字符串):true || Boolean(''):false

　　[注意]true不一定等于1，false也不一定等于0

包装类型继承的方法

　　valueOf():返回基本类型值true 或 false

　　toString()和toLocaleString():返回字符串'true' 或'false'

console.log(typeof true.valueOf(),true.valueOf());//boolean true
console.log(typeof false.valueOf(),false.valueOf());//boolean false
console.log(typeof true.toString(),true.toString());//String 'true'
console.log(typeof false.toString(),false.toString());//String 'false'
console.log(typeof true.toLocaleString(),true.toLocaleString());//String 'true'
console.log(typeof false.toLocaleString(),false.toLocaleString());//String 'false' 

Number

　　javascript只有一种数字类型，既可以表示32位的整数，还可以表示64位的浮点数

　　关于Number类型的详细信息移步到此

String

　　String类型是javascript中唯一没有固定大小的原始类型

下面接着来理解下JavaScript基本数据类型的包装对象

现象：为什么可以对字符串的操作采用对象的表示法？

例如：          

var s    = "this is a String";
      var len   = s.length; 

解析：

JavaScript三个基本数据类型都有相应的对象类；分别为Sring,Number,Boolean类；
JavaScript可以灵活的将一种类型的值转换为另一种类型；
当我们在对象环境中使用字符串时，即当我们试图访问这个字符串的属性或方法时；
JavaScript会为这个字符串值内部地创建一个String包装对象；
String对象会暂时代替原始的字符串值，完成我们的访问；
这个被内部创建的String对象是瞬间存在的，它的作用是使我们可以正常访问属性和方法；
String对象在使用过后会被系统丢弃掉；
而原始值并不会被改变；

    以上同样适用于数字和布尔值类型；

    使用Object()函数，任何数字、字符串、布尔值都可以转换为它对应的包装对象；

    例如：

var number_wrapper  = Object (3);