261

I have the following interface and code. I thought I was doing the definitions correctly but I am getting an error:

interface IenumServiceGetOrderBy { id: number; label: string; key: any }[];

and:

getOrderBy = (entity): IenumServiceGetOrderBy => {
        var result: IenumServiceGetOrderBy;
        switch (entity) {
            case "content":
                result =
                [
                    { id: 0, label: 'CId', key: 'contentId' },
                    { id: 1, label: 'Modified By', key: 'modifiedBy' },
                    { id: 2, label: 'Modified Date', key: 'modified' },
                    { id: 3, label: 'Status', key: 'contentStatusId' },
                    { id: 4, label: 'Status > Type', key: ['contentStatusId', 'contentTypeId'] },
                    { id: 5, label: 'Title', key: 'title' },
                    { id: 6, label: 'Type', key: 'contentTypeId' },
                    { id: 7, label: 'Type > Status', key: ['contentTypeId', 'contentStatusId'] }
                ];
                break;
        }
        return result;
    };

Error:

Error   190 Cannot convert '{}[]' to 'IenumServiceGetOrderBy':
    Type '{}[]' is missing property 'id' from type 'IenumServiceGetOrderBy'
Improve this question

17 Answers 17

Reset to default
394

You don't need to use an indexer (since it a bit less typesafe). You have two options : 

interface EnumServiceItem {
    id: number; label: string; key: any
}

interface EnumServiceItems extends Array<EnumServiceItem>{}


// Option A 
var result: EnumServiceItem[] = [
    { id: 0, label: 'CId', key: 'contentId' },
    { id: 1, label: 'Modified By', key: 'modifiedBy' },
    { id: 2, label: 'Modified Date', key: 'modified' },
    { id: 3, label: 'Status', key: 'contentStatusId' },
    { id: 4, label: 'Status > Type', key: ['contentStatusId', 'contentTypeId'] },
    { id: 5, label: 'Title', key: 'title' },
    { id: 6, label: 'Type', key: 'contentTypeId' },
    { id: 7, label: 'Type > Status', key: ['contentTypeId', 'contentStatusId'] }
];

// Option B
var result: EnumServiceItems = [
    { id: 0, label: 'CId', key: 'contentId' },
    { id: 1, label: 'Modified By', key: 'modifiedBy' },
    { id: 2, label: 'Modified Date', key: 'modified' },
    { id: 3, label: 'Status', key: 'contentStatusId' },
    { id: 4, label: 'Status > Type', key: ['contentStatusId', 'contentTypeId'] },
    { id: 5, label: 'Title', key: 'title' },
    { id: 6, label: 'Type', key: 'contentTypeId' },
    { id: 7, label: 'Type > Status', key: ['contentTypeId', 'contentStatusId'] }
]

Personally I recommend Option A (simpler migration when you are using classes not interfaces).

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Is adding ? to all the declarations in the interface, eg. id?: number; label?: string; key?: any the best way to avoid a casting issue if you use less properties than what is defined in the interface? Ie. I may not specify key in the typed array setup.
Option B is useful since it allows you to use the interface while composing higher level interfaces.
The second interface declaration gives the following tslint error: "an interface declaring no members is equivalent to its supertype"
May I suggest that 'key' is of type string | string[] instead of any. Like this: interface EnumServiceItem { id: number; label: string; key: string | string[] }
TSLint autocorrects this into type EnumServiceItems = Array<EnumServiceItem> and avoids the error mentioned by @Inigo
169

You can define an interface with an indexer:

interface EnumServiceGetOrderBy {
    [index: number]: { id: number; label: string; key: any };
}
Improve this answer

6 Comments

Not really an "interface for an array of objects with Typescript"
Yes, your example of defining an interface only for the particular items would be a more useful way to do it. It would be quite rare to have an array of items, but not want to conveniently reference a single item. Using a real array also exposes .length on the interface, which will probably be used quite often.
How to define class to impliment this interface?
The problem with this solution is this is not an Array interface, therefore all Array properties and methods such as length or push will be missing.
With this you will end up in error while using array functions see this - stackoverflow.com/q/50215823/9640177
|
148

You can define an interface as array with simply extending the Array interface.

export interface MyInterface extends Array<MyType> { }

With this, any object which implements the MyInterface will need to implement all function calls of arrays and only will be able to store objects with the MyType type.

Improve this answer

12 Comments

Why not to use a type (type MyTypeArray = Array<MyType>) instead of extending an interface?
OP asked for interface, I assume it is extended with other properties and methods, you cannot do that with a type and also type is more limited than an interfaces in terms of general usability
@NoNameProvided "type is more limited than an interfaces in terms of general usability" Can you provide more detail on this statement? What are the limitations of using types versus interfaces?
I look at this and I wish that MyType was also defined in this example. I can ALMOST use this answer, except, of course, I get stuck because I don't know what MyType is supposed to look like. Would it be possible to update the answer with that?
@PauFracés now even Microsoft discourages the usage of types and instead advice to use interfaces: github.com/microsoft/TypeScript/wiki/…
|
86

Additional easy option:

    interface simpleInt {
        id: number;
        label: string;
        key: any;
    }

    type simpleType = simpleInt[];
Improve this answer

Comments

33

Do not use 

interface EnumServiceGetOrderBy {
    [index: number]: { id: number; label: string; key: any };
}

You will get errors for all the Arrays properties and methods such as splice etc.

The solution is to create an interface that defines an array of another interface (which will define the object)

For example: 

interface TopCategoriesProps {
  data: Array<Type>;
}
interface Type {
  category: string;
  percentage: number;
}
Improve this answer

Comments

27

So I'll add my two cents :)

Let's say you want a Workplace type full of Persons. You need something like this:

Wrong! ... as interface


interface Workplace {
   name: string
   age: number
}[] 
// that [] doesn't work!! ;)

The problem here is that interface is for specifiing Class/Object shape .. not much more. So you may use type instead which is much more flexible

Better -> use type instead of interface


type Workplace = {
   name: string
   age: number
}[] 

// This works :D

But maybe best is ...

define inner object Person with interface and then Workplace as type made by array of persons -> Person[]


interface Person {
   name: string
   age: number
}

type Workplace = Person[]

// nice ;)

Good luck

Improve this answer

Comments

19

Use like this!

interface Iinput {
  label: string
  placeholder: string
  register: any
  type?: string
  required: boolean
}


// This is how it can be done

const inputs: Array<Iinput> = [
  {
    label: "Title",
    placeholder: "Bought something",
    register: register,
    required: true,
  },
]
Improve this answer

Comments

8

Here's an inline version if you don't want to create a whole new type:

export interface ISomeInterface extends Array<{
    [someindex: string]: number;
}> { };
Improve this answer

1 Comment

I like this option.
8

In Angular use 'extends' to define the interface for an 'Array' of objects.

Using an indexer will give you an error as its not an Array interface so doesn't contain the properties and methods.

e.g

error TS2339: Property 'find' does not exist on type 'ISelectOptions2'.

// good    
export interface ISelectOptions1 extends Array<ISelectOption> {}

// bad
export interface ISelectOptions2 {
    [index: number]: ISelectOption;
}

interface ISelectOption {
    prop1: string;
    prop2?: boolean;
}
Improve this answer

2 Comments

This method will result in "An interface declaring no members is equivalent to its supertype" if the linter doesn't allow empty interfaces.
This answer was soooo close it helped me solve my problem! For the initial object for which you want to create an array within another interface, you type "interface ISelectOptions { name1 : type; name2: type; } then within your BIG interface, when you get to the key you want to be an array of that type, keyZ: ISelectOptions[]; then when you create the JSON, myVar : BIG = {key1: val1, key2: val2, …, keyZ: [{name1 : valA, name2: valB}, {name1 : valC, name2: valD}] worked like a champ! (didn't need to extend the Array class, though) Thanks!
5

Easy option with no tslint errors ...

export interface MyItem {
    id: number
    name: string
}

export type MyItemList = [MyItem]
Improve this answer

3 Comments

The exported MyItemList type will be "a one element array of MyItem"
May it be export type MyItemList = MyItem[]?. IMO the combination of an interface and a type alias is the best fit for this case since you have all methods of the Array type in your type alias
this is not Array but tuple!!
4

Also you can do this.

            interface IenumServiceGetOrderBy {
                id: number; 
                label: string; 
                key: any;
            }

            // notice i am not using the []
            var oneResult: IenumServiceGetOrderBy = { id: 0, label: 'CId', key: 'contentId'};

            //notice i am using []
            // it is read like "array of IenumServiceGetOrderBy"
            var ArrayOfResult: IenumServiceGetOrderBy[] = 
            [
                { id: 0, label: 'CId', key: 'contentId' },
                { id: 1, label: 'Modified By', key: 'modifiedBy' },
                { id: 2, label: 'Modified Date', key: 'modified' },
                { id: 3, label: 'Status', key: 'contentStatusId' },
                { id: 4, label: 'Status > Type', key: ['contentStatusId', 'contentTypeId'] },
                { id: 5, label: 'Title', key: 'title' },
                { id: 6, label: 'Type', key: 'contentTypeId' },
                { id: 7, label: 'Type > Status', key: ['contentTypeId', 'contentStatusId'] }
            ];
Improve this answer

Comments

2

You can define a type as an array of objects by simply extending the interface. Here's an example below :

// type of each item in the Service list
interface EnumServiceItem {
    id: string;
    label: string;
}

// type of the Service 
interface ServiceType {
    id: string,
    label: string,
    childList?: Array<EnumServiceItem>
}

// type of the Service list
type ServiceListType = Array<ServiceType>

let draggableList:ServiceListType =  [
        {
            id: "1",
            label: 'Parent Item 1',
            childList: [
                {
                    id: "11",
                    label: 'Child Item 1',
                },
                {
                    id: "12",
                    label: 'Child Item 2',
                }
                ,
                {
                    id: "13",
                    label: 'Child Item 3',
                }
            ]
        },
        {
            id: "2",
            label: 'Parent Item 2',
            childList: [
                {
                    id: "14",
                    label: 'Child Item 4',
                },
                {
                    id: "15",
                    label: 'Child Item 5',
                }
                ,
                {
                    id: "16",
                    label: 'Child Item 6',
                }
            ]
        },
        {
            id: "3",
            label: 'Parent Item 3',
            childList: [
                {
                    id: "17",
                    label: 'Child Item 7',
                },
                {
                    id: "18",
                    label: 'Child Item 8',
                }
                ,
                {
                    id: "19",
                    label: 'Child Item 9',
                }
            ]
        },

    ]
Improve this answer

Comments

1

Programming is simple. Use simple usecase:

interface IenumServiceGetOrderBy { id: number; label: string; key: any }
 // OR
interface IenumServiceGetOrderBy { id: number; label: string; key: string | string[] }

// use interface like
const result: IenumServiceGetOrderBy[] = 
                [
                    { id: 0, label: 'CId', key: 'contentId' },
                    { id: 1, label: 'Modified By', key: 'modifiedBy' },
                    { id: 4, label: 'Status > Type', key: ['contentStatusId', 'contentTypeId'] }
                ];
Improve this answer

Comments

1

Here is one solution adapted to your example:

interface IenumServiceGetOrderByAttributes { 
  id: number; 
  label: string; 
  key: any 
}

interface IenumServiceGetOrderBy extends Array<IenumServiceGetOrderByAttributes> {

}


let result: IenumServiceGetOrderBy;

With this solution you can use all properties and methods of the Array (like: length, push(), pop(), splice() ...)

Improve this answer

Comments

1

I would use the following structure:

interface arrayOfObjects extends Array<{}> {}

And then it's easier to define:

let myArrayOfObjects: arrayOfObjects = [
  { id: 0, label: "CId", key: "contentId" },
  { id: 1, label: "Modified By", key: "modifiedBy" },
  { id: 2, label: "Modified Date", key: "modified" },
  { id: 3, label: "Status", key: "contentStatusId" },
  { id: 4, label: "Status > Type", key: ["contentStatusId", "contentTypeId"] },
  { id: 5, label: "Title", key: "title" },
  { id: 6, label: "Type", key: "contentTypeId" },
  { id: 7, label: "Type > Status", key: ["contentTypeId", "contentStatusId"] },
];
Improve this answer

Comments

0

I ran into this issue passing an array of arrays of on page TOC data from a content page to a Layout page in Astro, basically each array in the array holds three strings. I have a sting for indenting the <ol><li> tags, a string for the id used as the link anchor, and a string for what to display.

While the data for each display page is unique, the display of this data is the same for all content pages, so I put that code in the Layout page. This way I only have to deal with the code once.

The array defined in the content page looks like this:

    const loadOptoc = [
        ['1-0', 'pc-1', 'Troxel v. Granville'],
        ['1-0', 'pc-2', 'Meyer v. Nebraska'],
     ];

the interface in the Layout page looks like this:

    interface Props {
        loadOptoc?: Array<T>;
    }
    interface T {
        U: Array<U>;
    }
    interface U {
        position: string;
        id: string;
        display: string;
    }
Improve this answer

Comments

0

In my case, if I need an Interface for an Array, I use it like this:

interface IBooleanArray {
  0: boolean
  1: boolean
  2: boolean
  3: boolean
}

So if you want an Interface for an Array of Objects, I prefer to do something like:

interface IObjectArray {
  0: { key: number, value: string}
  1: { key: number, value: string}
  2: { key: number, value: string}
  3: { key: number, value: string}
}

Or just create Interfaces for your Objects and use them in your ArrayInterface

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.