17 JavaScript-Einzeiler

const hasFocus = (ele) => ele === document.activeElement;

const Geschwister = (ele) => [].slice.call(ele.parentNode.children).filter((child) => child !== ele);

// oder const siblings = (ele) => [...ele.parentNode.children].filter((child) => child !== ele);

const getSelectedText = () => window.getSelection().toString();

Geschichte.zurück();
// oder history.go(-1);

const clearCookies = () => Dokument.Cookie
  .Teilt(';')
  .forEach((c) =>(document.cookie = c.replace(/^ +/, '')
  .replace(/=.*/, `=;expires=${new Date().toUTCString()};path=/`)));

// „a“ und „b“ sind ein Array const isEqual = (a, b) => JSON.stringify(a) === JSON.stringify(b);
// oder const isEqual = (a, b) => a.length === b.length und a.every((v, i) => v === b[i]);

// Beispiel isEqual([1, 2, 3], [1, 2, 3]); // true
istgleich([1, 2, 3], [1, '2', 3]); // falsch

const toObject = (arr, key) => arr.reduce((a, b) => ({ ...a, [b[key]]: b }), {});
// oder const toObject = (arr, key) => Object.fromEntries(arr.map((it) => [it[key], it]));

// Beispiel toObject([
  { id: '1', name: 'Alpha', gender: 'Männlich' },
  { id: '2', name: 'Bravo', gender: 'Männlich' },
  { id: '3', name: 'Charlie', gender: 'Weiblich' }],
'Ausweis');

/*
{
'1': { id: '1', name: 'Alpha', gender: 'Männlich' },
'2': { id: '2', name: 'Bravo', gender: 'Männlich' },
'3': { id: '3', name: 'Charlie', gender: 'Weiblich' }
}
*/

const countBy = (arr, prop) => arr.reduce((prev, curr) => ((prev[curr[prop]] = ++prev[curr[prop]] || 1), prev), {});

// Beispiel countBy([
{ Branche: 'audi', Modell: 'q8', Baujahr: '2019' },
{ Branche: 'audi', Modell: 'rs7', Baujahr: '2020' },
{ Branche: 'Ford', Modell: 'Mustang', Baujahr: '2019' },
{ Branche: 'Ford', Modell: 'Explorer', Jahr: '2020' },
{ Branche: 'bmw', Modell: 'x7', Jahr: '2020' },
],
'Zweig');

// { 'audi': 2, 'ford': 2, 'bmw': 1 }

const isNotEmpty = (arr) => Array.isArray(arr) && Object.keys(arr).length > 0;

// Beispiel isNotEmpty([]); // false
istNichtEmpty([1, 2, 3]); // wahr

const isEqual = (...Objekte) => Objekte.jedes((Objekt) => JSON.stringify(Objekt) === JSON.stringify(Objekte[0]));

// Beispiel isEqual({ foo: 'bar' }, { foo: 'bar' }); // true
ist gleich ({ foo: 'bar' }, { bar: 'foo' }); // falsch

const pluck = (objs, Eigenschaft) => objs.map((obj) => obj[Eigenschaft]);

// Beispiel pluck([
  { Name: 'John', Alter: 20 },
  { Name: 'Smith', Alter: 25 },
  { Name: 'Peter', Alter: 30 },
],
'Name');

// ['John', 'Schmied', 'Peter']

const invert = (obj) => Objekt.keys(obj).reduce((res, k) => Objekt.assign(res, { [obj[k]]: k }), {});
// oder const invert = (obj) => Object.fromEntries(Object.entries(obj).map(([k, v]) => [v, k]));

// Beispiel invert({ a: '1', b: '2', c: '3' }); // { 1: 'a', 2: 'b', 3: 'c' }

const removeNullUndefined = (obj) =>
  Objekt.Einträge(Objekt).Reduzieren(
    (a, [k, v]) => (v == null ? a : ((a[k] = v), a)),
    {},
  );

// oder const removeNullUndefined = (obj) =>
  Objekt.Einträge(obj)
    .filter(([_, v]) => v != null)
    .reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});

// oder const removeNullUndefined = (obj) =>
  Objekt.fromEntries(Objekt.entries(obj).filter(([_, v]) => v != null));

// BeispielremoveNullUndefined({
  foo: null,
  Balken: undefiniert,
  Flaum: 42
});
// { fuzz: 42 }

const sort = (Obj) =>
  Objekt.Schlüssel(obj)
    .Sortieren()
    .reduce((p, c) => ((p[c] = obj[c]), p), {});

// Beispiel const colors = {
  weiß: '#ffffff',
  schwarz: '#000000',
  rot: '#ff0000',
  grün: '#008000',
  blau: '#0000ff',
};
sortieren (Farben);
/*
{
  schwarz: '#000000',
  blau: '#0000ff',
  grün: '#008000',
  rot: '#ff0000',
  weiß: '#ffffff',
}
*/

const isPromise = (obj) =>
  !!Objekt &&
  (Typ von Objekt === 'Objekt' || Typ von Objekt === 'Funktion') &&
  Typ von Objekt.dann === 'Funktion';

const isArray = (obj) => Array.isArray(obj);