JavaScript variables can belong to:
The local scope or The global scope
Global variables can be made local (private) with closures.
Closures makes it possible for a function to have “private” variables.
A local variable is a “private” variable defined inside a function.
A function can access all variables in the local scope. Continue reading JavaScript Closures
With the bind() method, an object can borrow a method from another object.
The example below creates 2 objects (person and member).
The member object borrows the fullname method from the person object :
const person = {
firstName:"John",
lastName: "Doe",
fullName: function () {
return this.firstName + " " + this.lastName;
}
}
const member = {
firstName:"Hege",
lastName: "Nilsen",
}
let fullName = person.fullName.bind(member);
With the apply() method, you can write a method that can be used on different objects.
The apply() method is similar to the call() method (previous chapter).
In this example the fullName method of person is applied on person1 :
const person = {
fullName: function() {
return this.firstName + " " + this.lastName;
}
}
const person1 = {
firstName: "Mary",
lastName: "Doe"
}
// This will return "Mary Doe":
person.fullName.apply(person1);
With the call() method, you can write a method that can be used on different objects.
In JavaScript all functions are object methods.
If a function is not a method of a JavaScript object, it is a function of the global object (see previous chapter).
The example below creates an object with 3 properties, firstName, lastName, fullName. Continue reading JavaScript Function call()
The code inside a JavaScript function will execute when “something” invokes it.
The code inside a function is not executed when the function is defined.
The code inside a function is executed when the function is invoked.
It is common to use the term “call a function” instead of “invoke a function“.
It is also common to say “call upon a function”, “start a function”, or “execute a function”.
In this tutorial, we will use invoke, because a JavaScript function can be invoked without being called. Continue reading JavaScript Function Invocation
A JavaScript function does not perform any checking on parameter values (arguments).
Earlier in this tutorial, you learned that functions can have parameters:
function functionName(parameter1, parameter2, parameter3) {
// code to be executed
}
Function parameters are the names listed in the function definition.
Function arguments are the real values passed to (and received by) the function. Continue reading JavaScript Function Parameters
JavaScript functions are defined with the function keyword.
You can use a function declaration or a function expression.
Earlier in this tutorial, you learned that functions are declared with the following syntax:
function functionName(parameters) {
// code to be executed
}
Declared functions are not executed immediately. They are “saved for later use”, and will be executed later, when they are invoked (called upon). Continue reading JavaScript Function Definitions
// Prevents re-assignment
const car = {type:"Fiat", model:"500", color:"white"};
// Prevents adding object properties
Object.preventExtensions(object)
// Returns true if properties can be added to an object
Object.isExtensible(object)
// Prevents adding and deleting object properties
Object.seal(object)
// Returns true if object is sealed
Object.isSealed(object)
// Prevents any changes to an object
Object.freeze(object)
// Returns true if object is frozen
Object.isFrozen(object)
The most common way to protect an object from being changed is by using the const keyword.
With const you can not re-assign the object, but you can still change the value of a property, delete a property or create a new property. Continue reading JavaScript Object Protection
ECMAScript 5 (ES5 2009) introduced Getter and Setters.
Getters and setters allow you to define Object Accessors (Computed Properties).
This example uses a lang property to get the value of the language property.
// Create an object:
const person = {
firstName: "John",
lastName: "Doe",
language: "en",
get lang() {
return this.language;
}
};
// Display data from the object using a getter :
document.getElementById("demo").innerHTML = person.lang;
This example uses a lang property to set the value of the language property. Continue reading JavaScript Object Accessors
// Adding or changing an object property
Object.defineProperty(object, property, descriptor)
// Adding or changing object properties
Object.defineProperties(object, descriptors)
// Accessing a Property
Object.getOwnPropertyDescriptor(object, property)
// Accessing Properties
Object.getOwnPropertyDescriptors(object)
// Returns all properties as an array
Object.getOwnPropertyNames(object)
// Accessing the prototype
Object.getPrototypeOf(object)
The Object.defineProperty() method can be used to: