Changing array type from generic to []

[hisuwh]

I wanted to start a discussion on this.
My preference for array types is T[] as opposed to the generic form Array<T>

It is more concise, less typing (2 chars as opposed to 7) and puts the more important information up front (what is this an array of).

But this is quite a significant change so I would be interested to see what the consensus of the company is.

[jamesadarich]

I'd vote in favour of Array due to the slightly more readable nature personally :)

[davidgruar]

Personally I prefer T[], for the same reasons I prefer int? to Nullable<int> in C# - easier to type and less noise.

[Jameskmonger]

I prefer Array<T> as opposed to T[] generally - I find it clearer and don't really see any benefit to shaving off a few characters. It also becomes much easier to read with multiple dimensional arrays, personally (T[][] vs Array<Array<T>>).

I think it reads more naturally, too: "an array of T" (Array<T>) vs "t array" (T[])

[petevb]

There's a fairly comprehensive style guide from Basarat here which I'd be inclined to follow, purely because MSFT don't go into enough detail in their Style/Contribution Guidelines.

However, it seems to be their way:

• https://github.com/Microsoft/TypeScript-Handbook/blob/master/pages/Generics.md
• https://github.com/Microsoft/TypeScript-Handbook/blob/master/pages/Basic%20Types.md#array
• Design Meeting Notes, 6/2/2017 microsoft/TypeScript#16414

FWIW, I've always written int[] (not Array<int>) and therefore also T[] not Array<T>. But I'm arguing for consistency rather than personal preference. Honest :)

[petevb]

Please get consensus and/or approval from a grown-up (e.g. Phil/Frans). After the commit is okay if this is blocking you, otherwise before ideally.

[Jameskmonger]

I'm not entirely happy with this, actually. It would cause some readability issues in EBC.

Now, we have:

• Array<T>
• KnockoutObservableArray<T>

Whereas this change would give us

• T[]
• KnockoutObservableArray<T>

[OwenPattison]

My preference would be to use Array for similar reasons to before, i find it more readable and its just what i use generally.

[petevb]

I don't care which we choose, only that we're consistent. That's why I looked for guidance on the web. If you guys (Experian) have already established a precedent then unless there's a very good reason to change we should continue with what you've done. I can't think of any justification to change from Array<T> to something else, even though I prefer the alternative.

[hisuwh]

I don't think we do have a precedent in Experian because we don't have any linting.
@OwenPattison do you mean the generic Array<> type?

[petevb]

Is the code reasonably consistent? The linter should match the code.

[OwenPattison]

Sorry yes i meant Array<T> but i agree with Pete consistency is the key here

Being internally consistent is more important than moving to msft/"Basarat" standard.

[Jameskmonger]

I'd prefer the Array generic type as that's what we're using in EBC due to the similarity with KnockoutObservableArray.

[hisuwh]

Your statement is not entirely correct James:

[hisuwh]

Experian is not consistent so I still believe this is still open for debate

[petevb]

Good to know. For comparison (with those 42 occurrences) how many Array<> would you find please?

[Jameskmonger]

108 usages of Array<> (not including KnockoutObservableArray<>)

Including KnockoutObservableArray<> there are 171 usages

[davidgruar]

I think KnockoutObservableArray is a red herring. It's like saying that because project A happens to use a .NET type called FooBarNullable<T> a lot, company style should be to use Nullable<T> instead of T?.

[petevb]

I agree with that, even so it's 108 to 42. A way greater majority than something trivial like exiting Europe, but not particularly consistent either.

[hisuwh]

@dfibuch @thyde1 - forgot you guys were using typescript on Finygo - what's your thoughts?

[thyde1]

I think consistency is what is important here. However, I personally prefer T[] because its more concise, and really shouldn't cause confusion. FWIW, we have generally used this syntax in Finygo.

[thyde1]

In terms of usages, Finygo has Array<T>: 118 vs T[]: 401

[hisuwh]

So to summarise:

• For ----- 3 - (Me, David, Tom)
• Against - 3 - (James, James, Owen)
• In favour of consistency - Pete

Yet to comment @dfibuch @philoUK

On consistency:

• usages of Array<> - 226
• usages of [] - 443

[dfibuch]

I personally follow the pattern already set out on the project, but my preference is to type as little as possible so generally would do T[]

[petevb]

Folks, Thanks for the discussion, stats, and summary.

Please use T[] going forward. It should be trivial to update Array<T> to T[] in existing code.

[hisuwh]

Can we merge this then if we have decided.

[petevb]

Please go ahead.

…

--- Pete van Blerk | Principal Developer | 020 3757 9050 pvanblerk@neworbit.co.uk<mailto:pvanblerk@neworbit.co.uk> From: Henry Ing-Simmons [mailto:notifications@github.com] Sent: 04 October 2017 13:37 To: NewOrbit/tslint-config <tslint-config@noreply.github.com> Cc: Pete van Blerk <pvanblerk@neworbit.co.uk>; Review requested <review_requested@noreply.github.com> Subject: Re: [NewOrbit/tslint-config] Changing array type from generic to [] (#9) Can we merge this then if we have decided. — You are receiving this because your review was requested. Reply to this email directly, view it on GitHub<#9 (comment)>, or mute the thread<https://github.com/notifications/unsubscribe-auth/AFTjxm038xKNUMmWSCFZWtXCxKHp7f8lks5so3v9gaJpZM4PUQds>.

[Jameskmonger]

I'll merge this and publish later.

[Jameskmonger]

Just come across a use case for Array<> over T[]. How would you instantiate an empty typed array without explicitly specifying the type? I can't figure out how. See the difference between the two below.

class Foo {
    private bazArray = new Array<number>();

    private barArray: number[] = [];   
}

That means that arrays are going to be declared differently to other types.

class Foo {
    private count = 3;
    private baz = new Baz();
    private isRed = false;
    private person = {
        name: "Bob",
        age: 22
    };

    // different to the others :(
    private friends: Friend[] = [];
}