JavaScript questions that don't deserve their own thread

<Custom Turn End Effect>
var cantorheal = 5;
user.friendsUnit().aliveMembers().forEach(ally => ally.gainHp(cantorheal));
user.friendsUnit().aliveMembers().startDamagePopup();
user.friendsUnit().aliveMembers().clearResult();
</Custom Turn End Effect>

<Custom Turn End Effect>
var cantorheal = 5;
user.friendsUnit().aliveMembers().forEach(ally => ally.gainHp(cantorheal));
user.friendsUnit().aliveMembers().forEach(ally => ally.startDamagePopup());
user.friendsUnit().aliveMembers().forEach(ally => ally.clearResult());
</Custom Turn End Effect>

    const _Alias_Window_ActorCommand_prototype_makeCommandList = Window_ActorCommand.prototype.makeCommandList;
    Window_ActorCommand.prototype.makeCommandList = function() {
        if (this._actor) {
            this.addNewCommand();
        }
        _Alias_Window_ActorCommand_prototype_makeCommandList.call(this);
    };

    Window_ActorCommand.prototype.addNewCommand = function() {
        this.addCommand("New", "new");
    };
    
    const _Alias_Scene_Battle_prototype_createActorCommandWindow = Scene_Battle.prototype.createActorCommandWindow;
    Scene_Battle.prototype.createActorCommandWindow = function() {
        _Alias_Scene_Battle_prototype_createActorCommandWindow.call(this);
        this._actorCommandWindow.setHandler("new", this.commandNew.bind(this));
    };

    Scene_Battle.prototype.commandNew = function() {
        this._newWindow.refresh();
        this._newWindow.show();
        this._newWindow.activate();
        this._newWindow.select(0);
        this._statusWindow.hide();
        this._actorCommandWindow.hide();
        this._actorCommandWindow.deactivate();
    };

    const _Alias_Scene_Battle_prototype_createAllWindows = Scene_Battle.prototype.createAllWindows;
    Scene_Battle.prototype.createAllWindows = function() {
        _Alias_Scene_Battle_prototype_createAllWindows.call(this);
        this.createNewWindow();
    };

    Scene_Battle.prototype.createNewWindow = function() {
        const rect = this.itemWindowRect();
        const NewWindow = new Window_New(rect);
        NewWindow.setHelpWindow(this._helpWindow);
        NewWindow.setHandler("ok", this.onNewOk.bind(this));
        NewWindow.setHandler("cancel", this.onNewCancel.bind(this));
        this.addWindow(NewWindow);
        this._newWindow = NewWindow;
    };

    Scene_Battle.prototype.onNewOk = function() {
        const item = this._newWindow.item();
        console.log(item);
        this.onNewCancel.call(this);
    };

    Scene_Battle.prototype.onNewCancel = function() {
        this._newWindow.hide();
        this._newWindow.deactivate();
        this._statusWindow.show();
        this._actorCommandWindow.refresh();
        this._actorCommandWindow.show();
        this._actorCommandWindow.activate();
    };

    //-----------------------------------------------------------------------------
    // Window_New
    //
    // The window for selecting an item to use on the battle screen.

    function Window_New() {
        this.initialize(...arguments);
    }

    Window_New.prototype = Object.create(Window_ItemList.prototype);
    Window_New.prototype.constructor = Window_New;

    Window_New.prototype.initialize = function(rect) {
        Window_ItemList.prototype.initialize.call(this, rect);
        this.hide();
    };

    Window_New.prototype.includes = function(item) {
        return item;
    };

    Window_New.prototype.show = function() {
        this.selectLast();
        this.showHelpWindow();
        Window_ItemList.prototype.show.call(this);
    };

    Window_New.prototype.hide = function() {
        this.hideHelpWindow();
        Window_ItemList.prototype.hide.call(this);
    };

const _Alias_Scene_Battle_prototype_isAnyInputWindowActive = Scene_Battle.prototype.isAnyInputWindowActive;
    Scene_Battle.prototype.isAnyInputWindowActive = function() {
        return _Alias_Scene_Battle_prototype_isAnyInputWindowActive.call(this) || this._newWindow.active;
    };

var arr1 = [{a: 0, b:0}];
var arr2 = structuredClone(arr1);
console.log(arr1, arr2); //[{a: 0, b:0}], [{a: 0, b:0}]
arr2[0].a = 4;
console.log(arr1, arr2); //[{a: 0, b:0}], [{a: 4, b:0}]

<Custom Battle Effect>
// This is the number of turns the buffs and debuffs will last
var turns = 4;
// Create a pool for the parameters that can be changed
var allowedParams = [];
// Insert Param ID's you want to randomly add here:
allowedParams.push(2, 4, 6, 7);
// Make a copy of the pool
var result = allowedParams.slice();

// Initialize the parameter ID
var paramId;
// Loop through each of the copied pool's parameters
while (result.length > 0) {
  // Get a randomly looped parameter
  paramId = result[Math.floor(Math.random() * result.length)];
  // Remove it from the copied pool
  result.splice(result.indexOf(paramId), 1);
  var members = [];
    // Loop through each of the target's alive allies.
    for (var i = 0; i < target.friendsUnit().aliveMembers().length; ++i) {
      // Set the potential variable to the current looped ally.
      var potential = target.friendsUnit().aliveMembers()[i];
      // If the ally doesn't exist, move onto the next.
      if (!potential) continue;
      // If the ally's HP is at zero (hence dead), move onto the next.
      if (potential.hp <= 0) continue;
      // Now that all checks have been cleared, put the potential ally into the members array.
      members.push(potential);
    }
    // Get a random member of the members array.
    var member = members[Math.floor(Math.random() * members.length)];
    // Check if the random member exists.
    if (member) {member.addBuff(paramId, turns); }
break;
  }
}
</Custom Battle Effect>