entfernen angehängt Skript javascript

wie kann ich Sie entfernen mein Skript angehängt, weil es bewirkt, dass einige Probleme in meiner app.

Dies ist mein code, um mein Skript

var nowDate = new Date().getTime();
var url = val.redirect_uri + "notify.js?nocache=" + nowDate + "&callback=dummy";
var script = document.createElement('script');
script.src = url;
document.body.appendChild(script);

Dann habe ich eine auto-load-Funktion, die Ursachen zu erstellen ein anderes element script.

Ich loswerden wollen von dem vorherigen element, das Hinzugefügt wurde, bevor ein weiteres element hinzu.

Einfach Einstellung script.src=''; oder entfernen von Skript-Knoten: script.removeNode(true);.
bedeutet das entfernen alle meine Skripte? Oder nur das Skript angehängt?
Naja, Nicht das hinzufügen des Skripts wieder klingt wie eine bessere Idee, dann entfernen Sie es...
Warum?! So könnte man es entfernen, rechts danach...???
Ich benutze diese für einen JSONP-Aufruf hinzufügen muss-Skript wegen der Rückrufe.

InformationsquelleAutor Robin Carlo Catacutan | 2012-02-22

3

Habe ich einige weitere tests, und vor bekommst du eine korrekte Antwort zu deiner Frage (hoffe es ist eine) Sie können versuchen, diese:
```
<button onclick="foo()">ShowHTML</button>
<script>
(function foo(){
    var b=function moo(){
        var c=document.getElementsByTagName('script');
        alert(document.body.innerHTML);
        c[0].parentElement.removeChild(c[0]);
        alert(document.body.innerHTML);
    }
    var a=setTimeout(b,1000);
    b=null;
})();
foo=null;
</script>
```
Dies ist nur ein test-code, aber es enthält auch eine Idee, wie Sie möglich das problem lösen könnte. Es entfernt <sript> aus dem DOM, und die Letzte Zeile zerstört alle Funktionen des Skripts.

(Der code hat auch ein kleines detail, was zeigt, dass setTimeout tun eval(), egal wie man es begründet...?)

Carlo Catacutan vielen Dank für die Annahme. Ich nehme an, Sie haben bemerkt, dass, wenn Sie die Definition globaler Variablen in closures sind, bleiben Sie trotz der Annullierung closured Funktion. Und setIntervals für immer...

InformationsquelleAutor Teemu
8

Grundsätzlich können Sie entfernen von Skript-tag mit Hilfe einer Funktion wie diese:
```
function removeJS(filename){
 var tags = document.getElementsByTagName('script');
 for (var i = tags.length; i >= 0; i--){ //search backwards within nodelist for matching elements to remove
  if (tags[i] && tags[i].getAttribute('src') != null && tags[i].getAttribute('src').indexOf(filename) != -1)
   tags[i].parentNode.removeChild(tags[i]); //remove element by calling parentNode.removeChild()
 }
}
```
Hinweis, es verwenden filename-parameter zu identifizieren, die Ziel-Skript zu entfernen. Bitte beachten Sie auch, dass die target-script könnte schon ausgeführt an der Zeit, die Sie versuchen, es zu entfernen.

Das Skript ist noch in der Erinnerung. Noch immer funktionieren.
Wie ich bereits in meinem Beitrag - dies ist das erwartete Verhalten in dem Fall, wenn Sie versuchen, um es zu entfernen, nachdem es ausgeführt wurde. Sie müssen aufhören, es durch die Verwendung von javascript und entfernen Sie dann.
Ja, du hast Recht. Das, was ich gesucht habe, so weit ist, dass es die genannte Speicherlecks.

InformationsquelleAutor Pavel Podlipensky
5

Ich würde einfach schauen, um zu sehen, wenn Sie ' ve bereits Hinzugefügt, das Skript. Hinzufügen und entfernen fügt eine unnötige Komplexität. So etwas wie dies funktionieren sollte:
```
var scriptAdded = false;

if(scriptAdded == false) {
    document.body.appendChild(script);
    scriptAdded = true;
}
```
+1. Für Sinn macht.
Wie der OP sagt code aktualisiert jede minute, ich glaube die variable scriptAdded wird falsch ankommen.
Vielleicht ist das Skript Hinzugefügt von OP ist ein JSONP-Aufruf?
das Teil verwirrt mich ein wenig, als gut. Ich nahm an, es war eine Art AJAX-refresh seit der OP auch angegeben, dass Sie immer 30 Instanzen des Skripts ergänzt (eine pro refresh). Es sei denn, Sie poste mehr code, ich bleibe bei meiner ursprünglichen Antwort 🙂
Ja, es ist ein JSONP-Aufruf. Ich denke, dass dies nicht mein problem lösen.

InformationsquelleAutor James Hill

Was Sie tun können, ist, das Skript sofort zu entfernen, nachdem es geladen wurde:

var nowDate = new Date().getTime();
var url = val.redirect_uri + "notify.js?nocache=" + nowDate + "&callback=dummy";
var script = document.createElement('script');
script.src = url;
script.onload = function( evt ) {
    document.body.removeChild ( this );
}
document.body.appendChild(script);

Ja, ich denke, es ist eine bessere Idee to fügen Sie den Skript in den header (da wo die anderen scripts befinden) als der Körper.

InformationsquelleAutor heinob

1

Bei JSONP und Ihre Nutzung von jQuery, warum nicht nehmen Sie den vollen Vorteil von jQuery JSONP-laden-Einrichtungen, die die post-clean-up für Sie? Laden von JSONP-Ressource wie dieses, nicht verlassen eine Spur in den DOM:
```
$.ajax({ url: 'http://example.com/', dataType: 'jsonp' })
```
Den <script> tag zum laden wird sofort entfernt, sobald es geladen ist. Wenn der laden ein Erfolg wird. Auf der anderen Seite, fehlgeschlagene Anfragen bekommen nicht automatisch gelöscht, und Sie haben zu tun, dass Sie sich mit so etwas wie dieses:
```
$('head script[src*="callback="]').remove();
```
genannt zur richtigen Zeit. Es entfernt alle ausstehenden JSONP <script> tags.

Danke. Aber ich habe zu halten mein classic script, da habe ich zu viele von diesen und die Frist ist in der Nähe. Naja ich werde setzen Sie dieses auf meinen Geist für die Zukunft braucht. Vielen Dank für die Angabe dieser für mich wirklich hilfreich.
Verstanden. Denke immer noch, können Sie die Zeile entfernen, um loszuwerden, Ihre bisherigen <script> wenn du als Ziel hast, es zu suchen "notify.js" in der src so: $('head script[src*="notify.js"]').remove();
Es bekam. tnx Männer!

InformationsquelleAutor Petr Vostrel

Gut,

Ich habe das gleiche Bedürfnis, weil der ajax-Aufrufe ausgelöst durch Ereignis.
Einige anrufen die frühesten können später zurückkehren, dann überschreiben Dokument
bevölkert von den letzten Aufruf.

removeChild(scriptEl)
funktioniert nicht. Ändern src - Attribut nicht funktioniert entweder.

Wenn jsonp ist Ihre einzige Ausweg
und wenn Sie die Kontrolle über die server-Antwort,
Sie können lassen Sie diese angehängt sind, zu unterscheiden Rückkehr auf den Rückruf.

Nur pass ein timestamp parameter, dann überprüfen Sie es auf die callback -

//callback
function dummy(res, ts) {
 if(YAHOO.util.Selector.query('script[id='scriptIdPrefix+ts+']').length>0) {
     do your job
 } else {
     do nothing
 }
}

//add script
var scriptIdPrefix='myScriptId';
function ajaxCall() {
    var timestamp = new Date().getTime();
    var scriptId = scriptIdPrefix+timestamp;
    //remove the previous script el
    s=YAHOO.util.Selector.query('script[id^='+scriptIdPrefix+']');
    if(s.length>0) {
        document.body.removeChild(s[0]);
    }
    var script = document.createElement('SCRIPT');
    script.id = scriptId;
    script.type = 'text/javascript';
    script.src = 'http://server/notify.js&callback=dummy&ts='+timestamp;
    document.body.appendChild(script);

}

Montieren Sie das Ergebnis der server notify.js entsprechend:

dummy([{"datax":"x","datay":"y"}], 1369838562792)

Auf diese Weise müssen Sie nur ein script-element wie das mit
parametrische id

<script id="myScriptId1369838562792" type="text/javascript"  
src="http://server/notify.js?callback=dummy&ts=1369838562792"></script>

InformationsquelleAutor user2432789

0

einfachste Weg.

Dokument.Skripts.s16483498357511596685.entfernen();

InformationsquelleAutor nonuser

-2

var flag1=0,flag2=0;
$(window).resize(function(){
    if ($(window).width() < 480){
        flag1++;
        console.log(flag1);
        flag2=0;  
    }
    else 
        if($(window).width() > 480){
            flag2++;
            console.log(flag2);
            flag1=0;
        }   
    if(flag1==1){
        $("body").append("<script class='abc' src='custom.js'/>");
    }
    else
        if(flag2==1){
            $(".abc").remove();
        }
});

InformationsquelleAutor akshay anand

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.