ECMAScript

There are 31 posts tagged ECMAScript (this is page 2 of 4).

ECMA-262-5 in detail. Chapter 0. Introduction.

We have finished analysis of the most important parts and theoretical aspects concerning 3rd edition of the ECMA-262 specification, i.e. standard devoted ECMAScript programming language. We have done and achieved a lot. Originally written in Russian, this series after more than half an year has been translated to several languages, what allowed this information to be shared with JavaScript developers and with everyone who interested in deep ECMAScript allover the world. Continue reading →

ECMA-262-3 in detail. Chapter 8. Evaluation strategy

Read this article in: Russian, French.

Note: this article was revisited and updated on Feb 10th, 2020

  1. Introduction
  2. General theory
    1. Eager and Lazy evaluation
    2. Arguments evaluation order
    3. Call by value
    4. Call by reference
    5. Call by sharing
      1. By sharing as a special case of by value
      2. By sharing and pointers
    6. Comparison table
  3. ECMAScript implementation
    1. Terminology versions
  4. Conclusion
  5. Additional literature

Introduction

In this small note we will consider strategy of passing arguments to functions in ECMAScript.

In general this part of computer science is known as evaluation strategy, that is, a set of rules for evaluating semantics of some expressions. The strategy of passing arguments to functions is one of its cases. Continue reading →

ECMA-262-3 in detail. Chapter 5. Functions.

Read this article in: Russian, French.

  1. Introduction
  2. Types of functions
    1. Function Declaration
    2. Function Expression
      1. Question “about surrounding parentheses”
      2. Implementations extension: Function Statement
      3. Feature of Named Function Expression (NFE)
      4. NFE and SpiderMonkey
      5. NFE and JScript
    3. Functions created via Function constructor
  3. Algorithm of function creation
  4. Conclusion
  5. Additional literature

Introduction

In this article we will talk about one of the general ECMAScript objects — about functions. In particular, we will go through various types of functions, will define how each type influences variables object of a context and what is contained in the scope chain of each function. Continue reading →

ECMA-262-3 in detail. Chapter 4. Scope chain.

Read this article in: Russian, French.

  1. Introduction
  2. Definition
  3. Function life cycle
    1. Function creation
    2. Function activation
  4. Scope features
    1. Closures
    2. [[Scope]] of functions created via Function constructor
    3. Two-dimensional Scope chain lookup
    4. Scope chain of the global and eval contexts
    5. Affecting on Scope chain during code execution
  5. Conclusion
  6. Additional literature

Introduction

As we already know from the second chapter concerning the variable object, the data of an execution context (variables, function declarations, and formal parameters of functions) are stored as properties of the variables object. Continue reading →

ECMA-262-3 in detail. Chapter 2. Variable object.

Read this article in: Russian, Chinese, French.

  1. Introduction
  2. Data declaration
  3. Variable object in different execution contexts
    1. Variable object in global context
    2. Variable object in function context
  4. Phases of processing the context code
    1. Entering the execution context
    2. Code execution
  5. About variables
  6. Feature of implementations: property __parent__
  7. Conclusion
  8. Additional literature

Introduction

Always in programs we declare functions and variables which then successfully use building our systems. But how and where the interpreter finds our data (functions, variable)? What occurs, when we reference to needed objects? Continue reading →

ECMA-262-3 in detail. Chapter 3. This.

Read this article in: Russian.

  1. Introduction
  2. Definitions
  3. This value in the global code
  4. This value in the function code
    1. Reference type
    2. Function call and non-Reference type
    3. Reference type and null this value
    4. This value in function called as the constructor
    5. Manual setting of this value for a function call
  5. Conclusion
  6. Additional literature

Introduction

In this article we will discuss one more detail directly related with execution contexts. The topic of discussion is the this keyword.
Continue reading →

ECMA-262-3 in detail. Chapter 7.2. OOP: ECMAScript implementation.

Read this article in: Russian, French.

  1. Introduction
  2. ECMAScript OOP implementation
    1. Data types
      1. Primitive value types
      2. Object type
        1. Dynamic nature
        2. Built-in, native and host objects
        3. Boolean, String and Number objects
        4. Literal notations
          1. Regular Expression Literal and RegExp Objects
        5. Associative arrays?
        6. Type conversion
        7. Property attributes
        8. Internal properties and methods
    2. Constructor
      1. Algorithm of objects creation
    3. Prototype
      1. Property constructor
      2. Explicit prototype and implicit [[Prototype]] properties
      3. Non-standard __proto__ property
      4. Object is independent from its constructor
      5. Feature of instanceof operator
      6. Prototype as a storage for methods and shared properties
    4. Reading and writing properties
      1. [[Get]] method
      2. [[Put]] method
      3. Property accessors
    5. Inheritance
      1. Prototype chain
  3. Conclusion
  4. Additional literature

Introduction

This is the second part of article about object-oriented programming in ECMAScript. In the first part we discussed the general theory and drew parallels with ECMAScript. Before reading of the current part, if it is necessary, I recommend reading the first part as in this article we will actively use the passed terminology. You can find the first part here: ECMA-262-3 in detail. Chapter 7.1. OOP: The general theory.
Continue reading →

ECMA-262-3 in detail. Chapter 7.1. OOP: The general theory.

Read this article in: Russian, French.

  1. Introduction
  2. General provisions, paradigms and ideology
    1. Features of class based and prototype based models
      1. Static class based model
        1. Classes and objects
        2. Hierarchical inheritance
        3. Key concepts of class based model
      2. Prototype based model
        1. Delegation based model
        2. Concatenative model
        3. “Duck” typing
        4. Key concepts of prototype based model
      3. Dynamic class based model
    2. Additional features of various OOP implementations
      1. Polymorphism
      2. Encapsulation
      3. Multiple inheritance
      4. Mixins
      5. Traits
      6. Interfaces
      7. Object composition
      8. AOP features
  3. Conclusion
  4. Additional literature

Introduction

In this article we consider major aspects of object-oriented programming in ECMAScript. That the article has not turned to “yet another” (as this topic already discussed in many articles), more attention will be given, besides, to theoretical aspects to see these processes from within. In particular, we will consider algorithms of objects creation, see how relationships between objects (including the basic relationship — inheritance) are made, and also give accurate definitions which can be used in discussions (that I hope will dispel some terminological and ideological doubts and messes arising often in articles on OOP in JavaScript). Continue reading →

ECMA-262-3 in detail. Chapter 6. Closures.

Read this article in: Russian, French.

  1. Introduction
  2. General theory
    1. Definitions
    2. Funarg problem
    3. Closure
  3. ECMAScript closures implementation
    1. One [[Scope]] value for “them all”
    2. Funarg and return
    3. Theory versions
  4. Practical usage of closures
  5. Conclusion
  6. Additional literature

Introduction

In this article we will talk about one of the most discussed topics related to JavaScript — about closures. The topic in fact is not new, and was discussed many times. However we will try to discuss and understand it more from a theoretical perspective, and also will look at how closures are implemented in ECMAScript.
Continue reading →