javascript - tag - title of page html

Javascript soporta rendimiento

Question

Leí sobre la palabra clave de rendimiento en JavaScript y necesito usarla en mi proyecto. Leí que esta palabra clave se implementó a partir de cierta versión de JS, por lo que creo que los navegadores antiguos no la admiten (¿verdad?).

¿Hay alguna forma de verificar si la palabra clave de rendimiento es compatible? ¿O al menos hay una manera de verificar si la versión de JS es mayor o igual a la que implementa esa palabra clave (1.7)?

Answer 1

Aquí está mi opinión sobre la comprobación de soporte de yield nativo.

var canYield = (function(){try{yield;}catch(e){}}())!==undefined;

Prueba modernizr

define([''Modernizr''], function( Modernizr ) {
  // native yield support.
  Modernizr.addTest(''yield'', (function(){try{yield;}catch(e){}}())!==undefined);
});

Rendimiento http://jsperf.com/yield-support

Answer 2

Aquí hay una función para verificar si se puede usar el rendimiento.

var can_yield = (function(){ 
    try { 
        return eval("!!Function(''yield true;'')().next()"); 
    } 
    catch(e) { 
        return false; 
    } 
})();

Answer 3

En sentido estricto, solo los navegadores Mozilla admiten JavaScript. Todos los navegadores deben admitir ECMAScript y las versiones anteriores de JavaScript son implementaciones de ECMAScript.

Este sitio enumera qué versiones de Javascript son compatibles con qué versiones de navegador.

MSIE utiliza JScript. JScript no tiene rendimiento en ello. Por lo tanto, utilizar el rendimiento limitará el soporte del navegador para su página.

Pruebe https://developer.mozilla.org/en/New_in_JavaScript_1.7 para obtener información sobre el uso de JavaScript 1.7

Answer 4

He pasado mucho tiempo con yield recientemente, y Bobince no está completamente equivocado, pero Chrome 31 no interpreta la versión de JavaScript en 1.7 bloques, incluso con el indicador Experimental de JavaScript activado (chrome: // flags / # enable-javascript -armonía). Debido a las diferencias de implementación entre Chrome 31 y Firefox, el método de Tymon Sturgeon no puede detectar el yield en Chrome 31 con Experimental JS activado, aunque está muy cerca. Con algunas modificaciones, puede detectar la existencia de yield tanto para Firefox como para Chrome 31 con Experimental JS activado.

Primero, cubriré rápidamente las diferencias de yield (escribiéndolas en el camino largo para mayor claridad):

En Firefox:

var fooGen = function(){ yield 1; yield 2; };
var iterator = fooGen();
console.log(iterator.next());    // prints 1
console.log(iterator.next());    // prints 2

En Chrome 31 con JavaScript experimental habilitado:

// Note the *
var fooGen = function*(){ yield 1; yield 2; };
var iterator = fooGen();
console.log(iterator.next().value);    // prints 1
console.log(iterator.next().value);    // prints 2

.value es requerido en Chrome porque produce un objeto, pero lo más importante es que el generador requiere un "*" en la definición de la función. Además, no pude encontrar una manera de crear un generador a partir de la función "F" capital: new Function('''', ''{yield 5;}''); en cromo. Si sabes cómo, deja un comentario abajo.

Para detectar correctamente el yield en Firefox y Chrome, he usado un poco de código con algunos de ida y vuelta:

<script type="application/javascript">
    var can_yield = (function(){ 
        try {
            // Assuming Chrome''s generator syntax
            var funcUsingYield = new Function('''', ''{ var interp = function* generator(){ yield true; }}'');
            return true;
        } catch(e) { 
            return false; 
        } 
    })();
</script>

<script type="application/javascript;version=1.7">
    // Redefine the `can_yield` function inside a JS1.7 block. Probably safe to simply return true
    can_yield = (function(){ 
        try { 
            return eval("!!Function(''yield true;'')().next()"); 
        } 
        catch(e) { 
            return false; 
        } 
    })();
</script>

<script type="application/javascript">
    if(!can_yield)
    {
        alert("Can''t Yield!");
    }
</script>

Probado en:

• Firefox 25 : el yield funciona
• Chrome 31 con JS experimental: el yield funciona
• Chrome 31 con JS desactivado experimental: el yield no funciona
• e IE10 : el yield no funciona

Answer 5

bueno, en realidad hay algunas técnicas que puedes usar, pero dudo que tales técnicas tengan algún valor real

(function test_key_word(keyword){
var wrong = false;
try {
    eval(keyword + "=42");
} 
catch(e) {
    wrong = true;
} finally {
    if (wrong) { return "definitely wrong" }
    else 
    if (window[keyword] !== 42) {
        return "very probably, wrong"
    }
    else {
        return "can be acceptable, but nevertheless i wouldn''t rely upon such tests"
    }
}})("in")

Answer 6

en realidad implementamos el "rendimiento", programáticamente, en "javascript puro", es decir, SIN UTILIZAR el "rendimiento" de FIREFOX, para pijamas, después de observar que skulpt también había hecho lo mismo.

en teoría, se podría hacer exactamente lo mismo ya sea manualmente (es decir, mediante la laboriosa codificación manual de una función traducida siguiendo las reglas sobre cómo convertir una función en un generador) o ejecutando javascript a través de un traductor de lenguaje de javascript a javascript ( !)

lo que se requiere para implementar tal "Bestia" es que tiene que hacer que la función sea capaz de saltar hasta el punto en que se "salió" por última vez (mediante una declaración de rendimiento). por lo tanto, todas las variables deben almacenarse en estado temporal (!) y la ejecución del código debe modificarse en consecuencia, para aceptar esta información de estado temporal. eso incluye las declaraciones while, para bucles, así como las declaraciones "if".

se puede hacer ...

... pero es solo una perra de trabajo: necesita, efectivamente, escribir un compilador completo que analice cualquier programa javascript, luego lo "transforme" y luego genere el javascript modificado.

l

Answer 7

yield introduce nueva sintaxis a JavaScript. No podrá utilizar el yield menos que haya especificado que desea la nueva sintaxis de JavaScript, incluyendo un número de versión en el atributo de script type (*).

Cuando especifique una versión de script, solo los navegadores que admiten la versión dada ejecutarán el bloqueo. Así que solo Firefox, y no IE, Opera o WebKit, ejecutarán el bloque superior en:

<script type="text/javascript;version=1.7">
    function x() {
        yield 0;
    }
    var canyield= true;
</script>
<script type="text/javascript">
    if (!window.canyield) {
        // do some fallback for other browsers
    }
</script>

(*: tenga en cuenta que el tipo y la versión especificados en el atributo type determinan exclusivamente si los scripts externos se recuperan y ejecutan, y el modo de ejecución. Desafortunadamente, el Content-Type de Content-Type de un script se ignora por completo).