How to Define Do Nothing to Keep User on the Same Page in JavaScript
-
Use
Void(0)to Define Do Nothing to Keep User on the Same Page in JavaScript -
Use
Window.close()to Define Do Nothing to Keep User on the Same Page in JavaScript - Use Null to Define Do Nothing to Keep User on the Same Page in JavaScript
- Conclusion
In web development, keeping users on the same page can be essential for various reasons, such as maintaining context, preventing unnecessary reloads, or ensuring a smooth user experience.
When designing interactive elements like buttons or links, you may encounter situations where you want a click to do nothing in terms of navigation or page reloading.
This tutorial will teach you three methods to keep users on the same page when they click the Cancel button in a JavaScript confirm window. The methods we’ll use are void(0), window.close() and null.
Use Void(0) to Define Do Nothing to Keep User on the Same Page in JavaScript
void is a built-in JavaScript operator that evaluates the given expression and always returns undefined.
When using void(0), you’re effectively instructing the browser to perform an operation (in this case, evaluate 0) that results in no meaningful change or action.
It’s a way to express “do nothing” or “prevent any action” in a JavaScript context.
void (0);
Here are some use cases for the void(0) operator:
-
Prevent Default Behavior:
When dealing with events like clicks on links or buttons, using
void(0)in the event handler prevents the default behavior, such as navigation to a different page or form submission.const cancelButton = document.getElementById('cancelButton'); cancelButton.addEventListener('click', function(event) { event.preventDefault(); void (0); }); -
In
hrefAttribute of Anchors:Placing
void(0)in thehrefattribute of an anchor tag (<a>) prevents the page from navigating when the user clicks the link.<a href="javascript:void(0)">Click me</a> -
Nullify Actions:
Using
void(0)as a return value for functions or events can effectively nullify their actions, providing a way to define a no-operation scenario.function doNothing() { return void (0); }
Let’s illustrate how to use void(0) to prevent navigation when a button is clicked. Here, we have an HTML link with a JavaScript onclick event handler.
The code in onclick has a confirm dialog that asks the user to close the application. If the user clicks Cancel, they’ll remain on the page.
<body>
<main>
<p><a id="do_nothing" href="#">Click me</a></p>
</main>
<script type="text/javascript">
let link = document.getElementById("do_nothing");
link.onclick = function() {
confirm("Do you want to close the application")? window.close(): void(0);
}
</script>
</body>
This code structures a simple web page containing a hyperlink labeled Click me inside a <main> section. This hyperlink has the ID do_nothing and has an href attribute set to #, ensuring that it doesn’t navigate anywhere when clicked.
In the accompanying JavaScript code, the let link = document.getElementById("do_nothing"); line fetches the hyperlink element with the ID "do_nothing" and stores it in a variable named link.
Following this, an event listener is set up for the click event on this hyperlink using link.onclick. When the hyperlink is clicked, the event listener triggers a function.
Within this function, there’s a conditional statement: if (confirm("Do you want to close the application?")) window.close();. If the user clicks the hyperlink and confirms the prompt asking if they want to close the application, the confirm function returns true, and window.close() is executed, which would typically close the browser window or tab.
However, there’s a behavior to note: if the user cancels the prompt (chooses not to close the application), the confirm function returns false. In this case, no action occurs due to the absence of an else clause or an alternative action within the conditional statement.
Essentially, if the user chooses not to close the application, nothing significant happens, and they remain on the current page.
Output:
Use Window.close() to Define Do Nothing to Keep User on the Same Page in JavaScript
The name of window.close() should give you an idea of what it does. If you think it’ll close a window, you are right.
When called, it usually triggers a confirmation prompt to the user, asking for their permission to close the window.
window.close();
By default, most modern browsers prompt the user before closing the window, and the user has the option to confirm or cancel the action. However, this behavior may vary depending on browser settings and configurations.
To achieve a “do nothing” effect using window.close(), we can utilize the confirmation prompt that is shown to the user when calling window.close(). Instead of confirming the closure, the user can simply cancel the action, effectively doing nothing.
The code below is essentially the same as the previous one. We used an if statement and window.close() to keep the user on the page after clicking the Cancel button.
<body>
<main>
<p><a id="do_nothing" href="#">Click me</a></p>
</main>
<script type="text/javascript">
let link = document.getElementById("do_nothing");
link.onclick = function() {
if (confirm("Do you want to close the application?")) window.close();
}
</script>
</body>
Output:
Use Null to Define Do Nothing to Keep User on the Same Page in JavaScript
Using null as the third part of a ternary operator is another technique in JavaScript that can be employed to effectively do nothing and keep the user on the same page when a condition is met.
Ternary operators are a concise way of writing conditional statements consisting of three parts:
- The condition.
- The code to execute if the condition is true.
- The code to execute if the condition is false.
Here’s how you can use null as the third part of a ternary operator to achieve the desired behavior:
condition ? doSomething() : null;
In this construct, if the condition is true, doSomething() will be executed, and if the condition is false, null will be returned, effectively doing nothing.
Here’s how you can use null in the ternary operator:
<body>
<main>
<p><a id="do_nothing" href="#">Click me</a></p>
</main>
<script type="text/javascript">
let link = document.getElementById("do_nothing");
link.onclick = function() {
confirm("Do you want to close the application?")? window.close(): null;
}
</script>
</body>
Similar to the previous examples, the link element with the id do_nothing is selected using document.getElementById. An onclick event handler is then attached to this link using an anonymous function.
When the link is clicked, a confirmation dialog is displayed with the message Do you want to close the application?. If the user confirms (by clicking OK), the confirm function returns true, and the expression window.close() is executed, attempting to close the window.
On the other hand, if the user cancels (by clicking Cancel), the confirm function returns false, and null is returned, effectively doing nothing in this context.
The use of null in the ternary operator signifies that no action is taken if the user decides not to close the application.
Output:
Conclusion
Defining “do nothing” actions in JavaScript is essential for maintaining user experience and preventing unwanted page transitions or actions. Whether it’s using void(0), window.close(), or using null in the ternary operator, you have various methods at your disposal to achieve this objective.
Choose the approach that best fits your use case and enhances the usability of your web application while keeping users on the same page.
Habdul Hazeez is a technical writer with amazing research skills. He can connect the dots, and make sense of data that are scattered across different media.
LinkedIn