Opcje nawigacji usługi SharePoint Online

Ważne : Ten artykuł został przetłumaczony maszynowo, zobacz zastrzeżenie. Angielskojęzyczną wersję tego artykułu można znaleźć tutaj .

W tym artykule opisano sposoby poprawy czasem ładowania strony usługi SharePoint Online za pomocą nawigacji strukturalnej i nawigację sterowanych wyszukiwaniem.

Nawigacja globalna i kwerend wymagane do utworzenia nawigacji strukturalnej, można wprowadzać stron ładowanie więcej wolniej w usłudze SharePoint Online. Jest to spowodowane każdej z tych kwerend wysyła kolejnego żądania do programu SQL server. Dla każdej witryny lub podwitryny, które posiadasz więcej żądania są kierowane do programu SQL server. Ten problem dotyczy również stron wzorcowych. Oznacza to, że dotyczy to również nawigacji globalnej.

Niektóre witryny programu SharePoint wymaga dużych i złożonych struktur. Za pomocą nawigacji strukturalnej w nowym polu, która używa zawartości przez zapytanie, może spowodować czasem ładowania strony działa wolno z powodu wielu warstw witryny. Tworzy każdej warstwy podwitryn również innej kwerendy.

Dostępne są dwie opcje nawigacji w nowym polu głównego programu SharePoint, a także innej, podejście niestandardowych, sterowanych wyszukiwaniem. Każda opcja ma wad i zalet opisane w poniższej tabeli.

Nawigacji strukturalnej

Nawigacji zarządzanej

Nawigacja sterowanych wyszukiwaniem

Zalety:

  • Łatwe do skonfigurowania

  • Przycięte zabezpieczeń

  • Automatyczne aktualizowanie podczas dodawania witryn

Zalety:

  • Łatwa w obsłudze

Zalety:

  • Przycięte zabezpieczeń

  • Automatyczne aktualizowanie podczas dodawania witryn

  • Szybkie ładowanie struktury nawigacji czas i lokalnie

Zalety:

  • Można wykonywać źle ze strukturą złożonej witryny

Zalety:

  • Automatycznie zaktualizowany w celu uwzględnienia struktura witryny

Zalety:

  • Nie możliwości łatwo kolejności witryn

  • Wymaga dostosowywania strony wzorcowej (wymagane umiejętności technicznych)

Jeśli masz witryny z dużą ilością podwitryn i korzystasz z nawigacji strukturalnej, może być spowalniając strony znacznie ładuje w dół. Najbardziej odpowiednią opcję w witrynie zależy od wymagań witryny i funkcję technicznych. Jeśli uważasz, przy użyciu niestandardowej strony wzorcowej i mają możliwość w organizacji, aby zachować zmiany, które mogą wystąpić w domyślnej strony wzorcowej dla usługi SharePoint Online, opcja sterowanych wyszukiwaniem da najlepszego środowiska pracy użytkownika. Jeśli chcesz prosty ziemi drugie pomiędzy nawigacji strukturalnej w nowym polu i wyszukiwanie, nawigacji zarządzanej jest bardzo dobrym rozwiązaniem. Opcja nawigacji zarządzanej można obsługiwać za pośrednictwem konfiguracji, nie wymagają plików dostosowanie kodu, która jest znacznie szybsze niż nawigacji strukturalnej w nowym polu.

Innym rozwiązaniem jest restrukturyzacja istniejącej witryny i Zmniejsz liczbę elementy nawigacyjne i podwitryn wymagane. Jest to spowodowane nawigacji strukturalnej wykonuje oraz jak długo struktury witryny i nawigacji nie jest zbyt skomplikowana.

W tym artykule porównano różnych metod, na przykład zbioru witryn. Przykład zbioru witryn ma podwitryny 11 i każdej podwitryny ma co najmniej czterech dodatkowych podwitryny.

Zrzut ekranu przedstawiający witryny i podwitryny

Za pomocą nawigacji strukturalnej w usłudze SharePoint Online

To jest domyślnie używana w nawigacji w nowym polu i najbardziej proste i właściwe rozwiązanie w większości przypadków. Jeżeli nie istnieje złożonej strukturze wielu podwitrynach lub wiele poziomów podwitryn, nawigacji strukturalnej wykonuje również. Główną zaletą tej metody to, że jest on przycięte zabezpieczeń, automatyczne aktualizowanie po dodaniu nowych witryn i nie wymaga Dostosowywanie strony wzorcowej. Zarówno użytkownik może także łatwe dodawanie elementów, ukrywanie elementów i zarządzanie nawigacji na stronie Ustawienia.

Włączanie nawigacji strukturalnej w usłudze SharePoint Online

Aby przedstawić, jak wydajność w standardowej rozwiązanie usługi SharePoint Online z nawigacji strukturalnej i Pokaż podwitryny opcja włączona. Poniżej jest zrzut ekranu ustawienia znajdujące się na stronie Ustawienia witryny > Nawigacja.

Zrzut ekranu przedstawiający podwitryny

Analizowanie wydajności nawigacji strukturalnej w usłudze SharePoint Online

Analizowanie wydajności strony programu SharePoint, należy użyć karty sieci narzędzi dla deweloperów F12 w programie Internet Explorer.

Zrzut ekranu przedstawiający F12 deweloperów narzędzia sieci kartę

Na karcie sieć kliknij na stronie aspx ładowanym, a następnie kliknij kartę Szczegóły.

Zrzut ekranu przedstawiający kartę Szczegóły

Kliknij pozycję Nagłówki odpowiedzi.

Zrzut ekranu przedstawiający szczegóły karty

SharePoint zwraca pewne użyteczne informacje diagnostyczne w jego nagłówków odpowiedzi. Jedną z najbardziej użyteczne jest SPRequestDuration    , która jest wartością w milisekundach, jak długo żądanie umożliwiły na początku procesów na serwerze.

Na poniższym obrazie zrzut Pokaż podwitryny jest zaznaczona pozycja dla nawigacji strukturalnej. Oznacza to, że w nawigacji globalnej jest łącze zbioru witryn:

Zrzut ekranu przedstawiający czasy ładowania jako czas trwania żądań

Klucz SPRequestDuration    ma wartość 245 milisekund. Jest to czas potrzebny na żądanie zwrotu. Ponieważ jest tylko jeden element nawigacji w witrynie, to dobre wzorzec dla jak usługi SharePoint Online wykonuje bez intensywnie nawigacji. Następny zrzut ekranu przedstawia, dodając w podwitrynach wpływu tego klucza.

Zrzut ekranu przedstawiający czas trwania żądania 2502 ms

Dodawanie podwitryn znacznie zwiększa czas potrzebny na zwracana żądanie strony.

Korzyści wynikające z używania zwykłą Nawigatora strukturalnych jest możesz łatwo organizować kolejności, ukrywanie witryn, dodać strony, wyniki są przycięte zabezpieczeń, oraz są nie różniących się od obsługiwanych stron wzorcowych używane w usłudze SharePoint Online. Jeśli starannie struktury witryny i minimalizować podwitryn w zbiorze witryn następnie nawigacji strukturalnej wykonuje również.

Za pomocą Nawigacja zarządzana i zarządzanych metadanych w usłudze SharePoint Online

Nawigacji zarządzanej jest inną opcję w nowym polu używanego do odtworzenia jest taka sama funkcjonalności jako nawigacji strukturalnej.

Korzyścią ze stosowania zarządzanych metadanych jest szybciej, aby pobrać dane programowi zawartości przez zapytanie do utworzenia nawigacji witryny. Mimo że znacznie szybsze jest niczym zabezpieczeń Usuń.zbędne.odstępy wyniki więc jeśli użytkownik nie ma dostępu do danej witryny, łącza będą nadal jest wyświetlana, ale będzie powodowało komunikat o błędzie.

Jak wdrażać Nawigacja zarządzana i wyniki   

Istnieje kilka artykułów w witrynie TechNet dotyczących szczegółów nawigacji zarządzanej, na przykład, zobacz Omówienie nawigacji zarządzanej w programie SharePoint Server 2013.

Aby można było zastosować nawigacji zarządzanej, można muszą być terminów przechowywanie uprawnienia administratora. Konfigurując terminów przy użyciu adresu URL, które pasują do struktury zbioru witryn, nawigacji zarządzanej można zastąpić opcję nawigacji strukturalnej. Na przykład:

Zrzut ekranu przedstawiający Subsite1 przykład

W poniższym przykładzie pokazano wydajności złożonych nawigacji za pomocą nawigacji zarządzanej.

Zrzut ekranu przedstawiający SPRequestDuration przykład

Spójne używanie nawigacji zarządzanej zwiększa wydajność w porównaniu z zawartością przez podejście nawigacji strukturalnej kwerendy.

Przy użyciu sterowanych wyszukiwaniem skryptów po stronie klienta

Używanie funkcji wyszukiwania mogą korzystać indeksów utworzonych w górę w tle przy użyciu przeszukiwania ciągłego. Oznacza to, istnieją Brak intensywnie kwerendy zawartości. Wyniki wyszukiwania są pobierane z indeksu wyszukiwania, a wyniki są przycięte zabezpieczeń. To jest większa niż przy użyciu zwykłego kwerendy zawartości. Za pomocą wyszukiwania dla nawigacji strukturalnej, zwłaszcza jeśli masz strukturze złożonej witryny spowoduje skrócenie znacznie ładowania czasu strony. Główną zaletą tego nad nawigacji zarządzanej to, że możesz korzystać z dostosowywania do zabezpieczeń.

Ta metoda polega na utworzenie niestandardowej strony wzorcowej i zastępowanie kodu nawigacji w nowym polu niestandardowy kod HTML. Wykonaj poniższą procedurę, aby zamienić kodu nawigacyjnego w seattle.html pliku.

W tym przykładzie zostanie Otwórz plik seattle.html i zamienić element całego id = "DeltaTopNavigation" niestandardowy kod HTML.

Przykład: Aby zamienić kod w nowym polu nawigacji na stronie wzorcowej

  1. Przejdź do strony Ustawienia witryny.

  2. Otwieranie galerii stron wzorcowych, klikając pozycję Strony wzorcowe.

  3. W tym miejscu można przejść za pośrednictwem biblioteki i pobrać plik seattle.master.

  4. Edytowanie kodu za pomocą edytora tekstów i Usuń blok kodu na poniższym obrazie zrzut.

    Zrzut ekranu przedstawiający DeltaTopNavigation kodu do usunięcia
  5. Usuwanie kodu między < SharePoint:AjaxDelta id = "DeltaTopNavigation" > i < \SharePoint:AjaxDelta > Znaczniki i zamień go na poniższy fragment:

    <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">
                    <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 }">
                        <span aria-haspopup="true" class="additional-background ms-navedit-flyoutArrow dynamic-children">
                            <span class="menu-item-text" data-bind="text: item.Title">
                            </span>
                        </span>
                    </a>
                    <ul id="menu" data-bind="foreach: children; visible: children.length>0" class="dynamic" >
                        <li class="dynamic">
                            <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>
                </li>
            </ul>
        </div>
    </div>
  6. Zamienianie adres URL ładowania obrazu tagu zakotwiczenia na początku, z łączem do obraz ładowania w zbiorze witryn. Po wprowadzeniu zmian, Zmień nazwę pliku, a następnie przekazanie go do galerii stron wzorcowych. Spowoduje to wygenerowanie nowego pliku .master.

  7. Kod HTML jest podstawowe adiustacji, który zostanie wypełniony przez wyniki wyszukiwania zwracane z kodu JavaScript. Należy edytować następujący kod, aby zmienić wartość w polu var root = “site collection URL , jak pokazano w poniższej wstawki kodu:

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

    Cały plik JavaScript jest następująca:

    //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.dynamic-children").mouseover(function () {
            var position = $(this).position();
            $(this).find("ul").css({ width: 125, left: position.left + 10, top: 50 });
    
        })
            .mouseout(function () {
                $(this).find("ul").css({ width: 0, left: -99999, top: 0 });
            });
    }
    
    _spBodyOnLoadFunctionNames.push("InitCustomNav");
    

    Aby podsumować kodu, jak pokazano powyżej w funkcji $(document).ready jQuery istnieje obiekt viewModel utworzony, a następnie loadNavigationNodes() funkcja obiektu, na którym jest nazywany. Ta funkcja ładowania albo hierarchii nawigacji uprzednio utworzony przechowywane w magazynie lokalnym HTML5 przeglądarki klienta lub wywołuje funkcji queryRemoteInterface().

    QueryRemoteInterface() tworzy żądanie przy użyciu funkcji getRequest() z parametrem kwerendy zdefiniowanej wcześniej w skrypt, a następnie zwraca dane z serwera. Te dane są zasadniczo tablicę wszystkich witryn w zbiorze witryn, przedstawione w postaci obiektów transfer danych z różnych właściwości. Te dane jest następnie rozpoznane obiekty wcześniej zdefiniowanych SPO.Models.NavigationNode , które umożliwia tworzenie widocznych właściwości do użytku Knockout.js przez powiązania wartości do kodu HTML, zdefiniowanego możemy wcześniej danych. Obiekty są następnie umieść do tablicy wyników. Tej tablicy jest rozpoznane JSON przy użyciu odcinania i przechowywane w magazynie przeglądarki lokalnej, aby poprawić wydajność w ładowaniu stron przyszłych.

  8. Następnie wyniki są przypisywane do tablicy self.nodes i hierarchii jest tworzona poza obiektów przy użyciu linq.js przypisywanie wynik do tablicy self.heirarchy. Tej tablicy jest obiekt, który jest powiązany z HTML. Jest to w funkcji toggleView() przekazując samym obiekcie funkcji ko.applyBinding() . Następnie powoduje tablicy hierarchii powiązać poniższy kod HTML:

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

    Na koniec obsługi zdarzeń mouseenter i mouseexit są dodawane do obszaru nawigacji najwyższego poziomu do obsługi list rozwijanych podwitryny, które odbywa się w funkcji addEventsToElements() .

    Wyniki nawigacji są widoczne na ekranie zrzut poniżej:

    Zrzut ekranu przedstawiający wyniki nawigacji

    W naszym przykładzie złożonych nawigacji strony świeży obciążenia bez lokalnej pamięci podręcznej pokazuje czas spędzony na serwerze zostało podzielone w dół z nawigacji strukturalnej testu uzyskanie podobny wynik jako podejście nawigacji zarządzanej.

    Zrzut ekranu przedstawiający SPRequestDuration 301

    Jeden główną zaletą tej metody jest, że przy użyciu magazynu lokalnego HTML5, nawigacji jest przechowywany lokalnie dla użytkownika następnym są ładowane strony.

Ulepszenia dotyczące wydajności głównych będziemy korzystać z przy użyciu funkcji wyszukiwania interfejsu API dla nawigacji strukturalnej; Jednak trwa kilka możliwości techniczne niezbędne do wykonania i dostosowywanie tej funkcji. W przykładzie implementacji witryn są sortowane w taki sam sposób jak w nowym polu nawigacji strukturalnej; kolejności alfabetycznej. Jeśli chcesz utworzyć różni się od tej kolejności, jest bardziej skomplikowana i rozwijanie. Ponadto ta metoda wymaga różni się od obsługiwanych stron wzorcowych. Jeśli nie są obsługiwane niestandardowej strony wzorcowej, witryny będą przeoczyć w serwisie aktualizacje i ulepszenia firma Microsoft udostępnia do stron wzorcowych.

Powyższy kod występują następujące zależności:

W bieżącej wersji programu LinqJS nie zawiera metodę ByHierarchy w kodzie powyżej i podziały kodu nawigacji. Należy rozwiązać ten problem, należy dodać do pliku Linq.js przed wierszem następujące metodę "Flatten: funkcja ()".

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);
         })
     });
 },

Uwaga : Zrzeczenie dotyczące tłumaczenia maszynowego: Ten artykuł został przetłumaczony przez system komputerowy bez interwencji człowieka. Firma Microsoft udostępnia te tłumaczenia maszynowe, aby ułatwić użytkownikom, którzy nie znają języka angielskiego, korzystanie z zawartości dotyczącej produktów, usług i technologii firmy Microsoft. Ponieważ ten artykuł został przetłumaczony maszynowo, może zawierać błędy w słownictwie, składniowe lub gramatyczne.

Rozwijaj swoje umiejętności
Poznaj szkolenia
Uzyskuj nowe funkcje w pierwszej kolejności
Dołącz do niejawnych testerów pakietu Office

Czy te informacje były pomocne?

Dziękujemy za opinię!

Dziękujemy za opinię! Wygląda na to, że połączenie Cię z jednym z naszych agentów pomocy technicznej pakietu Office może być pomocne.

×