How to push new object to an array without getting a bunch of duplicates?

Question

I am trying to create an array of multiple objects, but when I push the new object to my array, it is creating an array of the last pushed object. I am very new to javascript, and believe I am looking for something similar to the deepcopy in Python, but I keep reading that this isn't a thing for javascript.

I read that creating a clone object for each push would solve my problem; however, it's not working. Any advice about how to go about creating a new object to push my object to the array would be appreciated.

class Piece {
    constructor(length, quantity) {
        this.length = length;
        this.quantity = quantity;
    }
}

class Pattern {
    constructor(pattern, remainingLength) {
        this.pattern = pattern;
        this.remainingLength = remainingLength;
    }
}

const  stockLength = 144;
const piecesOrdered = [];
const piece1 = new Piece(19, 15);
const piece2 = new Piece(16, 30);
piecesOrdered.push(piece1);
piecesOrdered.push(piece2);
const allPossiblePatterns = [];

function getBestCuttingSequence() {
    getAllPossiblePatterns();
}

function getAllPossiblePatterns() {
    let previousPattern;
    let pattern = getFirstPattern();
    allPossiblePatterns.push(pattern);
    while(anotherPatternPossible(pattern.pattern)){
        previousPattern = pattern;
        pattern = getNextPattern(previousPattern);
        allPossiblePatterns.push(pattern);
    }
    console.log(allPossiblePatterns);
}

function getFirstPattern() {
    let pattern = [];
    let remainingLength = stockLength;

    for (let piece in piecesOrdered) {
        let quantityNeeded = piecesOrdered[piece].quantity;
        let maxQuantityPossible = Math.floor(remainingLength / piecesOrdered[piece].length);
        let quantity = Math.min(quantityNeeded, maxQuantityPossible);
        remainingLength -= quantity * piecesOrdered[piece].length;
        pattern.push(new Piece(piecesOrdered[piece].length, quantity));
    }

    return new Pattern(pattern, remainingLength);
}

function anotherPatternPossible(previousPattern) {
    for (let piece in previousPattern) {
        if (previousPattern[piece].quantity > 0) {
            return true;
        }
    }
    return false;
}

function getNextPattern(previousPattern) {
    const startIndexAndLoweredPattern = lowerSmallestLength(previousPattern);
    const nextPattern = useRemainingLength(startIndexAndLoweredPattern);
    return nextPattern;
}

function lowerSmallestLength(pattern) {
    let startIndex;
    let loweredPattern = pattern;
    for (let i = loweredPattern.pattern.length -1; i >= 0; i--) {
        if (loweredPattern.pattern[i].quantity > 0) {
            loweredPattern.pattern[i].quantity -= 1;
            loweredPattern.remainingLength += loweredPattern.pattern[i].length;
            startIndex = i + 1;
            break;
        }
    }

    return [startIndex, loweredPattern]
}

function useRemainingLength(startIndexAndLoweredPattern) {
    const startIndex = startIndexAndLoweredPattern[0];
    let loweredPattern = startIndexAndLoweredPattern[1];

    for (let i = startIndex; i < loweredPattern.pattern.length; i++) {
        while (loweredPattern.pattern[i].length <= loweredPattern.remainingLength && loweredPattern.pattern[i].quantity < piecesOrdered[i].quantity) {
            loweredPattern.pattern[i].quantity += 1;
            loweredPattern.remainingLength -= loweredPattern.pattern[i].length;
        }
    }
    let nextPattern = Object.assign({}, loweredPattern);
    return nextPattern;
}

getBestCuttingSequence();

This is not my full code, but a simplified version of it that produces the same result. Any help would be appreciated.

Expected Results:

[{[{19, 7}, {16, 0}], remainingLength: 11},
{[{19, 6}, {16, 1}], remainingLength: 14},
...,
{[{19, 0}, {16, 0}], remainingLength: 144}]

Actual Result:

[{[{19, 0}, {16, 0}], remainingLength: 144},
{[{19, 0}, {16, 0}], remainingLength: 144},
...
{[{19, 0}, {16, 0}], remainingLength: 144}]

Answer 1

Didn't get your question,but still you are asking for deepClone.you can try like this

var a = {b:{g:{54}}};
var clonedA = JSON.parse(JSON.stringify(a));

This solves the deepClone problem.if you need further more,just clarify your question with some small example.