1.基本数据类型：Symbol， String， Number ， Undefined， Null， Boolean
2null为一个对象，可以用typeof null || Object.prototype.toString(null) 测试
3区别：在拷贝时，基本数据类型直接拷贝内容，复杂数据类型拷贝引用地址

1、es5定义了5种基本类型，Null、Undefined、Boolean、String、Number，es6新增了Symbol。
2、虽然 typeof null === 'object' 为true，但是null 不是对象，属于基本类型的一种。
3、基本数据类型是值拷贝，复杂数据类型是引用拷贝

1、一共有六种，null、undefined、number、Boolean、string、symbol，其中symbol为es6新增。
2、null通过typeof打印是对象。
3、基本数据类型存在栈中，直接存入的是值。复杂数据类型在栈中存入的是地址，该地址指向堆内存，在堆内存存入的是具体值。因此，在拷贝时，基本数据类型拷贝的是具体值，而复杂数据类型拷贝的指向堆内存的引用地址。

1.基本数据类型(5种)：null、undefined、number、Boolean、string（es6新增symbol）
2.null是对象
3.基本数据类型把数据名和值直接存储在栈当中，复杂数据类型在栈中存储数据名和一个堆的地址，在堆中存储属性及值，访问时先从栈中获取地址，再到堆中拿出相应的值

1，js中有6中数据类型：string,boolean,number,null,undefined,object，ES6新增了symbol。
2，null本身不是对象，typeof null === 'object’,是语言本身的一个bug。其原理是不同的对象在底层都是用二进制来表示的，在js中二进制前3位是0即判断是为对象，null的二进制表示是全0，即前三位都是0，所以执行typeof返回的是object，实际上null为基本数据类型。
3，（1）基本数据类型的值存在栈中，复杂数据类型在栈中存的是地址，其真正的值存在堆中。
（2）当基本数据类型作为参数传给函数时，函数对其改变不会改变外面的值，复杂数据类型作为参数时，函数内部对参数值的修改会改变外部变量的值。

1,Number,Boolean,String,Symbol,Undefined,Object,null一共7种;
2,typeof(null) ===> 'object'
3.引用类型 存在与堆中地址中,基本类型存在与栈当中;就相当于C语言里面的指针

基本数据类型：Number, Boolean, String, Undefined, Null，es6多一个Symbol

null不是一个空引用，而是一个原始值。typeof null返回object似乎是历史遗留的bug😂

基本数据数据类型存储在栈，存储的是值；复杂数据类型的值存储在堆，地址存储在栈。所以在赋值的时候实际上复制的是地址，指向同一个内存空间；当一个对象改变时，另一个也会改变

1.基本数据类型：Symbol， String， Number ， Undefined， Null， Boolean
2null为一个对象，可以用typeof null || Object.prototype.toString(null) 测试
3区别：在拷贝时，基本数据类型直接拷贝内容，复杂数据类型拷贝引用地址

1.js中有5种数据类型：Undefined、Null、Boolean、Number和String。
2.NULL：代表声明了一个空对象，不是一个字符串，可以赋给任何对象
3.基本数据类型把数据名和值直接存储在栈当中
复杂数据类型在栈中存储数据名和一个堆的地址，在堆中存储属性及值，访问时先从栈中获取地址，再到堆中拿出相应的值

string、number、undefined、null、object、symbol。
null不是一个对象而是一个原始值。
基本数据类型的值存储在栈内存里，而复杂类型的的地址存储在栈内存，值存储在堆内存。

1. String，Number，Boolean，Null，Undefined，Symbol；
2. 不是
3. 基本数据类型是存在栈内存中的，引用类型是存在堆内存中的；
   引用类型是保存在堆内存中的，然后再栈内存中保存一个对堆内存中实际对象的引用，所以JS中引用数据类型的操作都是操作对象的引用而不是实际的对象，从而延伸出了 “深拷贝和浅拷贝”的问题

1.基本数据类型：Number, String, Undefined,Null ,Boolean es6新增Symbol
2null 不是一个对象 虽然typeof 判断返回一个对象
区别：基本类型 在创建是 会在栈上画出一块内存 将数值直接存到栈上
引用类型 在创建是 首先会在栈上给他引用分配一块空间 尔对象的具体信息存在堆内存里 然后根据栈的上的指针指向堆中的对象地址 也就是查询

基本数据类型有：
String, Number,Boolean, undefined, null
引用数据类型有: object,function
null 是对象
理解基本数据类型，和引用数据类型为 基本数据类型值 存放于栈内存中 引用数据类型 内存存放于堆内存中 只是向栈中保留一个指针 根据指针去取。

JS的基本类型(primitive values)有

• Undefined
• Null
• Boolean
• String
• Symbol （ES2015新增）
• Number
• Object

除 Object 以外的所有类型都是不可变的（值本身无法被改变）。

鱼头注：在最新的ECMA proposal里有个处于Stage 3的基本数据类型 BigInt ，用于表示比2⁵³大的所有数字。

具体可参考：

https://tc39.github.io/proposal-bigint/#sec-bigint-objects

null是对象吗？

在ECMA文档里的定义是：

原始值，表示缺省任何对象值（object value）

typeof null === 'object' 是个早在第一版的 JS 就存在的 BUG。在这个版本里，JS 值是以 32位 为单位存储的，由 小型标记（1 - 3位） 和 真实值 组成。类型标签存储在低位的单元里。其中5个是：

• 000：对象(object)
• 1：整型(int)
• 010：双精度浮点型(double)
• 100：字符串(string)
• 110：布尔值(boolean)

两种特殊值

• undefined (JSVAL_VOID)：-2的30次方以内的整数。
• null (JSVAL_NULL) ：机器码 NULL 空指针，空指针引用 加上 对象标记还是 0，所以有 Number(null) === 0 跟 typeof null === 'object'。

复杂类型

JS的复杂类型只有 Object 一种。

在计算机科学中, 对象是指内存中的可以被 标识符引用的一块区域。

在 Javascript 里，对象可以被看作是一组属性的集合。用 对象字面量语法 来定义一个对象时，会自动初始化一组属性。而后，这些属性还可以被增减。属性的值可以是任意类型，包括具有复杂数据结构的对象。属性使用键来标识，它的键值可以是一个字符串或者符号值 （Symbol）。

JS基本类型与复杂类型的区别

基本类型存储的是值，复杂类型存储的是地址（指针）。

当你创建了一个复杂类型的时候，计算机会在内存中帮我们开辟一个空间来存放值，但是我们需要找到这个空间，这个空间会拥有一个地址（指针）。

当我们将变量赋值给另外一个变量时，复制的是原本变量的地址（指针），当我们进行数据修改的时候，就会修改存放在地址（指针） 上的值。

基本类型有5种
null.undefined.string.number.booleen
es6新增symbol类型
通过typeof null返回object验证null是一个对象
基本类型储存在栈中，复杂类型储存在堆中，通过栈中保存的堆地址取值

1. 六中基本数据类型

string、number、boolean、undefined、null、symbol（es6新增）

2.null不是对象，属于基本数据类型

3 两者的区别

基本数据类型的值是存储在 栈里面， 他们所占据的空间是固定的，便于快速查询变量的值

引用数据类型是存储在 堆里面， 存储在变量处的值是一个指针（point），指向存储对象的内存地址

基本数据类型

基本数据类型有6种

• null
• undefined
• string
• number
• boolean
• symbol(ES6新增)

复杂数据类型

复杂数据类型就一种

• object

null是对象吗？

先看下MDN上的解释：

值 null 特指对象的值未设置。它是 JavaScript 基本类型 之一。

由此可见，null并不是一个对象，虽然typeof null返回的值为"object"。

《你不知道的JavaScript(上卷)》这本书说过：

null 有时会被当做一种对象类型，但是这其实只是语言本身的一个bug，即对null执行typeof null时会返回字符串"object"。实际上，null本身是基本类型。

原理是这样的，不同的对象在底层都表示为二进制，在JavaScript中二进制前三位都为0的话会被判断为object类型，null的二进制表示是全0，自然前三位也是0，所以执行typeof时会返回“object”。

思考：为什么typeof null会返回"object"而不是"null"？

大家可以看下MDN上的解释：

在 JavaScript 最初的实现中，JavaScript 中的值是由一个表示类型的标签和实际数据值表示的。对象的类型标签是 0。由于 null 代表的是空指针（大多数平台下值为 0x00），因此，null的类型标签也成为了 0，typeof null就错误的返回了"object"。

ECMAScript提出了一个修复（通过opt-in），但被拒绝。这将导致typeof null === 'null'。

感兴趣的，也可以看下这篇文章：http://www.cnblogs.com/xiaoheimiaoer/p/4572558.html

基本数据和复杂数据类型有什么区别？

1.声明变量时不同的内存分配

基本数据类型：存储在栈中的简单数据段，也就是说，它们的值直接存储在变量访问的位置。这是因为它们占据的空间是固定的，所以可将它们存储在较小的内存区域-栈。这样存储便于迅速查寻变量的值。

复杂数据类型：存储在堆中的对象，栈中存储的变量的值是一个指针，指向堆中的引用地址。这是因为复杂数据类型的值是会改变的，所以不能把它放在栈中，否则会降低变量查寻的速度。

2.不同的访问机制

在JavaScript中，是不允许直接访问保存在堆内存中的对象的，所以在访问一个对象时，首先得到的是这个对象在堆内存中的地址，然后再按照这个地址去获得对象中的值。这就是传说中的按引用访问。

而基本数据类型的值是可以直接访问得到的，即按值访问。

3.复制变量时的不同

基本数据类型：在将保存着原始值的变量复制给另一个变量时，会将原始值的副本赋值给新变量，此后这两个变量是完全独立的，不会相互影响，只是它们拥有相同的value而已。

看下面的例子：

var a = 10;
var b = a;
b = 20;
console.log(a); // 10

上面的代码说明：b获取的是a值的一份拷贝，虽然两个变量的值相等，但是两个变量保存了两个不同的基本数据类型，它们之间不会相互影响。

复杂数据类型：在将一个保存着对象内存地址的变量复制给另一个变量时，会把这个内存地址赋值给新变量，也就是说两个变量都指向了堆内存中d的同一个对象，它们中任何一个作出的改变都会反映在另一个身上。（这里要理解的一点就是，复制对象时并不会在堆内存中新生成一个一模一样的对象，只是多了一个保存指向这个对象的指针罢了）

看下面的例子：

var a = {
    name: 'dazhi'
}

var b = a;
b.name = 'dazhi_fe';

console.log(a.name); // "dazhi_fe"

上面的代码说明：a和b都指向了同一个堆中的对象，所以对其中一个作出改变，另一个也会跟着改变。

4.参数传递的不同

首先我们应该明确一点：ECMAScript中所有函数的参数都是按值来传递的。这也是我们容易疑惑的地方，因为访问变量有按值和按引用两种方式，而参数只能按值传递。这一点等下我们举例来说明。

基本数据类型：拷贝的是值

看例子：

function addTen(num) {
    num += 10;
    return num;
}
var count = 20;
var result = addTen(count);
console.log(count); // 20，没有变化
console.log(result); // 30

只是把变量的值传递给参数，之后参数和这个变量互不影响。

复杂数据类型：拷贝的是引用地址

看例子：

function setName(obj) {
    obj.name = "Nicholas";
}
var person = {
    name: 'jack'
}
setName(person);
console.log(person.name); // "Nicholas"

以上代码创建了一个对象，并将其保存在了变量person中。然后这个变量被传递到setName()函数之中就被复制给了oobj。在这个函数内部，ojb和person引用的是同一个对象。于是在函数内部修改了name属性后，函数外部的person也会有所反映。所以我们会错误的认为：在局部作用域中修改的对象会在全局作用域中反映出来，就说明参数是按引用传递的。

为了证明对象是按值传递的，我们再来看一个例子：

var obj1 = {
    value: '111'
}

var obj2 = {
    value: '222'
}

function changeStuff(obj) {
    obj.value = '333';
    obj = obj2;
    return obj.value;
}

var foo = changeStuff(obj1);

console.log(foo); // 222 参数obj指向了新的对象obj2
console.log(obj1.value); // 333

obj1仍然指向原来的对象，之所以value改变了，是因为changeStuff里的第一条语句，这个时候obj是指向obj1的；如果是按引用传递的话，这个时候obj1.value应该是等于'222'的。

实际上，在函数内部重写obj时，这个变量引用的就是一个局部对象了。而这个局部对象会在函数执行完毕后立即销毁。

参考：

1. https://www.zhihu.com/question/27114726

2. 《JavaScript高级程序设计（第3版）》第4章的内容

1.基本数据类型：Number，String，Underfined，Null，Boolean。
2.null指的是空指针的对象
3.基本数据和复杂数据类型区别：
（1）基本数据类型把数据名和值直接存储在栈当中
（2）复杂数据类型在栈中存储数据名和一个堆的地址，在堆中存储属性及值，访问时先从栈中获取地址，再到堆中拿出相应的值

（微信名：RUN）

Q：JS中基本数据类型有哪几种？
A：null、undefined、Boolean、Number、String、Symbol

Q：null 是对象吗？
A：console.log(typeof null) // 'object'，但不是对象，是个js历史遗留问题。

Q：基本数据和复杂数据类型有什么区别？
A：

• 基本数据类型

  • 赋值是值的赋值
  • 存在栈里

• 复杂数据类型

  • 赋值是指针的赋值，当改变里面某个属性的值，会影响到另一处的值
  • 存在堆里

1、null undefined number boolean string symbol
2、null 不是对象
3、基本数据类型是值，而复杂数据类型存储的引用地址

基本数据类型：string、number、boolean、null、undefined、symbol(es6)、BigInt(es10)
区别：基本数据类型保存在栈当中，复杂类型数据存放在堆和栈当中，栈当中存放复杂类型数据的地址(指针)，堆当中存放复杂类型的值；基本数据类型赋值是值传递，复杂类型数据赋值是地址传递，指向同一块内存空间，所以改变其中一个值时另一个值也会改变
null：typeof null返回Object,会误以为null是对象，这其实是js的一个BUG啦！！！typeof非常善于区分不同类型的原始值，并区分他们和对象，但是在区分不同类型的对象以及null时却完全没用。但是js作为一门强大的语言，Object.protoType.toString.call(null)返回[object, null]给了我们最终的答案，所以，null不是对象，它只是一个基本数据类型

1. number string boolean undefined null symbol
2. console.log(typeof null) // object 但是它不是一个对象，这是js的遗留问题。原因是在js的值类型都是以二进制保存的，js是根据二进制的前三位是否都为0来判断是否为对象的，而null的二进制全是0，所以typeof null时才会等于object
3. 基本数据类型在内存的栈区保存，而复杂数据类型在内存的堆区保存，只在栈区保存堆区的地址。当对基本数据类型进行传值时，会存在拷贝传值与引用传值区别。引用传值：传递值，引用传值：传递内存堆区地址

JS 中基本数据类型有哪几种？null 是对象吗？基本数据和复杂数据类型有什么区别？

JS 中基本数据类型有哪几种

6 种原始类型

• Null
• Undefined
• String
• Number
• Boolean
• Symbol -- ES6 新增加

1 种复杂类型

• Object

null 是对象吗

null 不是对象， typeof null 是历史遗留问题，但并不代表 null 就是对象

基本数据和复杂数据类型有什么区别

1. 内存

   • 基本类型的变量值是保存在栈中的
   • 复杂类型的值是保存在堆中，变量的值只是堆的一个地址

2. 访问

   • 基本类型直接访问其值
   • 复杂类型是需要先通过地址再去获取堆中的值

3. 赋值

   • 基本类型赋值是对后者的拷贝，赋值前后值相等但没有任何关系（修改其中之一并不会影响另外一个变量的值）
   • 复杂类型赋值是地址的赋值，赋值前后变量所指向的内存地址相同，任意一个对象修改其属性后都会影响到另外一个变量

4. 传参

   • 基本类型 按值传递
   • 复杂类型 按引用传递 （如果在函数体内有对该参数进行属性的添加或修改，外部的变量会受到影响）

1.基本数据类型：Symbol， String， Number ， Undefined， Null， Boolean
2null为一个对象，可以用typeof null || Object.prototype.toString(null) 测试
3区别：在拷贝时，基本数据类型直接拷贝内容，复杂数据类型拷贝引用地址

JS中基本数据类型有哪几种？null 是对象吗？基本数据和复杂数据类型有什么区别？

JS中基本数据类型有哪几种？

JS的基本数据类型一共有六种，分别是：string、boolean、number、null、undefined、symbol。

null 是对象吗？

null不是一个对象。但是我们在使用typeof检测基本数据类型null的时候，会返回object。在 JS 的最初版本中使用的是 32 位系统，为了性能考虑使用低位存储变量的类型信息，000 开头代表是对象，然而 null 表示为全部都是，所以将它错误的判断为 object 。虽然现在的内部类型判断代码已经改变了，但是对于这个 Bug 却是一直流传下来。

基本数据和复杂数据类型有什么区别？

1. 基本数据类型存储在栈内存，存储的是值。
2. 复杂数据类型的值存储在堆内存，地址（指向堆中的值）存储在栈内存。当我们把对象赋值给另外一个变量的时候，复制的是地址，指向同一块内存空间，当其中一个对象改变时，另一个对象也会变化。
   （这里可能会涉及到浅拷贝和深拷贝）

js中的基本数据类型

js主要分为基本数据类型和复杂数据类型（引用类型）。
基本数据类型一共包括6种，分别是：
Null、Undefined、Number、String、Object、Symbol（ES6新增）
以及一种复杂数据类型： Object

null是对象吗？

null不是一个对象，但是tyoepf null的返回值为object。因为这是js遗留的一个bug。

基本数据类型和复杂数据类型的区别？

1、基本数据类型存储在栈中，复杂数据类型存储在栈和堆了（地址存在才栈中，值存在在堆中）。
2、基本类型是值的复杂，复杂类型的复杂是引用地址。
3、基本类型值的修改互不影响，相互独立。复杂数据类型更改一个变量的值，会影响另一个变量。

js中基本数据类型有：Null,Undefined,Number,String,Boolean,Symbol
复杂数据类型只有Object,
Null不是一个对象 虽然用 type of检测返回是个object类型，这个是因为最开始是32位系统 以000开头的是对象，恰好null是000所以 null会变成对象，但是null依然是null类型
区别：1.存储方式不同，基本数据类型是存储在栈中，复杂数据类型存储在堆中，栈中存储的变量是堆的
访问地址
2.访问方式不同：基本数据类型是按值访问，复杂数据类型是按照栈中存储的地址访问
3.复值事不同，基本数据类型复制的是值如a=b, 复杂数据类型复制的地址，也就是说被复制的地址
变了，那么复制后的地址也会跟着变化。

①JS基本数据类型有6种：String、Number、Boolean、null、undefined、Symbol；
②null不是对象，虽然typeof null为object
③
1、基本数据类型的数据名和值存放在栈内存中，且无法改变；
2、复杂数据类型的数据名和堆地址存放在栈内存中，值存放在堆内存中，取值时从栈内存中获取堆地址查找相应的值。
3、作为参数时，修改基本数据类型的参数不会影响原有数据，复杂数据类型的话，由于是引用地址，所以在修改参数的属性时，会影响原有数据。

Javascript 中的基本数据类型(共六种)

• Number
• String
• Boolean
• Null
• Undefined
• Symbol(ES6新增)

null 是对象吗?

null 不是对象,虽然 typeof null = "object" ,因为JavaScript中底层表示对象时,前三位是000就是对象,但null是全0,所以也被识别成对象,这是一个遗留的bug

基本数据类型和复杂数据类型的区别

• 存储方式不同: 基本数据类型存在栈中,复杂数据类型存在堆中,栈中存放对象的引用
• 复制的时候不同: 基本数据类型复制的是值,复制后两个变量互不影响,而复杂数据类型复制的是地址,复制后两个对象指向同一个地址,所以修改一个会影响另一个
• 传参时不同: 基本数据类型按值传递,复杂数据类型按引用传值,函数内修改参数值,也会改变原来的值