javascript有哪些实现？

JavaScript有很多实现，以下列举几个比较出名的实现：

企业官网是企业形象的一张重要名片。创新互联的成都官网定制服务，能够将成都网页设计与企业的实力&公信力、产品服务优势、文化价值观等有机结合，把握企业的独特之处，突出重点核心内容，并以恰如其分的设计风格，抓住目标用户的关注点和兴趣点，帮助企业塑造好第一印象，成都全网营销展现公司实力。成都官网定制，为你解决成都创新互联网营销解决方案。

Mozilla Firefox的Gecko排版引擎SpiderMonkey及Rhino实现了ECMA-262的第五版；

Google Chrome的V8排版引擎实现了ECMA-262的第五版；

Internet Explorer的Trident排版引擎实现了ECMA-262的第五版；

KHTML排版引擎，用在KDE Konqueror及苹果公司 Safari实现了ECMA-262的第三版。

什么是按需加载javascript实现

其实按需加载不是很难，你只需要2个东西就能办到

一个模块加载器

一些符合模块加载器语法的代码

首先实现一个模块加载器其实并不复杂，不到50行就能办到，但是如果你想要一个功能完善的，可配置，具有完善的生态和社区的模块加载器。在几年前是requirejs和seajs，现在是browserify和webpack。webpack和browserify在模块加载方面相比requirejs和seajs更高级的地方是在node环境下自动进行依赖分析。

让我们来实现个简单的兼容commonJS规范的模块加载器吧。

(function (global) {

var factoryMap = {};

var resMap = {};

var moduleMaps = {};

window.resMap = resMap;

// define函数定义

define = function (id, factory) {

factoryMap[id] = factory;

}

// require函数定义

require = function (id) {

var mod = moduleMaps[id] = {

exports: {}

}

var factory = factoryMap[id];

if (!factory) {

throw 'Cannot find module `' + id + '`';

}

var ret = factory.apply(mod, [require, mod.exports, mod]);

if (ret) {

mod.exports = ret;

}

return mod.exports;

}

})(this);

对于这样的模块加载器你就得这样来用。

// 模块1 依赖 模块二的内容

define('module1', function (require, exports, module) {

// console.log(1);

var module2 = require('module2');

var module3 = require('module3');

var module5 = require('module5');

var module6 = require('module6');

console.log('module1 -- module2', module2);

console.log('module1 -- module3', module3);

console.log('module1 -- module5', module5);

console.log('module1 -- module6', module6);

module.exports = {

moduleName: 'module1'

}

})

// 模块二 依赖 模块三的内容

define('module2', function (require, exports, module) {

var module6 = require('module6');

console.log('module2 -- module6', module6);

module.exports = {

moduleName: 'module2'

}

})

// 模块三

define('module3', function (require, exports, module) {

// console.log('3');

var module4 = require('module4');

var module5 = require('module5');

var module2 = require('module2');

console.log('module3 -- module5', module5);

console.log('module3 -- module2', module2);

console.log('module3 -- module4', module4);

module.exports = {

moduleName: 'module3'

}

})

define('module4', function (require, exports, module) {

var module6 = require('module6');

console.log('module4 -- module6', module6);

module.exports = {

moduleName: 'module4'

}

});

define('module5', function (require, exports, module) {

var module2 = require('module2');

var module6 = require('module6');

console.log('module5 -- module2', module2);

console.log('module5 -- module6', module6);

module.exports = {

moduleName: 'module5'

}

})

define('module6', function (require, exports, module) {

module.exports = {

moduleName: 'module6'

}

})

require('module1');

可以把所有代码放到浏览器里面实验一下。。。

JavaScript如何实现？

监听KeyDown事件，获取按下的KeyCode

反过来对应的KeyUp事件获取抬起的KeyCode

JavaScript如何实现两个功能？

div style="opacity:1"点我/div

script

document.onclick=function(e){

var div=document.querySelector("div");

div.style.opacity=((e||event).target==divdiv.style.opacity==0)?1:0;

}

/script

javascript实现

html

head

script

function change_src(){

var label = document.getElementsByTagName("label")[0];

var label_value = label.lastChild.nodeValue;

var img = document.getElementsByTagName("img")[0];

var img_src = label_value + ".jpg";

img.setAttribute( "src", img_src );

}

/script

/head

body onload="change_src()"

labelxue/label

img src="xue.jpg" /

/body

/html

上面代码可以实现，你自己研究一下~~

javascript实现继承有哪些方式

Javascript的继承在很多书里面细致的分了很多种类型和实现方式，大体上就是两种：对象冒充、原型方式。这两种方式各有优点和缺陷，这里我给你先列举出来，再从底层分析区别：

(一)对象冒充

function A(name){

this.name = name;

this.sayHello = function(){alert(this.name+” say Hello!”);};

}

function B(name,id){

this.temp = A;

this.temp(name); //相当于new A();

delete this.temp; //防止在以后通过temp引用覆盖超类A的属性和方法

this.id = id;

this.checkId = function(ID){alert(this.id==ID)};

}

当构造对象B的时候，调用temp相当于启动A的构造函数，注意这里的上下文环境中的this对象是B的实例，所以在执行A构造函数脚本时，所有A的变量 和方法都会赋值给this所指的对象，即B的实例，这样子就达到B继承了A的属性方法的目的。之后删除临时引用temp，是防止维护B中对A的类对象（注 意不是实例对象）的引用更改，因为更改temp会直接导致类A（注意不是类A的对象）结构的变化。

我们看到了，在Js版本更新的过程中，为了更方便的执行这种上下文this的切换以达到继承或者更加广义的目的，增加了call和apply函数。它们的 原理是一样的，只是参数不同的版本罢了(一个可变任意参数，一个必须传入数组作为参数集合)。这里就以call为例子，解释一下用call实现的对象冒充 继承。

function Rect(width, height){

this.width = width;

this.height = height;

this.area = function(){return this.width*this.height;};

}

function myRect(width, height, name){

Rect .call(this,width,height);

this.name = name;

this.show = function(){

alert(this.name+” with area:”+this.area());

}

}

关于Call方法，官方解释：调用一个对象的一个方法，以另一个对象替换当前对象。

call (thisOb,arg1, arg2…)

这也是一种对象冒充的继承，其实在call方法调用的时候发生的事情也是上下文环境变量this的替换，在myRect函数体中this肯定是指向类 myRect对象的实例了，然而用这个this作为上下文环境变量调用名字叫Rect方法，即类Rect的构造函数。于是此时调用Rect时候对this 的赋值属性和方法都实际上是对一个myRect的对象进行。所以说尽管call和apply并不是仅仅为了继承而新增的方法，但用它们可以模拟继承。

对象冒充继承就是这么一回事，它可以实现多重继承，只要重复做这一套赋值的流程就可以了。不过目前真正大规模使用得并不多，为什么呢？因为它有一个明显的 性能缺陷，这就要说道OO的概念了，我们说对象是成员+成员方法的集合，构造对象实例的时候，这些实例只需要拥有各自的成员变量就可以了，成员方法只是一 段对变量操作的可执行文本区域而已，这段区域不用为每个实例而复制一份，所有的实例都可以共享。现在回到Js利用对象冒充模拟的继承里，所有的成员方法都 是针对this而创建的，也就是所所有的实例都会拥有一份成员方法的副本，这是对内存资源的一种极度浪费。其它的缺陷比如说对象冒充无法继承 prototype域的变量和方法就不用提了，笔者认为前一个致命缺陷就已经足够。不过，我们还是需要理解它，特别是父类的属性和方法是如何继承下来的原 理，对于理解Js继承很重要。

(二)原型方式

第二种继承方式是原型方式，所谓原型方式的继承，是指利用了prototype或者说以某种方式覆盖了prototype，从而达到属性方法复制的目的。 其实现方式有很多中，可能不同框架多少会有一点区别，但是我们把握住原理，就不会有任何不理解的地方了。看一个例子（某一种实现）：

function Person(){

this.name = “Mike”;

this.sayGoodbye = function(){alert(“GoodBye!”);};

}

Person.prototype.sayHello = function(){alert(”Hello!”);};

function Student(){}

Student.prototype = new Person();

关键是对最后一句Student原型属性赋值为Person类构造的对象，这里笔者解释一下父类的属性和方法是如何copy到子类上的。Js对象在读取某 个对象属性的时候，总是先查看自身域的属性列表，如果有就返回否则去读取prototype域(每个对象共享构造对象的类的prototype域所有属性 和方法)，如果找到就返回，由于prototype可以指向别的对象，所以Js解释器会递归的去查找prototype域指向对象的prototype 域，直到prototype为本身，查找变成了一种循环，就停止，此时还没找到就成undefined了。

这样看来，最后一句发生的效果就是将父类所有属性和方法连接到子类的prototype域上，这样子类就继承了父类所有的属性和方法，包括name、 sayGoodbye和sayHello。这里与其把最后一句看成一种赋值，不如理解成一种指向关系更好一点。这种原型继承的缺陷也相当明显，就是继承时 父类的构造函数时不能带参数，因为对子类prototype域的修改是在声明子类对象之后才能进行，用子类构造函数的参数去初始化父类属性是无法实现的， 如下所示：

function Person(name){

this.name = name;

}

function Student(name,id){

this.id = id;

}

Student.prototype = new Person(this.name);

两种继承方式已经讲完了，如果我们理解了两种方式下子类如何把父类的属性和方法“抓取”下来，就可以自由组合各自的利弊，来实现真正合理的Js继承。下面是个人总结的一种综合方式：

function Person(name){

this.name = name;

}

Person.prototype.sayHello = function(){alert(this.name+“say Hello!”);};

function Student(name,id){

Person.call(this,name);

this.id = id;

}

Student.prototype = new Person();

Student.prototype.show = function(){

alert(“Name is:”+ this.name+” and Id is:”+this.id);

}

总结就是利用对象冒充机制的call方法把父类的属性给抓取下来，而成员方法尽量写进被所有对象实例共享的prototype域中，以防止方法副本重复创 建。然后子类继承父类prototype域来抓取下来所有的方法。如想彻底理清这些调用链的关系，推荐大家多关注Js中prototype的 constructor和对象的constructor属性，这里就不多说了。

文章题目：关于实现javascript的信息
本文来源：http://scyanting.com/article/dsgoioj.html