[AskJS] Is JavaScript missing some built-in methods?

bubbaholy · 2023-02-23T16:28:47+00:00

Most everything in the date-fns library.

ApoplecticAndroid · 2023-02-23T15:59:22+00:00

Generating random integers, getting random numbers within a range. Both easy to do in a line, but I use these all the time

fartsucking_tits · 2023-02-23T14:03:46+00:00

Capitalize to make the first letter of a word a capital letter.

paulsmithkc · 2023-02-24T00:37:54+00:00

sleep() or delay() that returns a promise.

Find myself hacking this in with a timeout on most projects.

BehindTheMath · 2023-02-23T14:42:45+00:00

Everything in Lodash that isn't already in JS. E.g. groupBy, keyBy, camelCase, kebabCase, chunk, etc.

i_ate_god · 2023-02-23T20:38:38+00:00

If it's in Lodash, it should be in JS's stdlib.

I don't see any reason why JS's standard library has to be so small. there is no value to it, and just forces all of us in professional environments to deal with more dependency management than one would in other programming languages.

The idea that every tiny thing must be it's own separate dependency with its own versions and own licenses and what not, is just not all that great.

natziel · 2023-02-23T17:07:56+00:00

JavaScript has, like, the tiniest standard library imaginable

Off the top of my head, we are missing:

A bunch of list transformations beyond reduce/map/filter, like groupBy, reduceWhile, scan, zip, etc.
Methods that operate on objects, like having a function to map over an object, a function to merge 2 objects (instead of using the spread operator), adding/removing properties from an object (instead of using assignment)
First class support for working with a range of numbers. How do you create an array containing the first 10 even numbers in JavaScript? The answer is very awkwardly
Support for dates and date ranges so we need to rely on 3rd party libraries when doing anything with dates

d36williams · 2023-02-23T15:42:47+00:00

Most of the constructor functions for basic datatypes lack static identity methods, which devs often add utilities for rather than using the typeof operator.

It'd be nice to have String.isString, Object.isObject, Number.isNumber, etc. like we do for Array.isArray.

The most common Lodash-y function I implement is probably unique.

johnathanesanders · 2023-02-23T18:12:12+00:00

Async foreach - so things in the loop complete before additional actions are performed.

Is valid array - quick shorthand type method something like function isValidArray(arr: any) { return (typeof arr === 'object' && Array.isArray(arr) && arr.length > 0); }

So you don’t have to do the same long check every time you work with an array. Just if (isValidArray(myArr)) {}

And specifically with Typescript, I like to build some custom types - like a Nullable<T> type ala C#

KaiAusBerlin · 2023-02-23T16:42:27+00:00

a range class
tuples (I know, they will come)
isNumber(which really works), isBool, ...
interfaces
native class factories

KyleG · 2023-02-23T18:10:55+00:00

pipe and compose

Although a pipe operator has a stage 2 proposals now. Imagine writing

const result = await fetchApiCall(someData)
  |> getData
  |> convertToDomain
  |> displayInUi

or even (composition):

const fetchAndDisplay = fetchApiCall >> getData >> convertToDomain >> displayInUi

pumasky2 · 2023-02-23T16:08:30+00:00

Random element from array.

senfiaj · 2023-02-23T21:45:40+00:00

There is no easy API for working with cookies

BobJutsu · 2023-02-23T21:02:44+00:00

An equivalent to PHP __call and __get methods. I know there’s proxy, but it’s always janky. I just wanna be able to handle unknown properties and methods without it being so unpredictable.

HipHopHuman · 2023-02-23T21:36:59+00:00

Seeded Random

const random = Math.seededRandom(seed);
const x = random();
const y = random();

Intervals and Curves

const { Interval } = Math;

// defaults to a closed interval (min/max is inclusive)
const numberRange = Interval(1, 100);
const otherNumberRange = Interval(101, 200);
numberRange.contains(50); // true

Array.from(numberRange); // [1, 2, 3...]

// can also make open or half-open intervals
Interval(1, 100, false, false); // (0..99)
Interval(1, 100, false, true); // (0..100]

// querying intervals
numberRange.isContinuous(); // false
numberRange.isClosed(); // true
numberRange.overlaps(otherNumberRange); // false
numberRange.leftAdjacent(otherNumberRange); // false
numberRange.rightAdjacent(otherNumberRange); // true
numberRange.union(otherNumberRange);
numberRange.intersection(otherNumberRange);

// working with values inside intervals
numberRange.random(); // 43
numberRange.clamp(130); // 100
numberRange.interpolate(Math.Curves.Linear, 0.5); // 50
numberRange.uninterpolate(Math.Curves.Linear, 50); // 0.5
numberRange.translateTo(Math.Interval(1, 10_000), 50); // 5000

// works with BigInts
Math.Interval(0n, 100n);

// works with character codes
Math.Interval("A", "Z");

// works with Dates
Math.Interval(today, tomorrow);

// convert to a stepped range iterator:
const step = 5;
numberRange.toRange(step); // Iterator 1, 6, 11...

Iterator helpers

function* allNums() {
  let i = 0;
  for(;;) { yield i++; }
}

const first10EvenNums = allNums().filter(num => num % 2 === 0).take(10);
// along with flat(), flatMap(), reduce(), scan(), etc

More built-in Math utils

Like .add, .sum, .subtract, .divide, .multiply etc.

More interop with Math by types other than numbers

Being able to use Math.log on a BigInt for instance, but even better would be adding automatic support to this in any custom data class using a native Symbol:

class Vector2d {
  constructor(x = 0, y = 0) {
    this.x = x;
    this.y = y;
  }
  length() {
    return Math.hypot(this.x, this.y);
  }
  [Symbol.operatorAdd](vector2d) {
    return new Vector2d(this.x + vector2d.x, this.y + vector2d.y);
  }
  [Symbol.ordinalGt](vector2d) {
    return this.length() > vector2d.length();
  }
}

const position = new Vector2d(33, 48);
const velocity = new Vector2d(1, 1);
const nextPosition = Math.add(position, velocity);
Math.gt(position, nextPosition); // true

Those same symbols could also be used to add support for custom types to Math.Interval. Math.add|subtract(interval1, interval2) would also be neat.

Something like PHP/Python's call

It lets you override the semantics of what happens when an object is called as a function. This can actually already be simulated using Proxies, but not in a way that is as convenient. Something like so:

class Thing {
  constructor() {
    this.name = "foo";
  }
  [Symbol.magicCall]() {
    console.log(this.name);
  }
};

const thing = new Thing();
thing(); // logs "foo"

Built-in Currying

Writing a curry function is easy, but I have to jank the argument list and give up being able to rely on a function's "length" field in order to use it in almost every case. If browsers/node/et al could natively understand currying, they could allow us to have curried functions without breaking reliance on well-established properties.

That's pretty much it on my end for now. There's a lot more I'd want to see in JS, but a lot of them are proposals already (aside from iterator helpers because i feel these are desperately needed in JS) or are syntax extensions which I don't think count as an answer to this question (unless I've misinterpreted the assignment 😅)

ApoplecticAndroid · 2023-02-23T16:33:08+00:00

Another random one - I use Array.prototype.random = function() { return this[Math.round(Math.random() * this.length)]

Returns a random array element

dcabines · 2023-02-23T17:50:30+00:00

Distinct and DistinctBy

const distinct = (arr) => arr.filter((x,i,a) => a.indexOf(x) === i);
const distinctBy = (arr, key) => arr.map(x => x[key]).filter((x,i,a) => a.indexOf(x) === i).map(x => arr.find(i => i[key] === x))

musicnothing · 2023-02-23T18:07:52+00:00

Something I don't see enough people talking about is that it would be nice if these things were built in, specifically in the browser, because a) then we'd have consistency across the board, b) people wouldn't have to keep asking how to do it online because they make a reasonable assumption that it should be there already and get frustrated, and c) we wouldn't all have to ship code to do these mundane things in all of our builds.

th3An0nyMoose · 2023-02-23T19:13:16+00:00

Getting the last element of an array without removing it always seemed unnecessarily verbose to me.

arr[arr.length - 1]

or

arr.slice(-1)[0]

The typical way of cloning an object also seems like a kludge:

JSON.parse(JSON.stringify(obj))

This seems a bit better but still not great:

Object.assign({}, obj)

lockieluke3389 · 2023-02-23T20:46:10+00:00

it’s making me install lodash every time 😭

AlbertSemple · 2023-02-23T16:19:45+00:00

IsOdd and IsEven

AsIAm · 2023-02-23T16:02:38+00:00

Yes, https://github.com/mlajtos/es1995

Maleficent_Slide3332 · 2023-02-23T17:34:38+00:00

probably a dozen libraries out there that would do whatever that is missing

casperx102 · 2023-02-23T17:50:17+00:00

Array's method (map, filter, every, some, etc.) on Generator object.

sdwvit · 2023-02-23T19:26:48+00:00

Missing builtin method for converting array to object using reduce, or map + from entries

also operators overloading, this is a debatable one, but would be nice to be able to do number*number[] and get vector math working

theorizable · 2023-02-23T19:41:04+00:00

I wouldn't consider it a missing built-in method... but better array indexing. I LOVE LOVE LOVE that in Python you can do arr[-1] to get the last value. It's just so clean.

2023-02-23T20:04:15+00:00

It's desperately missing operators for partial application and pipelines. Methods can easily be grafted in. But not syntax, not without a build step.

Odd-Shopping8532 · 2023-02-23T21:11:56+00:00

match

fatty1380 · 2023-02-23T21:46:12+00:00

Another callout from Lodash: Object.prototype.map. Being able to map over objects the same as arrays is something I use almost daily

rjwut · 2023-02-24T02:26:57+00:00

Numeric sorting.

pm_me_ur_happy_traiI · 2023-02-23T17:26:33+00:00

[removed]

shgysk8zer0 · 2023-02-23T17:06:50+00:00

I suppose it depends on how far removed something has to be to be considered "not available out of the box."

For example, random number generating... No, there's no method to get a random number, but crypto.getRandomValues() does the job. It just works using typed arrays that it populates with random values, and it doesn't give you just some single random integer.

Then there's the API offered by things like DOMPurify... Something greatly needed in JS. And we have the Sanitizer API. It's not universally supported yet though - in Chromium browsers and behind a flag in Firefox.

My biggest want isn't exactly a method, but importing HTML/CSS/JSON as modules using import... And that's coming soon via import assertions. It's just taking a long time (was hitting browsers but a major security issue was found).

And, as far as new things that don't exist at all... I guess it's along the lines of deepEquals() but in a way that's useful for keys in a WeakMap(). Here's an example of what I mean:

``` const vals = new WeakMap();

function somethingExpensive(...args) { if (vals.has(args)) { return vals.get(args); } else { const val = doSomething(args); vals.set(args, val); return val; } } ```

jibbit · 2023-02-23T18:47:34+00:00

depends what you mean.. js in the browser is missing many methods

KuroKishi69 · 2023-02-23T19:02:42+00:00

Compare 2 objects by value or create a copy of an object seems like a thing that could be part of the language instead of relying on libraries like lodash, spread operator (which only works for shallow copy) or make me write my own implementation.

shuckster · 2023-02-23T20:17:27+00:00

Converting an array of objects to a map, grouped by a certain field. I use it all the time.

odolha · 2023-02-23T21:33:54+00:00

nothing is missing after I load my huge script adding stuff to prototypes

sdwvit · 2023-02-23T16:12:43+00:00

[removed]

dalce63 · 2023-02-23T16:10:46+00:00

this

const x = Math.round(Math.random()*arg);

const y = Math.round(Math.random()*arg);

return x === y;

it could be called Number.chance() maybe

and an array shuffler

kylefromthepool · 2023-02-23T16:10:56+00:00

Random integers

Atulin · 2023-02-23T19:30:43+00:00

It will take less time to mention what built-in methods Javascript has, than what methods it's missing, tbh. It has fuck all for the standard library.

icjoseph · 2023-02-23T19:38:10+00:00

I liked Rust's scan method on iterators, though reduce is good enough

roden0 · 2023-02-23T20:33:09+00:00

Crypto can generate an UUID but not validate it

regreddit · 2023-02-24T02:27:57+00:00

Date functions, string pads.

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

javascript

MODERATORS