찾다
웹 프론트엔드JS 튜토리얼JavaScript 프로토타입 체인이란 무엇입니까?

이 글에서는 주로 자바스크립트의 프로토타입과 프로토타입 체인에 대한 자세한 설명을 소개합니다. 이 글에서는 프라이빗 변수와 함수, 정적 변수와 함수, 인스턴스 변수와 함수, 프로토타입과 프로토타입 체인의 기본 개념을 설명합니다. JavaScript의 각 객체에는 내장 속성 프로토타입이 있습니다. JavaScript에서 객체의 프로토타입 속성에 대한 설명은 객체 유형 프로토타입에 대한 참조입니다. 이것이 의미하는 바는 프로토타입 속성이 현재 객체의 상위 객체 역할을 하는 다른 JavaScript 객체에 대한 참조를 보유한다는 것입니다.

1. JavaScript 클래스 및 개체

JS에서 "클래스"를 정의하는 방법에 대해 많은 책에서 설명합니다. 일반적으로 다음 코드를 사용합니다.

1 function foo () {2     this.x = 1;3     this.y = 2;4 }5 var obj = new foo();  //{x:1, y:2}
사실 이 코드는 매우 나쁩니다. 언어 메커니즘의 경우 먼저 JS에는 "클래스"라는 것이 없다는 점을 분명히 해야 합니다. 이를 이해하기 전에 먼저 JS의 개발 역사를 이해해야 합니다.

JavaScript는 인터넷과 브라우저와 함께 탄생했습니다. 초기에는 인터넷이 상대적으로 열악했고, 인터넷 접속 비용도 상대적으로 높았으며, 인터넷 속도도 보통 전송하는 데 오랜 시간이 걸렸습니다. 일반 텍스트. 그래서 당시 넷스케이프는 서버를 통하지 않고 클라이언트에서 일부 작업을 수행할 수 있는 솔루션이 필요하다고 제안했습니다. 예를 들어 사용자가 이메일 주소를 입력할 때 "@"을 놓친 경우 이를 서버에서 분석하지 않고도 오류 및 프롬프트를 사용자에게 확인할 수 있어 통신 작업으로 인한 지연 및 대역폭 소모를 크게 줄일 수 있습니다. 그 당시 우연히 JAVA가 나왔고 그것이 매우 인기가 있었기 때문에 Netscape는 SUN과 협력하여 JAVA 애플릿(이후 Java 애플릿이라고 함)을 브라우저에 내장하기로 결정했습니다. 그러나 나중에 이 솔루션에 대해 논쟁이 일어났습니다. 브라우저는 원래 작은 작업만 필요했고 JAVA 언어 자체는 너무 "무거웠으며" 양식 유효성 검사 문제를 처리하기에는 너무 과했기 때문에 우리는 새로운 솔루션을 개발하기로 결정했습니다. . 클라이언트 측에서 경량 작업을 지원하고 JAVA 구문을 학습하는 언어입니다. 그래서 넷스케이프는 구문 측면에서는 C와 JAVA, 데이터 구조 측면에서는 JAVA에 편향된 새로운 경량 언어를 개발했습니다. 이 언어는 원래 Mocha라고 불렸으며 수년 간의 발전을 거쳐 오늘날의 JavaScript가 되었습니다.

이야기는 여기서 마치고, 이 글과는 아무 관계도 없는 것 같네요... 걱정하지 마세요. 곧 본론으로 들어가겠습니다. 사실 이 언어의 이름이 JavaScript인 이유는 JAVA와는 아무런 관련이 없습니다. 단지 그 당시에는 객체지향 방법이 막 나왔기 때문에 모든 프로그래머가 객체지향 방법을 배우는 것을 존경했기 때문입니다. JAVA 갑작스런 등장과 활발한 홍보로 인해 JAVA와 관련된 모든 것은 얼굴에 금을 입히고 그 자체의 후광을 가져오는 것과 같습니다. 그래서 JAVA의 명성을 살려 홍보했지만, 객체지향 방법에 대한 동경으로 인해 다들 객체지향 구문, 즉

new Class()를 사용하여 코드를 작성하는 데 익숙합니다. 방법. 그러나 JavaScript 언어 자체에는 클래스라는 개념이 없습니다. 객체 지향 구문에 익숙한 프로그래머에게 더 적합하기 위해 new 연산자가 탄생했습니다.

그렇습니다. 많은 이야기를 한 후, 학생들에게

new 연산자 자체가 JavaScript에서 모호함으로 가득 찬 것이라는 점을 알려주고 싶습니다. 클래스라는 개념이 없으며 프로그래머에게 적합합니다. .. 그냥 습관이에요. 그렇다면 new 연산자와 JavaScript의 객체 사이에는 어떤 관계가 있을까요? 다음 코드를 고려해보세요:

1 function foo () {2     this.x = 1;3     this.y = 2;4     return {5         z:36     }7 }8 var obj = new foo();  //{z:3}

  咦?发生了什么奇怪的事情,x 和 y 哪里去了?实际上 new 操作符并不是传统面向对象语言那样,创建一个类的实例,new 操作符实际上只是在引擎内部帮我们在函数的开始创建好了一个对象,然后将函数的上下文绑定到这个对象上面,并在函数的末尾返回这个对象。这里需要注意的问题是,如果我们手动的返回了一个对象,那么按照函数执行机制,一旦返回了一个值,那么该函数也就执行结束,后面的代码将不会执行,所以说在刚才的例子中我们得到的对象只是我们手动定义的对象,并不是引擎帮我们创建的对象。 new 操作符实际上类似于以下操作:

1 function foo () {2     //新创建一个对象,将 this 绑定到该对象上3     4     //在这里编写我们想要的代码5 6     //return this;7 }

  不过需要注意的是,new 操作符只接受 Object 类型的值,如果我们手动返回的是基本类型,则还是会返回 this :

1 function foo () {2     this.x = 1;3     this.y = 2;4     return 0;5 }6 var obj = new foo();  //{x:1, y:2}

  现在我们现在可以将 new 操作符定义成以下方法:

 1 function newOpertor (cls, ...args) { 2     var obj = {}; 3     cls.apply(obj, args); 4     return obj; 5 } 6  7 function foo (x, y) { 8     this.x = x; 9     this.y = y;10 }11 12 var obj = newOpertor(foo, 1, 2);  //{x:1, y:2}

 二、对象的原型

   JavaScript 中存在类似继承的机制,但是又不是标准面向对象的继承,在 JS 中使用的是原型的机制。要记住,在 JS 中只有对象,没有类,对象的继承是由原型来实现,笼统的来说可以这样理解,一个对象是另一个对象的原型,那么便可以把它比作父类,子类既然也就继承了父类的属性和方法。

1 function foo () {2     this.x = 1;3     this.y = 2;4 }5 6 foo.prototype.z = 37 8 var obj = new foo();9 console.log(obj.z);  //3

  [[prototype]] 是函数的一个属性,这个属性的值是一个对象,该对象是所有以该函数为构造器创造的对象的原型。可以把它近似的理解为父类对象,那么相应的,子类自然会继承父类的属性和方法。不过为什么要区分原型继承和类继承的概念呢?标准的面向对象方法,类是不具有实际内存空间,只是一个事物的抽象,对象才是事物的实体,而通过继承得到的属性和方法,同属于该对象,不同的对象各自都拥有独立的继承而来的属性。不过在 JavaScript 当中,由于没有类的概念,一直都是对象,所以我们“继承”的,是一个具有实际内存空间的对象,也是实体,也就是说,所有新创建的子对象,他们共享一个父对象(后面我统称为原型),不会拥有独立的属性:

 1 function foo () { 2     this.x = 1; 3     this.y = 2; 4 } 5  6 foo.prototype.z = 3 7  8 var obj1 = new foo(); 9 10 console.log(obj1.z);  //311 12 foo.prototype.z = 213 14 console.log(obj1.z);  //2

  还记得我们之前所说的 new 操作符的原理吗?new 操作符的本质不是实例化一个类,而是引擎贴合习惯了面向对象编程方法的程序员,所以说 [[prototype]] 属性本质上也是 new 操作符的一个副产物。这个属性只在函数上面有意义,该属性定义了 new 操作符产生的对象的原型。除了 [[prototype]] 可以访问到对象原型以外,还有一个非标准的方法,在每一个对象中都有一个 __proto__ 属性,这个属性直接关联到了该对象的原型。这种方法没有写入 W3C 的标准规范,但是却得到了浏览器的广泛支持,许多浏览器都提供了该方法以供访问对象的原型。(个人觉得 __proto__ 比 [[prototype]] 更能体现原型链的本质)

 1 function foo () { 2     this.x = 1; 3     this.y = 2; 4 } 5  6 foo.prototype.z = 3 7  8 var obj1 = new foo(); 9 10 console.log(obj1.__proto__);  //{z:3}

  除了使用 new 操作符和函数的 [[prototype]] 属性定义对象的原型之外,我们还可以直接在对象上显示的通过 __proto_ 来定义,这种定义对象原型的方式更能够体现出 JavaScript 语言的本质,更能够使初学者理解原型链继承的机制。

1 var father = {x:1};2 3 var child = {4     y:2,5     __proto__:father6 };7 8 console.log(child.x);  //1

  现在我们来完成之前那个自定义 new 操作(如果你还不能理解这个函数,没有关系,跳过它,这并不影响你接下来的学习):

 1 function newOpertor (cls, ...args) { 2     var obj = Object.create(cls.prototype); 3     cls.apply(obj, args); 4     return obj; 5 } 6  7 function foo (x, y) { 8     this.x = x; 9     this.y = y;10 }11 12 foo.prototype.z = 313 14 var obj1 = newOpertor(foo, 1, 2)15 16 console.log(obj1.z);  //3

 三、原型链

  介绍完原型之后,同学们需要明确以下几个概念:

  •   JavaScript 采用原型的机制实现继承;

  •   原型是一个具有实际空间的对象,所有关联的子对象共享一个原型;

  那么 JavaScript 当中的原型是如何实现相互关联的呢?JS 引擎又是如何查找这些关联的属性呢?如何实现多个对象的关联形成一条原型链呢?

 1 var obj1 = { 2     x:1 3 } 4  5 var obj2 = { 6     y:2, 7     __proto__:obj1 8 } 9 10 var obj3 = {11     z:3,12     __proto__:obj213 }14 15 console.log(obj3.y);  //216 console.log(obj3.x);  //1

  在上面这段代码,我们可以看出,对象的原型可以实现多层级的关联的操作,obj1 是 obj2 的原型, obj2 同时又是 obj3 的原型,这种多层级的原型关联,就是我们常说的原型链。在访问一个处于原型链当中的对象的属性,会沿着原型链对象一直向上查找,我们可以把这种原型遍历操作看成是一个单向的链表,每一个处于原型链的对象都是链表当中的一个节点,JS 引擎会沿着这条链表一层一层的向下查找属性,如果找到了一个与之匹配的属性名,则返回该属性的值,如果在原型链的末端(也就是 Object.prototype)都没有找到与之匹配的属性,则返回 undefined。要注意这种查找方式只会返回第一个与之匹配的属性,所以会发生属性屏蔽:

 1 var obj1 = { 2     x:1 3 } 4  5 var obj2 = { 6     x:2, 7     __proto__:obj1 8 } 9 10 var obj3 = {11     x:3,12     __proto__:obj213 }14 15 console.log(obj3.x);  //3

  若要访问原型的属性,则需要一层的一层的先向上访问原型对象:

1 console.log(obj3.__proto__.x);  //22 console.log(obj3.__proto__.__proto__.x);  //1

  要注意的一点是,原型链的遍历只会发生在 [[getter]] 操作上,也就是取值操作,也可以称之右查找(RHS)。相反,若是进行 [[setter]] 操作,也就是赋值操作,也可以称作左查找(LHS),则不会遍历原型链,这条原则保证了我们在对对象进行操作的时候不会影响到原型链:

 1 var obj1 = { 2     x:1 3 } 4  5 var obj2 = { 6     __proto__:obj1 7 } 8  9 console.log(obj2.x);  //110 11 obj2.x = 2;12 13 console.log(obj2.x);  //214 console.log(obj1.x);  //1(并没有发生变化)

   在遍历原型链中,如果访问带有 this 引用的方法,可能会发生令你意想不到的结果:

 1 var obj1 = { 2     x:1, 3     foo: function  () { 4         console.log(this.x); 5     } 6 } 7  8 var obj2 = { 9     x:2,10     __proto__:obj111 }12 13 obj2.foo();  //2

  在上面的内容中,我们讨论过,对象的原型相当于父类,我们可以继承它所拥有的属性和方法,所以在我们访问 foo() 函数的时候时候,实际上调用该方法的对象是 obj2 而不是 obj1。关于更详细的内容,需要了解 this 和上下文绑定,这不在本篇文章的讨论范围之内。

  关于原型链的问题,大家需要理解的一点是,任何对象的原型链终点,都是 Object.prototype,可以把 Object 理解为所有对象的父类,类似于 JAVA 一样,所以说所有对象都可以调用一些 Object.prototype 上面的方法,比如 Object.prototype.valueOf() 以及 Object.prototype.toString() 等等。所有的 string 类型,其原型为 String.prototype ,String.prototype 是一个对象,所以其原型也就是 Object.prototype。这就是我们为什么能够在一个 string 类型的值上调用一些方法,比如 String.prototype.concat() 等等。同理所有数组类型的值其原型是 Array.prototype,数字类型的值其原型是 Number.prototype:

1 console.log({}.__proto__ === Object.prototype);  //true2 3 console.log("hello".__proto__ === String.prototype);  //true4 5 console.log(1..__proto__ === Number.prototype);  //true6 //注意用字面量访问数字类型方法时,第一个点默认是小数标志7 8 console.log([].__proto__ === Array.prototype);  //true

   理解了原型链的遍历操作,我们现在就可以学习如何添加属于自己的方法。我们现在知道了所有字符串的原型都是 String.prototype ,那么我们可以对其进行修改来设置我们自己的内置方法:

1 String.prototype.foo = function () {2     return this + " foo";3 }4 5 console.log("bar".foo());  //bar foo

  所以说,在处理一些浏览器兼容性问题的时候,我们可以直接修改内置对象来兼容一些旧浏览器不支持的方法,比如 String.prototype.trim() :

1 if (!String.prototype.trim) {2     String.prototype.trim = function() {3         return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');4     };5 }

  不过需要注意,切忌随意修改内置对象的原型方法,一是因为这会带来额外的内存消耗,二是这可能会在系统中造成一些隐患,一般只是用来做浏览器兼容的 polyfill 。

四、 有关原型的方法

   for ... in 语句会遍历原型链上所有可枚举的属性(关于属性的可枚举性质,可以参考 《JavaScript 常量定义》),有时我们在操作的时候需要忽略掉原型链上的属性,只访问该对象上的属性,这时候我们可以使用 Object.prototype.hasOwnProperty() 方法来判断属性是否属于原型属性:

 1 var obj1 = { 2     x:1, 3 } 4  5 var obj2 = { 6     y:2, 7     __proto__:obj1 8 } 9 10 for(var key in obj2){11     console.log(obj2[key]);  //2, 112 }13 14 for(var key in obj2){15     if(obj2.hasOwnProperty(key)){16         console.log(obj2[key]);  //217     }18 }

  我们知道通过 new 操作符创建的对象可以通过 instanceof 关键字来查看对象的“类”:

1 function foo () {}2 3 var obj = new foo();4 5 console.log(obj instanceof foo);  //true

  实际上这个操作也是不严谨的,我们现在已经知道了 new 操作符在 JavaScript 当中本是一个具有歧义设计,instanceof 操作符本身也是一个会让人误解的操作符,它并没有实例这种说法,实际上这个操作符只是判断了对象与函数原型的关联性,也就是说其返回的是表达式 object.__proto__ === function.prototype 的值。

 1 function foo () {} 2  3 var bar = { 4     x:1 5 } 6  7 foo.prototype = bar 8  9 var obj = {10     __proto__: bar11 }12 13 console.log(obj instanceof foo);  //true

  在这一段代码中,我们可以看出 obj 和 foo 并没有任何关系,只是 obj 的原型和 foo.prototype 关联到了同一个对象上面,所以其结果会返回 true。  

  不过对基本类型类型使用 instanceof 方法的话,可能会产生意外的结果:

1 console.log("1" instanceof String);  //false2 3 console.log(1 instanceof Number);  //false4 5 console.log(true instanceof Boolean);  //false

  但是我们同样可以使用使用字面量调用原型的方法,这可能会让人感到困惑,不过我们不用担心它,并不是原型链出现什么毛病,而是在对基本类型进行字面量操作的时候,会涉及到隐式转换的问题。JS 引擎会先将字面量转换成内置对象,然后在调用上面的方法,隐式转换问题不在本文的讨论范围之类,大家可以参考 Kyle Simpson — 《你不知道的 JavaScript (中卷)》。

  实际对象的 Object.prototype.isPrototypeOf() 方法更能体现出对象原型链的关系,此方法判断一个对象是否是另一个对象的原型,不同于 instanceof 的是,此方法会遍历原型链上所有的节点,若有匹配项则返回 true:

 1 var obj1 = { 2 } 3  4 var obj2 = { 5     __proto__:obj1 6 } 7  8 var obj3 = { 9     __proto__:obj210 }11 12 console.log(obj2.isPrototypeOf(obj3));  //true13 console.log(obj1.isPrototypeOf(obj3));  //true14 console.log(Object.prototype.isPrototypeOf(obj3));  //true

  在 ES5 当中拥有标准方法 Object.getPrototypeOf() 可以供我们获得一个对象的原型,在ES6 当中拥有新的方法 Object.setPrototypeOf() 可以设置一个对象的原型,不过在使用之前请先查看浏览器兼容性。

 1 var obj1 = { 2     x:1 3 } 4  5 var obj2 = { 6     y:2 7 } 8  9 Object.setPrototypeOf(obj2, obj1);10 11 console.log(Object.getPrototypeOf(obj2) === obj1);  //true

  我们现在知道,通过 new 操作符创建的对象,其原型会关联到函数的 [[prototype]] 上面,实际上这是一个很糟糕的写法,一味的贴合面向对象风格的编程模式,使得很多人无法领域 JavaScript 当中的精髓。许多书籍都会写到 JavaScript 中有许多奇怪的地方,然后教你如何避开这些地雷,实际上这不是一个好的做法,并不是因为 JavaScript 是一门稀奇古怪的语言,而是我们不愿意去面对它的特性,正确的理解这些特性,才能让我们写出更加高效的程序。Object.create() 方法对于对象之间的关联和原型链的机制更加清晰,比 new 操作符更加能够理解 JavaScript 的继承机制。该方法创建一个新对象,并使新对象的原型关联到参数对象当中:

1 var obj1 = {2     x:13 }4 5 var obj2 = Object.create(obj1);6 7 console.log(obj1.isPrototypeOf(obj2));  //true

  不过使用的时候还需要注意浏览器的兼容性,下面给出 MDN 上面的 polyfill:

 1 (function() { 2     if (typeof Object.create != 'function') { 3         Object.create = (function() { 4             function Temp() {} 5             var hasOwn = Object.prototype.hasOwnProperty; 6             return function(O) { 7                 if (typeof O != 'object') { 8                     throw TypeError('Object prototype may only be an Object or null'); 9                 }10                 Temp.prototype = O;11                 var obj = new Temp();12                 Temp.prototype = null;13                 if (arguments.length > 1) {14                     var Properties = Object(arguments[1]);15                     for (var prop in Properties) {16                         if (hasOwn.call(Properties, prop)) {17                             obj[prop] = Properties[prop];18                         }19                     }20                 }21                 return obj;22             };23         })();24     }25 })();

  关于 Object.create() 方法要注意的一点是,如果参数为 null 那么会创建一个空链接的对象,由于这个对象没有任何原型链,所以说它不具有任何原生的方法,也无法进行原型的判断操作,这种特殊的对象常被称作“字典”,它完全不会受原型链的干扰,所以说适合用来存储数据:

 1 var obj = Object.create(null); 2 obj.x = 1 3  4 var bar = Object.create(obj); 5 bar.y = 2; 6  7 console.log(Object.getPrototypeOf(obj));  //null 8  9 console.log(Object.prototype.isPrototypeOf(obj));  //false10 11 console.log(obj instanceof Object);  //false12 13 console.log(bar.x);  //114 15 obj.isPrototypeOf(bar);  //TypeError: obj.isPrototypeOf is not a function16 17 /**18  * 注意由于对象没有关联到 Object.prototype 上面,所以无法调用原生方法,但这并不影响此对象的关联操作。19  */

 总结

  原型链是 JavaScript 当中非常重要的一点,同时也是比较难理解的一点,因为其与传统的面向对象语言有着非常大的区别,但这是正是 JavaScript 这门语言的精髓所在,关于原型与原型链,我们需要知道以下这几点:

  •   JavaScript 通过原型来实现继承操作;

  •   几乎所有对象都有原型链,其末端是 Object.prototype;

  •   原型链上的 [[getter]] 操作会遍历整条原型链,[[setter]] 操作只会针对于当前对象;

  •   我们可以通过修改原型链上的方法来添加我们想要的操作(最好不要这样做);

  关于 JavaScript 原型链,在一开始人们都称为“继承”,其实这是一种不严谨的说法,因为这不是标准的面向对象方法,不过初期人人常常这么理解。现在我往往称之为关联委托,关联指的是一个对象关联到另一个对象上,而委托则指的是一个对象可以调用另一个对象的方法。

위 내용은 JavaScript 프로토타입 체인이란 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
JavaScript, C 및 브라우저의 관계JavaScript, C 및 브라우저의 관계May 01, 2025 am 12:06 AM

서론 나는 당신이 이상하다는 것을 알고 있습니다. JavaScript, C 및 Browser는 정확히 무엇을해야합니까? 그들은 관련이없는 것처럼 보이지만 실제로는 현대 웹 개발에서 매우 중요한 역할을합니다. 오늘 우리는이 세 가지 사이의 밀접한 관계에 대해 논의 할 것입니다. 이 기사를 통해 브라우저에서 JavaScript가 어떻게 실행되는지, 브라우저 엔진의 C 역할 및 웹 페이지의 렌더링 및 상호 작용을 유도하기 위해 함께 작동하는 방법을 알게됩니다. 우리는 모두 JavaScript와 브라우저의 관계를 알고 있습니다. JavaScript는 프론트 엔드 개발의 핵심 언어입니다. 브라우저에서 직접 실행되므로 웹 페이지를 생생하고 흥미롭게 만듭니다. 왜 Javascr

Node.js는 TypeScript가있는 스트림입니다Node.js는 TypeScript가있는 스트림입니다Apr 30, 2025 am 08:22 AM

Node.js는 크림 덕분에 효율적인 I/O에서 탁월합니다. 스트림은 메모리 오버로드를 피하고 큰 파일, 네트워크 작업 및 실시간 애플리케이션을위한 메모리 과부하를 피하기 위해 데이터를 점차적으로 처리합니다. 스트림을 TypeScript의 유형 안전과 결합하면 Powe가 생성됩니다

Python vs. JavaScript : 성능 및 효율성 고려 사항Python vs. JavaScript : 성능 및 효율성 고려 사항Apr 30, 2025 am 12:08 AM

파이썬과 자바 스크립트 간의 성능과 효율성의 차이는 주로 다음과 같이 반영됩니다. 1) 해석 된 언어로서, 파이썬은 느리게 실행되지만 개발 효율이 높고 빠른 프로토 타입 개발에 적합합니다. 2) JavaScript는 브라우저의 단일 스레드로 제한되지만 멀티 스레딩 및 비동기 I/O는 Node.js의 성능을 향상시키는 데 사용될 수 있으며 실제 프로젝트에서는 이점이 있습니다.

JavaScript의 기원 : 구현 언어 탐색JavaScript의 기원 : 구현 언어 탐색Apr 29, 2025 am 12:51 AM

JavaScript는 1995 년에 시작하여 Brandon Ike에 의해 만들어졌으며 언어를 C로 실현했습니다. 1.C Language는 JavaScript의 고성능 및 시스템 수준 프로그래밍 기능을 제공합니다. 2. JavaScript의 메모리 관리 및 성능 최적화는 C 언어에 의존합니다. 3. C 언어의 크로스 플랫폼 기능은 자바 스크립트가 다른 운영 체제에서 효율적으로 실행하는 데 도움이됩니다.

무대 뒤에서 : 어떤 언어의 힘이 자바 스크립트입니까?무대 뒤에서 : 어떤 언어의 힘이 자바 스크립트입니까?Apr 28, 2025 am 12:01 AM

JavaScript는 브라우저 및 Node.js 환경에서 실행되며 JavaScript 엔진을 사용하여 코드를 구문 분석하고 실행합니다. 1) 구문 분석 단계에서 초록 구문 트리 (AST)를 생성합니다. 2) 컴파일 단계에서 AST를 바이트 코드 또는 기계 코드로 변환합니다. 3) 실행 단계에서 컴파일 된 코드를 실행하십시오.

파이썬과 자바 스크립트의 미래 : 트렌드와 예측파이썬과 자바 스크립트의 미래 : 트렌드와 예측Apr 27, 2025 am 12:21 AM

Python 및 JavaScript의 미래 추세에는 다음이 포함됩니다. 1. Python은 과학 컴퓨팅 분야에서의 위치를 ​​통합하고 AI, 2. JavaScript는 웹 기술의 개발을 촉진하고, 3. 교차 플랫폼 개발이 핫한 주제가되고 4. 성능 최적화가 중점을 둘 것입니다. 둘 다 해당 분야에서 응용 프로그램 시나리오를 계속 확장하고 성능이 더 많은 혁신을 일으킬 것입니다.

Python vs. JavaScript : 개발 환경 및 도구Python vs. JavaScript : 개발 환경 및 도구Apr 26, 2025 am 12:09 AM

개발 환경에서 Python과 JavaScript의 선택이 모두 중요합니다. 1) Python의 개발 환경에는 Pycharm, Jupyternotebook 및 Anaconda가 포함되어 있으며 데이터 과학 및 빠른 프로토 타이핑에 적합합니다. 2) JavaScript의 개발 환경에는 Node.js, VScode 및 Webpack이 포함되어 있으며 프론트 엔드 및 백엔드 개발에 적합합니다. 프로젝트 요구에 따라 올바른 도구를 선택하면 개발 효율성과 프로젝트 성공률이 향상 될 수 있습니다.

JavaScript가 C로 작성 되었습니까? 증거를 검토합니다JavaScript가 C로 작성 되었습니까? 증거를 검토합니다Apr 25, 2025 am 12:15 AM

예, JavaScript의 엔진 코어는 C로 작성되었습니다. 1) C 언어는 효율적인 성능과 기본 제어를 제공하며, 이는 JavaScript 엔진 개발에 적합합니다. 2) V8 엔진을 예를 들어, 핵심은 C로 작성되며 C의 효율성 및 객체 지향적 특성을 결합하여 C로 작성됩니다.

See all articles

핫 AI 도구

Undresser.AI Undress

Undresser.AI Undress

사실적인 누드 사진을 만들기 위한 AI 기반 앱

AI Clothes Remover

AI Clothes Remover

사진에서 옷을 제거하는 온라인 AI 도구입니다.

Undress AI Tool

Undress AI Tool

무료로 이미지를 벗다

Clothoff.io

Clothoff.io

AI 옷 제거제

Video Face Swap

Video Face Swap

완전히 무료인 AI 얼굴 교환 도구를 사용하여 모든 비디오의 얼굴을 쉽게 바꾸세요!

뜨거운 도구

에디트플러스 중국어 크랙 버전

에디트플러스 중국어 크랙 버전

작은 크기, 구문 강조, 코드 프롬프트 기능을 지원하지 않음

PhpStorm 맥 버전

PhpStorm 맥 버전

최신(2018.2.1) 전문 PHP 통합 개발 도구

SecList

SecList

SecLists는 최고의 보안 테스터의 동반자입니다. 보안 평가 시 자주 사용되는 다양한 유형의 목록을 한 곳에 모아 놓은 것입니다. SecLists는 보안 테스터에게 필요할 수 있는 모든 목록을 편리하게 제공하여 보안 테스트를 더욱 효율적이고 생산적으로 만드는 데 도움이 됩니다. 목록 유형에는 사용자 이름, 비밀번호, URL, 퍼징 페이로드, 민감한 데이터 패턴, 웹 셸 등이 포함됩니다. 테스터는 이 저장소를 새로운 테스트 시스템으로 간단히 가져올 수 있으며 필요한 모든 유형의 목록에 액세스할 수 있습니다.

안전한 시험 브라우저

안전한 시험 브라우저

안전한 시험 브라우저는 온라인 시험을 안전하게 치르기 위한 보안 브라우저 환경입니다. 이 소프트웨어는 모든 컴퓨터를 안전한 워크스테이션으로 바꿔줍니다. 이는 모든 유틸리티에 대한 액세스를 제어하고 학생들이 승인되지 않은 리소스를 사용하는 것을 방지합니다.

스튜디오 13.0.1 보내기

스튜디오 13.0.1 보내기

강력한 PHP 통합 개발 환경