Public
Edited
Feb 3, 2024
lol = [{ a: 1, b: "b" }, { a: 2, b: "" }, { b: "y" }, { a: 6 }]
"map" in Array.prototype
function proxyCol(arr, prop) {
return new Proxy(arr, {
get(obj, key) {
const val = obj[key];
return key in Array.prototype ? val : val?.[prop];
}
});
}
a = proxyCol(lol, "a")
a[2]
b = proxyCol(lol, "b")
Reflect.getPrototypeOf([])
({
x: (function* () {
yield 1;
yield 2;
})()
})
[1, 2].values()
function from(columns, objects) {
// Support arguments in wrong order or just single argument of either type
if (Array.isArray(columns)) [columns, objects] = [objects, columns];
const atleastOneArgumentGiven = !!columns || !!objects;
const columnsIsRightType =
!columns || (columns instanceof Object && !Array.isArray(columns));
const objectsIsRightType = !objects || Array.isArray(objects);
if (!(atleastOneArgumentGiven && columnsIsRightType && objectsIsRightType))
throw new TypeError(
"Bad arguments, should be one array of objects or one object of columns or both in any order"
);
// Trust the length of the objects array or the first column
const length = (objects ?? Object.values(columns).at(0))?.length;
const marker = Symbol();
return {
length,
*[Symbol.iterator]() {
let i = 0;
const proxy = new Proxy(
{},
{
get(_, prop) {
if (prop === marker) return true;
return columns && prop in columns
? columns[prop]?.[i]
: objects?.[i]?.[prop];
},
ownKeys(_) {
return (columns ? Object.getOwnPropertyNames(columns) : []).concat(
objects && objects[i]
? Object.getOwnPropertyNames(objects[i])
: []
);
},
has(_, prop) {
return this.ownKeys().includes(prop);
},
getOwnPropertyDescriptor(_, prop) {
return {
enumerable: true,
configurable: true,
value: this.get(0, prop)
};
}
}
);
for (; i < length; ++i) yield proxy;
},
where(predicate) {
const prev = this;
return {
...this,
*[Symbol.iterator]() {
for (const it of prev) if (predicate(it)) yield it;
}
};
},
select(selector) {
const prev = this;
return {
...this,
*[Symbol.iterator]() {
for (const it of prev) yield selector(it);
}
};
},
array(type = Array) {
return type.from(this, (it) => (it[marker] ? { ...it } : it));
},
map(f) {
return this.select(f);
},
filter(p) {
return this.where(p);
}
};
}
function from_(columns, objects) {
// Support arguments in wrong order or just single argument of either type
if (Array.isArray(columns)) [columns, objects] = [objects, columns];
const atleastOneArgumentGiven = !!columns || !!objects;
const columnsIsRightType =
!columns || (columns instanceof Object && !Array.isArray(columns));
const objectsIsRightType = !objects || Array.isArray(objects);
if (!(atleastOneArgumentGiven && columnsIsRightType && objectsIsRightType))
throw new TypeError(
"Bad arguments, should be one array of objects or one object of columns or both in any order"
);
// Trust the length of the objects array or the first column
const length = (objects ?? Object.values(columns).at(0))?.length;
// Use Lodash to enhance generator
return _(function* () {
let i = 0;
const proxy = new Proxy(
{},
{
get(_, prop) {
return columns && prop in columns
? columns[prop]?.[i]
: objects?.[i]?.[prop];
}
}
);
for (; i < length; ++i) yield proxy;
});
}
tests = [
from({ a: [1], b: [2], i: [1] }),
from([{ a: 1, b: 2, i: 2 }]),
from({ a: [1] }, [{ b: 2, i: 3 }]),
from([{ a: 1 }], { b: [2], i: [4] })
]
tests.map((it) => it.select((x) => [x.i, x.a + x.b]).array()[0])
function assertThrows(...args) {
try {
return from(...args);
} catch {
return true;
}
}
[
assertThrows([{ 1: 1 }], [{ 1: 1 }]),
assertThrows({ 1: [1] }, { 1: [1] }),
assertThrows()
]
c = from({ a, b })
.map((it) => `${it.a}, ${it.b}`)
.array()
c1 = from({ a, b })
.where((it) => it.a % 2 === 0)
.map((it) => `${it.a}, ${it.b}`)
.array()
from({ a, b }).array()
{
const it = from({ a, b }).array();
return it;
}
from({ a, b })
.select((it) => ({ ...it }))
.array()
Apache Arrow comparison
arrow = require("apache-arrow@15.0.0/Arrow.es2015.min.js")
t = arrow.tableFromJSON(lol)
t.toArray()
t.getChild("a")
[t.get(2).a, t.get(3).b]
t.batches
arr_a = arrow.vectorFromArray(lol.map(({ a }) => a))
arr_a.get(2)
arr_a_nulls = arrow.vectorFromArray(lol.map(({ a = null }) => a))
arr_a_nulls.get(2)
arr_b = arrow.vectorFromArray(lol.map(({ b }) => b))
arr_b.get(3)
arr_b_nulls = arrow.vectorFromArray(lol.map(({ b = null }) => b))
arr_b_nulls.get(3)
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
