JavaScript基础总结：数据类型、数据&变量&内存、对象、函数

数据类型：1～6

1.有哪些分类？
基本（值）类型： --5种
string：任意字符串
number：任意的数字，与正负、整数还是小数无关
boolean：true、false
null：null
undefined：undefined

**对象（引用）类型**：
Object：任意对象都是object
Function：一种特别的对象（可以执行，即函数时可以调用的对象）
Array：一种特殊的对象（有数值下标、内部数据是有序的）

2.判断：
tyoeof：返回基本类型的字符串表达，即返回字符串，例：typeof a
可以判断：string、number、boolean、undefined，不可判断null
instanceof：判断对象的具体类型（因为所有对象都是object类型，所以需要进一步判断是什么具体类型），例：A instanceof Array
可以判断array和function，不能判断null和object
===：可以判断undefined、null，不可以判断数值，因为只有undefined和null这两个类型有唯一值
Q:判断数组的方法：
1）A instanceof Array
2）Array isArray（A）
3)原型链的方法：？？？
先定义一个数组：var a = []
然后对比进行原型对比：Array.prototype.isPrototypeOf(a)
栗子：

 	  var a
	  var b = function () {
	  }
	  var c = null
	  console.log(typeof a)  // undefined
	  console.log(typeof b)  // function
	  console.log(typeof c)  // objact
	  console.log(null === c) // true
	  console.log(undefined === a) // true

3.null和undefined的区别–它们都代表什么都没有
undefined：定义了但是没有赋值
null：定义并赋值，只是初值为null
null是基本类型，但是tyoeof null却返回‘object’，这矛盾吗？不矛盾，例子：
// 最初：
var b = null //表明将要赋值为对象，现在先置为null，之后有可能：
//确定对象就赋值
b= [1,2,3]或者 b={name: ‘kk’,age: 18}
//最后
b=null //让b指向的对象成为垃圾对象（被垃圾回收器回收-浏览器中）

4.什么时候给变量赋值null？
1）表明这个变量后面会赋值为对象
2）结束前赋值null，让对象成为垃圾对象（被垃圾回收器回收）

5.严格区别变量类型和数据类型？
数据的类型：
基本类型
对象类型
变量的类型（变量内存值的类型）：
基本类型：保存的是基本类型的数据
引用类型：保存的是地址值

6.什么是实例？什么叫类型？
实例是实例对象的简称，类型是类型对象的简称
function Person （name,age){ // 构造函数 类型
this.name=name
this.age=age
}
var p =new Person(‘lily’，18) // 根据类型创建的实例对象，当函数被用来创建实例时才是构造函数
// Person（‘lily’，18） 可以这么调用，但此时Person不是构造函数

数据、变量、内存 7～10

7.什么是数据？
存储在内存内存中代表某个信息的东西，本质上是010101…
例如，var age = 18
数据的特点：
可传递，如var a = 3; var b = a
可运算，如var b = a + 2

8.什么是内存？
内存条通电后，产生可以存储数据的空间（临时的，永久的存储的空间是硬盘），虚拟的不可见的。
内存产生和死亡：内存条（电路板）==> 通电 ==> 产生内存空间 ==> 存储数据 ==> 处理数据 ==> 内存空间和数据消失
内存的分类：
栈内存：全局变量、局部变量
堆内存：对象（表示该对象的变量在栈内存中）

9.什么是变量
可变化的量，有变量名和变量值组成（变量名是内存的标识）
每个变量都对应一块小内存，变量名用来查找对应的内存，例1：
var a = 18
console.log(a) // 经历过程：通过变量名a找到a所对应的内存，然后取出该内存储存的数据，然后打印出来
例2：
var obj = {name: ‘kally’}
var a = obj // 把obj保存的地址复制给变量a
console.log(obj.name) // 先找到obj这块内存，然后obj内存中存储着一个对象的地址，这个地址保存着对象的值

变量的读和写：
a = {sayHello: 'hello' } -- 写
其他情况均为读，如，a.name 、 a() 、a[]...都是读

10.数据、变量、内存三者之间的关系？
内存是储存数据的空间，变量是内存的标识

Q:var a = xxx,a内存中保存的是什么？
A:xxx是基本类型数据时，a内存保存的是这个数据
  xxx是引用类型数据时，a内存保存的是对象的地址
  xxx是一个变量时，a内存保存的有可能是这个数据，可能是地址值

Q:关于变量赋值的问题：
A1:两个引用变量指向同一个对象时，通过一个变量改变对象内部的数据，另一个变量的内部数据也会发生改变

var obj1 = {
	  name: 'lily'
	}
	function fn1(obj){
	  obj.name = 'kally'
	}
	fn1(obj1)
	console.log(obj1.name)  // kally
	function fn2(obj) {  // 形参的本质是变量、实参的本质是数据
	  var obj2=obj // 此时obj2和obj指向同一个对象
	  obj.name='Bob'
	}
	fn2(obj1)
	console.log(obj1.name) // Bob

A2:两个引用变量指向同一个对象时，让其中一个对象指向另一个对象另一引用变量仍然指向前一个对象

var a ={age:12,name:'kaka'}
	var b = a
	a= {name:'hana',age:18} // a已经指向另一一个对象（另一块内存）-- 此时a指向另一个对象，和b已经不是指向同一个对象
	b.age=20 // b仍然指向之前的一个对象
	console.log(b.name,b.age,a.name,a.age) // 'kaka',20 "hana" 18

Q:在js调用函数时传递变量参数，是值传递还是引用传递？--两种解释，说清楚就行
理解1：值传递！只是引用型数据的值是地址！基本类型就是数据本身！
理解2：可能是值传递，也可能是引用传递（地址值）

var a=3
	function fn(a){
	  a= a+3 // 传进来的不是a而是3
	}
	fn(a)
	console.log(a) // 3

Q:JS引擎如何管理内存？
1.生命周期：
  分配小内存空间，得到使用权
  储存数据，可以反复进行操作
  释放内存空间

2.释放内存
  局部变量，函数执行结束后自动释放
  对象：成为垃圾对象（置为null）==>垃圾回收器回收
  全局变量：运行过程中都不会被释放内存

function fn（）{
	var b ={}
	}
	fn（） // b是自动释放内存，b所指向的对象会在后面的某个瞬间被垃圾回收器回收
	

对象：11~14

11.什么是对象？
对象是保存多个数据的容器
一个对象代表现实世界的一个事物

12.为什么使用对象？
便于统一管理多个数据，不需要一个一个数据去声明

13.对象的组成？–属性和方法
属性 – 由属性名（字符串）和属性值（任意类型）组成
方法 – 一种特别的属性（属性值是函数）

14.怎么访问对象内部数据？
对象.属性名：属性名中不能包含空格、‘-’等特殊字符，不是所有情况都可以使用
对象[‘属性名’] ：属性名可以包含空格、‘-’等特殊字符，通用，任何情况都可以用

Q：什么时候必须使用：对象[‘属性名’]？
A: 1）属性名包含空格、 ‘-’等特殊字符时
2）属性名是数字
var p = {}
p[23] = ‘hh’
console.log(p[23])
3）变量名不确定时，比如属性名保存在变量中例子：

var p = {}
var proName = ‘myAge’
var value = 18
// p.proName = value // 属性名保存在变量中
// console.log§ // 报错
p[proName] = value // 属性名保存在变量中
console.log§ // {myAge: 18}
console.log(p[proName]) // 18

函数：15~22

15.什么是函数？
可以实现某个功能的n条语句的封装体
只有函数可以执行，其他类型数据的不能执行

16.为什么要用函数？–函数体现的是封装的思想，你写的函数要让别人看得懂
提高代码复用
17.怎么定义一个函数？–函数声明、函数表达式
函数声明：function fn（）{ // 操作} --可以函数提升
函数表达式：var fn =function（）{ // 操作} --不可以函数提升

18.如何调用（执行）函数？
1）直接调用： fn（）
2）作为构造函数被调用：new fn（）
3）临时调用：fn.call(test)/fn.apply(test) --在test中临时去调用fn函数

 var obj = {}
	  function fn(){
	    this.name='hello world!'
	  }
	  fn.call(obj ) // 相当于obj.fn(),call\apply提供了obj临时去访问不属于它自身的函数
	  console.log(obj.name) // hello world!

19.回调函数
1）什么是回调函数？
符合三个特点：
你定义的、你没有调用、最终执行了（某个条件下，比如达到时间点的定时器，再如，点击按钮触发）
2）常见的回调函数
* dom事件回调函数，如都dom元素的click事件
* 定时器回调函数，如setTimeout
* ajax请求回调函数 – 后面总结
* 生命周期回调函数 – 后面总结
例子：

document.getElementById('btn').onclick = function (){  // dom事件回调函数
	  alert('点击事件回调函数')
	}
	// 定时器
	// 超时定时器
	setTimeout(function () { // 定时器回调函数
	  alert('hello world')
	},3000)
	
	// 循环定时器
	setInterval(function () { // 定时器回调函数
	  alert('hello piixi')
	},3000)

Q:什么叫交互？
用户交互：比如用户点击要有什么反应？你得绑定某个事件来相应用户的操作 --与人的交互
前后台交互：前台数据从后台动态获取，前台需要写请求函数向后台获取数据等

20.IIFE–Immediately Invoked Function Expression，立即调用函数表达式，就是平时说的匿名函数自调用
例子：

(function (){  // 匿名函数自调用
console.log('hello world')
})()  // hello world

作用（好处）：
1）隐藏实现–实现不是暴露在外部的，尽在匿名函数内部
2）不会污染外部（全局）命名空间
3）用它编码js模块
例1：

(function (){  // 匿名函数自调用
                 var a =3  // 局部属性，不会污染匿名函数外部（全局）命名空间
                 console.log(5+a)
                 })()  // 8

例2：

(function () {
      var a = 1
      function test() {
        console.log(++a)
      }
      window.$=function () {  // 向外暴露一个全局函数
        return {
          test: test
        }
      }
    })()
    $().test()  // 2 ，$是一个函数，$执行后返回的是一个对象，对象的值是test函数

22.函数的this
Q1:this是什么？
所有的函数内部都有this变量，指向它的调用者 – 即函数必须通过某个对象来调用，这个对象就是函数的this；如果没有指定，该this就是window

Q2:如何确定this的值？
test(); --window
p.test(); --p
(隐式指向)new test(); --新创建的对象
test.call/apply(obj) -- obj
栗子：

function Person(color) {
	    console.log(this) // 会被执行
	    this.color = color;
	    this.getColor = function () {
	      console.log(this) // 没有调用相关属性，不会被执行
	      return this.color;
	    };
	    this.setColor = function (color) {
	      console.log(this) // 没有调用相关属性，不会被执行
	      this.color = color;
	    };
	  }
	  Person("red"); //this是谁? --window，因为Person是全局函数，调用Person是window对象（Person函数调用时仅有第一句concole.log被执行）

 var p = new Person("yello");  // this是谁?--p，因为此时p指向new出来的这个对象（也是仅有第一句concole.log被执行）
	  p.getColor();  // this是谁? --p
	  var obj = {};
	  p.setColor.call(obj, "black"); //this是谁? --obj
	  var test = p.setColor;
	  test();  // this是谁? --window

 function fun1() {
	    function fun2() {
	      console.log(this);
	    }
	    fun2(); //this是谁?--window，fn2只是在fn1内部，但是fn1并没有调用fn2，即没有指定，所以此时this是window
	  }
	  fun1();

**“题外话”**--js代码应不应该加分号？
看个人喜好加不加分号，但是有**两种情况必须加分号**：
1.小括号（比如，匿名自运行函数）前必须加分号，否则在代码合并压缩（合并时）出现问题---解决方式：在行首加分号
  栗子：

  var a = 'hello'
	  //(function () {
	  //  console.log('hello world')
	  //})()  // 会报错
	
	  ;(function () {  // 匿名自运行函数前加分号
	    console.log('hello world')
	  })()  // hello world

2.中方括号前必须加分号
  ;[1,2,3].forEach(function (item,index) {
})