数据类型：
1、基本类型：String、Number、boolean、undefined、null
2、对象类型：Object（任意对象）、Function（一种特殊的对象）、Array（一种特别的对象，内部数据是有序的）
判断方法：
1、typeof（返回数据类型的字符串表达）
可以判断：undefined、数值、字符串、boolean、function
不能判断：null和Object、Object和Array
2、instance：判断对象的具体类型
3、=== 可以判断：undefined、null
var b1 = { b2: [1, 'abc', console.log], b3: function () { console.log('b3') return function () { return 'xfzhang' } } } console.log(b1 instanceof Object, b1 instanceof Array) // true false console.log(b1.b2 instanceof Array, b1.b2 instanceof Object) // true true console.log(b1.b3 instanceof Function, b1.b3 instanceof Object) // true true console.log(typeof b1.b2, '-------') // 'object' console.log(typeof b1.b3==='function') // true console.log(typeof b1.b2[2]==='function') b1.b2[2](4) console.log(b1.b3()())
undefined和null的区别：undefinded代表定义未赋值，null定义并且赋值，其值为null
什么时候给变量赋值为null：
1、初始化的时候，表明该值之后将赋值为对象
2、结束前，让它成为垃圾对象（以便被垃圾回收器回收）
什么是数据：数据是存储在内存中的东西，本质上是0、1序列
数据的特点：可传递性，可运算，一切皆数据，内存中操作的目标：数据，算术运算、逻辑运算、赋值、运行函数
什么是内存：内存条通电后产生可以存储和数据的空间（临时空间），以小块内存的2个数据（地址值、内部存储的数据）
内存的分类：
栈：全局变量、局部变量
堆：对象
什么是变量：可以变化的量，由变量名和变量值构成，每个变量都对应一块小区域，变量名用于查找用户，变量值就是内存存储的数据
内存、变量、数据之间的关系：内存用来存放数据，变量用于表示数据
var = xxx
当xxx是基本数据类型的时候，保存的就是这个数据，xxx是对象的时候，保存的时候对象的地址值（xxx是一个变量，保存的xxx的内存内容，可能是基本数据、也可能是地址值）
引用变量赋值的：
多个引用变量指向同一个对象，通过一个变量修改对象内部的数据，另外的变量看到是修改之后的数据
<script type="text/javascript"> var obj1 = {name: 'Tom'} var obj2 = obj1 obj2.age = 12 console.log(obj1.age) // 12 function fn (obj) { obj.name = 'A' } fn(obj1) console.log(obj2.name) //A var a = {age: 12} var b = a a = {name: 'BOB', age: 13} b.age = 14 console.log(b.age, a.name, a.age) // 14 Bob 13 function fn2 (obj) { obj = {age: 15} } fn2(a) console.log(a.age) </script>
js引擎如何管理内存：
内存的声明周期：
分配好内存区域，得到使用权，存储数据，可以反复进行操作，释放内存
释放内存：
局部变量：函数执行完自动释放
对象：称为垃圾对象，垃圾回收期回收
什么是对象：多个数据的封装体，用来保存多个数据的容器，一个对象代表现实世界中的一个事务
为什么要使用对象：统一管理多个对象
对象的组成：
属性：属性名（字符串）、属性值（任意类型） 方法：一种特别的属性（属性值是函数）
如何访问对象内部的数据：
1、对象.属性名
2、['属性值']
<script type="text/javascript"> var p = { name: 'Tom', age: 12, setName: function (name) { this.name = name }, setAge: function (age) { this.age = age } } p.setName('Bob') p['setAge'](23) console.log(p.name, p['age']) </script>什么时候必须使用['属性名']的方式：1、属性名包特殊字符的时候，2、属性名用变量的时候
<script type="text/javascript"> var p = {} //1. 给p对象添加一个属性: content type: text/json // p.content-type = 'text/json' //不能用 p['content-type'] = 'text/json' console.log(p['content-type']) //2. 属性名不确定 var propName = 'myAge' var value = 18 // p.propName = value //不能用 p[propName] = value console.log(p[propName]) </script>
什么是函数：实现特定功能的多条语句的集合体，只有函数是可以执行的，其他类型的数据都是不可执行的
为什么要使用函数：提高代码的复用性，便于阅读交流
如何定义函数：1、函数声明 2、表达式
var obj = {} function test2 () { this.xxx = 'atguigu' } // obj.test2() 不能直接, 根本就没有 test2.call(obj) // obj.test2() // 可以让一个函数成为指定任意对象的方法进行调用 console.log(obj.xxx)
什么函数才是回调函数： 1、由自己定义的，2、自己没有进行调用，3、最终函数执行了
常见的回调函数：1、dom事件的回调函数， 2、定时器的回调函数， 3、ajax的异步回调函数， 4、声明周期的回调函数
IIFE：全称: Immediately-Invoked Function Expression
作用：
隐藏实现，不污染全局命名空间，用它来编码js模块
(function () { //匿名函数自调用 var a = 3 console.log(a + 3) })() (function () { var a = 1 function test () { console.log(++a) } window.$ = function () { // 向外暴露一个全局函数 return { test: test } } })() $().test() // 1. $是一个函数 2. $执行后返回的是一个对象
this是什么：
1、任何函数本质上都是通过某个对象来调用的，如果没有直接指定就是window
2、所有函数的内部都有一个变量this，它的值是调用函数的当前对象
Person("red"); //this是谁? window var p = new Person("yello"); //this是谁? p p.getColor(); //this是谁? p var obj = {}; p.setColor.call(obj, "black"); //this是谁? obj var test = p.setColor; test(); //this是谁? window
函数的prototype属性：
每个函数都有一个prototype属性，它默认指向一个Object空对象（原型对象）
原型对象有一个属性constructor，它指向函数对象
给原型中添加属性（一般都是方法）：函数所有的实例对象中自动拥有原型对象中的属性
<script type="text/javascript"> // 每个函数都有一个prototype属性, 它默认指向一个Object空对象(即称为: 原型对象) console.log(Date.prototype, typeof Date.prototype) function Fun () { } console.log(Fun.prototype) // 默认指向一个Object空对象(没有我们的属性) // 原型对象中有一个属性constructor, 它指向函数对象 console.log(Date.prototype.constructor===Date) console.log(Fun.prototype.constructor===Fun) //给原型对象添加属性(一般是方法) ===>实例对象可以访问 Fun.prototype.test = function () { console.log('test()') } var fun = new Fun() fun.test() </script>每个函数function都有一个prototype，即显示原型（属性）
每个实例对象都有一个__proto__，可以成为隐式原型（属性）
对象的隐式原型值=构造函数的显示原型值
函数的prototype属性：在定义函数时候自动添加，默认是一个Object空对象
对象的__proto__属性：创建对象的时候自动添加，默认值是构造函数的prototype属性值
<script type="text/javascript"> //定义构造函数 function Fn() { // 内部语句: this.prototype = {} } // 1. 每个函数function都有一个prototype，即显式原型属性, 默认指向一个空的Object对象 console.log(Fn.prototype) // 2. 每个实例对象都有一个__proto__，可称为隐式原型 //创建实例对象 var fn = new Fn() // 内部语句: this.__proto__ = Fn.prototype console.log(fn.__proto__) // 3. 对象的隐式原型的值为其对应构造函数的显式原型的值 console.log(Fn.prototype===fn.__proto__) // true //给原型添加方法 Fn.prototype.test = function () { console.log('test()') } //通过实例调用原型的方法 fn.test() </script>
原型链：访问一个对象的属性时候：先在自身查找，找到返回，没有找到，则沿__proto__这条链向上查找，找到就返回，如果最终没有找到，返回undefined
转载于:https://www.cnblogs.com/lzb0803/p/9061254.html
