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

[YvetteLau]

No description provided.

[zyq503454535]

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

[jizx]

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

[tpxiang]

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

[dashengzi66]

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

[chang229]

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）当基本数据类型作为参数传给函数时，函数对其改变不会改变外面的值，复杂数据类型作为参数时，函数内部对参数值的修改会改变外部变量的值。

[shenanheng]

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

[ZhangWeiC]

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

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

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

[zwq357smile]

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

[taoyaoyaoa]

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

[CCZX]

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

[ahaow]

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

[zhangxianhui]

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

[chongyangwang]

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

[KRISACHAN]

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基本类型与复杂类型的区别

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

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

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

[965969480]

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

[clairing]

1：JS中基本数据类型 Undefined 、Null、Boolen 、Number、 String、Symbol(ES6新增)，
Object是 复杂数据类型
2：null不是一个对象，通过typeof可以检测是object ，但,它是一个空对象指针，如果一个对象准备保存值时，初始化时最好用null, 另外：undefined派自生于null。
3: 基本数据类型：
1：基本数据类型的值是不可变的 ，改变的是值的指针指向。
2：不可添加属性和值；
3：值存在栈中
4：赋值是简单的赋值
5：比较时候比较的是值的比较

复杂数据类型（引用数据类型）：
1：值是可以变的，
2：可以添加属性和值
3：存在堆和栈中，堆存出的是值，栈存储的变量名和堆的引用
4：赋值是对象的引用
5：比较 的时候比较的是对象的引用的比较

[Diamondjcx]

1.JS的基本数据类型：Undefined、Null、Boolean、Number、String

　　Undefined类型只有一个值，即特殊的undefined，声明变量但是没有初始化，这个变量的值就是undefined

　　Null类型只有一个值null，表示一个空对象指针，正式使用typeof操作符检测null会返回object

　　Boolean有两个字面值：true和false

　　Number:用来表示整数和浮点数，还有一种特殊的值即NaN,这个数值用来表示一个本来要返回数值的操作数未返回数值的情况（这样就不会抛出错误了）

　　String类型用于表示由零或多个16位Unicode字符组成的字符序列，即字符串。字符串可以由单引号(')或双引号(")表示。

2.三大引用类型

　　Object类型

　　Array类型

　　Function类型

3.区别
存储空间：基本类型存在栈中，引用类型存在栈上

值传递：基本类型传递的是值，引用类型传递的是地址（引用）

作为函数的参数：基本类型传递的是值，引用类型传递得是地址
4.null是对象 指的是空指针。tryeof（null）object

[AILINGANGEL]

1. JS基本数据类型分为基本类型和引用类型

基本类型有如下几种：

• null
• undefined
• string
• number
• boolean
• symbol

引用类型

• object

2. null是对象吗?
   虽然typeof null === 'object' 但是null并不是对象，这是一个历史遗留问题，浏览器没有修复。如果使用instanceof 操作符， null instanceof Object 会返回 false

3. 基本数据类型和复杂类型的区别
   基本类型存储在栈内存中，如果把一个基本类型的变量赋值给另一个变量实际上进行的是值拷贝。引用类型的指针（地址）存储在栈内存中，这个指针指向的对象存储在堆内存中，如果进行拷贝拷贝的是栈内存中存储的指针而不是对象真正的值

[toyxz]

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

JavaScript中类型有8种：

• 基本类型：Number、String、Boolean、undefined、null、Symbol(ES6)、BigInt(ES10)
• 引用类型

Sybmol表示独一无二的值

BigInt可以表示任意精度的整数，在数字末尾加上一个n表示BigInt类型

const b = 123456789n; 

null

使用typeof可以判断类型，得到的是对应类型的字符串

    typeof undefined == 'undefined' // true
    typeof null == 'object' // true
    typeof '42' == 'string'
    typeof 42 == 'number'
    typeof true == 'boolean'
    typeof Symbol() == 'symbol'

null不是对象，null不是引用类型，虽然

typeof null === 'object'

但是null不是一个对象,仍然是一种基本类型。

基本数据和引用的区别

• 基本类型存储在栈内存中，引用类型将引用类型的地址存储在栈内存中，将引用类型本身存储在堆内存中。
• 基本类型不需要考虑深浅复制，因为复制都是重新开辟一个新的栈空间；而引用类型浅复制是在栈内存中复制一个地址,深复制则是重新开辟一个堆内存

[kaiking01]

答一：
5种基本数据类型：Number, String, Boolean, Undefined, Null;
3种引用类型：Array, Object, Function。

答二：
Null是空对象，空对象也是对象，永远只有一个值，那就是Null。

答三：区别
基本数据类型之间的赋值，相当拷贝，栈内存中会同时存在两份数据，修改其中任意一个数据，另一个数据不会变化；
引入数据类型之间的赋值，是改变指针的指向，共享一份数据；

[gitluck1314]

1、JS的基本数据类型有：undefined，null，number，string，Boolean ，Symbol
2、null不是对象。

从逻辑上看，null值表示一个空对象指针，这就是为什么使用typeof操作符检测null值时会返回‘object’的原因，也是JavaScript遗留下来的bug。
而真正的原因是：JS类型值是存在32bit 单元里,为了性能考虑用低位储存了变量的类型信息，其中000表示是Object类型，而null对应机器码的NULL指针，一般全为零，所以typeof(null)为Object。

  null instanceof Object //false

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

• 基本数据类型值指的是简单的数据段，而复杂的数据类型值是由一个或多个值构成的对象。

• 基本数据类型拷贝时，拷贝的是值，并且原变量和拷贝后的变量是相互独立的，这两个变量可以参与任何操作而不会相互影响。
  复杂数据类型拷贝时，也就是所说的引用类型的值拷贝时，副本拷贝的是指针，而这个指针指向存储在堆中的一个对象。复制操作结束后，两个变量实际上引用的是同一个对象，因此，改变其中一个变量，就会影响另一个变量。

• 传递参数时，道理和拷贝一样。在向参数传递基本类型的值时，被传递的值会被赋值给一个arguments对象中的一个元素（即局部变量）；在向参数传递引用类型的值时，会把对应值的地址复制给一个局部变量，因此局部变量的变化会反映到函数的外部。

[yuzhang9804]

基本数据类型

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

复杂数据类型

• Object

当我们用 typeof null时, 会输出object, 这是因为在JS 最初的版本中, 000开头代表对象, 而null表示为全0, 所有将其错误的判断为object, 即使后来内部的判断规则改变了, 这个bug 还是流传下来啦

1. 基本数据类型存储的是值,而复杂数据类型存储的是地址(指针)
2. 当我们拷贝一个值时, 基本数据类型拷贝的时独立的值, 而复杂数据类型存储的是地址(指针), 这就导致了我们复制的是原来变量的地址(指针), 当我们进行数据修改时, 所有拥有相同地址(指针)的变量的值都会发生改变
3. typeof 可以正确判断除了null其他的所有基本类型, 而判断复杂数据类型,我们建议使用instanceof

[YvetteLau]

目前，JS原始类型有六种，分别为:

• Bool
• String
• Number
• Undefined
• null
• Symbol(ES6新增)

ES10新增了一种基本数据类型：BigInt

复杂数据类型只有一种:

• Object

null 不是一个对象，尽管 typeof null 输出的是 object，这是一个历史遗留问题，JS 的最初版本中使用的是 32 位系统，为了性能考虑使用低位存储变量的类型信息，000 开头代表是对象，null 表示为全零，所以将它错误的判断为 object 。

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

1.内存的分配不同

• 基本数据类型存储在栈中。

• 复杂数据类型存储在堆中，栈中存储的变量，是指向堆中的引用地址。

2.访问机制不同

• 基本数据类型是按值访问
• 复杂数据类型按引用访问，JS不允许直接访问保存在堆内存中的对象，在访问一个对象时，首先得到的是这个对象在堆内存中的地址，然后再按照这个地址去获得这个对象中的值。

3.复制变量时不同

• 基本数据类型：a=b;是将b中保存的原始值的副本赋值给新变量a，a和b完全独立，互不影响
• 复杂数据类型：a=b;将b保存的对象内存的引用地址赋值给了新变量a;a和b指向了同一个堆内存地址，其中一个值发生了改变，另一个也会改变。

let b = {
    age: 10
}

let a = b;
a.age = 20;
console.log(a); //{ age: 20 }

4.参数传递的不同(实参/形参)

函数传参都是按值传递(栈中的存储的内容)：基本数据类型，拷贝的是值；复杂数据类型，拷贝的是引用地址

//基本数据类型
let b = 10

function change(info) {
    info=20;
}
//info=b;基本数据类型，拷贝的是值得副本，二者互不干扰
change(b);
console.log(b);//10

//复杂数据类型
let b = {
    age: 10
}

function change(info) {
    info.age = 20;
}
//info=b;根据第三条差异，可以看出，拷贝的是地址的引用，修改互相影响。
change(b);
console.log(b);//{ age: 20 }

[MissNanLan]

A1

基本数据类型

• number
• string
• boolean
• undefined
• null
• symbol

引用数据类型

• function
• object
• array

A2

null不是一个对象，它只是用来保存对象，还没有真正的保存值，所以说它是一个空对象指针
即使

typeof null // object

可是它也

typeof []  // object呢

A3

基本数据类型： 存放在栈内存中，它们是按值存放的
引用数据类型： 存放在堆内存当中，它们是按引用地址存放的

这道题可以引出另外一个问题，浅拷贝和深拷贝

[YvetteLau]

A1

基本数据类型

• number
• string
• boolean
• undefined
• null
• symbol

引用数据类型

• function
• object
• array

A2

null不是一个对象，它只是用来保存对象，还没有真正的保存值，所以说它是一个空对象指针
即使

typeof null // object

可是它也

typeof []  // object呢

A3

基本数据类型： 存放在栈内存中，它们是按值存放的
引用数据类型： 存放在堆内存当中，它们是按引用地址存放的

这道题可以引出另外一个问题，浅拷贝和深拷贝

O(∩_∩)O哈哈赞
深拷贝和浅拷贝后面的issue中会有~~~
比如深拷贝和浅拷贝的区别是什么？如果实现一个深拷贝~

[TTTTTTTZL]

以最新ES6标准：
基本类型: String,Number,Boolean,null,undefined,Symbol

typeof null === 'object' ---> null属于对象

此处延伸一下对null的理解:
null与undefined相似，表示一个空值，即此处的值为空，调用函数时，某个参数未设置任何值，这时就可以传入null，表示该参数为空。

基本类型因数据量小存储于栈中，复杂数据类型因数据量可扩展而存储于堆中。
通常声明的复杂数据类型实际上只是一个指针，相当于宾馆的房间号，仅仅表示该声明指向这个房间。所以会引发浅拷贝/深拷贝的情况，而基本类型不会发生这种情况
---tl

[xyfay536475008]

1. 基本数据类型

Number, String, Boolean, Null, Undefined, Symbol

2. null 不是真正意义上的对象或者对象的实例。它只是空指针，它不引用内存地址。

3. 基本数据类型存在栈内存中，传值的时候是拷贝赋值。复杂数据类型由基本数据类型按照一定结构组成，包含数组，对象，函数。他们存在堆内存中，并有一个唯一的16进制地址，他们传值其实是传地址。堆内存不会自动销毁，在被没有引用时，在浏览器空闲时会被浏览器回收。

[lqzo]

JS中基本数据类型

• 原始数据类型 （不是对象且没有方法）

  Boolean、Null、Undefined、Number、String、Symbol（ES6 新增）、BigInt（ES10）

  1. Boolean 类型
     表示一个逻辑实体，有两个值：true 和 false。
  2. Null 类型
     表示缺少的标识，指示变量未指向任何对象。
  3. Undefined 类型
     一个没有被赋值的变量会有个默认值 undefined。
  4. Number 类型
     根据 ECMAScript 标准，Number 基于 IEEE 754 标准的双精度 64 位二进制格式的值（-(263 -1) 到 263 -1）。它并没有为整数给出一种特定的类型。除了能够表示浮点数外，还有一些带符号的值：+Infinity，-Infinity 和 NaN (非数值，Not-a-Number)。
  5. String 类型
     用于表示文本数据。它是一组16位的无符号整数值的“元素”。
  6. Symbol 类型
     表示独一无二的值。
  7. BigInt 类型
     BigInt 是 JavaScript 中的一个新的原始数值类型，它可以以任意精度表示整数。使用 BigInt 可以安全地存储和操作大型整数，甚至超过数字的安全整数限制。一个 BigInt 数据可以通过将 n 附加到 Integer 的末尾或通过调用构造函数创建。

• 复杂数据类型
  Object
  （emm 这个内容太多了）

null 是对象吗？

不是。null 值表示缺少的标识，指示变量未指向任何对象。

The value null is written with a literal: null. null is not an identifier for a property of the global object, like undefined can be. Instead, null expresses a lack of identification, indicating that a variable points to no object.

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

基本数据类型： 存放在栈内存中，它们是按值存放的
引用数据类型： 存放在堆内存当中，它们是按引用地址存放的
在变量赋值或函数传参时，数据传递的方式会有不同，基本类型是复制一份值进行传递，引用类型则是传递了内存地址。

---

今天的答案真早啊，给刘小夕打call

[darlingyz]

JS的基本数据类型:null string number Symbol undefined boolean 对象类型 object
null 不是对象 检测null 是不是对象 typeof 检测不出来，用instanceof
原因：在JS的最初版本中使用的是32位系统，为了性能考虑使用低位存储变量的类型信息，000开头的是对象，null是全0，所以将null误判为Object了，虽然现在的内部类型判断代码已经改变了，但bug永久的遗留下来了
eg:
var srt = null
console.log(srt instanceof Object)//false 说明不是对象
基本数据类型和复杂数据类型区别:
基本数据类型把数据名和值直接存储在栈当中,
复杂数据类型在栈中存储数据名和一个堆的地址，在堆中存储属性及值，访问时先从栈中获取地址，再到堆中拿出相应的值
基本数据类型作为参数时，函数内部对参数值的修改不会改变外部变量的值
因为复杂数据类型赋值是把栈中对象的地址赋给变量，函数内外两个变量指向同一个对象，所以只要对象的属性值改变，两个变量值都会改变
eg: function student(age, name, grade) {
this.age = age;
this.name = name;
this.score = grade;
}
var s1 = new student(18, "yz", 100);//创建一个student对象
function a(s) {
s.name = "hello";
}
a(s1)//把s1赋给s
console.log(s1.name);//输出hello

-----给小姐姐打call

[Timoeser]

boolean string number null undefined 以及新增的symbol

区别是：基本数据类型存在栈里面，复杂数据存在堆里面，需要访问堆里面的数据，是去栈里面获取地址，根据地址去堆里面查找

[web-data-MrLi]

js的原始数据类型有7种

1. null undefined string number object boolean Symbol(es6)
   2.对于null的理解，typeof的检测是object，但是实际机制不是这样的，是一个假的对象，这是windows机制的问题导致的
   3.数据类型中又分基本数据类型和引用数据类型如下；
   基本数据类型有
   null
   undefined
   string
   number
   boolean
   Symbol
   引用数据类型
   object
   array和function属于object
   注意：两种类型的用途和检测有区别

[Nancy0611]

基本数据类型

• Undefined
• Null
• Boolean
• Number
• String
• Symbol（ES6新增）

null不是对象

尽管typeof null输出的是object，但这其实是个历史遗留问题，不同的对象在底层都表示为二进制，在JavaScript中二进制前三位都为0的话会被判为object类型，null的二进制表示是全0，自然前三位也是0，所以执行typeof时会返回obkect，这个bug是第一版的JavaScript中留下来的。这个版本中，数值是以32字节存储的，由标志位（1-3个字节）和数值组成，000是对象的标志位。

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

1. 内存分配不同
   • 基本数据类型存储在栈中
   • 复杂数据类型存储在堆中，栈中存储的是指向内存的引用
2. 访问机制不同
   • 基本数据类型是按值访问的
   • 复杂数据类型的值是保存在内存中的对象，JavaScript不允许直接访问内存中的位置，也就是说不能直接操作对象的内存空间，所以操作对象时实际上是在操作对象的引用而不是实际的对象，所以是按引用访问的

[binh123]

javascript数据类型及基本类型与复杂类型的区别：
1.值类型（基本类型）：undefined、String、Boolean、Number、null（对象）、Symbol
2. 引用类型(复杂类型 ):Array、Object、Function
3.typeof不能区分引用类型(Function除外)，用instanceof来判断
4.NAN是一个特殊的number
5.值类型存储在栈中，引用类型存储在堆中。引用类型作为函数参数时，传递的是内存地址，函数内修改属性的对象是函数外部创建的对象。这是引用类型的本质所在。
`function pInfo(obj){

obj.name = '深圳';

}

var city = new Object();
city.name = '杭州';
city2 = city;
pInfo(city2);
console.log(city2);
console.log(city);
`

[wanglinyj]

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

[libraxiang]

null boolean undefined string number
null 不是对象
基本数据是值传递，改变后面的值，不影响前面
复杂数据类型是把前者的地址赋给后者，改变任何一个的值，两个都会一起改变

[tangjian1891]

1.基本类型6中:string,number,boolean,null,undefined,symbol(es6)
2.引用数据类型:Object
区别:引用数据类型传递的是地址值，指向同一块内存空间。其中一个修改，会影响其他相同指向的对象
基本类型是值传递。互不相干
另外:Object.prototype.toString().call()这个方式可以用来判定对象 typeof null是个bug,返回的Object，实际上null是基本类型。（js底层根据二进制判断，前三位为0则为对象，null全是0.）

[noggcool]

基础数据类型有：string number boolean undefined null symbol
null是对象吗？不是，虽然typeof出来是object，其实这是一个遗留下来的bug。js中判断为不同对象的标准是其二进制，而null的前三位二进制都表示为0，而js中前3位是0就判断为对象。而null实际是基础数据类型。
基本数据和复杂数据类型有什么区别？基本数据的复制，是直接开辟新的栈空间，在栈内保存新的值，所以修改复制的后的变量，原变量不会发生改变，虽然原变量不会发生改变，但是属于浅拷贝哦。而复杂数据类型的复制是复制栈地址指向堆值的指针，栈内存存的是地址，值在对内存。所以复制后的变量改变会影响原变量。如果想不改变原变量就需要使用深拷贝。在很多项目中，我们对store里面的数据进行操作，都会将对象的值通过如Object.assign的方式来复制一份来操作，这样的操作一般就是深拷贝

[coloryjl]

1、基本数据类型：string、null、boolean、undefined、number、symbol
2、null不是对象
3、基本数据类型存在栈中，复杂数据类型存在堆中。

[muyiweibo]

1、基本数据类型:null,unfined,number,string,boolen,symbol
2、null是对象吧，万物皆对象，什么才是对象呢？我已经搞不清了。
3、基本数据类型判断全等时值相等就为true，复杂数据类型判断全等时要求值与引用地址都相同，在内存中存放方式不同，基本数据类型应该是存在栈中，复杂数据类型应该是存在堆中？

[ccvaille]

• 基本类型：String Number Boolean Undefined Null Symbol
• null 是对象，可以理解成尚未创建的对象
• 区别：

  • 基本数据类型把数据名和值直接存储在栈当中

  • 基本数据类型作为参数时，函数内部对参数值的修改不会改变外部变量的值

  • 复杂数据类型在栈中存储数据名和一个堆的地址，在堆中存储属性和值

  • 复杂数据类型作为参数时，函数内部堆参数值的修改会改变外部变量的值，原因是把栈中对象的地址赋值给变量的时候，函数内外两个变量指向同一个对象，所以只要对象的属性值改变，两个变量值都会改变

[954545647]

基本类型有:
null undefined number string boolean symbol 还有 bigint!!!!!
null 不是对象,但通过 typeof null 返回的是 object 原因是底层都是以二进制的形式,如果前三位为0,则代表对象,而null全部为0,所以返回值是 object
基本数据类型和复杂数据类型的区别在于:
基本数据类型保存在栈当中，复杂类型数据存放在堆和栈当中,栈中存放复杂类型数据的地址(指针),堆中存放复杂类型的值

[ivan0525]

• 基本数据类型：Number、String、Boolean、Undefined、Null、Symbol（ES6）

• null不是对象，它是基本数据类型。尽管 typeof null === 'object'，我们可以看个栗子：

  let a = null;
  let b = null;
  a === b // true

  显然，null不是对象，如果是对象，那么a和b是不相等的。

• 区别：基本数据类型是存在栈中，复杂数据类型将指针存在栈中，指针指向堆内存中的复杂的值。

[0xBrooke]

基本数据类型：共有六种：null、undefined、number、boolean、string、symbol（es6）。
null不是对象：重点解释为什么 typeof null === 'object' 是 true？
js 在底层存储变量的时候，会在变量的机器码的低位1-3位存储其类型信息
000：对象
010：浮点数
100：字符串
110：布尔
1：整数
但是，对于 undefined 和 null 来说，这两个值的信息存储是有点特殊的。
null：所有机器码均为0 undefined：用 −2^30 整数来表示
所以，typeof 在判断 null 的时候就出现问题了（bug），由于 null 的所有机器码均为0，因此直接被当做了对象来看待。

区别：
基本数据类型存储在栈内存，存储的是值。数据大小确定，内存空间大小可以分配
复杂数据类型在栈中存储数据名和指针，其对象存储在堆中，每个空间大小不一样，要根据情况进行特定的配置。
访问方式不同：
在javascript中是不允许直接访问保存在堆内存中的对象的，所以在访问一个对象时，首先得到的是这个对象在栈内存中的地址，然后再按照这个地址去获得这个对象中的值，这就是传说中的按引用访问。

[luohong123]

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

共6种，包括string、number、boolean、null、undefined、symbol

二、null 是对象吗？

• 值 null 是一个字面量，它不像undefined 是全局对象的一个属性。null 是表示缺少的标识，指示变量未指向任何对象。把 null 作为尚未创建的对象，也许更好理解。在 APIs 中，null 常在返回类型是对象，但没关联值的地方使用。

console.log(typeof null === 'object'); // true

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

这个bug是第一版Javascript留下来的。在这个版本，数值是以32字节存储的，由标志位（1~3个字节）和数值组成。标志位存储的是低位的数据。这里有五种标志位：
000：对象，数据是对象的应用。
1：整型，数据是31位带符号整数。
010：双精度类型，数据是双精度数字。
100：字符串，数据是字符串。
110：布尔类型，数据是布尔值。
最低位有一位，那么标志位只有一个1字节长度；或者是零位，标志位有3个字节长度，多出两个了字节，一共多出四种类型

typeof null        // "object" (因为一些以前的原因而不是'null')
typeof undefined   // "undefined"
null === undefined // false
null  == undefined // true
null === null // true
null == null // true
!null //true
isNaN(1 + null) // false
isNaN(1 + undefined) // true

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

1、基本数据类型把数据名和值直接存储在栈当中
2、复杂数据类型在栈中存储数据名和一个堆的地址，在堆中存储属性及值，访问时先从栈中获取地址，再到堆中拿出相应的值
3、基本数据类型作为参数时，函数内部对参数值的修改不会改变外部变量的值
4、复杂数据类型作为参数时，函数内部对参数值的修改会改变外部变量的值

[RanSatious]

基本数据类型

• null
• undefined
• number
• boolean
• string
• symbol(es6)

null 不是对象

typeof null; // object

只是一个历史遗留下来的bug

区别

• 除了上面几种基础数据类型之外的类型都是复杂数据
• 基础数据存放在执行栈中，复杂数据存放在堆中
• 传递基础数据类型是传递它的值，传递复杂数据类型是传递它的引用

[ght5935]

1. 六中基本数据类型

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

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

3 两者的区别

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

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

[DazhiFe]

基本数据类型

基本数据类型有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章的内容

[MissWXiang]

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

（微信名：RUN）

[tanxchen]

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

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

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

• 基本数据类型

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

• 复杂数据类型

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

[mcDullLi]

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

[qinmeishuying]

基本数据类型：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不是对象，它只是一个基本数据类型

[ITHcc]

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

[xiterjia]

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

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

6 种原始类型

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

1 种复杂类型

• Object

null 是对象吗

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

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

1. 内存

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

2. 访问

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

3. 赋值

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

4. 传参

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

[yinluoyu]

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

[plane-hjh]

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

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

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

null 是对象吗？

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

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

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

[riluocanyang]

js中的基本数据类型

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

null是对象吗？

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

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

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

[EcSunshine]

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

[chenjiake]

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

[lovelycarrot]

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

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

null 是对象吗?

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

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

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