Używam TypeScript w mojej aplikacji, gdzie używam funkcji:

Object.assign(this.success, success.json())

Jednak podczas kompilacji pojawia się następujący błąd:

 error TS2339: Property 'assign' does not exist on type 'ObjectConstructor'.

Czy masz pojęcie, jak mogę pozbyć się tego błędu?

Możesz użyć asercji typu , na przykład:

(<any>Object).assign(this.success, success.json())

Skonfiguruj:

Jeśli używasz kodu VS (lub jeśli widzisz tsconfig.jsonplik):

Powinieneś dodać tę libwłaściwość do swojego, tsconfig.jsona wtedy twój edytor użyje dołączonych definicji typów maszynopisu, a także zapewni ci inteligencję.

Po prostu dodaj "lib": ["esnext", "dom"]do swojego tsconfig.jsoni uruchom ponownie VS Code

{
    "compilerOptions": {
        // ...
        "target": "es5",
        "lib": ["esnext", "dom"]
        // ...
    }
}

Zobacz wszystkie tsconfig.jsonopcje tutaj .

Jeśli używasz programu Visual Studio lub MSBuild, dołącz ten tag:

<TypeScriptLib>esnext, dom</TypeScriptLib>

Zobacz wszystkie opcje kompilatora MSBuild i użycie tutaj .

Sprawdź swoją pracę:

Jeśli skonfigurowałeś projekt do korzystania z typów wbudowanych i zrestartowałeś edytor, wynikowy typ będzie wyglądał następująco, a nie typem, anygdy używasz Object.assign:

Uwaga dotycząca wypełniaczy i zgodności ze starszymi przeglądarkami:

Zauważ, że jeśli transpilujesz do ES5 lub niższej i kierujesz się na IE11, będziesz musiał dołączyć polyfills, ponieważ kompilator maszynopisu nie będzie zawierał polyfillów.

Jeśli chcesz dołączyć polyfills (co powinieneś), polecam użycie polyfills core-js.

npm install --save core-js

lub

yarn add core-js

Następnie w punkcie wejścia w aplikacji (np. /src/index.ts) Dodaj import dla core-jsna górze pliku:

import 'core-js';

Jeśli nie używasz menedżera pakietów, możesz po prostu wkleić następujący wypełniacz pobrany z MDN w dowolnym miejscu w kodzie, który jest uruchamiany przed użyciem Object.assign.

if (typeof Object.assign != 'function') {
  // Must be writable: true, enumerable: false, configurable: true
  Object.defineProperty(Object, "assign", {
    value: function assign(target, varArgs) { // .length of function is 2
      'use strict';
      if (target == null) { // TypeError if undefined or null
        throw new TypeError('Cannot convert undefined or null to object');
      }

      var to = Object(target);

      for (var index = 1; index < arguments.length; index++) {
        var nextSource = arguments[index];

        if (nextSource != null) { // Skip over if undefined or null
          for (var nextKey in nextSource) {
            // Avoid bugs when hasOwnProperty is shadowed
            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
              to[nextKey] = nextSource[nextKey];
            }
          }
        }
      }
      return to;
    },
    writable: true,
    configurable: true
  });
}

Jest to spowodowane korzystaniem z funkcji ECMAScript 6 i kierowaniem na ECMAScript 5 lub 3. Najłatwiejszym rozwiązaniem jest ustawienie właściwego celu, na przykład jeśli używasz Grunt:

options: {
    target: 'es6'
}

zmiany odpowiedniej karty właściwości w programie Visual Studio lub ręcznie, edytując plik .csproj i znajdując element TypeScriptTarget i zmieniając go na ES6, na przykład:

<TypeScriptTarget>ES6</TypeScriptTarget>

Jeśli chcesz kierować na ES5, po prostu dodaj następujące elementy do kodu TypeScript

declare interface ObjectConstructor {
    assign(target: any, ...sources: any[]): any;
}

To łączy dodatkową metodę, rozwiązując problem. Więcej szczegółów tutaj . Możesz jednak potrzebować polyfill, w zależności od wymagań dotyczących zgodności przeglądarki - na przykład ten z MDN :

if (typeof Object.assign != 'function') {
  (function () {
    Object.assign = function (target) {
      'use strict';
      if (target === undefined || target === null) {
        throw new TypeError('Cannot convert undefined or null to object');
      }

      var output = Object(target);
      for (var index = 1; index < arguments.length; index++) {
        var source = arguments[index];
        if (source !== undefined && source !== null) {
          for (var nextKey in source) {
            if (source.hasOwnProperty(nextKey)) {
              output[nextKey] = source[nextKey];
            }
          }
        }
      }
      return output;
    };
  })();
}

Możesz użyć operatora spreadu, tak jak w ES6

const obj = {...this.success,...success.json()};

Dodałem typy:

typings install dt~es6-shim --global --save

Dlaczego nie skorzystać z operatora spreadu?

return {this.success, ...success.json() || {}};

Wiem, że to trwało długo, ale tutaj jest łatwe rozwiązanie

(Object as any).assign(this.success, success.json())