JS insider and 5 falsey values

Abhiman — Mon, 15 Jan 2024 07:07:20 +0000

Unveiling the JavaScript Stack: How Code Runs and the Intricacies of Falsey Values

Introduction:
JavaScript, the language that powers the interactive and dynamic aspects of the web, has a fascinating way of executing code. In this blog, we'll take a deep dive into the JavaScript stack and explore how the code is built and executed. Additionally, we'll shed light on a fundamental concept in JavaScript – falsy values.

Understanding the JavaScript Stack:
When a JavaScript program is executed, it utilizes a data structure known as the call stack. The stack operates on a Last In, First Out (LIFO) basis, meaning the last function called is the first to finish. Let's break down the key components:

Execution Context:
Each function call creates an execution context that contains information about the function, its parameters, and local variables. These contexts are stacked on top of each other in the call stack.
Call Stack:
The call stack keeps track of the execution flow. As functions are called, they are added to the stack, and as they complete, they are removed. This sequential process ensures a structured execution of code.
Event Loop:
JavaScript is single-threaded and uses an event loop to manage asynchronous operations. Callbacks, promises, and async/await are mechanisms that allow non-blocking code execution.

Code Implementation in the Stack:
Now, let's explore how the JavaScript code gets implemented in the stack:

Function Invocation:

When a function is called, an execution context is created, including the function's parameters and local variables.
Adding to the Stack:

The execution context is pushed onto the call stack, making it the current running context.
Executing Code:

The statements inside the function are executed in sequence.
Removing from the Stack:

Once the function completes, its execution context is popped from the stack.
Return Values:

If a function returns a value, it's passed back to the calling function.
This process repeats until the entire program has been executed.

Falsey Values in JavaScript:
In JavaScript, truthiness and falsiness are essential concepts. While certain values are inherently considered "truthy," there are five specific values that are "falsey":

false: The boolean value false.
0: The number zero.
'' (empty string): An empty string.
null: The absence of any object value.
undefined: A declared variable that hasn't been assigned a value.
Understanding falsey values is crucial when writing conditional statements, as they help determine the flow of your code.

Conclusion:
JavaScript's stack-based execution and the concept of falsy values play pivotal roles in shaping the language's behavior. By grasping these fundamental aspects, developers can write more efficient and error-resistant code. Stay tuned for more insights into the intricate workings of JavaScript!

PQ vs SET

Abhiman — Sun, 14 Jan 2024 17:22:36 +0000

Understanding time complexity of Dijkstra priority queue vs set vs queue-->

Dijkstra's Algorithm using Priority Queue:
vector dijkstra(int V, vector> adj[], int S) {
priority_queue, vector>,
greater>> pq;
vector distTo(V, INT_MAX);
distTo[S] = 0;
pq.push({0, S});
while (!pq.empty()) {
int node = pq.top().second;
int dis = pq.top().first;
pq.pop();
for (auto it : adj[node]) {
int v = it[0];
int w = it[1];
if (dis + w < distTo[v]) {
distTo[v] = dis + w;
pq.push({dis + w, v});
}
}
}
return distTo;
}

Dijkstra's Algorithm using Set:
vector dijkstra(int V, vector> adj[], int S) {
set> st;
vector dist(V, 1e9);
st.insert({0, S});
dist[S] = 0;
while (!st.empty()) {
auto it = *(st.begin());
int node = it.second;
int dis = it.first;
st.erase(it);
for (auto it : adj[node]) {
int adjNode = it[0];
int edgW = it[1];
if (dis + edgW < dist[adjNode]) {
if (dist[adjNode] != 1e9)
st.erase({dist[adjNode], adjNode});
dist[adjNode] = dis + edgW;
st.insert({dist[adjNode], adjNode});
}
}
}
return dist;
}
Comparison:

Data Structure Used:
The first version uses a priority_queue to efficiently extract the minimum distance node.
The second version uses a set to maintain nodes in ascending order based on distances.

Complexity:
The first version (with the priority queue) usually has better time complexity in practice as compared to the second version.
The second version has a higher time complexity due to the overhead of searching and erasing elements from the set.

Code Length:
The first version is generally more concise and easier to read.
The second version involves more lines of code, mainly due to handling set operations.

Efficiency:
The first version is generally more efficient for large graphs due to the efficient extraction of the minimum element from the priority queue.
The second version may be less efficient for large graphs due to the overhead of set operations.

In conclusion, while both versions implement Dijkstra's algorithm, the version using the priority queue is typically more efficient and concise. The version using the set might be useful in certain scenarios or for educational purposes, but for practical implementations, the version with the priority queue is often preferred.

DEV Community: Abhiman

JS insider and 5 falsey values

PQ vs SET