Syntaxe JavaScript

Objects can be created using a constructor or an object literal. The constructor can use either a built-in Object function or a custom function. It is a convention that constructor functions are given a name that starts with a capital letter:

This is the basis for JSON, which is a simple notation that uses JavaScript-like syntax for data exchange.

A method is simply a function that has been assigned to a property name of an object. Unlike many object-oriented languages, there is no distinction between a function definition and a method definition in object-related JavaScript. Rather, the distinction occurs during function calling; a function can be called as a method.

When called as a method, the standard local variablejQuery do unusual things with ;}functionFoo(yz){this.prefix="a-";if(yz>0){this.pyz=function(){returnthis.prefix+"Y";};}else{this.pyz=function(){returnthis.prefix+"Z";};}this.m1=px;returnthis;}constfoo1=newFoo(1);constfoo2=newFoo(0);foo2.prefix="b-";console.log("foo1/2 "+foo1.pyz()+foo2.pyz());// foo1/2 a-Y b-Zfoo1.m3=px;// Assigns the function itself, not its evaluated result, i.e. not px()constbaz={"prefix":"c-"};baz.m4=px;// No need for a constructor to make an object.console.log("m1/m3/m4 "+foo1.m1()+foo1.m3()+baz.m4());// m1/m3/m4 a-X a-X c-Xfoo1.m2();// Throws an exception, because foo1.m2 does not exist.

Constructor functions simply assign values to slots of a newly created object. The values may be data or other functions.

Example: Manipulating an object:

The constructor itself is referenced in the object's prototype's constructor slot. So,

JavaScript supports inheritance hierarchies through prototyping in the manner of Self.

In the following example, the );};this.aBaseFunction=function(){console.log("Base::aBaseFunction()");};}functionDerived(){this.anOverride=function(){console.log("Derived::anOverride()");};}constbase=newBase();Derived.prototype=base;// Must be before new Derived()Derived.prototype.constructor=Derived;// Required to make `instanceof` workconstd=newDerived();// Copies Derived.prototype to d instance's hidden prototype slot.dinstanceofDerived;// truedinstanceofBase;// truebase.aBaseFunction=function(){console.log("Base::aNEWBaseFunction()");};d.anOverride();// Derived::anOverride()d.aBaseFunction();// Base::aNEWBaseFunction()console.log(d.aBaseFunction==Derived.prototype.aBaseFunction);// trueconsole.log(d.__proto__==base);// true in Mozilla-based implementations and false in many others.

The following shows clearly how references to prototypes are copied on instance creation, but that changes to a prototype can affect all instances that refer to it.

In practice many variations of these themes are used, and it can be both powerful and confusing.

TypeScript provides static typing through type annotations to enable type checking at compile time.

When a TypeScript script gets compiled, there is an option to generate a declaration file (with the extension .d.ts) that functions as an interface to the components in the compiled JavaScript. In the process, the compiler strips away all function and method bodies and preserves only the signatures of the types that are exported. The resulting declaration file can then be used to describe the exported virtual TypeScript types of a JavaScript library or module when a third-party developer consumes it from TypeScript.

The concept of declaration files is analogous to the concept of header files found in C/C++.

Although TypeScript does not have manual memory management, it has resource management similar to using-with-resource blocks in C# or try-with-resources blocks in Java, or C++resource acquisition is initialization, that automatically close resources without need for finally blocks. In TypeScript, to automatically close an object, it must implement a global interface Disposable, and implement a method Symbol.dispose(). This will automatically be called at the end of scope.