I have a page with 2 forms; each form has an input text field;
The value found in the input text of the 1st form must be the same with the value found in the input text of the 2nd form;
When the value changes, the other input text field also modifies its value;
Should I use both onkeyup and onchange events?
If not, which one is the right one to use?
I am asking this because it seams that I have 2 post requests, and I think that this is why.
$('input.searchbox').keyup( function(){
$('input.txtfieldsearch').val($('input.searchbox').val());
listViewUpdate();
$('input.txtfieldsearch').trigger("keyup");
});
$('input.txtfieldsearch').keyup( function(){
$('input.searchbox').val($('input.txtfieldsearch').val());
listViewUpdate();
});
$('input.searchbox').change( function(){
$('input.txtfieldsearch').val($('input.searchbox').val());
listViewUpdate();
$('input.txtfieldsearch').trigger("change");
});
$('input.txtfieldsearch').change( function(){
$('input.searchbox').val($('input.txtfieldsearch').val());
listViewUpdate();
});
You can use $.on() function and attach multiples handlers.
$("#element").on('keyup change', function (){
// Your stuff...
});
You can use only "input" event if you don't need to provide support for the older browsers. It will be fired everytime a value changes in the input element. Here's a list of the supported browsers: https://developer.mozilla.org/en-US/docs/Web/Events/input
onkeyup mostly fires when a key was pressed by the user and then released. onchange can happen if the user uses the browser's autocomplete feature. You should use the .on() method to catch both events, just in case:
$('input.searchbox').on('keyup change', function(e){
$('input.txtfieldsearch').val($('input.searchbox').val());
listViewUpdate();
$('input.txtfieldsearch').trigger(e.type);
});
$('input.txtfieldsearch').on('keyup change', function(){
$('input.searchbox').val($('input.txtfieldsearch').val());
listViewUpdate();
});
If you want to react to change, you should use change.
There are some occasions where a keyup doesn't make a change(like shift) and occasions where there's a change without a keyup (paste).
Related
Consider the following:
<input type="text" id="foo" />
I need that, when the value of the input.#foo is changed, without blur, it shot my event. Here comes the problem: I can't use onkey events because the input is dinamically received by a virtual HTML-composed keyboard.
I can easily do, with the true keyboard:
document.querySelector("#foo").addEventListener('keypress', function() {
// Implementation
});
The W3C recommend using onchange, but onchange only works after the blur event occurs. I need a mix of onkeypress, to be dynamic, on time modify, and onchange, to know when it changes. You can see this: http://jsfiddle.net/zuq733La/
JS Fiddle
use textInput it will check for every character added
document.querySelector("#foo").addEventListener('textInput', function () {
alert('Value changed!');
});
the only way I can think of (without using blur, change, keypress, keyup or keydown events) is using a setInterval(): DEMO
var value=$('#foo').val();
setInterval(function(){
if(value!=$('#foo').val()){
value=$('#foo').val();
//here you need to write what will happen if the value is changed
}
},50);
in the DEMO you can see that even if you copy and paste a text (using only your mouse even without blurring the input) the event fires.
I'd like to run a function upon each modification of a textbox control as soon as the user is typing. the event .keyup() is fine for most of the cases.
However, browsers (like Chrome or Firefox) may suggest autocompletion entries for textbox controls (probably because the #name or #id of the input control is known).
Unfortunately, I can't have any of the below events fired when "clicking on a suggested entry". ( .keyup() fires when selected with keyboard )
$('input#email')
.click(function() { console.log('click'); })
.keyup(function() { console.log('keyup'); })
.keydown(function() { console.log('keydown'); })
.change(function() { console.log('change'); })
.focus(function() { console.log('focus'); })
.blur(function() { console.log('blur'); });
As much as possible, I'd like to avoid using a setInterval() periodical check.
Is there a way to detect this "select a suggestion" event ?
bind propertychange event:
$('input').bind('input propertychange', function() {
var input = this.value.trim();
[...]
});
The short answer is no, there is no event for detecting a suggestion selection. You could try looking at DOM mutation observers but I'm uncertain if these cover attribute changes, and there is little support for this API so far anyway.
So if you really need to handle this case then I think setInterval is your only option.
Edit: 3 years later you can use propertychange with jQuery as in the new accepted answer (which I assume uses mutation observers under the hood).
alternative solution disable autocomplete and handle other events like keyup,keydown etc
<input type="text" name="foo" autocomplete="off" />
The change event seems to works fine, but does require you to click away
When using jquery .change on an input the event will only be fired when the input loses focus
In my case, I need to make a call to the service (check if value is valid) as soon as the input value is changed. How could I accomplish this?
UPDATED for clarification and example
examples: http://jsfiddle.net/pxfunc/5kpeJ/
Method 1. input event
In modern browsers use the input event. This event will fire when the user is typing into a text field, pasting, undoing, basically anytime the value changed from one value to another.
In jQuery do that like this
$('#someInput').bind('input', function() {
$(this).val() // get the current value of the input field.
});
starting with jQuery 1.7, replace bind with on:
$('#someInput').on('input', function() {
$(this).val() // get the current value of the input field.
});
Method 2. keyup event
For older browsers use the keyup event (this will fire once a key on the keyboard has been released, this event can give a sort of false positive because when "w" is released the input value is changed and the keyup event fires, but also when the "shift" key is released the keyup event fires but no change has been made to the input.). Also this method doesn't fire if the user right-clicks and pastes from the context menu:
$('#someInput').keyup(function() {
$(this).val() // get the current value of the input field.
});
Method 3. Timer (setInterval or setTimeout)
To get around the limitations of keyup you can set a timer to periodically check the value of the input to determine a change in value. You can use setInterval or setTimeout to do this timer check. See the marked answer on this SO question: jQuery textbox change event or see the fiddle for a working example using focus and blur events to start and stop the timer for a specific input field
If you've got HTML5:
oninput (fires only when a change actually happens, but does so immediately)
Otherwise you need to check for all these events which might indicate a change to the input element's value:
onchange
onkeyup (not keydown or keypress as the input's value won't have the new keystroke in it yet)
onpaste (when supported)
and maybe:
onmouseup (I'm not sure about this one)
With HTML5 and without using jQuery, you can using the input event:
var input = document.querySelector('input');
input.addEventListener('input', function()
{
console.log('input changed to: ', input.value);
});
This will fire each time the input's text changes.
Supported in IE9+ and other browsers.
Try it live in a jsFiddle here.
As others already suggested, the solution in your case is to sniff multiple events.
Plugins doing this job often listen for the following events:
$input.on('change keydown keypress keyup mousedown click mouseup', handler);
If you think it may fit, you can add focus, blur and other events too.
I suggest not to exceed in the events to listen, as it loads in the browser memory further procedures to execute according to the user's behaviour.
Attention: note that changing the value of an input element with JavaScript (e.g. through the jQuery .val() method) won't fire any of the events above.
(Reference: https://api.jquery.com/change/).
// .blur is triggered when element loses focus
$('#target').blur(function() {
alert($(this).val());
});
// To trigger manually use:
$('#target').blur();
If you want the event to be fired whenever something is changed within the element then you could use the keyup event.
There are jQuery events like keyup and keypress which you can use with input HTML Elements.
You could additionally use the blur() event.
This covers every change to an input using jQuery 1.7 and above:
$(".inputElement").on("input", null, null, callbackFunction);
Using jQuery, I would like to capture a keyboard event that is:
before the user lifts their finger from the key
after the characters from the keyboard event have registered in the input box.
To clarify, view this example. When keypress fires, the input value has not been updated yet.
[Edit]
Apparently I wasn't clear as to what I need.
The function must be called before the user lifts their finger up from the key, but after the key's character is placed in the input box. So the following do not work:
keydown: at the keypress event, the value in the text box has not been updated
keypress: at the keypress event, the value in the text box has not been updated
keyup: this is called when the user lifts their finger, which is too late.
You can use the input event, which works in recent versions of all major browsers:
var input = document.getElementById("your_input_id");
input.oninput = function() {
alert(input.value);
};
Unfortunately, it doesn't work in IE <= 8. However, in those browsers you can use the propertychange event on the value property instead:
input.onpropertychange = function() {
if (window.event.propertyName == "value") {
alert(input.value);
}
};
SO regular JavaScript answerer #Andy E has covered this in detail on his blog: https://web.archive.org/web/20140626060232/http://whattheheadsaid.com/2011/10/update-html5-oninput-event-plugin-for-jquery
Use keyup event, an example on jsFiddle
$("textarea").keyup(function(e){
alert($(this).val());
});
It happens after you lift the key. I don't know what you want to achieve, but you can store the state before lifting the key (on keydown or keypress) and restoring later if needed. You also can stop the output in the keyup event using e.preventDefault(), so even after the key is up it will not register the values in the area.
You could listen on keydown event and store the value in a variable. That variable would have the value as it was before the new input, and the new input would be included in the keyup event
UPDATE:
Ok, I misunderstood your requirements, but there isn't an event that would meet your needs. The only thing I can think of to simulate this behaviour is the following:
listen on keydown/keypress
get the value from the event object (get event.which, then convert it to actual value)
use a variable like I mentioned in the original advice and concatenate the new input to it
Here is a fiddle: http://jsfiddle.net/HpXuU/13/
This is obviously not a perfect solution, as it needs some (one might argue unnecessary) work to get done right. I would advise to rethink your needs, but if this behavior is absolutely what you need, I think this is a step in the right direction.
You can use setTimeout:
$('input').keypress(function() {
var that = this;
setTimeout(function() {
// read that.value
}, 0);
});
Live demo: http://jsfiddle.net/HpXuU/8/
I'm trying to have a form where the values are updated based on changes in either a select, or changes in a text field.
I started with
jQuery('select[name=measure]','form').live('change',function(){
alert('triggered');
});
I then added the keyup for when the user alters a text box
jQuery('select[name=measure],input[name=amount]','form').live('change keyup',function(){
alert('triggered');
});
For some reason this enters an infinite loop when I select an option, and is triggered multiple times on keyup (though not infinitely).
When I change to
...live('keyup', function()...
changes to the text-box are only triggered once.
I could split them into two seperate .live events and then create a separate function, but that doesn't seem to be efficient code.
It's attaching the change and keyup to select[name=measure] and input[name=amount].
I doubt you want the input to have a change event and the select to have a keyup event.
I recommend you separate these two live events. You probably don't need the form selector either.
$('select[name=measure]').live('change', SomeFunction);
$('input[name=amount]').live('keyup', SomeFunction);
function SomeFunction() {
// this isn't inefficient
}
working example: http://jsfiddle.net/K7586/
or you could use delegate()
$("form")
.delegate("input[name=amount]", "keyup", SomeFunction)
.delegate("select[name=measure]", "change", SomeFunction);
function SomeFunction() {
// this isn't inefficient
}