So löschen Sie den Inhalt eines ObservableArray, das von früheren Besuchen einer Ansicht ausgefüllt wurde

Question

Ich habe eine Single Page-Anwendung, die Knockout für die Datenbindung verwendet. Die Ansicht "CAApproval.html" in meiner Einzelseitenanwendung hat im ViewModel-Code ein beobachtbares Array namens "AllCertificates". Es füllt auf der Seite gut aus. Wenn Sie von der Ansicht weg navigieren, indem Sie auf einen Link im Abschnitt navigation.html der Seite klicken und dann zur CAApproval-Seite zurückkehren, befinden sich die Werte des vorherigen Besuchs immer noch im ObservableArray von AllCertificates und werden daher in der CAApproval-Ansicht angezeigt.

Ich muss den Inhalt des observablearray AllCertificates jedes Mal löschen, wenn ein Benutzer auf die CAApproval-Seite zurückkehrt, die dieses observablearray verwendet. Wenn ein Benutzer die Seite verlässt und zurückkommt, ist der Inhalt des observablearray null und daher nein Daten werden auf dem Bildschirm angezeigt. Hier sind die Highlights meines Viewmodels Code-

define(['services/logger', 'durandal/system', 'durandal/plugins/router', 'services/CertificateDataService','controls/Lucas'], 

     function(logger, system, router, CertificateDataService) { 
     var allCertificates = ko.observableArray([]); 

    var activate = function() { 
      // go get local data, if we have it 
      return SelectAllCerts(),SelectMyCerts(), GetCertificateDetails(), GetDDABankNums(); 
      }; 
     var vm = { 
      activate: activate, 
      allCertificates: allCertificates, 
    SelectAllCerts: SelectAllCerts 

     }); 

    return vm; 

    function SelectAllCerts() { 
       return CertificateDataService.getallCertificates(allCertificates); 
     } 
    }); 

Wie lösche ich den Inhalt eines observablearray jedesmal, wenn die Seite ein Benutzer auf dieser Seite kommt (nicht, wenn innerhalb der Seite zu navigieren selbst, um nur den observablearray, wenn die Benutzer kommt von einer separaten Seite)?

Answer 1

Nur stellen Sie sie gleich nichts (allCertificates([])) in Ihrer activate-Funktion, die jedes Mal Ihrer Ansicht Modell Lasten genannt wird -

function(logger, system, router, CertificateDataService) { 
    var allCertificates = ko.observableArray(); 

var activate = function() { 
    allCertificates([]); 
    // go get local data, if we have it 
    return SelectAllCerts(),SelectMyCerts(), GetCertificateDetails(), GetDDABankNums(); 
}; 

var vm = { 
    activate: activate, 
    allCertificates: allCertificates, 
    SelectAllCerts: SelectAllCerts 
}); 

Answer 2

Auch Knockout observableArray interessante Methoden hat. Rufen Sie removeAll auf, um alle Elemente zu löschen.
Sehen Sie sich die offizielle Website observable array manual an.

self.mycertificates = ko.observableArray(['C1', 'C2']); 
self.mycertificates.removeAll(); 

Answer 3

Für Jeremy T (nicht genug Platz in Kommentar).
Der erste Grund und absolut genug für mich ist die Existenz der öffentlich zugänglichen API für den gewünschten Zweck.

Aber um die Leistung zu schätzen, können Sie die Quelle überprüfen. "ObservableArray" ist auch "beobachtbar" mit zusätzlichen Funktionen in Objekt injiziert.

So Initialisierung wie folgt aussieht:

ko.observableArray = function (initialValues) { 
    initialValues = initialValues || []; 

    if (typeof initialValues != 'object' || !('length' in initialValues)) 
     throw new Error("The argument passed when initializing an observable array must be an array, or null, or undefined."); 

    var result = ko.observable(initialValues); 
    ko.utils.extend(result, ko.observableArray['fn']); 
    return result.extend({'trackArrayChanges':true}); 
}; 

ko.observable = function (initialValue) { 
    var _latestValue = initialValue; 

    function observable() { 
     if (arguments.length > 0) { 
      // Write 

      // Ignore writes if the value hasn't changed 
      if (!observable['equalityComparer'] || !observable['equalityComparer'](_latestValue, arguments[0])) { 
       observable.valueWillMutate(); 
       _latestValue = arguments[0]; 
       if (DEBUG) observable._latestValue = _latestValue; 
       observable.valueHasMutated(); 
      } 
      return this; // Permits chained assignments 
     } 
     else { 
      // Read 
      ko.dependencyDetection.registerDependency(observable); // The caller only needs to be notified of changes if they did a "read" operation 
      return _latestValue; 
     } 
    } 
    if (DEBUG) observable._latestValue = _latestValue; 
    ko.subscribable.call(observable); 
    observable.peek = function() { return _latestValue }; 
    observable.valueHasMutated = function() { observable["notifySubscribers"](_latestValue); } 
    observable.valueWillMutate = function() { observable["notifySubscribers"](_latestValue, "beforeChange"); } 
    ko.utils.extend(observable, ko.observable['fn']); 

    ko.exportProperty(observable, 'peek', observable.peek); 
    ko.exportProperty(observable, "valueHasMutated", observable.valueHasMutated); 
    ko.exportProperty(observable, "valueWillMutate", observable.valueWillMutate); 

    return observable; 
} 

Und alle Elemente entfernen sieht wie folgt aus:

'removeAll': function (arrayOfValues) { 
     // If you passed zero args, we remove everything 
     if (arrayOfValues === undefined) { 
      var underlyingArray = this.peek(); 
      var allValues = underlyingArray.slice(0); 
      this.valueWillMutate(); 
      underlyingArray.splice(0, underlyingArray.length); 
      this.valueHasMutated(); 
      return allValues; 
     } 
     // If you passed an arg, we interpret it as an array of entries to remove 
     if (!arrayOfValues) 
      return []; 
     return this['remove'](function (value) { 
      return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0; 
     }); 
    }