Navigatieopties voor SharePoint Online

In dit artikel wordt beschreven hoe laadtijden van pagina voor SharePoint Online verbeteren met behulp van beheerde navigatie of zoekopdracht navigatie.

Opmerking:  We willen u graag zo snel mogelijk de meest recente Help-inhoud in uw eigen taal bieden. Deze pagina is automatisch vertaald en kan grammaticale fouten of onnauwkeurigheden bevatten. Wij hopen dat deze inhoud nuttig voor u is. Kunt u ons onder aan deze pagina laten weten of de informatie nuttig voor u was? Hier is het Engelstalige artikel ter referentie.

Globale navigatie en de query's die zijn vereist om de structurele navigatie te bouwen, kunnen er voor zorgen dat uw pagina's langzamer in SharePoint Online worden geladen. Dit komt omdat door elk van deze query's een ander verzoek naar SQL Server wordt verzonden. Voor elke site en subsite die u hebt, worden er meer verzoeken naar SQL Server verzonden. Dit probleem geldt ook voor de basispagina's. Dit betekent dat de globale navigatie ook wordt beïnvloed.

Sommige SharePoint-sites vereisen grote en complexe structuren. Het gebruik van gebruiksklare structurele navigatie, die inhoud per query gebruikt, kan leiden tot lange laadtijden voor pagina's omdat de site meerdere lagen heeft. Ook wordt door elk van de lagen met subsites ook nog een nieuwe query gemaakt.

Er zijn twee belangrijke gebruiksklare navigatieopties in SharePoint en een derde, aangepaste benadering met zoekopdrachten. Elke optie heeft voor- en nadelen, zoals in de volgende tabel wordt beschreven.

Structurele navigatie

Beheerde navigatie

Navigatie met zoekopdrachten

Voordelen:

  • Eenvoudig te configureren

  • Beveiligd

  • Wordt automatisch bijgewerkt wanneer sites worden toegevoegd

Voordelen:

  • Gemakkelijk te onderhouden

Voordelen:

  • Beveiligd

  • Wordt automatisch bijgewerkt wanneer sites worden toegevoegd

  • Snelle laadtijden en een navigatiestructuur in de lokale cache

Nadelen:

  • Levert soms slechte prestaties bij complexe sitestructuur

Nadelen:

  • Niet automatisch bijgewerkt overeenkomstig de sitestructuur

Nadelen:

  • Geen mogelijkheid om sites eenvoudig te rangschikken

  • Aanpassing van de basispagina vereist (technische vaardigheden vereist)

Als u een site met een groot aantal subsites hebt en structurele navigatie gebruikt, kan dit mogelijk de laadtijden voor pagina's aanzienlijk vertragen. Welke optie voor uw site het meest geschikt is, hangt af van de vereisten voor uw site en van uw technische vaardigheden. Als u vertrouwd bent met het gebruik van een aangepaste basispagina en er binnen uw organisatie capaciteit aanwezig is voor het bijhouden en doorvoeren van eventuele wijzigingen in de standaardbasispagina van SharePoint Online, dan biedt de optie met zoekopdrachten de beste gebruikerservaring. Als u een optie wilt die zich ergens tussen de gebruiksklare structurele navigatie en die met zoekopdrachten bevindt, dan is de beheerde navigatie een heel goede optie. Beheerde navigatie kan worden bijgehouden via configuratie, er zijn geen codeaanpassingsbestanden voor nodig en het is een aanzienlijk snellere optie dan de gebruiksklare structurele navigatie.

Een andere methode is om de bestaande site te herstructureren en het aantal vereiste navigatie-items en subsites kleiner te maken. Dit komt doordat structurele navigatie goed functioneert zolang de sitestructuur en de navigatie niet te complex is.

In dit artikel worden de verschillende manieren met elkaar vergeleken in een voorbeeldsiteverzameling. De voorbeeldsiteverzameling heeft 11 subsites en elke subsite heeft minimaal vier extra subsites.

Tabblad Start in PowerPoint, groep Opmaak

Het gebruik van structurele navigatie in SharePoint Online

Dit is de gebruiksklare navigatie die standaard wordt gebruikt en in de meeste situaties de meest ongecompliceerde en voor de hand liggende oplossing is. Tenzij er een complexe structuur van meerdere subsites of meerdere niveaus met subsites zijn, functioneert structurele navigatie goed. De belangrijkste voordelen van deze methode zijn dat deze beveiligd is en dat er automatisch updates worden uitgevoerd wanneer u nieuwe sites toevoegt. Bovendien hoeft de basispagina niet te worden aangepast. Een niet-technische gebruiker kan ook eenvoudig items toevoegen, items verbergen en de navigatie vanaf de instellingenpagina beheren.

Structurele navigatie in SharePoint Online inschakelen

Illustratie van de prestaties in een standaard SharePoint Online-oplossing met structurele navigatie en de optie om subsites weer te geven ingeschakeld. Hieronder wordt een schermafbeelding weergegeven met instellingen die u kunt vinden op de pagina Site-instellingen > Navigatie.

Tabblad Zoeken van E-mail, groep 2

De prestaties analyseren van structurele navigatie in SharePoint Online

Voor het analyseren van de prestaties van een SharePoint-pagina gebruikt u het tabblad Netwerk van de F12-hulpprogramma's voor ontwikkelaars.

Screenshot showing F12 dev tools Network tab

Klik op het tabblad Netwerk op de ASPX-pagina die wordt geladen en klik vervolgens op het tabblad Details.

Functies van InfoPath 2010 die niet beschikbaar zijn in browserformulieren

Klik op Antwoordheaders.

Screenshot of Details tab

SharePoint plaatst nuttige diagnostische informatie in de antwoordheaders. Heel handig is SPRequestDuration   , een waarde die in milliseconden aangeeft hoelang het duurde voordat een verzoek op de server was verwerkt.

Op de volgende schermafbeelding is Subsites weergeven niet ingeschakeld voor de structurele navigatie. Dit betekent dat er zich in de globale navigatie alleen de koppeling van de siteverzameling bevindt:

Screenshot showing load times as request duration

De sleutel SPRequestDuration    heeft een waarde van 245 milliseconden. Hiermee wordt aangegeven hoelang het heeft geduurd om het verzoek te retourneren. Aangezien er zich slechts één navigatie-item op de site bevindt, is dit een goede maatstaf om te beoordelen hoe SharePoint Online presteert zonder zware navigatie. In de volgende schermafbeelding ziet u hoe toevoegingen aan de subsites deze sleutel beïnvloeden.

Screenshot showing a request duration of 2502 ms

Door de subsites toe te voegen, is de tijd die het duurt om het verzoek te retourneren aanzienlijk toegenomen.

De voordelen van het gebruik van de reguliere gestructureerde navigatie is dat u eenvoudig de volgorde kunt rangschikken, sites kunt verbergen, pagina's kunt toevoegen, de resultaten beveiligd zijn en u niet afwijkt van de ondersteunde basispagina's die in SharePoint Online worden gebruikt. Als u uw site zorgvuldig structureert en het aantal subsites in uw siteverzameling zo klein mogelijk houdt, dan levert structurele navigatie goede prestaties.

Het gebruik van beheerde navigatie en beheerde metagegevens in SharePoint Online

Beheerde navigatie is een andere gebruiksklare optie die u kunt gebruiken om dezelfde soort functionaliteit als de structurele navigatie opnieuw te maken.

Het voordeel van het gebruik van beheerde metagegevens is dat hiermee veel sneller de gegevens kunnen worden opgehaald dan wanneer er gebruikt wordt gemaakt van inhoud per query om de sitenavigatie te bouwen. Hoewel dit veel sneller gaat, bestaat er geen mogelijkheid om de resultaten te beveiligen. Als een gebruiker geen toegang tot een bepaalde site heeft, wordt de koppeling nog steeds weergegeven, maar leidt deze tot een foutbericht.

Het implementeren van beheerde navigatie en de resultaten   

Er zijn verschillende artikelen op TechNet over de details van beheerde navigatie, bijvoorbeeld, Zie overzicht van beheerde navigatie in SharePoint Server 2013.

Als u beheerde navigatie wilt implementeren, moet u beschikken over machtigingen op het niveau van een beheerder van het termenarchief. Door termen met URL's in te stellen die overeenkomen met de structuur van een siteverzameling, kan beheerde navigatie worden gebruikt om structurele navigatie te vervangen. Bijvoorbeeld:

Screenshot of Subsite1 example

Het volgende voorbeeld illustreert de prestaties van de complexe navigatie met behulp van beheerde navigatie.

Screenshot of SPRequestDuration example

Met beheerde navigatie verbeteren zich de prestaties consistent vergeleken met de inhoud per query-aanpak van structurele navigatie.

Het gebruik van scripts met zoekopdrachten aan de clientzijde

Door een zoekopdracht te gebruiken kunt u gebruikmaken van de indexen die op de achtergrond worden opgebouwd met behulp van een continue crawl. Dat betekent dat er geen zware inhoudsquery's zijn. De zoekresultaten komen uit de zoekindex en de resultaten zijn beveiligd. Dit is sneller dan wanneer u gewone inhoudsquery's gebruikt. Als u zoekopdrachten gebruikt voor structurele navigatie, met name als u een complexe sitestructuur hebt, worden de laadtijden voor pagina's aanzienlijk korter. Het belangrijkste voordeel hiervan vergeleken met beheerde navigatie is dat u profiteert van beveiligingsbeperkingen.

Met deze methode wordt een aangepaste basispagina gemaakt en wordt de gebruiksklare navigatiecode vervangen door aangepaste HTML-code. Volg deze procedure om de navigatiecode in het bestand seattle.html te vervangen.

In dit voorbeeld gaat u het bestand seattle.html openen en vervangt u het volledige element id=”DeltaTopNavigation” met de aangepaste HTML-code.

Voorbeeld: Voor het vervangen van de code out-van-het-box-navigatie in een basispagina

  1. Ga naar de pagina Site-instellingen.

  2. Open de galerie met basispagina's door op Basispagina's te klikken.

  3. Van hieruit kunt u door de bibliotheek navigeren en het bestand seattle.master downloaden.

  4. Bewerk de code met een teksteditor en verwijder het codeblok dat in de volgende schermafbeelding wordt weergegeven.

    Uw bestanden opslaan in de cloud
  5. Verwijder de code tussen de labels <SharePoint:AjaxDelta id=”DeltaTopNavigation”> en <\SharePoint:AjaxDelta> en vervang deze door het volgende codefragment:

    <div id="loading">
      <!--Replace with path to loading image.-->
      <div style="background-image: url(''); height: 22px; width: 22px; ">
      </div>
    </div>
    <!-- Main Content-->
    <div id="navContainer" style="display:none">
        <div data-bind="foreach: hierarchy" class="noindex ms-core-listMenu-horizontalBox">
            <a class="dynamic menu-item ms-core-listMenu-item ms-displayInline ms-navedit-linkNode" data-bind="attr: { href: item.Url, title: item.Title }">
                <span class="menu-item-text" data-bind="text: item.Title">
                </span>
            </a>
            <ul id="menu" data-bind="foreach: $data.children" style="padding-left:20px">
                <li class="static dynamic-children level1">
                    <a class="static dynamic-children menu-item ms-core-listMenu-item ms-displayInline ms-navedit-linkNode" data-bind="attr: { href: item.Url, title: item.Title }">
                   
                     <!-- ko if: children.length > 0-->
                        <span aria-haspopup="true" class="additional-background ms-navedit-flyoutArrow dynamic-children">
                            <span class="menu-item-text" data-bind="text: item.Title">
                            </span>
                        </span>
                    <!-- /ko -->
                    <!-- ko if: children.length == 0-->   
                        <span aria-haspopup="true" class="ms-navedit-flyoutArrow dynamic-children">
                            <span class="menu-item-text" data-bind="text: item.Title">
                            </span>
                        </span>
                    <!-- /ko -->   
                    </a>
                   
                    <!-- ko if: children.length > 0-->                                                       
                    <ul id="menu"  data-bind="foreach: children;" class="dynamic  level2" >
                        <li class="dynamic level2">
                            <a class="dynamic menu-item ms-core-listMenu-item ms-displayInline  ms-navedit-linkNode" data-bind="attr: { href: item.Url, title: item.Title }">
             
              <!-- ko if: children.length > 0-->
              <span aria-haspopup="true" class="additional-background ms-navedit-flyoutArrow dynamic-children">
               <span class="menu-item-text" data-bind="text: item.Title">
               </span>
              </span>
               <!-- /ko -->
              <!-- ko if: children.length == 0-->
              <span aria-haspopup="true" class="ms-navedit-flyoutArrow dynamic-children">
               <span class="menu-item-text" data-bind="text: item.Title">
               </span>
              </span>                 
              <!-- /ko -->   
                            </a>
              <!-- ko if: children.length > 0-->
             <ul id="menu" data-bind="foreach: children;" class="dynamic level3" >
              <li class="dynamic level3">
               <a class="dynamic menu-item ms-core-listMenu-item ms-displayInline ms-navedit-linkNode" data-bind="attr: { href: item.Url, title: item.Title }">
                <span class="menu-item-text" data-bind="text: item.Title">
                </span>
               </a>
              </li>
             </ul>
               <!-- /ko -->
                        </li>
                    </ul>
                    <!-- /ko -->
                </li>
            </ul>
        </div>
    </div>
  6. De URL in het laden vervangen afbeelding ankercode aan het begin, met een koppeling naar een afbeelding laden in uw siteverzameling. Nadat u de wijzigingen hebt aangebracht, naam van het bestand en uploadt dit naar de galerie met basispagina's. Hierdoor wordt een nieuw .master-bestand gegenereerd.

  7. Deze HTML is de basisopmaak waarin de zoekresultaten worden ingevuld die de JavaScript-code retourneert. U moet de volgende code bewerken om de waarde voor de var root = “site collection URL te wijzigen zoals in het volgende codefragment wordt aangetoond:

    var root = “https://spperformance.sharepoint.com/sites/NavigationBySearch”;

    Het volledige JavaScript-bestand is als volgt:

    //Models and Namespaces
    var SPOCustom = SPOCustom || {};
    SPOCustom.Models = SPOCustom.Models || {}
    SPOCustom.Models.NavigationNode = function () {
    
        this.Url = ko.observable("");
        this.Title = ko.observable("");
        this.Parent = ko.observable("");
    
    };
    
    var root = "https://spperformance.sharepoint.com/sites/NavigationBySearch";
    var baseUrl = root + "/_api/search/query?querytext=";
    var query = baseUrl + "'contentClass=\"STS_Web\"+path:" + root + "'&trimduplicates=false&rowlimit=300";
    
    var baseRequest = {
        url: "",
        type: ""
    };
    
    
    //Parses a local object from JSON search result.
    function getNavigationFromDto(dto) {
        var item = new SPOCustom.Models.NavigationNode();
        if (dto != undefined) {
    
            var webTemplate = getSearchResultsValue(dto.Cells.results, 'WebTemplate');
    
            if (webTemplate != "APP") {
                item.Title(getSearchResultsValue(dto.Cells.results, 'Title')); //Key = Title
                item.Url(getSearchResultsValue(dto.Cells.results, 'Path')); //Key = Path
                item.Parent(getSearchResultsValue(dto.Cells.results, 'ParentLink')); //Key = ParentLink
            }
    
        }
        return item;
    }
    
    function getSearchResultsValue(results, key) {
    
        for (i = 0; i < results.length; i++) {
            if (results[i].Key == key) {
                return results[i].Value;
            }
        }
        return null;
    }
    
    //Parse a local object from the serialized cache.
    function getNavigationFromCache(dto) {
        var item = new SPOCustom.Models.NavigationNode();
    
        if (dto != undefined) {
    
            item.Title(dto.Title);
            item.Url(dto.Url);
            item.Parent(dto.Parent);
        }
    
        return item;
    }
    
    /* create a new OData request for JSON response */
    function getRequest(endpoint) {
        var request = baseRequest;
        request.type = "GET";
        request.url = endpoint;
        request.headers = { ACCEPT: "application/json;odata=verbose" };
        return request;
    };
    
    /* Navigation Module*/
    function NavigationViewModel() {
        "use strict";
        var self = this;
        self.nodes = ko.observableArray([]);
        self.hierarchy = ko.observableArray([]);;
        self.loadNavigatioNodes = function () {
            //Check local storage for cached navigation datasource.
            var fromStorage = localStorage["nodesCache"];
            if (false) {
                var cachedNodes = JSON.parse(localStorage["nodesCache"]);
    
                if (cachedNodes && timeStamp) {
                    //Check for cache expiration. Currently set to 3 hrs.
                    var now = new Date();
                    var diff = now.getTime() - timeStamp;
                    if (Math.round(diff / (1000 * 60 * 60)) < 3) {
    
                        //return from cache.
                        var cacheResults = [];
                        $.each(cachedNodes, function (i, item) {
                            var nodeitem = getNavigationFromCache(item, true);
                            cacheResults.push(nodeitem);
                        });
    
                        self.buildHierarchy(cacheResults);
                        self.toggleView();
                        addEventsToElements();
                        return;
                    }
                }
            }
            //No cache hit, REST call required.
            self.queryRemoteInterface();
        };
    
        //Executes a REST call and builds the navigation hierarchy.
        self.queryRemoteInterface = function () {
            var oDataRequest = getRequest(query);
            $.ajax(oDataRequest).done(function (data) {
                var results = [];
                $.each(data.d.query.PrimaryQueryResult.RelevantResults.Table.Rows.results, function (i, item) {
    
                    if (i == 0) {
                        //Add root element.
                        var rootItem = new SPOCustom.Models.NavigationNode();
                        rootItem.Title("Root");
                        rootItem.Url(root);
                        rootItem.Parent(null);
                        results.push(rootItem);
                    }
                    var navItem = getNavigationFromDto(item);
                    results.push(navItem);
                });
                //Add to local cache
                localStorage["nodesCache"] = ko.toJSON(results);
    
                localStorage["nodesCachedAt"] = new Date().getTime();
                self.nodes(results);
                if (self.nodes().length > 0) {
                    var unsortedArray = self.nodes();
                    var sortedArray = unsortedArray.sort(self.sortObjectsInArray);
    
                    self.buildHierarchy(sortedArray);
                    self.toggleView();
                    addEventsToElements();
                }
            }).fail(function () {
                //Handle error here!!
                $("#loading").hide();
                $("#error").show();
            });
        };
        self.toggleView = function () {
            var navContainer = document.getElementById("navContainer");
            ko.applyBindings(self, navContainer);
            $("#loading").hide();
            $("#navContainer").show();
    
        };
        //Uses linq.js to build the navigation tree.
        self.buildHierarchy = function (enumerable) {
            self.hierarchy(Enumerable.From(enumerable).ByHierarchy(function (d) {
                return d.Parent() == null;
            }, function (parent, child) {
                if (parent.Url() == null || child.Parent() == null)
                    return false;
                return parent.Url().toUpperCase() == child.Parent().toUpperCase();
            }).ToArray());
    
            self.sortChildren(self.hierarchy()[0]);
        };
    
    
        self.sortChildren = function (parent) {
    
            // sjip processing if no children
            if (!parent || !parent.children || parent.children.length === 0) {
                return;
            }
    
            parent.children = parent.children.sort(self.sortObjectsInArray2);
    
            for (var i = 0; i < parent.children.length; i++) {
                var elem = parent.children[i];
    
                if (elem.children && elem.children.length > 0) {
                    self.sortChildren(elem);
                }
            }
        };
    
        // ByHierarchy method breaks the sorting in chrome and firefix 
        // we need to resort  as ascending
        self.sortObjectsInArray2 = function (a, b) {
            if (a.item.Title() > b.item.Title())
                return 1;
            if (a.item.Title() < b.item.Title())
                return -1;
            return 0;
        };
    
    
        self.sortObjectsInArray = function (a, b) {
            if (a.Title() > b.Title())
                return -1;
            if (a.Title() < b.Title())
                return 1;
            return 0;
        }
    }
    
    //Loads the navigation on load and binds the event handlers for mouse interaction.
    function InitCustomNav() {
        var viewModel = new NavigationViewModel();
        viewModel.loadNavigatioNodes();
    }
    
    function addEventsToElements() {
        //events.
    

    $("li.level1") .mouseover(function () {
              var positie = $(this).position();
              $(this).find("ul.level2").css ({breedte: 100, links: position.left + 10 belangrijkste: 50});

    })
       .MouseOut(Function () {
         $(this).find("ul.level2").css ({links:-99999, bovenste: 0});

        });

         $("li.level2") .mouseover(function () {
              var positie = $(this).position();
              console.log(JSON.stringify(Position));
              $(this).find("ul.level3").css ({breedte: 100, links: position.left + 95, de beste: position.top});        

    })
       .MouseOut(Function () {
         $(this).find("ul.level3").css ({links:-99999, bovenste: 0});
        });

    } _spBodyOnLoadFunctionNames.push("InitCustomNav");

    Als u wilt samenvatten van de code die hierboven wordt weergegeven in de functie van de $(document).ready jQuery er is een viewModel -object dat is gemaakt en vervolgens de loadNavigationNodes() , functie voor dat object wordt genoemd. Deze functie ofwel wordt geladen de eerder-en-klare navigatiehiërarchie die zijn opgeslagen in de HTML5 lokale opslag van de clientbrowser of deze de functie queryRemoteInterface()belt.

    QueryRemoteInterface() genereert een verzoek om het gebruik van de functie getRequest() met de queryparameter die eerder in het script gedefinieerd en retourneert vervolgens gegevens van de server. Deze gegevens is in principe een matrix van alle sites in de siteverzameling die wordt weergegeven als gegevens doorverbinden objecten met verschillende eigenschappen. Deze gegevens wordt vervolgens geparseerd in de eerder gedefinieerde SPO.Models.NavigationNode objecten waarmee Knockout.js waarneembare eigenschappen maken door gegevens binden van de waarden in de HTML-code die we eerder hebt gedefinieerd. De objecten zijn en zet vervolgens in een matrix van resultaten. Deze matrix is verdeeld in JSON met uitnemen en opgeslagen in de lokale browser opslagruimte voor verbeterde prestaties op toekomstige pagina wordt geladen.

  8. Vervolgens de resultaten zijn toegewezen aan de matrix self.nodes en een hiërarchie afmelden bij het gebruik van de uitvoer toewijzen aan een matrix self.heirarchylinq.js objecten is gebaseerd. Deze matrix is het object dat is gekoppeld aan de HTML-code. Dit is de functie toggleView() doet door het self object doorgeven aan de functie ko.applyBinding() . Hierdoor wordt vervolgens de hiërarchie matrix die zijn gekoppeld aan de volgende HTML-code:

    <div data-bind=”foreach: hierarchy” class=”noindex ms-core-listMenu-horizontalBox”>

    Ten slotte worden de gebeurtenishandlers voor mouseenter en mouseexit toegevoegd aan de navigatiebalk op het hoogste niveau worden afgehandeld de vervolgkeuzelijsten subsite die wordt uitgevoerd in de functie addEventsToElements() .

    De resultaten van de navigatie zijn te zien in de schermafbeelding hieronder:

    Screenshot of navigation results

    Ons voorbeeld met complexe navigatie laat zien dat de tijd voor het laden van een nieuwe pagina zonder deze in de lokale cache op de server op te slaan, is teruggebracht van de structurele navigatie die als maatstaf diende, om tot eenzelfde resultaat te komen als bij beheerde navigatie.

    Reeks blauwe tegels die de belangrijkste pijlers van de SharePoint 2013-functies belichten; dit zijn Delen, Indelen, Ontdekken, Maken en Beheren.

    Een belangrijk voordeel van deze methode is dat, doordat lokale HTML5-opslag wordt gebruikt, de navigatie voor de gebruiker lokaal wordt opgeslagen wanneer deze de pagina een volgende keer laadt.

We zien belangrijke prestatieverbeteringen bij structurele navigatie door gebruik te maken van de zoek-API. Er is echter enige technische vaardigheid vereist om deze functionaliteit uit te voeren en aan te passen. In de implementatie uit het voorbeeld worden de sites op dezelfde manier gerangschikt als bij de gebruiksklare structurele navigatie, de alfabetische volgorde. Als u van deze volgorde wilt afwijken, worden ontwikkeling en onderhoud complexer. Bij deze methode moet u ook van de ondersteunde basispagina's afwijken. Als de aangepaste basispagina niet wordt bijgehouden, mist uw site de updates en verbeteringen die Microsoft voor de basispagina's beschikbaar maakt.

De bovenstaande code heeft de volgende afhankelijkheden:

De huidige versie van LinqJS geen de ByHierarchy methode gebruikt in de bovenstaande code bevat en de navigatie-code worden afgebroken. U lost dit probleem, voegt u de volgende methode naar het bestand Linq.js voor de regel ' Flatten:, functie () '.

ByHierarchy: function(firstLevel, connectBy, orderBy, ascending, parent) {
     ascending = ascending == undefined ? true : ascending;
     var orderMethod = ascending == true ? 'OrderBy' : 'OrderByDescending';
     var source = this;
     firstLevel = Utils.CreateLambda(firstLevel);
     connectBy = Utils.CreateLambda(connectBy);
     orderBy = Utils.CreateLambda(orderBy);
    
     //Initiate or increase level
     var level = parent === undefined ? 1 : parent.level + 1;

    return new Enumerable(function() {
         var enumerator;
         var index = 0;

        var createLevel = function() {
                 var obj = {
                     item: enumerator.Current(),
                     level : level
                 };
                 obj.children = Enumerable.From(source).ByHierarchy(firstLevel, connectBy, orderBy, ascending, obj);
                 if (orderBy !== undefined) {
                     obj.children = obj.children[orderMethod](function(d) {
                         return orderBy(d.item); //unwrap the actual item for sort to work
                     });
                 }
                 obj.children = obj.children.ToArray();
                 Enumerable.From(obj.children).ForEach(function(child) {
                     child.getParent = function() {
                         return obj;
                     };
                 });
                 return obj;
             };

        return new IEnumerator(

        function() {
             enumerator = source.GetEnumerator();
         }, function() {
             while (enumerator.MoveNext()) {
                 var returnArr;
                 if (!parent) {
                     if (firstLevel(enumerator.Current(), index++)) {
                         return this.Yield(createLevel());
                     }

                } else {
                     if (connectBy(parent.item, enumerator.Current(), index++)) {
                         return this.Yield(createLevel());
                     }
                 }
             }
             return false;
         }, function() {
             Utils.Dispose(enumerator);
         })
     });
 },
Uw Office-vaardigheden uitbreiden
Training verkennen
Als eerste nieuwe functies krijgen
Deelnemen aan Office Insiders

Was deze informatie nuttig?

Bedankt voor uw feedback.

Hartelijk dank voor uw feedback! Het lijkt ons een goed idee om u in contact te brengen met een van onze Office-ondersteuningsagents.

×