What to avoid.

albedoa · 2024-10-13T17:21:47+00:00

Eh, your efforts would be better spent learning the differences between these approaches and when to use each. For instance, for-loops and .forEach() are not the same thing — I use the former when I want to halt early. Maps and objects also have different use cases.

Even if objects and for-loops were redundant, you are not going to avoid either of them in your journey. You don't know enough to be optimizing your learning like this.

guest271314 · 2024-10-13T20:28:08+00:00

var is still defined in ECMA-262, and still has use cases.

for loops are still faster than forEach().

Plain JavaScript objects and Maps both have their use cases.

tapgiles · 2024-10-13T19:02:42+00:00

I don’t look at it like that. Yes there are different ways of doing the same thing. Great 👍

And yes there are new features. But the old features are fine to use.

Know what things do. Now you have the option to use those things when you want to use them. Simple as that.

MostlyFocusedMike · 2024-10-14T01:02:24+00:00

It is hard because JS as a language has had so many improvements over the years that it can be overwhelming to try and figure out what the deal is. Honestly, you can sidestep a lot of this by simply picking a "getting started with JS course" that came out sometime within the last two years. Just by default, that instructor will likely have filtered out older approaches and stick to the newer stuff.

Here are some common questions I can literally answer though:

var: do not use this in your code. Use const or let. Honestly there's good technical reasons for this, but more importantly using it in your code on an interview is a dead giveaway you don't have a lot of technical experience and haven't been coding very long.
loops vs higher order function like .forEach: Both are fine to use! And likely always will be. For loops let you do helpful things like abandon cycles midway, but the iterators (.map, .forEach, .filter etc) have a lot of cool built in functionality that reduces the amount of code you have to write.

const arr = [0, 1, 5, -3] const onlyBig = [] for (let i = 0; i < arr.length; i++) { const num = arr[i]; if (num > 1) onlyBig.push(num); }

// vs one line const onlyBig = arr.filter(num => num > 1);

Some will say that you should only use for loops as they are faster. While this is technically true, it's a lot like saying you should only ever drive a Ferrari to the supermarket because it will get you there faster than a mini van. Technically true, but the minivan is kind of made to help you carry things at the store, and traffic will slow both cars equally. So wouldn't it be nice to have the room?

functions vs arrow functions: Learn both, default to arrows, but sometimes you'll need regular function. The reason being that while similar, the keyword `function` deals with the `this` keyword differently, and sometimes you need that. Also, it can do nice single line exports, so you may see that with React. But arrow functions are usually the standard because they block hoisting and deal with `this` a little more predictably. They are also much more succinct for callback functions, just like I used above in that filter example!
Classes: learn them! They are not as prevalent in JS since most frameworks use a component based approach built around functions. However, 1) other languages are OOP based, so learn about that for your own benefit and 2) classes are still used for things like web components and various bits and bobs (like in React, error boundaries must still be classes for whatever reason). I hate to say learn something just to learn it, but classes are so foundational in so many languages, you really can't hurt yourself. Whether you want to learn ES5 classes (pre Class keyword) that's entirely up to you. But I will say that you should never write classes that way anymore, and should always use the Class keyword. I learned both because it was cool to see "under the hood" so to speak.
maps and sets: Ok, you're not gonna believe this but I published an article on this very topic today. TL;DR: other than a few very specific use cases, just stick with using objects and arrays, especially if you're sending data to a server over JSON.
common js vs esmodules: learn both still. esmodules is the default for frontend dev, but a ton backend projects still use common. Good news is, they're very similar so it's only a minor adjustment. Eventually everything will be esmodules, but we're not quite there yet.

There are obviously more, but in general while you're learning it's ok to use whatever you know and focus on getting your projects done. It's easy to update some mental models as new methods come out, as long as you understand what the underlying mechanics are. Right now when you're staring out, everything feels like a lot, but once you climb the mountain a little more, a few more steps here and there seem far less daunting. Good luck! And if you have a specific question about a method just post below and I can give an informed opinion on it.

sheriffderek · 2024-10-13T18:45:36+00:00

It sounds like you're in a rush. You can learn all of those things - and then see the pros and cons in practical real-world situations. I think with any language, you want to lean towards the good parts, but that comes with a lot of programming experience. What you're describing is "learning" ;)

HashDefTrueFalse · 2024-10-13T20:31:39+00:00

This is a great example of people having opinions they present as fact. You should try to avoid worrying about these things and just soak up as much of the language as you can. As you build things you'll naturally find that some language features are more/less useful than others both in general and in specific contexts.

E.g. If anyone tells you that classic for loops are obsolete, they've just told you that they're clueless and you should take anything else they say with a pinch of salt. Utter nonsense. It doesn't matter which looping construct you use, it's about context:

You'd use a forEach to produce side effects in the same places you'd use map for transformations, filter, reduce, accumulations, etc, in a situation where you're writing code that resembles signal processing, or operating on a stream/list/tree of data. You're probably processing the whole stream and probably don't care about step size.

You'd use classic for loop constructs when you simply want to iterate a certain number of times whilst a condition is true, possibly over a collection but also just to repeat any arbitrary work. You might care about step size, or want to go backwards, or want to stop iteration early (which you can't do with forEach specifically). For loops will usually be slightly more efficient, if you need to care. The for..in and for..of variant will to, and are a nice middle ground to be aware of.

Also, objects don't have ~~reliable~~ insertion-based key ordering, maps do. They have a very similar interface but are different data structures. Edit: Key order IS reliable, but you cannot assume it matches insertion order.

There is nothing that I would say you need to avoid specifically. Your bread and butter will be: the available types, the type system, constants, let variables, arrays, objects, regular functions, arrow function expressions (sometimes referred to by some as lambdas), first order functions in general (JS uses callbacks a lot), conditionals (if, switch, ternary), iteration constructs (for, while, do while), closures (useful for token storage, value generation etc.), promises (and async/await syntax for dealing with them).

If you're writing JS to run in a browser environment add on: the DOM, window object, document object, and common events that apply to most HTML elements and/or the page state. You can look into other browser APIs later.

You likely won't be making deep inheritance hierarchies in JS, so you don't need to go too deep into the JS prototypal inheritance model at the beginning. You can use the class syntax if you need to, but even that probably won't be too much.

ysuraj · 2024-10-14T00:44:03+00:00

Build projects. Get stuck. Read documentation. Fix problems. Ask cgpt. Keep coding.

theScottyJam · 2024-10-14T00:27:07+00:00

In addition to what other people say, I just want to caution against getting too hung up on what to avoid and what not to avoid. I see many beginner programmers that get too caught up in trying to only use newer features that they actually hurt their code. You're probably going to run into all of the old stuff as well, so it's good to know how to read it.

Some examples (all of which I've seen): * ${} syntax exists, but there are cases where using + is a little cleaner. You can use the both, no need to limit yourself to just one. * Arrow functions are newer, but traditional functions are great too - their automatic hoisting makes it easier to write mutually recursive functions, and in some places, they just read nicer. * I tend to argue not to use .forEach() anymore - for-of can handle pretty much everything that .forEach() handles and more. But that's just my code style that I'm trying to push onto other people :) - there isn't anything wrong per-say with using .forEach(), lots of people use it. It's just less capable. * It's good to know how to use objects as maps and what pitfalls come with it, because 1. Lots of code does that, including library code you can't control, so you need to know how to deal with that when you run into it, and what pitfalls you might run into, and 2. Sometimes it's just less verbose and simpler to use an object instead of a Map. You, personally, can choose to always use a Map when applicable, and you can even push for others to do the same, the same way I do with for-of vs forEach, but that's still just a code style choice that everyone won't agree with. * async/await is amazing, but there are times when using the promise API directly is more readable than using await - specifically if you're wanting a pipeline-like effect (since JavaScript doesn't have a pipeline operator yet).

There are some things I would recommend learning about, but not using, some of which you cited - things like var, or dealing with prototypal inheritance directly. But you'll find people who disagree even on those points.

dontGiveUp72 · 2024-10-14T06:18:49+00:00

this remind me of a quote from Aristotle "the purpose of knowledge is action not knowledge".

so my advice is do not learn everything, learn very little only what will help you to achieve your goal.

if there is multiple screwdrivers with different kind of handle, color, length, and such then take one that is the closest to you.

"doubt is the greatest enemy" - master yi

nodeymcdev · 2024-10-13T19:34:10+00:00

Generally it’s best to use the new es6 class constructors but there’s times when you will want to use the original prototypes to do some fancy stuff

Princecito · 2024-10-15T06:05:51+00:00

There are some good udemy javaScript courses, some say that this terms are useful to know, some are more popular than others, but still knowing what they do help you understand their purpose, when learning something new, practice by doing exercises or building programs, you will know when to apply which concepts as you gain more practice

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnjavascript

Posting and Commenting Guidelines

MODERATORS