detección de compatibilidad de la versión de jQuery

Question

¿Hay algún recurso que pueda probar una secuencia de comandos jQuery/extensión/complemento/lo que sea para problemas de compatibilidad de versión?

Answer 1

¿Desea obtener la versión actual de jQuery y probarla para ver si es una versión determinada?

$().jquery; 

Que obtendrá la versión.

Metropolis

Answer 2

No hay herramientas automatizadas para esto, al menos que yo he visto. El razonamiento para esto es que el equipo central de jQuery intenta no introducir cambios de ruptura a menos que haya un beneficio real a largo plazo. Esto significa que cuando hay cambios bruscos, lo que quería no es algo que un sistema automatizado siempre pueda decirle.

Vamos a usar jQuery 1.4 como ejemplo, he aquí una lista de los cambios de última hora:
http://jquery14.com/day-01/jquery-14#backwards

• jQuery() es ahora un conjunto vacío, bueno o malo?
• jQuery.browser.version ¿es ahora la versión del navegador, buena o mala?
• JSON ahora está sujeto a un análisis mucho más estricto, ¿bueno o malo?

Esos son solo unos pocos, pero si se rompen o ayudan a su código a menudo depende. Ahora bien, si tuviera .attr(val, func()), obviamente esto es solo 1.4+, que podría detectar ... por lo que podría ser posible un motor que podría determinar la versión mínima de jQuery que su código podría utilizar.

Comprobando los problemas de compatibilidad, que en mi opinión significan cambios en la mayoría de los casos, sería mucho más difícil, porque son (por naturaleza) muy raros o se rompen los casos ... de lo contrario el equipo no los han roto :)

Answer 3

Acabo de escribir un pequeño plugin jQuery para ayudar con los problemas de compatibilidad de versiones ... no duden en mejorarlo.

(function($) { 
    /** 
    * Used for version test cases. 
    * 
    * @param {string} left A string containing the version that will become 
    *  the left hand operand. 
    * @param {string} oper The comparison operator to test against. By 
    *  default, the "==" operator will be used. 
    * @param {string} right A string containing the version that will 
    *  become the right hand operand. By default, the current jQuery 
    *  version will be used. 
    *   
    * @return {boolean} Returns the evaluation of the expression, either 
    *   true or false. 
    */ 
    $.isVersion = function(left, oper, right) { 
     if (left) { 
      var pre = /pre/i, 
       replace = /[^\d]+/g, 
       oper = oper || "==", 
       right = right || $().jquery, 
       l = left.replace(replace, ''), 
       r = right.replace(replace, ''), 
       l_len = l.length, r_len = r.length, 
       l_pre = pre.test(left), r_pre = pre.test(right); 

      l = (r_len > l_len ? parseInt(l) * ((r_len - l_len) * 10) : parseInt(l)); 
      r = (l_len > r_len ? parseInt(r) * ((l_len - r_len) * 10) : parseInt(r)); 

      switch(oper) { 
       case "==": { 
        return (true === (l == r && (l_pre == r_pre))); 
       } 
       case ">=": { 
        return (true === (l >= r && (!l_pre || l_pre == r_pre))); 
       } 
       case "<=": { 
        return (true === (l <= r && (!r_pre || r_pre == l_pre))); 
       } 
       case ">": { 
        return (true === (l > r || (l == r && r_pre))); 
       } 
       case "<": { 
        return (true === (l < r || (l == r && l_pre))); 
       } 
      } 
     } 

     return false; 
    } 
})(jQuery); 

Puede ser utilizado como tan:

$.isVersion("1.4.2"); // returns true, if $().jquery == "1.4.2" 
$.isVersion("1.3.2", ">"); // returns true if $().jquery > "1.3.2" 
$.isVersion("1.3", ">", "1.2.6"); // returns true 
$.isVersion("1.3.2", "<", "1.3.1"); // returns false 
$.isVersion("1.4.0", ">=", "1.3.2"); // returns true 
$.isVersion("1.4.1", "<=", "1.4.1"); // returns true 

apoya también pre-versiones (releases se pesan más pesado que el pre-versiones, de modo que 1.4.0pre < 1.4.0):

$.isVersion("1.4.2", "<=", "1.4.2pre"); // returns false 

Answer 4

El código tiene algunos errores, sobre todo

1. $ .isVersion ('1.9.2.17', '<', '2.0') devuelve falso
2. $ .isVersion ('1.17.2.1', '>', '1.8') devuelve falso

Solución
1. se fija con el código adjunto.
2. no es como es más complicado sin una reescritura completa, y es un caso más raro de todos modos.

(function($) { 
/** 
* Used for version test cases. 
* 
* @param {string} left A string containing the version that will become 
*  the left hand operand. 
* @param {string} oper The comparison operator to test against. By 
*  default, the "==" operator will be used. 
* @param {string} right A string containing the version that will 
*  become the right hand operand. By default, the current jQuery 
*  version will be used. 
* 
* @return {boolean} Returns the evaluation of the expression, either 
*   true or false. 
*/ 
$.isVersion = function(left, oper, right) { 
    if (left) { 
     var pre = /pre/i, 
      replace = /[^\d]+/g, 
      oper = oper || "==", 
      right = right || $().jquery, 
      l = left.replace(replace, ''), 
      r = right.replace(replace, ''), 
      l_len = l.length, r_len = r.length, 
      l_pre = pre.test(left), r_pre = pre.test(right); 

     l = (r_len > l_len ? parseInt(l) * Math.pow(10, (r_len - l_len)) : parseInt(l)); 
     r = (l_len > r_len ? parseInt(r) * Math.pow(10, (l_len - r_len)) : parseInt(r)); 

     switch(oper) { 
      case "==": { 
       return (true === (l == r && (l_pre == r_pre))); 
      } 
      case ">=": { 
       return (true === (l >= r && (!l_pre || l_pre == r_pre))); 
      } 
      case "<=": { 
       return (true === (l <= r && (!r_pre || r_pre == l_pre))); 
      } 
      case ">": { 
       return (true === (l > r || (l == r && r_pre))); 
      } 
      case "<": { 
       return (true === (l < r || (l == r && l_pre))); 
      } 
     } 
    } 

    return false; 
} 
})(jQuery); 

Answer 5

Holy smokes people, esas son las soluciones más verbosas de todos! ¿Me estoy perdiendo de algo? Debo ser. A continuación está mi solución, ¿qué me estoy perdiendo?

versión comprimida:

(parseInt(jQuery.fn.jquery.split('.').join('')) > 140) ? alert("Running jquery greater than 1.4.0") : alert("current jquery version is 1.4.0 or less"); 

Versión larga para mayor claridad:

// get version as a string and get rid of the periods. 
version = jQuery.fn.jquery.split('.').join(''); 

// Make into one long number for easy comparison. Example, 171, or 141. 
version = parseInt(version); 
if(version > 141){ 
    alert("We're using a version greater than 1.4.1"); 
}else{ 
    alert("jQuery version is 1.4.1 or lower"); 
} 

Answer 6

Aquí está mi solución rápida y sucia: el uso

var versionGTE = function (valueA, valueB) { 
    var values = [valueA, valueB]; 
    values.sort(); 
    // if valueA > valueB, values will have switched 
    return (values[1] === valueA); 
}; 

Ejemplo:

if (versionGTE(jQuery.fn.jquery, "1.3")) { 
    // don't use @ in attr selectors 
} 

Hace un orden alfabético en la matriz. La única vez que falla es si, por alguna razón, la versión "x.y" contra "x.y.0". En ese caso, la versión .0 se percibe como mayor. Tampoco es compatible con las versiones "pre".

Aquí es una versión más pequeña:

var versionGTE = function (valueA, valueB) { 
    return ([valueA, valueB].sort()[1] === valueA); 
}; 

Aquí es una función más fiable si usted está preocupado acerca de "rc1", "pre" o x.0 versiones:

var versionCompare = function (versionStringA, versionStringB) { 
    // quick test of equality before digging in 
    if (versionStringA === versionStringB) return 0; 

    var versionedAlpha = /[a-z]+(\d+)/gi, 
     getArray = function (verString) { 
     // replace rc1, rc2, beta3, etc with .-1.1, .-1.2, .-1.3, etc 
     return verString.replace(versionedAlpha, ".-1.$1").split("."); 
     }, 
     valuesA = getArray(versionStringA), 
     valuesB = getArray(versionStringB), 
     maxLength = Math.max(valuesA.length, valuesB.length), 
     hasLetters = /[a-z]/gi, 
     // assume any version with letters is -1 (pre, rc, etc) 
     // also assume that any null entries are 0 (1.5 === 1.5.0) 
     parseVersion = function (verString) { 
     return (verString) ? (hasLetters.test(verString)) ? -1 : parseInt(verString, 10) : 0; 
     }; 

    // verify both arrays are the same size 
    valuesA.length = maxLength; 
    valuesB.length = maxLength; 

    for (var i = 0; i < maxLength; i++) { 
    var valueA = parseVersion(valuesA[i]), 
     valueB = parseVersion(valuesB[i]); 

    if (valueA < valueB) { 
     return -1; 
    } else if (valueA > valueB) { 
     return 1; 
    } 
    } 

    // all equal at this point 
    return 0; 
}; 

Esto es como una sort or .compare función en que devolverá 0 si es igual, 1 si a> b, y -1 si es < b. Ejemplo:

if (versionCompare(jQuery.fn.jquery, "1.3") >= 0) { 
    // don't use @ in attr selectors 
} 

Answer 7

Escribí la solución en mi esencia bifurcada: https://gist.github.com/budiadiono/7954617. ¿Qué piensas?