Trovare più vicino valore corrispondente utilizzando jQuery o JavaScript

Question

consideri un markup come

<select id="blah"> 
    <option value="3">Some text</option> 
    <option value="4">Some text</option> 
    <option value="8">Some text</option> // <---- target this tag based on value 7 
    <option value="19">Some text</option> 
</select> 

Supponiamo che io ho un valore con me, dire 7. E 'possibile indirizzare il tag opzione il cui value attributo è più vicino a 7 che , in questo caso, sarebbe <option value="8">?

Sono a conoscenza di ^ che significa iniziare con e $ che significa terminare con e speravo se ci fosse qualcosa di simile a trovare la corrispondenza più simile per un dato valore.

Answer 1

andrò in questo modo:

http://jsfiddle.net/GNNHy/

var $tmpOption = $('<option value="7">Some text 7</option>'); 
$("#blah").append($tmpOption); 
var my_options = $("#blah option"); 
my_options.sort(function(a,b) { 
    if (parseInt(a.value,10) > parseInt(b.value,10)) return 1; 
    else if (parseInt(a.value,10) < parseInt(b.value,10)) return -1; 
    else return 0 
}) 

$("#blah").empty().append(my_options); 

Answer 2

Sì, basta sottrarre il valore (7) con i valori dell'opzione (utilizzare ciascuna funzione) ... il valore con il risultato positivo minimo sarà l'opzione mirata. Spero che tu abbia il risultato desiderato.

Answer 3

Che ne dici di una ricorsione? Troverà il valore più vicino:

JS-BIN Demo

function getClosest(val, ddl, increment){ 
    if(ddl.find('option[value="'+val+'"]').length){ 
     return val; 
    } 
    else 
    try{ 
     if(increment) 
    return getClosest(++val, ddl, increment); 
     else 
     return getClosest(--val, ddl, increment); 
    } 
    catch(err){ 
    return -1; 
    } 
} 

function findClosest(val, ddl){ 
    var larger = getClosest(val, ddl, true); 
    var smaller = getClosest(val, ddl, false); 
    if(larger == smaller == -1) 
    return -1; 
    else if (larger == -1) 
    return smaller; 
    else if (smaller == -1) 
    return larger; 

    if(larger - val > val - smaller) 
    return smaller; 
    else 
    return larger 
}  

Answer 4

Il modo più semplice è forse la buona ricerca lineare vecchio (si può fare binario, ma è più difficile del solito):

var target; 
var $options; 

var best=Infinity; 
var bestAt; 

$options.each(function(){ 
    var error = this.value - target; 
    error = error>0 ? error : -error; 
    if(error<=best){ 
    best=error; 
    bestAt=this; 
    } 
}) 

//return $(bestAt); 

Answer 5

Se è possibile utilizzare jquery, farei qualcosa come

$(function() { 
     // comes from somewhere 
     var val = 7; 

     var sortByDifference = $("#blah option").sort(function (opt1, opt2) { 
      return Math.abs(parseInt($(opt1).val()) - val) - Math.abs(parseInt($(opt2).val()) - val); 
     }); 

     alert($(sortByDifference[0]).val()); 
    }); 

In sortByDifference tutti i valori sono ordinati in base alla vicinanza al valore. La routine restituisce il più vicino più grande o più basso e non richiede l'ordinamento delle opzioni.

Answer 6

function findClosest(num){ 
    var select = document.getElementById('blah'); 
    var options = select.options; 
    var dif = Infinity; 
    var index; 
    for(var i = 0; i < options.length; i++){ 
     var newdif = Math.abs(parseInt(options[i].value) - num); 
     if(newdif < dif){ 
      dif = newdif; 
      index = i; 
     } 
    } 
    select.selectedIndex = index; 
}