Injecter du code javascript dans une fonction javascript

J'ai une question étrange que j'ai besoin d'injecter du code javascript dans une autre fonction javascript. Je suis à l'aide d'un cadre qui est verrouillé donc je ne peux pas changer la fonction.

Ce que j'ai est quelque chose comme ceci

fonction doSomething(){
...
}

...***

Je peux manipuler le ***(ci-dessus), cependant je ne peux pas changer la fonction doSomething... au Lieu de cela j'ai besoin de quelque sorte d'injecter un peu de lignes de code à la fin de la doSomething code.

La raison que j'ai besoin de faire cela est que la coutume cadre des appels doSomething() et il en résulte une ID retourné par le serveur que j'ai besoin d'extraire. Cet ID n'est référencé à l'intérieur de la fonction doSomething donc je ne peux pas l'attraper, à moins que j'ai injecter du code de la fonction (à moins que j'ai raté quelque chose).

Est-il un moyen de faire cela?

Quelle est la fonction "verrouillé"?
Double Possible de Est-il un moyen pour envelopper toutes les méthodes JavaScript avec une fonction?

OriginalL'auteur Grunt | 2010-01-21

5

Alias.
```
var oldDoSomething = doSomething;
doSomething = function() {
  //Do what you need to do.
  return oldDoSomething.apply(oldDoSomething, arguments);
}
```
il a besoin d'accéder à une variable qui est portée à la fonction d'origine
Mauvaise réponse. Nécessite au cas par cas d'utilisation.

OriginalL'auteur August Lilleaas

Merci pour tous vos commentaires. Chaque réponse m'a donné une idée, et je suis venu avec la solution suivante.

<body>
<script type="text/javascript">
    var val;
    function doSomething(item1, item2) {
        var id = 3;
    }
    function merge() {
        var oScript = document.createElement("script");
        var oldDoSomething = doSomething.toString();
        oScript.language = "javascript";
        oScript.type = "text/javascript";
        var args = oldDoSomething.substring(oldDoSomething.indexOf("(") + 1, oldDoSomething.indexOf(")"));
        var scr = oldDoSomething.substring(oldDoSomething.indexOf("{") + 1, oldDoSomething.lastIndexOf("}") - 1);
        var newScript = "function doSomething(" + args + "){" + scr + " val = id; }";
        oScript.text = newScript;
        document.getElementsByTagName('BODY').item(0).appendChild(oScript);
    }

    merge();

</script>
<input type="button" onclick="doSomething();alert(val);" value="xx" />

Une meilleure solution (ne nécessite pas de manipulation du DOM, Javascript): stackoverflow.com/a/9134757/39722

OriginalL'auteur Grunt

2

Je ne suis pas sûr de ce que vous entendez par "verrouillé" - le JavaScript est interprété par votre navigateur. Même si elle a été minimisé ou codé, vous pouvez toujours copier le source de la fonction de source de la page de script. À ce stade, vous réaffectez la fonction d'origine de l'un de votre propre conception, qui contient le code copié en plus de votre propre.
```
var id;
var myFunction = function() {
  //code copied from their source, which contains the variable needed

  //insert  your own code, such as for copying the needed value
  id = theirIDvalue;

  //return the value as originally designed by the function
  return theirValue;
};

theirObject.theirFunction = myFunction;
```
OriginalL'auteur Matt

Modifiant la fonction en travaillant avec le code source des chaînes peut être assez simple. Pour une instance spécifique, essayez:

eval(doSomething.toString().replace(/}\s*$/, ' return id; $&');

Maintenant doSomething renvoie l'ID. Je ne suis pas habituellement un fan de eval, mais c'est normal la programmation orientée aspects techniques ne s'appliquent pas ici, en raison de l'exigence de l'accès à une variable locale.

Si doSomething déjà renvoie une valeur, essayez de:

eval(doSomething.toString().replace(/}\s*$/, ' window.someID = id; $&');

À transformer cela en une fonction, nous avons besoin de faire le code évaluer dans la portée globale:

function insertCode(func, replacer, pattern) {
    var newFunc = func.toString().replace(pattern, replacer);
    with (window) {
        eval(newFunc);
    }
}
function after(func, code) {
    return insertCode(func, function (old) { code + old }, /}\s*$/ );
}
...
after(doSomething, 'return id;');

Si vous voulez réécrire les méthodes et les fonctions anonymes lié à des variables, changement insertCodeBefore:

function insertCode(funcName, replacer, pattern) {
    var newFunc = eval('window.' + funcName).toString().replace(pattern, replacer);
    eval('window.' + funcName + '=' + newFunc);
}
...
function Foo() {}
Foo.prototype.bar = function () { var secret=0x09F91102; }
...
after('doSomething', 'return id;');
after('Foo.prototype.bar', 'return secret;');

Note le premier argument des fonctions sont maintenant des chaînes de caractères. On peut définir d'autres fonctions:

function before(func, code) {
    return insertCode(func, function (old) {old + code}, /^function\s+\w+\([^)]*\)\s+{/);
}
function around(func, beforeCode, afterCode) {
    before(func, beforeCode);
    after(func, afterCode);
}

Cela ne fonctionnera pas dans le cas général, car la fonction peut exécuter un retour à tout moment plus tôt, afin de ne pas atteindre l'injection de code.

OriginalL'auteur outis

function doSomething() { ... }
var oldVersionOfFunc = doSomething;
doSomething = function() {
    var retVal = oldVersionOfFunc.apply(oldVersionOfFunc, args);
    //your added code here
    return retVal;
}

Ce qui semble provoquer une erreur (Trop de récursivité)

function doSomething(){ document.write('Test'); return 45; } 
var code = 'myDoSomething = ' + doSomething + '; function doSomething() { var id = myDoSomething(); document.write("Test 2"); return id; }';
eval(code)
doSomething();

Cela fonctionne pour moi, même si c'est laid.

OriginalL'auteur Anonymous

0

Fonctions sont de première classe, des valeurs en Javascript, ce qui signifie que vous pouvez les stocker dans des variables (et, en fait, la déclaration d'une fonction nommée est essentiellement l'attribution d'une fonction anonyme pour une variable).

Vous devriez être en mesure de faire quelque chose comme ceci:
```
function doSomething() { ... }
var oldVersionOfFunc = doSomething;
doSomething = function() {
    var retVal = oldVersionOfFunc.apply(oldVersionOfFunc, args);
    //your added code here
    return retVal;
}
```
(Mais je peux me tromper. Mon javascript est un peu rouillé. ;))

Si j'ai le droit de la question, ce qui n'aidera pas ici, puisque le problème est d'extraire la valeur d'une variable locale qui n'est référencé à l'intérieur de doSomething. Et la nouvelle version de doSomething ne peut pas faire référence à des variables à l'intérieur de l'ancien.

OriginalL'auteur Amber
0

Je ne peux pas changer la fonction doSomething... au Lieu de cela j'ai besoin de quelque sorte d'injecter un peu de lignes de code à la fin de la doSomething code

L'injection de quelques lignes à la fin de la doSomething code sonne comme la modification de la doSomething fonction, pour moi. Je pense, malheureusement, que vous êtes foutu.

(Je suis un peu brumeux sur tout cela, mais je pense que les fonctions sont comment les gens qui s'inquiètent de mettre en œuvre de telles choses se cacher de l'information dans le JavaScript, précisément parce que vous ne pouvez pas accéder à leur champ d'application à partir de l'extérieur.)

OriginalL'auteur Paul D. Waite

Vous devez vous connecter pour publier un commentaire.