Estou usando o TypeScript no meu aplicativo, onde uso a função:

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

No entanto, durante a compilação, eu recebo o seguinte erro:

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

Você tem alguma idéia de como posso me livrar desse erro?

Você pode usar asserção de tipo , assim:

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

Configure:

Se você estiver usando o código VS (ou se vir um tsconfig.jsonarquivo):

Você deve adicionar a libpropriedade ao seu tsconfig.jsone, em seguida, seu editor usará as definições de tipo de texto datilografado em pacote e também fornecerá inteligência.

Basta adicionar o "lib": ["esnext", "dom"]ao seu tsconfig.jsone reiniciar o VS Code

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

Veja todas as tsconfig.jsonopções aqui .

Se você estiver usando o Visual Studio ou MSBuild, inclua esta tag:

<TypeScriptLib>esnext, dom</TypeScriptLib>

Veja todas as opções e uso do compilador datilografado do MSBuild aqui .

Verifique seu trabalho:

Se você configurou seu projeto para usar os tipos internos e reiniciou o editor, o tipo resultante será semelhante a esse em vez do tipo anyquando você usar Object.assign:

Nota sobre polyfills e compatibilidade com navegadores mais antigos:

Observe que se você estiver transpilando para o ES5 ou inferior e estiver direcionando o IE11, precisará incluir polyfills, porque o compilador de texto datilografado não incluirá os polyfills para você.

Se você deseja incluir os polyfills (o que você deve), recomendo o uso dos polyfills do core-js.

npm install --save core-js

ou

yarn add core-js

Em seguida, no ponto de entrada do seu aplicativo (por exemplo /src/index.ts), adicione a importação core-jsna parte superior do arquivo:

import 'core-js';

Se você não estiver usando um gerenciador de pacotes, basta colar o seguinte polyfill retirado do MDN em algum lugar do seu código que é executado antes do uso do 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
  });
}

Isso é causado por você usar um recurso do ECMAScript 6 e direcionar o ECMAScript 5 ou 3. A correção mais fácil é definir o destino certo, por exemplo, se você estiver usando o Grunt:

options: {
    target: 'es6'
}

de alterar a guia de propriedades relevantes no Visual Studio ou manualmente, editando o arquivo .csproj e localizando o elemento TypeScriptTarget e alterando para ES6, por exemplo:

<TypeScriptTarget>ES6</TypeScriptTarget>

Se você precisar segmentar o ES5, basta adicionar o seguinte ao seu código TypeScript

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

Isso mescla o método extra, resolvendo o problema. Mais detalhes aqui . Você pode precisar de um polyfill, dependendo dos requisitos de compatibilidade do navegador - por exemplo, este da 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;
    };
  })();
}

Você pode usar o operador spread como no ES6

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

Eu adicionei digitações:

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

Por que não usar o operador de propagação?

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

Eu sei que isso tem sido longo, mas aqui está uma solução fácil

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