STOP Using Classes In JavaScript | Prime Reacts 

lol never thought of it that way but 100% true

​@smash3689 really? As a php dev i often think about it.

You just described Smalltalk

All functional first languages are same.

Classes are actually functions. class Dog {} typeof Dog === 'function'

aybe it's just me, but I think it's aweso

THIS IS WHY I DO IT. IT FEELS SOOOOO GOOD

​@@ThePrimeTimeagen accurate text selection is the final frontier in software accessibility and your blazing the path by showing full-bookending is a fools gamble!

I can’t stop noticing this now

why tho

I think this goes for all software dev advice. Don't always or never do something just because someone on the internet said so.

But more lines of code and complexity means quality and elegance!

​@@danvilela This is the way! The more complex your code is, the more secure your job becomes and the more money you can demand from that company, because their business won't survive without someone understanding that "high quality and elegant" code :D At least until ChatGPT becomes better.

@@danvilelaexaclty. Let me just uhh… FactoryManagerFactory.CreateFactoryManager(options)

Clean code/solid/Oop have done a lot of damage. People thing you always need a class for everything.

Exactly, using invalids semantics as that. People who complain about OOP really just mean they hate overly abstracted code. Just say that and move on

@@tc2241 no. they're just saying that there are better abstractions out there. the author of the article could've referred to closures as a better alternative to objects and classes, but he's just a boomer stuck on ES5 lol

It's like the Borg... Resistance is futile

JS is everywhere ... one of us! one of us!

Glad you haven't, my experience with it was i have a feeling of it purposely make me dumber each line i wrote

Your son will be genetically made inside an incubator that runs Javascript so be ready for the future

You programmer tho?

The name is new AbstractNameGetterMethodDelegateFactory() { }.gen()

@@nisonatic newing and invoking inline. chadlike

Also public-static-void-main-string-args-agen

Tell him to KISS a girl

Your colleague suffers from patternitis maybe he would need to go to doctor

Does your colleague like Java? 😂

i wish i would see more KISS on my lips :(

This is a typical mistake beginners do when first learning OOP. After learning a new design pattern they feel the need to apply it to all of their codebase and completely ignoring any common sense. When it comes to design patters, less is often more.

see, that'd be actually useful information, if the article actually was investigating the thing it purported to investigate. it's just a weird crappy opinion piece.

Do you have any sources or something to read more about it?

This is not part of JS. Chrome does nit compile c++

@@AndriiMuliar You obviously don't know C++ or you'd know what he meant. He said C++ structs. Not code. Learn the difference.

​@@DanniDuckstill not part of JS

At the time the article was posted private fields were not widely supported in browsers. Firefox got the feature over a year later (according to caniuse). I agree that it would have been nice for them to say that it was being worked on, though.

​@@Derik. Oh, I should've realised this article is from 2020, thanks for noticing. :) Then the author was indeed right with that point.

Meanwhile, private variables can always be used in JS via closures.

Me too, I try to use it more like structured data

try to avoid classes -first in JS- when functions will do

@oodevr I believe it is nested function definitions whose top-level function returns a bucket object containing the top level function locals and the nested functions. It's cute but a cluster**** in terms of performance. People have dogmatic prejudice against classes.

​@@damienlmooreit at least used to be that it was faster than classes, that's why typescript itself is written that way. It currently seems to be slower a lot of the time, but if you unwrap the actual allocations and lookup logic involved, that's not actually necessarily true, they're just missing some fast paths that classes have. The trade off for not having the semantic clarity of the class syntax is that without using "this", you can much more easily grab a function and call it without using .bind() or .call(), you can have much more natural multiple or private constructors, and without instanceof you can swap it out for tests far more easily. But I've used both, and you can mix them pretty easily, especially with Typescript interfaces. I mostly just wish Typescript didn't default the this parameter to any.

Maybe is a good approach, i don't know. But it sound like another technique that solves nothing and starts a new religion like clean code and agile.

@@xodr5 I... can't figure out what you're actually asking? I didn't say that using "this" was slower than scope lookup, I said it at least used to be. As in they've put a lot of work into v8 to make classes less abysmally slow, and now they're mostly just really fast. I also said that there's not really any real reason for scopes to be slower, which I meant to imply that they currently can be slower, but that that could be fixed. There's not really much in it either way unless you're doing things you shouldn't be doing either way, like allocating a million vectors as objects.

@@xodr5 just checking: you're aware that JavaScript performance changes, as the implementation has work done on it, right? The v8 blog has lots of examples where using some new feature was something like 50 times (not percent!) slower than some earlier equivalent until they made a fix. Don't pay too much attention to performance numbers without specifically measuring, and don't pay much attention to micro-benchmarks (it's stupidly hard to benchmark JavaScript accurately), and don't keep assumptions about performance around for too long either, as things are fixed. For example, are you aware that let and const still have something like 10-20% performance impact in real workloads over var, for example? You'd think it wouldn't make any difference, but it absolutely can (sometimes!), and it might not in the future, as I think it's being looked at right now. The reason I prefer avoiding classes is that it's simpler to think about JavaScript without using "this", not performance. I don't know why you're picking on that point.

yep agree, the moment i saw "Private isnt available" literally null everything he said

Exactly this😂

JS has always been a powerful lang in all the wrong ways. Prototypical OO doesn't add anything useful to the table and its patterns can be replicated using far better abstractions. Every now and then there's a prototype-related vulnerability in V8 that wouldn't exist had JS been any saner to implement and develop with. JS should've had multiple dispatch like Julia imo. At least that seems to be much truer to the aggressive late-binding early OOP advocated.

Hehe, prototypal OO allows you to implement extension methods, like in C#. It is a little over the hand, and the syntax sucks, but after you put up the scaffold it goes pretty smooth

Yep, class-oriented OOP isn't the only game in town.

I saw a “It’s time to say goodbye to Bootstrap” a couple of months ago. I actually read it and as you can guess it was garbage. Just a bunch of “we have tailwind!” And “css is modern” like bootstrap is not constantly taking advantage of new css features At the end of the day, the message is “just be normal” lol. If you dont like bootstrap, sure, talk about it. But dont pretend like you have arrived to a revolutionary “truth” lol

Don't use else is correct though.

Na this absolutely exists in every industry. You just haven't seen the other industries' blogs yet.

That's why the Whitespace language is bound to take off. Nobody can complain "don't use this feature!" when they can't see it.

@@brad1785 lol

For me using “new” and “this” is enough to never use classes. Never!

It was actually (very) briefly mentioned.

If only that were more true for JavaScript. VS Code and Visual Studio do a decent job but when you start passing class instances as arguments they get totally stupid. Luckily there is a silly but mostly harmless work-around: Add a line of code to your class constructor that checks if the constructor's first parameter is an instance of the class itself and simply return it if so. Then whenever you have a function that wants to accept an argument of that class, reconstruct it at the beginning (e.g. arg1 = new className(arg1)). That's enough to make VS Code and Visual Studio remember the class properties again and give you the correct code completion.

​@@stevenleonmusicor just use typescript

just use typescript

Classes actually are much better optimized, especially with the JIT, so that guy is talking out of his ass

Exactly. I’m starting to believe programmer bloggers are just narcissists with an axe to grind

what does shitastic even mean, is that a good or a bad thing?

​@@FlanPoirotprobably "so shit it's funny and thus fun to read"

Ah yes, the IIFE closure returning a public interface :-) I used this pattern extensively past and honestly liked it too, but the minute we had support for native classes I dropped it. I just don’t see the downsides of classes - at least not the way I use them.

@@JensRoland I pretty much exclusively write code for a browser and rarely find the need for anything oop-like, so maybe that's why I don't really use them. Then again I might be stuck in the past a bit too much. Last month I used setTimeout to break a long running fuzzy search algorithm up and prevent it from blocking and make it cancellable. When I was looking at my code after I was done I realized I should have just used a web worker.

@@JensRoland the native classes have no downsides, especially now that you have fully private members. The IIFE closure instead is a bitch and eats a lot of memory

Closures are much slower than classes. JIT compilers optimize classes very well.

Pipe would be so awesome to have. It's one of those things from elixir I always miss in js. that and proper pattern matching. switch is cumbersome.

Yup...event dispatch libraries that leverage composition - like MiniSignals - are a God send.

And yet, encapsulation is the sole reason OOP sucks. At a fine-grained level it just doesn't work

Because you’re working on frontend

Classes are more or less just a familiar syntax for objects with their own “this scope”. Normal struct literal objects in js don’t have their own “this” so it’s difficult to reference “your self”. The way to get a “this scope” in JS is the new keyword, calling a function with new before it creates a “this scope” and applies it to the function being called and if the function doesn’t return a value it returns “this” implicitly or you can explicitly return “this”. Classes work the same way but with a more familiar syntax. You can use classes and constructor functions more or less 1 to 1 but that might change as JS matures further. According to the spec they aren’t currently required to be treated differently by the interpreter. Where are they useful? Classes (scoped objects) have most value you when you have a lot of things that need to keep up with their own state and have methods based on that state. Struct literals can have functions but they can’t easily reference themselves as they don’t have their own scope. They really shine in things like games where you need to co-locate data and self referential functionality.

They are really good for custom elements

Imagine you need to describe a medkit in each funtion TakeFromMedkit AddToMedkit ... You could just write a service that accepts the class MedKit MedKitManipulationService with functions accepting the param MedKit Makes it 10 times easier to track what you need to do whern you make changes

Here's my take, since frontend component usually just need to pass or receive "static" attributes. It doesn't really need full encapsulation that class Provide. Example of Class where it is really powerful is in gamedev, since it translate very well, both the structure and the implementation. Enemy, Player on each own has its own move /attack function Do you really need to encapsulate function in frontend? 99% you dont

Nah. this is what I consider the most correct use case for classes. It lets you decouple a dependency in a modular manner. Say you have 3 data sets depending on some arbitrary choice. (file type, encryption set, Auth provider, and what have you) Your code can then choose the correct resolver for that particular request going trough your resolver pipeline.. A class gives you easy complete encapsulation and abstraction in those cases where you need it most. Inheritance is just wrong 99.999% of the time unless you have like 50 alternative resolves with only small differences or something. like having a db common set of functions shared by schema types. (GraphQL says hi)

@@MrAnticeI don't think I completely followed what you were trying to convey, could you elaborate on the specific case you have in mind and what the worst off alternative would be?

The best case I know that isn't graphql related is having multiple auth providers. (google, facebook ++) Each of these give you a auth token, that all have different encryption keys and schemes. they all come with their own sdk's from the provider as well in many cases. Your user has a request, and as part of that request they are giving you a bearer token, alongside a header that tells you witch provider it comes from. A typical very bad, but far too common solution is to interact directly with the sdk's, by invoking if cases whenever you need to interact with the provider. in effect, your code has to branch whenever you need to interact with auth related data like access rights etc. something that is a common occurence in business logic. Another common one is to completely resolve all users data in the auth middleware at a substantial hit to performance. I've actually seen implementations that use both of these, and it's pure hell. it breaks really easily during updates of any kind. Using encapsulation and abstraction with classes paired with dependency injection solves the same case with far cleaner code, and you get away with only having to choose dependency in your auth middleware once. The rest of your code is then able to be completely auth provider agnostic. you can even pass a mock auth module for unit testing business logic if you want. (A very good idea btw, especially when there is access controll involved)

Hot take 🙂

I realize that this is probably one of the only cases where OOB is actually useful at all 😅

This allows you to combine the methods of multiple objects, into 1 prototype, removing the need of linking prototypes together in an awkward way, and allowing you to combine multiple things on the same level in a simple way.

And that matters only in apps that make use of a MASSIVE number of "instances", the footprint will be smaller because prototypes allow to not duplicate a property value for each instance but simply reference it. It causes more operations needed to go up the prototype chain, but imho that's neglectable. I am ignorant tho, about internals or how that's optimized inside engines.

you should have bigger problems than that in life my boy

you should learn how LZ77 works

Same people who are spouting Go does not support OOP because it has structs.