JavaScript的二十年：从脚本语言到全球标准

javascript

需积分: 0 141 浏览量更新于2024-06-30 收藏 2.93MB PDF 举报

身份认证购VIP最低享 7 折!

30元优惠券

"JavaScript 20年1" 这篇文章探讨了JavaScript这门编程语言从1995年到2015年间的设计、发展、进化和标准化的过程。JavaScript最初是由Netscape公司在一个十天的快速开发项目中创造出来，作为Java的辅助脚本语言，但很快它就成为了一个事实上的Web标准，并最终成为了全球最广泛使用的编程语言。在技术细节方面，JavaScript的设计受到了当时技术环境的影响，如Web浏览器的需求和Java语言的流行。JavaScript引入了动态类型、原型继承和函数作为一等公民的概念，这些特性使其在网页交互和动态内容生成中表现出色。ECMAScript（ECMA-262）是JavaScript的标准化规范，它的每一次更新（例如ES5、ES6/2015、ES7/2016等）都带来了新的语言特性和改进，推动了JavaScript的演进。在历史背景中，JavaScript的发展故事也是一部关于竞争与合作的历史。Netscape与Microsoft的浏览器大战期间，JavaScript（在微软称为JScript）成为两家公司争夺Web市场的关键工具。而随着开源社区的崛起，JavaScript的生态系统得到了极大的扩展，Node.js的出现让JavaScript在服务器端也得到了广泛应用。此外，标准的制定过程也是一个关键点。ECMAScript标准的制定由欧洲计算机制造商协会(ECMA)领导，旨在确保JavaScript的跨平台兼容性。这个过程中，来自不同组织和公司的专家们进行了深入讨论和合作，以推动语言的统一和进步。JavaScript的标准版本包括ECMAScript 3、5、6、7等，每个版本都对语言做了重要的更新和完善。在社会和专业话题方面，JavaScript的普及改变了互联网的面貌，催生了大量的框架、库和工具，如React、Angular、Vue等，它们构建了现代Web应用的基础。同时，JavaScript也促进了前端开发工程师的职业发展，成为许多开发者入门编程的首选语言。 JavaScript的20年历程是一个技术、市场和社区力量相互作用的典型案例，展示了编程语言如何适应快速变化的技术环境，以及如何通过持续创新和标准化来满足不断增长的需求。JavaScript的影响力远远超出了Web浏览器的范畴，现在它已经深入到移动应用、物联网设备和云计算等多个领域，继续塑造着我们的数字化世界。

资源详情

资源推荐

16 Allen Wirfs-Brock and Brendan Eich

// de f i ne funct i ons to be used as meth o d s

func t ion ptSum ( pt2 ) { return new Point ( this . x + pt2 .x , thi s .y + pt2 . y ) }

func t ion ptD i sta n ce ( pt2 ) {

return Math . sqrt ( Ma t h . pow ( pt2 .x - this . x , 2) + Math . pow ( pt2 . y - this .y ,2) ) ;

}

// de f i ne Po i n t c o nst r uct or

func t ion Point (x , y) {

// cr e a te / init i ali ze a new object 's data p rop e rti e s

this . x = x;

this . y = y;

}

// add me t hods to s hared prot o typ e obj e c t

Point . prot o typ e . sum = pt S u m ;

Point . prot o typ e . d i stan c e = ptD i sta nce ;

var origin = new Point (0 ,0) ; // create a Point object

Fig. 7. Defining a Point abstraction using JavaScript 1.1. Instance objects inherit method properties from the

Point.prototype object rather than defining method properties on each instance.

Figure 7 shows the JavaScript 1.1 the denition of the simple Point abstraction from Figure 6. It

diers in that the methods are installed only once on the prototype object rather than repeatedly

during construction of each instance object. A property provided to an object by a prototype

property is called an inherited property

. A property dened directly on an object is called an own

property

. An own property shadows an identically-named–own property.

The properties of a prototype object are usually methods. In that case, the prototype provided by

a constructor is serving the same role as a C++ vtable or Smalltalk MethodDictionary—it associates

common behaviors with a set of objects. The constructor is essentially serving the role of a class

object and its prototype is the container of the methods which are shared by instances of the class.

This is a reasonable interpretation of JavaScript 1.1’s object model but not the only one.

The naming of the constructor

prototype

property is a clear hint that Brendan Eich had another

object model in mind. That model was inspired by the Self programming language [Ungar and

Smith 1987]. In Self, a new object is created by partially cloning the prototypical object of some

category of objects. Each clone has a parent link back to the prototype so that the prototype can

provide the features intended to be common to all of its clones. The JavaScript 1.1 object model

can be viewed as a variant of the Self model where the prototype objects are accessed indirectly

via constructor functions and the

new

operator clones new instances from the prototype. The

cloned instances inherit

the properties of the prototype objects as common shared features. Some

JavaScript programmers call this mechanism “prototypal inheritance

.” It is a form of delegation.

Some JavaScript programmers also use the double entendre “classical inheritance

” to refer to the

style of inheritance used in Java and many other object-oriented languages.

The JavaScript 1.1 documentation [Netscape 1996e] does not fully describe either of these object

models. It maintained a marketing story consistent with the December 1995 Netscape/Sun press

release. JavaScript was positioned as a language for scripting object interactions while the actual

denition of object abstractions (class denitions) were to be written in Java. Native JavaScript

object abstraction capabilities were limited to secondary features that drew minimal attention and

were largely undocumented.

Authors’ Preprint 2020-03-13, HOPL-4, Publication date: June 2020.

JavaScript: The First 20 Years 17

3.4 Function Objects

In JavaScript 1.0/1.1, a function denition creates and names a callable function. JavaScript functions

are rst-class object values. The name provided in a

function

declaration denes a global variable,

similar to a

var

declaration in top-level code. Its value is the function object and may be assigned to

variables, set as property values, passed as arguments in function calls, and returned as values from

functions. Because functions are objects they may have properties dened on them. The following

examples shows how a property can be added to a function object:

func t ion co u nte dHe l lo () {

alert ( " Hello , World ! ") ;

cou n te d Hel lo . ca l lCou n t ++; // in c rem e nt th i s fun c tion 's ca l lCo u nt prop e rty

}

cou n te d Hel lo . ca l lCou n t = 0; // a sso c iat e cou n ter wi t h fun c tion and ini t ial i ze

for ( var i =0; i <5 ; i ++) coun t edH e ll o () ;

alert ( cou n te d Hel lo . ca l lCou n t ) ; // disp l a ys : 5

Functions are declared with a formal parameter list, but the size of the parameter list does not

limit the number of arguments that can be passed when calling the function. If a function is called

with fewer arguments than its declared number of parameters, the extra parameters are set to

undened. If a function is called with more arguments than the number of formal parameters, the

extra arguments are evaluated but their values are not available via parameter names. However, an

array-like arguments object is available as the value of the function object’s

arguments

property

during execution of the body of the function. All of the actual arguments passed in a call to the

function are available as integer-keyed properties of the

arguments

object. This enables a function

to be written that can process a variable length arguments list.

3.5 Built-in Library

JavaScript 1.0 comes with a library of built-in functions, objects, and constructors. The library

denes a small number of general-purpose objects

and functions along with a larger set of host-

specic objects and functions. For Netscape Navigator, host objects

provided a model of portions

of the current HTML document. These APIs ultimately became known as the Document Object

Model (DOM) level 0 [Koch 2003; Netscape 1996b]. For Netscape Enterprise Server, host objects

supported client/server communications, managing the state of client and server sessions, and le

and database access. That design for server host objects did not achieve adoption beyond Netscape

server products.

The early design of JavaScript was largely driven by the needs of the browser platform. The

Netscape documentation for the early JavaScript versions did not explicitly distinguish between

library elements that were intended to be host environment independent or host dependent.

However, the design, evolution, and standardization of the DOM and other browser platform APIs

constitute its own signicant story deserving its own history. The current paper mentions browser

related issues only when they are relevant to the overall design of JavaScript.

JavaScript 1.0 has only two general-purpose object Classes:

String

and

Date

. In addition, there

is a singleton global object

Math

, whose properties are commonly used mathematical constants

and functions. The constructors for several inactive or incompletely implemented Classes are also

observable to JavaScript 1.0 programs that know how to access them. JavaScript 1.1 completes

Lack of a formally named object abstraction mechanism makes it dicult to talk about specic kinds of objects supported

by the JavaScript library. JavaScript documentation has used various terms including “type,” “object,” “constructor,” and

“class” to talk about such abstractions. In the remainder of this paper we use the capitalized word “Class” when we need to

talk about the denition of a set of JavaScript objects that share a common representation and methods, regardless of the

actual form of the denition.

Authors’ Preprint 2020-03-13, HOPL-4, Publication date: June 2020.

18 Allen Wirfs-Brock and Brendan Eich

Base Objects Properties Properties

1.0 1.1 1.0 Added in 1.1

<global functions> eval, isNaN,

parseFloat,

parseInt

Array

Array join, reverse, sort, toString

Boolean

Boolean toString

Date getDate, getDay, getHours,

getMinutes, getMonth, getSeconds,

GetTime, getTimezoneOset,

getYear, setDate, setHours,

setMinutes, setMonth, setSeconds,

setTime, setYear, toGMTString,

toLocaleString, Date.parse, Date.UTC

toString

<function objects> arguments, length, caller

Function

prototype, toString

Math E, LN2, LN10, LOG2E, LOG10E, PI,

SQRT1_2, SQRT2, abs, acos, asin,

atan, ceil, cos, exp, oor, log, max,

min, pow, random,

round, sin, sqrt,

tan

Object constructor, eval, toString, valueOf

Number

Number toString, Number.NaN,

Number.MAX_VALUE,

Number.MIN_VALUE,

Number. NEGATIVE_INFINITY,

Number.POSITIVE_INFINITY

<string values> length

String

charAt,

indexOf, lastIndexOf, split

substring, toLowerCase, toUpperCase,

(plus 13 HTML wrapper methods)

split, toString, valueOf

In 1.0 available only on Unix platforms.

In 1.0 behavior diers depending upon host operating system.

Exists in 1.0 but is not operational or buggy.

In 1.0 these methods appear to be properties of string values. In 1.1 they are properties of String.prototype.

Fig. 8. JavaScript 1.0/1.1 Host-Independent Built-In Library

the implementation of these features and documents their existence. Figure 8 summarizes the

host-independent Classes dened in JavaScript 1.0 and 1.1.

The String Class provides the length property and six general-purpose methods that operate

upon immutable string values and, when appropriate, return new string values. The JavaScript 1.0

String

Class also includes thirteen methods for wrapping a string value with various HTML tags.

This is an example of the uid boundary between host-dependent and general-purpose functionality

in JavaScript 1.0/1.1. JavaScript 1.0 does not provide a global

String

constructor function. All string

values are created using string literals or by operators and built-in functions. JavaScript 1.1 adds

the global String constructor and the split method.

The

Date

Class is used to represent calendar dates and time. JavaScript 1.0

Date

was a direct

transliteration, bugs and all, of the

java.util.Date

class of Java 1.0 [Gosling et al

1996]. This

includes encoding details such as using a millisecond resolution time value centered on 00:00:00

GMT on January 1, 1970, externally numbering months from 0–11, and Year 2000 ambiguities

that were present in the Java design. This design choice was motivated by Java interoperability

Authors’ Preprint 2020-03-13, HOPL-4, Publication date: June 2020.

JavaScript: The First 20 Years 19

requirements. The only Java methods excluded were

equals

before

, and

after

which were not

needed because JavaScript’s automatic coercions permitted its numeric relational operators to be

directly used with Date objects.

Other than

Object

Date

is the only usable built-in constructor function in JavaScript 1.0.

Date

is also the only Class that exposed methods on the constructor object in addition to methods for

Class instances. None of the browser-specic Classes exposed a constructor function.

Some properties of built-in library objects and host-provided objects have characteristics which

are not available for properties dened by JavaScript programmers. For example, their method

properties are not enumerated by the

for

statement. Some of their properties are ignored by

the

delete

operator or have read-only values. Accessing or modifying some of their properties

trigger special behaviors with observable side eects.

JavaScript 1.1 adds a usable

Array

Class. The

Array

constructor creates objects intended for use

as integer-index, zero-origin vectors of heterogeneous values. The array elements are presented as

object properties whose keys are the string representation of their integer indices. Array objects

also have a

length

property whose value is initially set by the constructor. The

length

property’s

value is updated whenever an element index that is greater or equal to the current

length

value is

accessed. Thus the number of elements of an Array object may dynamically grow.

3.6 Execution Model

In Netscape 2 and subsequent browsers, an HTML Web page may contain multiple

elements. When a page is loaded, a fresh JavaScript execution environment and global context is

created for the HTML document. The global context includes its global object, which is an object

whose property keys are the names of the built-in functions and variables provided by JavaScript

and the host environment plus the global variables and functions dened by the scripts.

In Netscape 2, the JavaScript code for each

element is parsed and evaluated in the

order they occur within the page’s HTML le. In later browsers

elements may be tagged

for deferred evaluation which lets the browser continue processing HTML while it waits for the

JavaScript code to be retrieved from the network. In either case the browser evaluates one script at

a time. Scripts normally share the same global object. Global variables and functions created by a

script are visible to all subsequent scripts. Each script is run to completion without preëmption or

interruption. This characteristic of early browsers became a fundamental principle of JavaScript.

Scripts are atomic units of execution and once started each one runs until it is completed. Within a

script it is not necessary to worry about interference from concurrent execution of other scripts

because it cannot occur.

Netscape 2 also introduced the concept of Web page frames.

A frame is a region of a Web

page into which a separate HTML document may be loaded. All of the frames on a page share

the same JavaScript execution environment but each frame has a separate global context within

that environment. Scripts loaded in dierent frames see a dierent global object, dierent built-

ins, and dierent global variables and functions. But a global context is not an address space. A

JavaScript execution environment has a single address space of objects that is shared among all of

the frames within that environment. Because of this single address space of objects, it is possible for

object references to be passed among the JavaScript code in dierent frames intermingling objects

from dierent global contexts. This can lead to surprising behavior. Consider the JavaScript 1.1

example in Figure 9. Each frame has its own distinct

Object

constructor and

Object.prototype

that provide properties inherited by all objects created by that constructor. Adding a property to

The original HTML

<frame>

tag is considered obsolete and has been superseded by the

tag. The semantics

described in this section are common to both kinds of elements.

Authors’ Preprint 2020-03-13, HOPL-4, Publication date: June 2020.

20 Allen Wirfs-Brock and Brendan Eich

// The v a riab l e alien ref e ren ces an o b ject create d with i n a d iff e rent frame

// by eval u ati ng : new O b ject ()

var alien = c r ea te N ew Ob je c tI nA Di f fe re n t F ra me () ;

var native = new Obj e c t () ; // create an obj e c t in the curr e n t fr a me

Object . pr o tot y pe . sh a re d Pr o pe r ty = " e a ch frame has distin c t built - ins " ;

alert ( native . sh are d Pr o pe r ty ); // disp l ays : each frame has d isti n ct built - ins

alert ( alien . sha r ed P rop ert y ) ; // d i spla y s : u n def i ned

Fig. 9. JavaScript 1.1 example showing that code in dierent HTML frames can interchange objects even

though they have distinct built-in objects.

a frame’s

Object.prototype

does not make the property visible to objects created by another

frame’s Object constructor.

Interactive JavaScript Web pages are event-driven applications where the event loop is provided

by the browser. HyperCard [Apple Computer 1988] inspired Brendan Eich to use the concept of

events in the original Netscape 2 DOM [Netscape 1996c] design. Originally events were triggered

primarily by user interactions, but in modern browsers there are many kinds of events, only some

of which are user originated.

When all the scripts dened by a Web page have been executed, the JavaScript environment for

the page remains active waiting for an event to occur. Event handlers can be associated with objects

provided by the browser, including many DOM objects. An event handler is simply a JavaScript

function that is called in response to the occurrence of an event. Assigning a function to certain

properties of browser objects makes that function the handler for the event associated with the

property. For example, objects that correspond to clickable pointing devices have an

onclick

property that can be set. A JavaScript event handler can also be dened directly in an HTML

element using a snippet of JavaScript code, for example:

<button onclick="doSomethingWhenClicked()">Click me</button>

When the HTML element is processed the browser creates a JavaScript function and assigns it as

the value of the

onclick

property of the button object. The

onclick

code snippet is used as the

function body. When an event with a JavaScript event handler occurs it is placed into a pool of

pending events. When no JavaScript code is executing, the browser takes a pending event from the

event pool and calls the associated function. Like scripts, event handler functions run to completion.

3.7 Oddities and Bugs

JavaScript has several unusual or unexpected features. Some were intentional and others were

artifacts of quick design decisions made during the original Mocha 10-day sprint. JavaScript 1.0

also had bugs and incompletely implemented features.

3.7.1 Redundant Declarations. JavaScript tolerates multiple declarations of the same name within

a scope. All declarations of a name within a function correspond to a single binding that is visible

throughout the entire body of the function. For example, the following is a valid function denition:

func t ion f ( x , x ) { // x names the second pa r a m e t e r , ignor e s 1 st x

var x ; // sa m e bind i n g as sec o n d param e ter

for ( var x in obj ) { // same b i nding as s econd par a mete r

var x =1 , x =2; // same b i ndin g s as se c o n d param e ter

}

var x =3; // sa m e bind i n g as sec o n d param e ter

}

Authors’ Preprint 2020-03-13, HOPL-4, Publication date: June 2020.

剩余189页未读，继续阅读

亚赛大人

粉丝: 31
资源: 332

JavaScript的二十年：从脚本语言到全球标准

JavaScript权威指南(第6版).JavaScript：The.Definitive.Guide

JavaScript中英文手册.zip

常用javascript语句大全

html语言起源,为什么javascript日期是从1970年1月1日开始算的？

请你用JavaScript计算某年某月某日是这一年的多少天

用js计算20年后的3月3日

javascript new date()格式化

利用gee计算20年的rsei

使用javaScript通过日期按周、月、年分类

使用javaScript通过时间戳按周、月、年分类

编写html代码：一个农场有头母牛，现在母牛才一岁，要到四岁才能生小牛,四岁之后,每 年生一头小牛。假设每次生的都是母牛，并 且也遵守4年才生育并生母牛的原则,且牛到15岁开始绝育，问20年之后共有多少头 牛?

利用gee使用Landsat影像计算20年的rsei

编写html代码：一个农场有头母牛，现在母牛才一岁，要到四岁才能生小牛,四岁之后,每 年生一头小牛。假设每次生的都是母牛，并 且也遵守4年才生育并生母牛的原则,且所 生的牛都不会死，问20年之后共有多少头 牛?

做一个HTML包含css和JavaScript内容是河北传媒学院网站

javascript newDATE

javascript时间转换成标准"yyyy-MM-dd HH:mm:ss"格式的函数 本地时间 代码最短 "yyyy-MM-dd HH:mm:ss"

JavaScript身份证号正则表达式

用css html JavaScript 写一个圣诞表白代码 给出代码

用html，css，javascript写一个高校宿舍管理系统页面

用html5和css和JavaScript做个汽车网站的首页

最新资源

编写html代码：一个农场有头母牛，现在母牛才一岁，要到四岁才能生小牛,四岁之后,每年生一头小牛。假设每次生的都是母牛，并且也遵守4年才生育并生母牛的原则,且牛到15岁开始绝育，问20年之后共有多少头牛?

编写html代码：一个农场有头母牛，现在母牛才一岁，要到四岁才能生小牛,四岁之后,每年生一头小牛。假设每次生的都是母牛，并且也遵守4年才生育并生母牛的原则,且所生的牛都不会死，问20年之后共有多少头牛?

javascript时间转换成标准"yyyy-MM-dd HH:mm:ss"格式的函数本地时间代码最短 "yyyy-MM-dd HH:mm:ss"

用css html JavaScript 写一个圣诞表白代码给出代码