Index signatures

It is possible to denote obj as any, but that defeats the whole purpose of using typescript. obj = {} implies obj is an Object. Marking it as any makes no sense. To accomplish the desired consistency an interface could be defined as follows, using an index signature

interface LooseObject {
    [key: string]: any
}

var obj: LooseObject = {};

OR to make it compact:

var obj: {[k: string]: any} = {};

LooseObject can accept fields with any string as key and any type as value.

obj.prop = "value";
obj.prop2 = 88;

The real elegance of this solution is that you can include typesafe fields in the interface.

interface MyType {
    typesafeProp1?: number,
    requiredProp1: string,
    [key: string]: any
}

var obj: MyType ;
obj = { requiredProp1: "foo"}; // valid
obj = {} // error. 'requiredProp1' is missing
obj.typesafeProp1 = "bar" // error. typesafeProp1 should be a number

obj.prop = "value";
obj.prop2 = 88;

Record<Keys,Type> utility type

Update (August 2020): @transang brought up the Record<Keys,Type> utility type in comments

Record<Keys,Type> is a Utility type in typescript. It is a much cleaner alternative for key-value pairs where property-names are not known. It's worth noting that Record<Keys,Type> is a named alias to {[k: Keys]: Type} where Keys and Type are generics. IMO, this makes it worth mentioning here

For comparison,

var obj: {[k: string]: any} = {};

becomes

var obj: Record<string,any> = {}

MyType can now be defined by extending Record type

interface MyType extends Record<string,any> {
    typesafeProp1?: number,
    requiredProp1: string,
}

While this answers the Original question, the answer here by @GreeneCreations might give another perspective on how to approach the problem.

What's wrong with your code is that idx will be the object not the index as you are using for...of. Use a simple regular for like:

Copyfor(let idx = 0; idx < data.length; idx++) {
    data[idx].date = dates[idx];
}

Or use forEach to loop one of the arrays and use the index it provides to get the value from the other array:

Copydata.forEach((obj, i) => obj.date = dates[i]);

There are two ways to add new properties to an object:

var obj = {
    key1: value1,
    key2: value2
};

Using dot notation:

obj.key3 = "value3";

Using square bracket notation:

obj["key3"] = "value3";

The first form is used when you know the name of the property. The second form is used when the name of the property is dynamically determined. Like in this example:

var getProperty = function (propertyName) {
    return obj[propertyName];
};

getProperty("key1");
getProperty("key2");
getProperty("key3");

A real JavaScript array can be constructed using either:

The Array literal notation:

var arr = [];

The Array constructor notation:

var arr = new Array();

The code in your question is largely correct, here is a full working example:

const profile = {
    "RouteID": "B76F77922EF83A4EE04024921F591A6F",
    "Name": "3019998FALCON",
    "rName": "KILGORE REMOVED"
}

profile["userID"] = "jzket";

// Works everywhere
console.log(profile["userID"]);

// Works, but violates the type information available here
console.log(profile.userID);

You'll notice that the type system will complain about the latter usage, because userID isn't part of the type inferred for profile.

You can either stick with the first example (profile['userID']) or provide a bit more type information:

interface Profile {
    RouteID: string;
    Name: string;
    rName: string;
    userID?: string;
}

const profile: Profile = {
    "RouteID": "B76F77922EF83A4EE04024921F591A6F",
    "Name": "3019998FALCON",
    "rName": "KILGORE REMOVED"
}

profile["userID"] = "jzket";

// Works everywhere
console.log(profile["userID"]);

// Works, but violates the type information available here
console.log(profile.userID);

You are not modifying products in your array. You have two options:

• use products.forEach and pass in a function that modifies a product. Return modified products.
• use products.map and pass in a function that takes a product and creates new object with additional property, return the result of mapping.

I would argue that 2nd approach is more idiomatic in JS/TS.

const countTotalPrice = (products: Product[]): Product[] => {
  return products.map((product) => 
    ({    // the parentheses are necessary in this position
          // we want object literal, not code block
          ...product,
          totalPrice: product.basePrice - product.discount
    })
  );
}

Playground link