2021-03-29

2020年3月29日 ——不积硅步无以至千里，不积小流无以成江海。

（js部分）

认识 堆与栈？

我们通常写的代码，在计算机语言中需要进行解释或者编译 ，这个过程是在内存中完成的，内存的使用和分配，会涉及到堆与栈。

栈：

javascript的基本类型就5种:Undefined、Null、Boolean、Number和String，它们都是直接按值存储在栈中，每种类型的数据占用的内存空间的大小是确定的。（栈由系统自动分配, 例如，声明在函数中一个局部变量var a; 系统自动在栈中为a开辟空间
只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出）

堆：

堆：javascript中其他类型的数据被称为引用类型的数据 : 如对象(Object)、数组(Array)、函数(Function) …，
它们是通过拷贝和new出来的，这样的数据存储于堆中
其实，说存储于堆中，也不太准确，因为，引用类型的数据的地址指针是存储于栈中的，当我们想要访问引用类型的值的时候，需要先从栈中获得对象的地址指针，然后，在通过地址指针找到堆中的所需要的数据。

函数 ：

     1.使用数组构造函数 ;       
     var arr = new Array();
     arr[0] = 'a';
     arr[1] = 'b';
      (1).字面量表示法 var arr = ['alice','angela','jack']  ;
      2.使用object构造函数
      var person  = new object();
      person.name = 'alice';
      person['age'] = 20;

检测属性:

      hasOwnProperty() 方法用于检测属性是否是自有属性，是则返回true,否则返回false

遍历属性：for …in

var obj = {name:‘a’,age:20}; (键值对)
for(var key in obj){
console.log(key)
console.log(obj[key])
};

序列化

JSON.stringify() 方法用于将 JavaScript 值转换为 JSON 字符串
例如：
var obj = {name:‘a’,age:20};
console.log(typeof JSON.stringfy(obj))

什么是深拷贝和浅拷贝？

简单来说：假设B复制了A，当修改A时，如果B没有发生变化，那就是深拷贝；反之则是浅拷贝。（但并不能完全称作深拷贝，因为深拷贝本身就针对的是复杂的Object类型数据，并且深拷贝需要将属性的各个层级都要拷贝过来，刚刚的例子只有一个层级。）
具体了解你可以看看深入分析：https://blog.csdn.net/ning1994724/article/details/91491528；

解析原则：

预解析过程中，当变量和函数同名时：只留下函数的值，不管谁前谁后，所以函数优先级更高。

作用域：

是指某一变量和方法具有访问权限的代码空间，在JS中，作用于是在函数之间哦维护的。即具有执行上下文的权限。
注意：
(1)在全局变量和局部变量不同名时，其作用域是整个程序。
(2)在全局变量和局部变量同名时，全局变量的作用域不包含同名局部变量的作用域。

普通对象和函数对象

通过new Function创建的对象都是函数对象，其他都是普通对象（通常通过Object创建），可以通过typeof来判断。
function f1(){};
typeof f1 //“function”

function 中的prototype

function Cat(name,color){ //构造函数
this.name = name;
this.color = color;
};
var cat1 = new Cat(“大明”,“黄色”);
var cat2 = new Cat(“小明”,“白色”);
如果当前cat函数中添加了eat()方法和type属性
function Cat(name,color){
this.name = name;
this.color = color;
this.type=‘动物’;
this.eat = function(){console.log(“吃老鼠”)};
};
存在一个浪费内存的问题，那就是对于每一个实例对象，type属性和eat()方法都是一模一样的内容
既不环保，也缺乏效率
解决方法：
function Cat(name,color){ //构造函数
this.name = name;
this.color = color;
//this.type=‘动物’;
//this.eat = function(){console.log(“吃老鼠”)};
};
Cat.prototype.type=‘动物’;
Cat.prototype.eat = function(){console.log(“吃老鼠”)};

继承的几种常见方式

原型继承
function Animal(){
this.type = “动物”
};

function Cat(name,color){
this.name = name;
this.color = color;
};
Cat.prototype = new Animal();
var c1 = new Cat(‘x’,‘白色’);
var c2 = new Cat(‘t’,‘花色’);
c1.type
优点：同一个原型对象
缺点：不能修改原型对象，会影响所有实例
function Animal(){ //动物对象
this.type = ‘动物’
};
function Cat(name,color){ //猫对象
this.name = name;
this.color = color;
this.type=‘我是猫’;
};
Cat.prototype = new Animal(); //猫的原型对象指向了动物函数
var cat1 = new Cat(“大明”,“黄色”);
var cat2 = new Cat(“大明”,“黄色”);
console.log(cat1.type); //获取的是当前构造器中的属性
console.log(cat2.type); //获取的是当前构造器中的属性
//想获取Animal成员值
console.log(cat1.proto.type);
console.log(cat2.proto.type);
//当我们访问一个原型对象的属性时，__proto__是一级级来获取，当继承关系很复杂，未知继承时
构造函数的继承
function Animal(){
this.type = “动物”
};
function Cat(name,color){
Animal.apply(this); //将Animal对象的成员放到Cat对象上
this.name = name;
this.color = color;
};
var cat1 = new Cat(“大明”,“黄色”);
var cat2 = new Cat(“小明”,“白色”);
cat1.type = ‘我是黄猫’;
cat2.proto.type = ‘我是动物’;
console.log(cat1.type); //‘我是黄猫’ cat1被修改
console.log(cat2.type); //“动物”
优点：不存在修改原型对象影响所有实例，各自拥有独立属性
缺点：父类的成员会被创建多次，存在冗余且不是同一个原型对象
通过apply/call只能拷贝成员，原型对象不会拷贝

此篇结束。。。。。