This document explains JavaScript functions, prototypes, and self-executing functions. It covers how functions are declared, how prototypes simplify the addition of properties and methods to objects, and how self-executing functions isolate variables and initialize data.
JavaScript Functions
Function Declaration and Usage
- A function is a block of reusable code that can be called after being declared.
- Functions consist of:
- The
function keyword. - A name for the function.
- Parentheses for optional parameters.
- Curly braces containing the logic.
- An optional
return statement to return a value.
Example: Function Declaration
1function add(a, b) {
2 return a + b
3}
4console.log(add(5, 10)) // Output: 15
- Functions in JavaScript are loosely typed, meaning the data type of arguments is determined at runtime.
- Functions can return different types based on the input, such as adding numbers or concatenating strings.
JavaScript Prototypes
Overview of Prototypes
- Prototypes allow properties and methods to be shared across all instances of an object.
- Objects created with the
new keyword inherit properties and methods from their prototype.
Example: Using Prototypes
1function Car(make, model, year) {
2 this.make = make
3 this.model = model
4 this.year = year
5}
6
7Car.prototype.getName = function () {
8 return `${this.make} ${this.model} (${this.year})`
9}
10
11const car1 = new Car('Toyota', 'Corolla', 2020)
12console.log(car1.getName()) // Output: Toyota Corolla (2020)
- Adding a method to a prototype ensures all instances of the object inherit the method.
- Changes to the prototype are reflected in all instances.
Self-Executing Functions
What Are Self-Executing Functions
- Self-executing functions, also known as auto-invocation or immediately invoked function expressions (IIFE), run immediately after being declared.
- These functions isolate variables and logic from the global scope.
Example: Self-Executing Function
1;(function () {
2 const message = 'Hello, World!'
3 console.log(message)
4})() // Output: Hello, World!
- Self-executing functions are often used for initialization tasks or to declare DOM elements.
- Variables and functions inside an IIFE are not accessible outside of it.
Conclusion
JavaScript functions provide reusable blocks of code, while prototypes simplify the addition of shared properties and methods to objects. Self-executing functions isolate logic and variables, making them useful for initialization and encapsulation.
FAQ
A function in JavaScript is declared using the function keyword, followed by a name, parentheses for optional parameters, and curly braces containing the logic. For example:
1function add(a, b) {
2 return a + b;
3}
Prototypes are important because they allow properties and methods to be shared across all instances of an object, reducing memory usage and enabling inheritance.
Self-executing functions are better for isolating variables because they prevent pollution of the global scope, ensuring variables and logic are encapsulated.
Yes, JavaScript functions are loosely typed and can return different types of values based on the input, such as numbers, strings, or objects.
Prototypes simplify object-oriented programming by enabling shared methods and properties, reducing redundancy, and allowing dynamic updates to all instances of an object.
If two functions have the same name in the same scope, the latter function will overwrite the former, as JavaScript does not support function overloading.
Self-executing functions, or IIFEs, are used to immediately execute code, isolate variables, and initialize data without affecting the global scope.
The return statement should be used when you need to send a value back to the caller of the function, such as the result of a calculation or a processed value.
Yes, you can add methods to an object after it has been created by modifying its prototype or directly assigning a method to the object.
A function declaration defines a named function and is hoisted, meaning it can be called before its definition. A function expression assigns a function to a variable and is not hoisted.
In a prototype method, the this keyword refers to the specific instance of the object that is calling the method.
Self-executing functions are useful for initialization tasks because they execute immediately and can set up variables, event listeners, or other configurations without polluting the global scope.
Using prototypes for method sharing reduces memory usage, ensures consistency across instances, and allows updates to methods to propagate to all instances.
Yes, self-executing functions can access global variables, but they can also define their own variables to avoid conflicts with the global scope.
A self-executing function is appropriate when you need to encapsulate logic, initialize data, or execute code immediately without affecting the global scope.