Which am I better off doing? .hide() is quicker than writing out .css("display", "none"), but what’s the difference and what are both of them actually doing to the HTML element?
This question is related to
javascript
jquery
html
css
show-hide
From the jQuery page about .hide():
"The matched elements will be hidden immediately, with no animation. This is roughly equivalent to calling .css('display', 'none'), except that the value of the display property is saved in jQuery's data cache so that display can later be restored to its initial value. If an element has a display value of inline, then is hidden and shown, it will once again be displayed inline."
So if it's important that you're able to revert to the previous value of display, you'd better use hide() because that way the previous state is remembered. Apart from that there's no difference.
$(function() {_x000D_
$('.hide').click(function(){_x000D_
$('.toggle').hide();_x000D_
setDisplayValue();_x000D_
});_x000D_
$('.show').click(function(){_x000D_
$('.toggle').show();_x000D_
setDisplayValue();_x000D_
});_x000D_
});_x000D_
_x000D_
function setDisplayValue() {_x000D_
var display = $('.toggle')[0].style.display;_x000D_
$('.displayvalue').text(display);_x000D_
}div {_x000D_
display: table-cell;_x000D_
border: 1px solid;_x000D_
padding: 5px;_x000D_
}<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>_x000D_
<p>_x000D_
<button class="hide">Hide</button>_x000D_
<button class="show">Show</button>_x000D_
</p>_x000D_
_x000D_
<div class="toggle">Lorem Ipsum</div>_x000D_
_x000D_
<p>_x000D_
The display value of the div is:_x000D_
<span class="displayvalue"></span>_x000D_
</p>Looking at the jQuery code, this is what happens:
hide: function( speed, easing, callback ) {
if ( speed || speed === 0 ) {
return this.animate( genFx("hide", 3), speed, easing, callback);
} else {
for ( var i = 0, j = this.length; i < j; i++ ) {
var display = jQuery.css( this[i], "display" );
if ( display !== "none" ) {
jQuery.data( this[i], "olddisplay", display );
}
}
// Set the display of the elements in a second loop
// to avoid the constant reflow
for ( i = 0; i < j; i++ ) {
this[i].style.display = "none";
}
return this;
}
},
See there is no difference if you use basic hide method. But jquery provides various hide method which give effects to the element. Refer below link for detailed explanation: Effects for Hide in Jquery
To use both is a nice answer; it's not a question of either or.
The advantage of using both is that the CSS will hide the element immediately when the page loads. The jQuery .hide will flash the element for a quarter of a second then hide it.
In the case when we want to have the element not shown when the page loads we can use CSS and set display:none & use the jQuery .hide(). If we plan to toggle the element we can use jQuery toggle.
.hide() stores the previous display property just before setting it to none, so if it wasn't the standard display property for the element you're a bit safer, .show() will use that stored property as what to go back to. So...it does some extra work, but unless you're doing tons of elements, the speed difference should be negligible.
They are the same thing. .hide() calls a jQuery function and allows you to add a callback function to it. So, with .hide() you can add an animation for instance.
.css("display","none") changes the attribute of the element to display:none. It is the same as if you do the following in JavaScript:
document.getElementById('elementId').style.display = 'none';
The .hide() function obviously takes more time to run as it checks for callback functions, speed, etc...
Both do the same on all browsers, AFAIK. Checked on Chrome and Firefox, both append display:none to the style attribute of the element.
Source: Stackoverflow.com