Ben bir süper sınıf var ebeveyn ( Entitybirçok alt sınıf için) ( Customer, Product, ProductCategory...)

Dinamik olarak Typescript farklı alt nesneler içeren bir nesneyi klonlamak için arıyorum.

Örneğin: Customerfarklı Productolan birProductCategory

var cust:Customer  = new Customer ();

cust.name = "someName";
cust.products.push(new Product(someId1));
cust.products.push(new Product(someId2));

Tüm nesne ağacını klonlamak için, Entity

public clone():any {
    var cloneObj = new this.constructor();
    for (var attribut in this) {
        if(typeof this[attribut] === "object"){
           cloneObj[attribut] = this.clone();
        } else {
           cloneObj[attribut] = this[attribut];
        }
    }
    return cloneObj;
}

newO javascript transpiled aşağıdaki hatayı yükselir:error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.

Komut dosyası çalışmasına rağmen, aktarılan hatadan kurtulmak istiyorum

Belirli Sorunu Çözme

Derleyiciye daha iyi bildiğinizi bildirmek için bir tür iddiası kullanabilirsiniz:

public clone(): any {
    var cloneObj = new (this.constructor() as any);
    for (var attribut in this) {
        if (typeof this[attribut] === "object") {
            cloneObj[attribut] = this[attribut].clone();
        } else {
            cloneObj[attribut] = this[attribut];
        }
    }
    return cloneObj;
}

Klonlama

Unutmayın ki bazen tamamen dinamik olmaktan ziyade kendi eşlemenizi yazmak daha iyidir. Ancak, size farklı efektler veren birkaç "klonlama" püf noktası vardır.

Sonraki tüm örnekler için aşağıdaki kodu kullanacağım:

class Example {
  constructor(public type: string) {

  }
}

class Customer {
  constructor(public name: string, public example: Example) {

  }

  greet() {
    return 'Hello ' + this.name;
  }
}

var customer = new Customer('David', new Example('DavidType'));

Seçenek 1: Yayılma

Özellikler: Evet
Yöntemler: Hayır
Derin Kopya: Hayır

var clone = { ...customer };

alert(clone.name + ' ' + clone.example.type); // David DavidType
//alert(clone.greet()); // Not OK

clone.name = 'Steve';
clone.example.type = 'SteveType';

alert(customer.name + ' ' + customer.example.type); // David SteveType

Seçenek 2: Object.assign

Özellikler: Evet
Yöntemler: Hayır
Derin Kopya: Hayır

var clone = Object.assign({}, customer);

alert(clone.name + ' ' + clone.example.type); // David DavidType
alert(clone.greet()); // Not OK, although compiler won't spot it

clone.name = 'Steve';
clone.example.type = 'SteveType';

alert(customer.name + ' ' + customer.example.type); // David SteveType

Seçenek 3: Object.create

Özellikler: Miras Alınan
Yöntemler: Miras Alınan
Derin Kopya: Sığ Miras (derin değişiklikler hem orijinali hem de klonu etkiler)

var clone = Object.create(customer);

alert(clone.name + ' ' + clone.example.type); // David DavidType
alert(clone.greet()); // OK

customer.name = 'Misha';
customer.example = new Example("MishaType");

// clone sees changes to original 
alert(clone.name + ' ' + clone.example.type); // Misha MishaType

clone.name = 'Steve';
clone.example.type = 'SteveType';

// original sees changes to clone
alert(customer.name + ' ' + customer.example.type); // Misha SteveType

Seçenek 4: Derin Kopyalama İşlevi

Özellikler: Evet
Yöntemler: Hayır
Derin Kopya: Evet

function deepCopy(obj) {
    var copy;

    // Handle the 3 simple types, and null or undefined
    if (null == obj || "object" != typeof obj) return obj;

    // Handle Date
    if (obj instanceof Date) {
        copy = new Date();
        copy.setTime(obj.getTime());
        return copy;
    }

    // Handle Array
    if (obj instanceof Array) {
        copy = [];
        for (var i = 0, len = obj.length; i < len; i++) {
            copy[i] = deepCopy(obj[i]);
        }
        return copy;
    }

    // Handle Object
    if (obj instanceof Object) {
        copy = {};
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) copy[attr] = deepCopy(obj[attr]);
        }
        return copy;
    }

    throw new Error("Unable to copy obj! Its type isn't supported.");
}

var clone = deepCopy(customer) as Customer;

alert(clone.name + ' ' + clone.example.type); // David DavidType
// alert(clone.greet()); // Not OK - not really a customer

clone.name = 'Steve';
clone.example.type = 'SteveType';

alert(customer.name + ' ' + customer.example.type); // David DavidType

1. forma operatörü kullanın

const obj1 = { param: "value" };
const obj2 = { ...obj1 };

Spread operatörü tüm alanları obj1'den alır ve obj2 üzerine yayar. Sonuçta yeni referans ve orijinal alanla aynı alanlara sahip yeni bir nesne elde edersiniz.

Sığ bir kopya olduğunu unutmayın, eğer nesne iç içe yerleştirilmişse, iç içe geçmiş bileşik parametrelerinin aynı referansla yeni nesnede mevcut olacağı anlamına gelir.

2.Object.assign ()

const obj1={ param: "value" };
const obj2:any = Object.assign({}, obj1);

Object.assign gerçek kopya oluşturur, ancak yalnızca kendi özelliklerini oluşturur, bu nedenle prototipteki özellikler kopyalanan nesnede bulunmaz. Aynı zamanda sığ bir kopyadır.

3.Object.create ()

const obj1={ param: "value" };
const obj2:any = Object.create(obj1);

Object.create gerçek klonlama yapmıyor , prototipten nesne yaratıyor. Bu nedenle, nesne birincil tür özelliklerini klonlaması gerekiyorsa kullanın, çünkü birincil tür özellikleri ataması başvuru ile yapılmaz.

Artıları Object.create prototip bildirilen herhangi fonksiyonlar bizim yeni oluşturulan nesne satışa sunulacak yönünde.

Sığ kopya hakkında birkaç şey

Sığ kopya, eskisinin tüm alanlarını yeni nesneye koyar, ancak orijinal nesnede bileşik tür alanları (nesne, diziler vb.) Varsa, bu alanların aynı referanslarla yeni nesneye konulduğu anlamına gelir. Orijinal nesnede bu tür bir mutasyon yeni nesneye yansıtılacaktır.

Belki bir tuzak gibi görünüyor, ama tüm karmaşık nesnenin kopyalanması gerektiğinde gerçekten durum nadirdir. Sığ kopya hafızanın çoğunu yeniden kullanır, bu da derin kopyaya kıyasla çok ucuzdur.

Derin kopya

Forma operatörü derin kopyalama için kullanışlı olabilir.

const obj1 = { param: "value", complex: { name: "John"}}
const obj2 = { ...obj1, complex: {...obj1.complex}};

Yukarıdaki kod obj1'in derin kopyasını yarattı. Kompozit alan "kompleks" de obj2'ye kopyalandı. Mutasyon alanı "karmaşık" kopyayı yansıtmayacaktır.

Bunu dene:

let copy = (JSON.parse(JSON.stringify(objectToCopy)));

Çok büyük nesneler kullanana veya nesnenizin dizileştirilemeyen özelliklerine sahip olana kadar iyi bir çözümdür.

Tür güvenliğini korumak için, sınıfta kopyasını almak istediğiniz bir kopyalama işlevini kullanabilirsiniz:

getCopy(): YourClassName{
    return (JSON.parse(JSON.stringify(this)));
}

veya statik bir şekilde:

static createCopy(objectToCopy: YourClassName): YourClassName{
    return (JSON.parse(JSON.stringify(objectToCopy)));
}

TypeScript / JavaScript'in sığ klonlama için kendi operatörü vardır:

let shallowClone = { ...original };

TypeScript 2.1'de sunulan "Object Spread" ile sığ bir kopya elde etmek kolaydır

bu TypeScript: let copy = { ...original };

şu JavaScript'i üretir:

var __assign = (this && this.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
var copy = __assign({}, original);

https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-1.html

Serileştirilebilir derin klon için Tip Bilgisi ile,

export function clone<T>(a: T): T {
  return JSON.parse(JSON.stringify(a));
}

Benim almam:

Object.assign(...) sadece özellikleri kopyalar ve prototip ve yöntemleri kaybederiz.

Object.create(...) benim için özellikleri kopyalamıyor ve sadece bir prototip oluşturuyor.

Benim için işe yarayan bir prototip oluşturmak Object.create(...)ve özelliklerini kullanarak kopyalamaktır Object.assign(...):

Yani bir nesne için foo, böyle klonlayın:

Object.assign(Object.create(foo), foo)

Bunun gibi bir şeye de sahip olabilirsiniz:

class Entity {
    id: number;

    constructor(id: number) {
        this.id = id;
    }

    clone(): this {
        return new (this.constructor as typeof Entity)(this.id) as this;
    }
}

class Customer extends Entity {
    name: string;

    constructor(id: number, name: string) {
        super(id);
        this.name = name;
    }

    clone(): this {
        return new (this.constructor as typeof Customer)(this.id, this.name) as this;
    }
}

cloneTüm Entityalt sınıflarda yöntemi geçersiz kıldığınızdan emin olun, aksi takdirde kısmi klonlarla karşılaşırsınız.

Dönüş türü thisher zaman örnek türüyle eşleşir.

Ekle "lodash.clonedeep": "^4.5.0"Blogunuza package.json. Sonra şöyle kullanın:

import * as _ from 'lodash';

...

const copy = _.cloneDeep(original)

İşte benim mash-up! Ve işte bir StackBlitz bağlantısı . Şu anda sadece basit türleri ve nesne türlerini kopyalamakla sınırlı ama kolayca değiştirilebileceğini düşünüyorum.

   let deepClone = <T>(source: T): { [k: string]: any } => {
      let results: { [k: string]: any } = {};
      for (let P in source) {
        if (typeof source[P] === 'object') {
          results[P] = deepClone(source[P]);
        } else {
          results[P] = source[P];
        }
      }
      return results;
    };

Bu hatayı alırsanız:

TypeError: this.constructor(...) is not a function

Bu doğru komut dosyasıdır:

public clone(): any {
    var cloneObj = new (<any>this.constructor)(); // line fixed
    for (var attribut in this) {
        if (typeof this[attribut] === "object") {
            cloneObj[attribut] = this[attribut].clone();
        } else {
            cloneObj[attribut] = this[attribut];
        }
    }
    return cloneObj;
}

Bu sorunla karşılaştım ve sonunda soyut bir sınıf sağlayan küçük bir kütüphane klonlanabilir-ts yazdı , bu da onu genişleten herhangi bir sınıfa bir klon yöntemi ekler. Soyut sınıf Fenton sadece değiştirerek kabul yanıt açıklandığı Derin Kopya İşlevini ödünç copy = {};ile copy = Object.create(originalObj)orijinal nesnenin sınıfını korumak için. İşte sınıfı kullanma örneği.

import {Cloneable, CloneableArgs} from 'cloneable-ts';

// Interface that will be used as named arguments to initialize and clone an object
interface PersonArgs {
    readonly name: string;
    readonly age: number;
}

// Cloneable abstract class initializes the object with super method and adds the clone method
// CloneableArgs interface ensures that all properties defined in the argument interface are defined in class
class Person extends Cloneable<TestArgs>  implements CloneableArgs<PersonArgs> {
    readonly name: string;
    readonly age: number;

    constructor(args: TestArgs) {
        super(args);
    }
}

const a = new Person({name: 'Alice', age: 28});
const b = a.clone({name: 'Bob'})
a.name // Alice
b.name // Bob
b.age // 28

Veya sadece Cloneable.cloneyardımcı yöntemi kullanabilirsiniz :

import {Cloneable} from 'cloneable-ts';

interface Person {
    readonly name: string;
    readonly age: number;
}

const a: Person = {name: 'Alice', age: 28};
const b = Cloneable.clone(a, {name: 'Bob'})
a.name // Alice
b.name // Bob
b.age // 28    

TypeScript 3.7 piyasaya sürüldüğünden, özyinelemeli tür takma adları artık desteklenmektedir ve bir tür güvenli deepCopy()işlev tanımlamamıza izin verir :

// DeepCopy type can be easily extended by other types,
// like Set & Map if the implementation supports them.
type DeepCopy<T> =
    T extends undefined | null | boolean | string | number ? T :
    T extends Function | Set<any> | Map<any, any> ? unknown :
    T extends ReadonlyArray<infer U> ? Array<DeepCopy<U>> :
    { [K in keyof T]: DeepCopy<T[K]> };

function deepCopy<T>(obj: T): DeepCopy<T> {
    // implementation doesn't matter, just use the simplest
    return JSON.parse(JSON.stringify(obj));
}

interface User {
    name: string,
    achievements: readonly string[],
    extras?: {
        city: string;
    }
}

type UncopiableUser = User & {
    delete: () => void
};

declare const user: User;
const userCopy: User = deepCopy(user); // no errors

declare const uncopiableUser: UncopiableUser;
const uncopiableUserCopy: UncopiableUser = deepCopy(uncopiableUser); // compile time error

Oyun alanı

Hole nesnesinin içeriğinin basit bir klonu için, basitçe örneği dizgi ve ayrıştırma:

let cloneObject = JSON.parse(JSON.stringify(objectToClone))

ObjectToClone ağacındaki verileri değiştirirken, cloneObject öğesinde herhangi bir değişiklik yoktur. Bu benim isteğimdi.

Umarım yardımcı olur

Sonunda şunu yaptım:

public clone(): any {
  const result = new (<any>this.constructor);

  // some deserialization code I hade in place already...
  // which deep copies all serialized properties of the
  // object graph
  // result.deserialize(this)

  // you could use any of the usggestions in the other answers to
  // copy over all the desired fields / properties

  return result;
}

Çünkü:

var cloneObj = new (<any>this.constructor());

@Fenton'dan çalışma zamanı hataları verdi.

Patlama sürümü: 2.4.2

İyi eski jQuery ne dersiniz ?! İşte derin klon:

var clone = $.extend(true, {}, sourceObject);

Yuvalanmış nesneler için türleri koruyan genel bir kopya / klon hizmeti oluşturmada bir bıçak aldım. Yanlış bir şey yapıyorsam geri bildirim isterdim, ama şu ana kadar çalışıyor gibi görünüyor ...

import { Injectable } from '@angular/core';

@Injectable()
export class CopyService {

  public deepCopy<T>(objectToClone: T): T {
    // If it's a simple type or null, just return it.
    if (typeof objectToClone === 'string' ||
      typeof objectToClone === 'number' ||
      typeof objectToClone === 'undefined' ||
      typeof objectToClone === 'symbol' ||
      typeof objectToClone === 'function' ||
      typeof objectToClone === 'boolean' ||
      objectToClone === null
    ) {
      return objectToClone;
    }

    // Otherwise, check if it has a constructor we can use to properly instantiate it...
    let ctor = Object.getPrototypeOf(objectToClone).constructor;
    if (ctor) {
      let clone = new ctor();

      // Once we've instantiated the correct type, assign the child properties with deep copies of the values
      Object.keys(objectToClone).forEach(key => {
        if (Array.isArray(objectToClone[key]))
          clone[key] = objectToClone[key].map(item => this.deepCopy(item));
        else
          clone[key] = this.deepCopy(objectToClone[key]);
      });

      if (JSON.stringify(objectToClone) !== JSON.stringify(clone))
        console.warn('object cloned, but doesnt match exactly...\nobject: ' + JSON.stringify(objectToClone) + "\nclone: " + JSON.stringify(clone))

      // return our cloned object...
      return clone;
    }
    else {
      //not sure this will ever get hit, but figured I'd have a catch call.
      console.log('deep copy found something it didnt know: ' + JSON.stringify(objectToClone));
      return objectToClone;
    }
  }
}

TypeScript'te açısal ile test ediyorum ve sorun yok

deepCopy(obj) {


        var copy;

        // Handle the 3 simple types, and null or undefined
        if (null == obj || "object" != typeof obj) return obj;

        // Handle Date
        if (obj instanceof Date) {
            copy = new Date();
            copy.setTime(obj.getTime());
            return copy;
        }

        // Handle Array
        if (obj instanceof Array) {
            copy = [];
            for (var i = 0, len = obj.length; i < len; i++) {
                copy[i] = this.deepCopy(obj[i]);
            }
            return copy;
        }

        // Handle Object
        if (obj instanceof Object) {
            copy = {};
            for (var attr in obj) {
                if (obj.hasOwnProperty(attr)) copy[attr] = this.deepCopy(obj[attr]);
            }
            return copy;
        }

        throw new Error("Unable to copy obj! Its type isn't supported.");
    }

Başka nesneler, diziler ve benzeri içerebilen bir nesneyi derin klonlamak için kullanıyorum:

const clone = <T>(source: T): T => {
  if (source === null) return source

  if (source instanceof Date) return new Date(source.getTime()) as any

  if (source instanceof Array) return source.map((item: any) => clone<any>(item)) as any

  if (typeof source === 'object' && source !== {}) {
    const clonnedObj = { ...(source as { [key: string]: any }) } as { [key: string]: any }
    Object.keys(clonnedObj).forEach(prop => {
      clonnedObj[prop] = clone<any>(clonnedObj[prop])
    })

    return clonnedObj as T
  }

  return source
}

kullanın:

const obj = {a: [1,2], b: 's', c: () => { return 'h'; }, d: null, e: {a:['x'] }}
const objClone = clone(obj)

Yıkım atamasını forma sözdizimi ile kullanabilirsiniz :

var obj = {id = 1, name = 'product1'};
var clonedObject = {...obj};

Hedef nesneye zaten sahipseniz, onu yeniden oluşturmak istemiyorsanız (bir diziyi güncelliyor gibi) özellikleri kopyalamanız gerekir.
Bu şekilde yaptıysanız:

Object.keys(source).forEach((key) => {
    copy[key] = source[key]
})

Övgü zamanı geldi. ("sürüm 2" başlığına bakın)