An object is a data structure which is usually made up of key value pairs. An example of an object that you might see at an incredibly basic level is: { name: “Elon”, surname: “Musk” } The brackets indicate it’s an object, everything inside of it is the data. In this example you can identify the key as name and the value as Elon This concept is consistent across both JavaScript and especially React because after all, React is just a framework for building user interfaces in JavaScript! When we talk about the concept of parent and child, you need to understand that the way data is structured is often hierarchical. In React, we may have a component function that outputs some JSX. It might be a button, let’s say. Well, that button probably sits inside of a container or menu, right? So in this case the button is a child of that container or menu potentially. In regards to props, well, they’re short for properties and you’ve already seen them in the example above! name or surname could be considered properties, or props for short. In React, we often pass data through these component functions using props, and props are normally objects, much like you’ve seen above. In React, you may see an example like props.surname, that is just referring to our object above and referencing the surname property or key. Hope that helps :) More on reddit.com

To build off up someone else's response if you are transferring enough data for this to matter. I would suggest making the following function: const createNote = ([title,message,date])=>({ title, message, date }); Objects are just sooo much easier to deal with on the frontend and whatever speed up you would get on the frontend by reducing memory usage would pale in comparison to the cost of the extra function calls i( getTitle ). More on reddit.com

Ok so I found this: https://github.com/xpl/string.ify . Formatting seems to be ok - not a big fan of the lispy looking output, but it works. would be nice to find something with a little better output More on reddit.com

EDIT: This post has been published--refined and expanded--as a SitePoint article. https://www.sitepoint.com/javascript-object-creation-patterns-best-practises/ So, here's how things evolved. Simple objects. Obviously the simplest way to make an object in JavaScript is an object literal. var o = { x: 42, y: 3.14, f: function() {}, g: function() {} }; But there's a drawback. If you need to use the same type of object in other places, then you'll end up copy-pasting the object's structure and initialization. The fix... 2) Factory functions. Objects are created, initialized, and returned from functions. function thing() { return { x: 42, y: 3.14, f: function() {}, g: function() {} }; } var o = thing(); But there's a drawback. We're creating fresh copies of functions "f" and "g" with each object. It would be better if all "thing" objects could share just one copy of each function. (Note: JavaScript engines are heavily optimized, so this issue is less important today than it used to be.) The fix... 3) Delegating to prototypes. JavaScript makes it easy to delegate property accesses to other objects through what we call the prototype chain. var thingPrototype = { f: function() {}, g: function() {} }; function thing() { var o = Object.create(thingPrototype); o.x = 42; o.y = 3.14; return o; } var o = thing(); This is such a common pattern that the language has some built-in support. A prototype object is created automatically for each function. thing.prototype.f = function() {}; thing.prototype.g = function() {}; function thing() { var o = Object.create(thing.prototype); o.x = 42; o.y = 3.14; return o; } var o = thing(); But there's a drawback. This is going to result in some repetition. In the "thing" function, the first and last lines are going to be repeated almost verbatim in every such delegating-to-prototype-factory-function. The fix... 4) Consolidate the repetition. function create(func) { var o = Object.create(func.prototype); func.call(o); return o; } Thing.prototype.f = function() {}; Thing.prototype.g = function() {}; function Thing() { this.x = 42; this.y = 3.14; } var o = create(Thing); The repetitive lines from "thing" have been moved into "create" and made generic to operate on any such function. This too is such a common pattern that the language has some built-in support. The "create" function we defined is actually a rudimentary version of the "new" keyword. Thing.prototype.f = function() {}; Thing.prototype.g = function() {}; function Thing() { this.x = 42; this.y = 3.14; } var o = new Thing; We've now arrived at ES5 classes. They are object creation functions that delegate shared properties to a prototype object and rely on the new keyword to handle repetitive logic. But there's a drawback. It's verbose and ugly. And implementing the notion of inheritance is even more verbose and ugly. The fix... 5) ES6 classes. They offer a significantly cleaner syntax for doing the same thing. class Thing { constructor() { this.x = 42; this.y = 3.14; } f() {} g() {} } var o = new Thing; More on reddit.com