堆和栈的区别js（js栈内存和堆内存的区别）

本文目录

• js栈内存和堆内存的区别
• JavaScript原型，原型链 有什么特点
• javascript 中不同类型以及不同环境下变量的内存都是何时释放
• js 堆内存和栈内存的区别，还有就是对象的值是保存在哪个内存的
• js中String()、new String()探究
• JS中查询一个对象的构造函数使用什么属性
• 在java中=和==的区别

js栈内存和堆内存的区别

这很好理解，比如说这么个函数：function sum(i){if (i == 1) return 1;return i + sum(i - 1);}显然，这是一个递归函数，函数自己调用自己。那么每个调用，都必须保存一个i的变量。此时就要用堆栈。堆栈的栈顶始终保持着函数的局部变量。当函数返回，则往回收缩，这多方便。而堆呢？适合全局的、一般的存储。

JavaScript原型，原型链 有什么特点

1.1 一切皆为对象JavaScript里所有的东西都是对象. 对象是属性的集合. 数字, 字符串, 布尔值等原始值是"伪对象", 它们同样拥有属性, 但是是在栈上分配并按值传递. 而其他的对象是堆上分配并按引用传递.一个很重要的概念是, 函数也是对象, 能够作为变量的值, 返回值, 参数或者属性的值. 函数对象特殊的地方是能通过"xxx()"语法执行包含在xxx函数对象内的代码. 因为这一特殊性, typeof xxx 将会返回function, 但这只是一种便利设施.1.2 对象的属性可以动态添加和删除

var foo = new Object();// 为foo对象添加bar属性foo.bar = "foobar";alert(foo.bar); //foobar// 删除foo对象的bar属性delete foo.bar;alert(foo.bar); //undefined

1.3 除了宿主对象, 其它对象皆由构造函数创建要有对象, 就先要有创建对象的方法. 在C++/Java等语言, 这个方法就是实例化XXX类的一个实例xxx.而在JavaScript的世界里实际没有类的东西, 当然仍然可以用"类"和"实例"等惯用语来描述JavaScript中类似的行为, 但其机制是完全不同的. JavaScript的对象是由构造函数创建的, 每个对象都有constructor属性表示创建该对象的构造函数:

function Test() { this.a = "hello"; }var test = new Test(); // 由Test构造函数创建alert(test.constructor);var o = { a: "hello" };//实际相当于var o_ = new Object();o_.a = "hello"; // 由Object构造函数创建alert(o.constructor);

构造函数也是对象, 那构造函数是由什么创建? 内建的Function函数:

function Test(a, b){alert(a+b);}// 相当于:Test = new Function(, "alert(a+b);");

Function函数又是由什么创建? 实际上Function是本机代码实现的固有对象. 不过为了一致性, Function也有constructor属性, 该属性指向它自己. 接上面的代码:

/* 输出 function Function(){}*/alert(Test.constructor);alert(Test.constructor.constructor === Test.constructor); // truealert(Test.constructor === Object.constructor); // true

2 原型prototype2.1 prototype的概念prototype是构造函数的一个属性, 该属性指向一个对象. 而这个对象将作为该构造函数所创建的所有实例的基引用(base reference), 可以把对象的基引用想像成一个自动创建的隐藏属性. 当访问对象的一个属性时, 首先查找对象本身, 找到则返回; 若不, 则查找基引用指向的对象的属性(如果还找不到实际上还会沿着原型链向上查找,  直至到根). 只要没有被覆盖的话, 对象原型的属性就能在所有的实例中找到.原型默认为Object的新实例, 由于仍是对象, 故可以给该对象添加新的属性:

// prototype默认为new Object(); 为了方便, 记为p_objfunction Person(name) {this.name = name;}// 为 p_obj 增加 sayName 属性Person.prototype.sayName = function(){alert(this.name);}var john = new Person("John"); // john 的 base reference指向p_objvar eric = new Person("Eric");  // eric 的 base reference也是指向p_obj// 注意sayName代码中的this将指向实例化后的对象(this绑定)john.sayName(); // john对象本身没有sayName属性, 于是访问原型对象p_obj的sayName属性eric.sayName(); // 访问同一个原型对象p_obj的sayName属性var tmp = Person.prototype;tmp.boss = "David";// 于这个运行点, p_obj已经被修改// 根据上述属性访问流程, 新的修改(boss属性)能反映到所有的实例, 包括已经创建和即将创建的alert("John’s boss is " + john.boss);alert("Eric’s boss is " + eric.boss);// hisCar和sayCar属性将增加到john对象而不是p_obj对象..john.hisCar = "Audi";john.sayCar = function(){alert(this.name + " has a car of " + this.hisCar);}john.sayCar();// ..因此下一句将错误, 因为eric对象本身和原型p_obj都没有sayName属性/* eric.sayCar(); */

2.2 原型链除了能修改prototype指向的对象, 还能修改prototype指向哪一个对象, 即为prototype赋予一个不同的对象. 这可以实现一种简单的继承:

function Superman() {}Superman.prototype.sayHello = function(){alert("I’m a superman.");}function SupermanCan(skill){this.skill = skill;}// 为prototype赋予Superman的实例..SupermanCan.prototype = new Superman();// ..再动态添加新的属性SupermanCan.prototype.sayMore = function(){this.sayHello(); // 调用"父类"的方法alert("I can " + this.skill);}var david = new SupermanCan("fly");// output: I’m a superman. I can flydavid.sayMore();

如果先实例化出一个对象, 再为构造函数prototype赋予一个不同的对象, 将会: 已经创建的对象的基引用不变, 将来创建的对象的基引用为新的原型对象:

var f1 = {echo: function() { alert("sound"); } };function Foo() {};var foo = new Foo(); // foo的基引用指向Object实例Foo.prototype = f1;/* 未定义, 因为这是"foo对象自己或者基引用指向的对象有echo属性吗?"而不是"foo对象自己或者Foo.prototype指向的对象有echo属性吗?" */alert(foo.echo);var foo2 = new Foo(); // foo2的基引用指f1对象foo2.echo(); // output: sound

所有的构造函数的prototype都不能为空, 就是说Superman.prototype = null 会被解释引擎无视;  另一方面, Object构造函数也有prototype属性(该属性是只读的, 可以为原型增加属性,但不能赋予不同的对象), 故因此可以有多层的原型链, 但原型链的根必定会是Object.prototype . 这意味着给Object.prototype增加属性影响到所有对象:

Object.prototype.echo = function() {alert("hello");}// echo属性将增加到所有对象固有对象和自定义对象var arr = new Array();arr.echo();Array.echo();function ObjCons()    {this.dummy = "d";}var obj = new ObjCons();obj.echo();ObjCons.echo();

3. 构造函数和new的实质构造函数是一个地地道道的函数, 一个函数之所以能成为构造函数, 是因为new运算符:

this.msg = "window";function Test(){alert(this.msg);}Test(); // windowvar test = new Test(); // undefined. 因为test对象没有定义msg属性

二者区别在于如何切入对象: Test() 在某个对象(例子中为window)的上下文上执行代码, 即this指向这个对象; new Test()创建一个新对象, 并以这个新的对象为上下文(this指向新对象)执行代码, 然后返回这个新对象. 假如有个函数:

function Test() {var dummy = "have money";this.wish = dummy;doSomeThing();}

结合以上的所有论述, 可以推测new Test()行为的伪代码表示为:创建一个新对象temp;temp.constructor = Test;temp.(base reference) = Test.prototype; // 这一句先于代码体执行, 意味着构造函数里的this.xxx能访问原型对象的属性xxxbind: this = temp; // 将this绑定到temp对象// 开始执行函数代码var dummy = "have money";this.wish = dummy; // 为temp对象添加wish属性doSomeThing();....// 结束执行函数代码return temp;这个未必会符合内部的二进制实现, 但却能很好地解释了JavaScript的特性.

javascript 中不同类型以及不同环境下变量的内存都是何时释放

一.基本类型和引用类型的值javascript中的变量包含两种不同数据类型的：基本类型值和引用类型值。基本类型值指的是简单的数据段，而引用类型值指那些可能右多个值构成的对象。1.动态的属性定义基本类型值和引用类型值的方式是类似的：创建一个变量并为该变量赋值。但是，当这个值保存到变量中以后，对不同类型值可以执行的操作则大相径庭。对于引用类型的值，我们可以为其添加属性和方法，也可以改变和删除其属性和方法：var person = new Object();person.name = "Nicholas";alert(person.name);// “Nicholas”基本类型值不能动态添加：var name = "Nicholas";name.age = 27;alert(name.age);// undefined2.复制变量值复制变量值时两种类型也会有所不同。基本类型：重新在内存中开辟一段空间，赋值前后的两者相互独立引用类型：虽然也会重新开辟一段空间，但其接受到的值实际上是一个指针，而这个指针指向存储在堆中的一个对象。赋值操作结束后，两个变量实际上将引用同一个对象。3.传递参数javascript中所有函数的参数都是按值传递的。基本类型值的传递如同基本类型变量的复制一样，而引用类型的值的传递，则如同引用类型变量的复制一样。在向参数传递引用类型的值时，会把这个值在内存中的地址复制给一个局部变量，因此这个局部变量的变化会反映在函数的外部，情况下面例子：function addTen(num){num += 10;return num;}var count = 20;var result = addTen(count);alert(count);// 20，没有变化alert(result);// 30引用传递：function setName(obj){obj.name = "Nicholas";}var person = new Object();setName(person);alert(person.name);// "Nicholas"证明对象是按值传递的例子：function setName(obj){obj.name = "Nicholas";obj = new Object();obj.name = "Greg";}var person = new Object();setName(person);alert(person.name);// "Nicholas"4.检测类型在检测基本类型时typeof是非常得力的助手，但在检测引用类型的值时，这个操作符的用处不大。通常，我们并不是想知道某个值是对象，而是想知道它是什么类型的对象。为此，javascript提供了instanceof操作符，其语法如下：result = variable instanceof constructoralert(person instanceof Object);// 变量person是Object吗？alert(colors instanceof Array);// 变量colors是Array吗？alert(pattern instanceof RegExp);// 变量parrern是RegExp吗二.执行环境和作用域执行环境是javascript中最为重要的一个概念。执行环境定义了变量或函数有权访问的其他数据，决定了它们各自的行为。每个执行环境都有一个与之关联的变量对象，环境中定义的所有变量和函数都保存在这个对象中。每个函数都有自己的执行环境。当执行流进入一个函数时，函数的执行环境就会被推入一个环境栈中。而在函数执行之后，栈将其环境弹出，把控制权返回给之前的执行环境。Javascript中的执行流正式右这个方便的机制控制着。当代码在一个环境中执行时，会创建变量对象的一个作用域链。作用域链的用途是保证对执行环境有权访问的所有变量和函数的有序访问。作用域链的前端，始终都是当前执行的代码所在环境的变量对象。如果这个环境是函数，则将其活动对象作为变量对象。活动对象最开始只包含一个变量，即arguments对象。作用域链中的下一个变量对象来自包含（外部）环境，直至全局执行环境的变量对象1.延长作用域链虽然执行环境的类型总共只有两种——全局和局部（函数），但是可以延长作用域链。因为有些语句可以在作用域链的前端临时增加一个变量对象，该变量对象在执行代码后被移除：try-catch语句的catch快with语句2.没有块级作用域先看如下例子：if (true){var color = "blue";}alert(color);// "blue"for (var i = 0; i 《 10; ++i){doSomething(i);}alert(i); // 10使用var声明的变量会自动被添加到最接近的环境中。在函数内部，最接近的环境就是函数的局部环境；在with语句中，最接近的环境是函数环境。如果初始化变量时没有使用var声明，该变量会被添加到全局变量3.垃圾收集1.收集方式标记清除、引用清除2.性能问题（临界值）3.管理内存（不用的数据即使设置为null）四.总结javascript变量可以用来保存两种类型的值：基本类型值和引用类型值。基本类型的值源自以下5种基本类型数据：Undefined、Null、Boolean、Number和String。基本类型值和引用类型值具有以下特点：基本类型值在内存中占据固定大小的空间，因此被保存在栈内存中从一个变量向另一个变量复制基本类型的值，会创建这个值的一个副本引用类型的值是对象，保存在堆内存中包含引用类型值的变量实际上包含的并不是对象本身，而是一个指向该对象的指针从一个变量向另一个变量复制引用类型的值，赋值的其实是指针，因此两个变量最终都指向同一个对象确定一个值是哪种基本类型可以使用typeof操作符，而确定一个值是哪种引用类型可以使用instanceof操作符所有变量（包括基本类型和引用类型）都存在于一个执行环境（也称为作用域）当中，这个执行环境决定了变量的声明周期，以及哪一部分代码可以访问其中的变量。以下是关于执行环境的几点总结：执行环境有全局执行环境（也成为全局环境）和函数执行环境之分每次进入一个新执行环境，都会创建一个用于搜索变量和函数的作用域链函数的局部环境不仅有权访问函数作用域中的变量，而且有权访问其包含（父）环境，乃至全局环境全局环境只能访问在全景环境中定义的变量和函数，而不能直接访问局部环境中的任何数据变量的执行环境有助于确定应该合适释放环境javascript是一门具有自动垃圾收集机制的编程语言，开发人员不必关心内存分配和回收问题。可以对Javascript的垃圾收集例程作如下总结：离开作用域的值将被自动标记为可以回收，因此将在垃圾收集期间被删除“标记清除”是目前主流的垃圾收集算法，这种算法的思想是给当前不实用的值加上标记，然后再回收其内存另一种垃圾收集算法是“引用计数“，这种算法的思想是跟踪记录所有值被引用的次数。Javascript引擎不浅不再使用这种算法；但在IE中访问非原声JavaScript对象（如DOM对象）时，这种算法仍然可能导致问题当代码中存在循环引用现象时，“引用技术”算法就会导致问题解除变量的引用不仅有助于消除循环引用现象，而且对垃圾收集也有好处。为了确保有效地回收内存，应该及时接触不再使用的全局对象、全局对象属性以及循环引用变量的引用

js 堆内存和栈内存的区别，还有就是对象的值是保存在哪个内存的

栈内存运行效率比堆内存高，空间相对推内存来说较小，反之则是堆内存的特点。所以将构造简单的原始类型值放在栈内存中，将构造复杂的引用类型值放在堆中而不影响栈的效率。

js中String()、new String()探究

js中的基础类型有6种 5种基础类型：undefined null String Number Boolean 1中引用类型：Object

基础类型的string有如下定义方式：

这三种方式有什么区别吗？

str1、str2是普通的字符串，str3是个对象？什么原因呢？

用 typeof 验证一下

用 instanceof 验证一下

可以看出 str3 确确实实是个String对象了 再来看个有意思的事，如果给String加上自定义方法和属性呢？

虽然 str1、str2不是对象，但可以用String上的方法和属性 再看，如果直接给str1、str2定义方法和属性呢？

可以看出str1、str2是不能定义自己的方法和属性的，而str3可以 这就能看出 js 的神奇部分了，什么原理呢？

来看包装对象和原始资料类型

上面看到的str1、str2即为原始资料类型，str3为包装对象，通过typeof可以看出 但str1、str2不能自己定义属性和方法，却可以用String的属性和方法

总结一下 1、第一种和第二种方法定义出来的是原始资料类型，并储存于栈中,并向包装对象(new ..())借来方法和属性. 2、第三种是 包装对象，栈中储存堆指针，堆中储存内容。

关于堆、栈、指针的问题，咱们继续学习

JS中查询一个对象的构造函数使用什么属性

《scripttype="text/javascript"》functionfun(){alert("good");varage=1;this.name=’MrS.G’;this.method=fun2;}functionfun2(){alert("thisisthesecondmethodshow");}functionfun1(){varobj=newfun();alert(obj.name);obj.method();alert(obj.age);}window.onload=fun1;《/script》在fun1()方法中通过varobj=newfun()创建了一个对象。fun()是一个特殊的函数构造函数，它和普通的函数有什么区别和联系我将在下边谈论。注意到上边有两种形式定义变量。this.name和varage.其实通过this方式创建的变量叫做对象的成员变量，可以在外部通过对象引用。而varage是一个局部变量（如果放到外层，是一个全局变量）这个变量不能被对象在外部引用（如obj.age)否则是undefine，可以将它看成是一个对象的私有成员变量。接下来看看看构造函数的执行过程。首先执行varobj=newfun()这一步后，记录现场，然后跳到fun()的构造函数中，执行alert("good")跳出对话框。接下来就是创建成员变量了（如java中在堆中创建内存空间，创建栈）。好了fun()执行完了，回到fun1()，执行下去。注意一点，alert(obj.age)是undefine.我现在想知道哪些函数可以new()，哪些不可以new().《scripttype="text/javascript"》functionfun2(){alert("thisisthesecondmethodshow");}functionfun1(){varobj=newfun2();alert(obj);alert(’ifdisplaytherenoerrothroughthecall’);}window.onload=fun1;《/script》这里functionfun2()是一个函数，但是它是构造函数吗？你可以将它当做一个构造函数。这里会发现fun1()中的alert()可以正常执行。这里可以总结为任何函数都可以new,在js中函数就是对象。但是试想一下这里new有意义吗?fun2()中没有变量，或者都是var定义的变量，那么在外部引用不了。new它干嘛呢？，还不如让fun2()作为全局函数执行好了。这里可以回答本章的要探索的问题了：任何函数都是构造函数，如果通过new就可以得到一个对象。通过函数不同的上下文调用分下面几种：(1).当在一个函数调用之前有new关键字，则上下文为新建的对象；//任何函数可以new创建一个对象(2).当一个函数使用call或者apply调用时，给定的第一个参数即为上下文；//构造方法中可以写成员方法。然后通过对象来调用(3).否则，如果一个函数作为一个对象的属性(obj.func)或者obj)来调用时，它就把该对象作为上下文来运行；//上边newfun2()没意义，直接fun2()调用，这里在全局上下文运行(4)如果与上述几条都不符的话，则函数将在全局上下文中运行。

在java中=和==的区别

"="是赋值操作符，它的操作是把符号右边的变量或者常量或者对象的值赋值给符号右边的变量。"=="是算数运算符中的一个操作符，主要用在判断中，如if（a==b）{...}这条语句中，a==b语句的意思是先比较a和b的值是否相等（java中的相等不止是有值相等，还有对象的引用相等，这在比较两个值相等时需要注意和分清），然后返回比较的结果（只有两张，true和false）。