What the Internal Property in ECMAScript is defined for ? What does the spec mean by
This specification uses various internal properties to define the semantics of object values.These internal properties are not part of the ECMAScript language. They are defined by this specification purely for expository purposes.
Does it mean that Internal properties defined by ECMAScript are not available for programming. They are used in the implementation of the javascript engine ?
Internal properties define the behavior of code as it executes but are not accessible via code. ECMAScript defines many internal properties for objects in JavaScript. Internal properties are indicated by double-square-bracket notation.
For example, JavaScript function is an object and it has [[call]] property. [[call]] property is unique to function.
Another internal property example is [[prototype]] property. This property is a pointer pointing back to the prototype object that the instance is using. Since internal property cannot be accessed via code, an object instantiation cannot access to the prototype while its properties are all available to the object. You can get the value of [[prototype]] property by using Object.getPrototypeOf() method on an object.
var obj = new Object();
var prototype = Object.getPrototypeOf(obj);
console.log(prototype == Object.prototype);
Does it mean that Internal properties defined by ECMAScript are not available for programming. They are used in the implementation of the javascript engine ?
Yes. They are only for implementation purposes, and don't need "real names". You can read about that in #8.6.2 Object Internal Properties and Methods.
The often used example is the internal property [[prototype]], all objects have one but you can't access it directly eg.
function foo(){
this.first = "hi"
this.second = something
}
foo.prototype = {
constructor : foo,
anotherProp : "hello"
}
var obj = new foo();
console.log(obj.anotherProp); //hello
//here the runtime will look in obj for anotherProp and
//fail to find it so it will look in obj's internal property
//[[prototype]] which is pointing to the object foo.prototype
so you can access the objects that the internal property [[prototype]] is pointing to but not directly through the internal [[prototype]] property that is only for the runtime to use, not the programmer.
They are used in an example of how to implement a JavaScript engine.