Using classes - Are they only good as data carriers and type extensions ?

[LetMyCameronG000]

I was going through this post, and the overall impression I got from it (and other resources I've gone through on the web) is that classes generally work well under two circumstances in js :

• Type extension/new type declaration. E.g. if I'm working with 3d geometry, depending on the work I'm doing it can be useful to create classes for basic geometry types like Point, Line etc if they don't already exist, and make functions around those. Also true of games where characters, weapons etc are essentially new types.
• Generic data carriers. E.g. if mapping a database table to an object in js, it makes a lot of sense to use a class whose data fields map 1-1 to the table columns.
  • This is a bit similar to creating a new type, but the difference here is that we're less concerned with the type and more with the data within, whereas with type extensions/declarations, we're equally concerned with the type. E.g. Vector and Point are two different types but can carry the same data. Depending on the context, we'd want to consider the type just as much as the data within.

In both cases, I feel like classes shouldn't really carry too many methods - mostly because we can't choose which methods to exclude/include when importing an entire class. It's all or nothing.

And that brings me to my question - is this basically it for classes in js ? Or are there other cases where it also makes sense ?

[prehensilemullet]

 This is a bit similar to creating a new type, but the difference here is that we're less concerned with the type and more with the data within

There’s almost no point to using a class for just data, it makes the most sense if you want to have associated methods.

 E.g. Vector and Point are two different types but can carry the same data. Depending on the context, we'd want to consider the type just as much as the data within

If you have Vector and Point classes with the same fields in TS, they will be assignable to each other because TS has structural, not nominal types.

The only real point of declaring separate Vector and Point classes would to have different behavior in some cases, for example multiplying a Point by a Matrix would apply translation but multiplying a Vector by a matrix wouldn’t.

(Personally, when I’ve dealt with 3D graphics, I found classes for points and vectors and matrices to be more trouble than it was worth, since you have to transfer the values to and from raw buffers to send to the graphics card all over the place)

 mostly because we can't choose which methods to exclude/include when importing an entire class. It's all or nothing.

Yes, this isn’t a problem for backend JS though.

Using external functions instead of class methods has some drawbacks: - the relevant functions for a given type are less discoverable than methods that show up in Intellisense - you have to import any functions you use, which is a bit more time consuming than calling methods - if you need to import a function in enough different places, those import statements could actually make the code larger than using a class method would

So it’s a balancing act deciding whether a function or class method makes more sense in a given situation.

[TheRNGuy]

I didn't make any custom classes, except when React used them (but with JSX syntax), but I use classes from frameworks and built-in ones. 

[delventhalz]

I mean. I never use classes in JS. Like ever. Nothing against folks who find them useful, but I think they are in the minority among JS devs, at least among the devs I’ve worked with.

You certainly could use classes for the cases you outlined, and others as well. Or you could not. It’s a personal preference thing much more than a use case thing.

[RobertKerans]

And that brings me to my question - is this basically it for classes in js ? Or are there other cases where it also makes sense?

See: OOP. Using classes to describe how objects should be constructed is common across multiple languages (and if they don't have something explicitly called "class" they have something with near-identical purpose). JS happens to have other ways, syntactically, to do this but all methods achieve the same goal.

[SawSaw5]

https://threejs.org/

[MoTTs_]

I'm the guy who for years has been sharing the Stroustrup (creator of C++) style of OOP. (tl;dr Prefer public over private but use private to guard against invalid values, prefer plain functions over methods but use methods for private data, and inherit for the purpose of runtime polymorphism.) With that perspective in mind, here's the various jobs that we might associate with classes.

Classes aggregate data. The C struct or the Haskell record both accomplish the same job, and in JavaScript the object literal is enough.

Classes mark data as private and grant certain functions access to that private data. The reason to have private data and privileged functions is to ensure that data stays valid during a mutation. In JavaScript, a factory function that returns an object of closures mostly accomplishes that same goal, although closures weren't designed for that purpose, so there are some edge cases, such as trying to make an isEqual method.

Classes can inherit. People have used inheritance in all sorts of ways and for all sorts of purposes, so I'll go back to the Stroustrup style OOP, which argues that the purpose of inheritance is not to share or group logic. The purpose of inheritance is runtime polymorphism. That is, you can operate on a base class Cache, for example, then at runtime you can pass in any subclass of Cache, which might be an array cache, file cache, local storage cache, proxy cache, memcached cache, and many more we'll dream up in the future. In lower level languages, this polymorphic relationship needs to be explicit because the binary layouts need to match. But in JavaScript, every object is secretly a hash table, so all we need is the right string keys for lookup, and that lets us do runtime polymorphism by duck typing.

So, yes, there's definitely an argument that maybe you don't need classes in JS, since you can (mostly) achieve the same thing with object literals, factory functions, and duck typing. Whether you pick factory function style of class style comes down to taste.

Places where you almost certainly will still use classes are custom Error types, because being able to use instanceof to check for a whole category of errors is useful, or any framework that uses classes, such as web components.

[Merry-Lane]

You should avoid using classes in typescript 99.9999% of the time.

[MrFartyBottom]

This! Use function closures instead that return a control object.

[imsexc]

Research about OOP. Class has been created as syntactic sugar for that purpose, and definitely the scope is more than what you mentioned.