Set type of object javascript

Can I set the type of a Javascript object?

Sets are a new object type with ES6 (ES2015) that allow creating collections of unique values. The values in a set can be either simple primitives like strings or integers as well as more complex object types like object literals or arrays.,Strings are a valid iterable so they can also be passed-in to initialize a set:,Here’s another example where we pass-in an array to initialize the set. Notice how the initializing array gets deconstructed, but an array added added later stays in the form of an array:,Sets also have the keys and values methods, with keys being an alias for values, so both methods do exactly the same thing. Using either of these methods returns a new iterator object with the values of the set in the same order in which they were added to the set. Here’s an example:

Here’s a simple example showing off a basic set and a few of the available methods on it like add, size, has, forEach, delete and clear:

let animals = new Set(); animals.add('?'); animals.add('?'); animals.add('?'); animals.add('?'); console.log(animals.size); // 4 animals.add('?'); console.log(animals.size); // 4 console.log(animals.has('?')); // true animals.delete('?'); console.log(animals.has('?')); // false animals.forEach(animal => < console.log(`Hey $!`); >); // Hey ?! // Hey ?! // Hey ?! animals.clear(); console.log(animals.size); // 0

Here’s another example where we pass-in an array to initialize the set. Notice how the initializing array gets deconstructed, but an array added added later stays in the form of an array:

let myAnimals = new Set(['?', '?', '?', '?']); myAnimals.add(['?', '?']); myAnimals.add(< name: 'Rud', type: '?' >); console.log(myAnimals.size); // 4 myAnimals.forEach(animal => < console.log(animal); >); // ? // ? // ["?", "?"] // Object

Strings are a valid iterable so they can also be passed-in to initialize a set:

console.log('Only unique characters will be in this set.'.length); // 43 let sentence = new Set('Only unique characters will be in this set.'); console.log(sentence.size); // 18

On top of using forEach on a set, for…of loops can also be used to iterate over sets:

let moreAnimals = new Set(['?', '?', '?', '?']); for (let animal of moreAnimals) < console.log(`Howdy $< animal >`); > // Howdy ? // Howdy ? // Howdy ? // Howdy ?

Sets also have the keys and values methods, with keys being an alias for values, so both methods do exactly the same thing. Using either of these methods returns a new iterator object with the values of the set in the same order in which they were added to the set. Here’s an example:

let partyItems = new Set(['?', '?', '?']); let items = partyItems.values(); console.log(items.next()); console.log(items.next()); console.log(items.next()); console.log(items.next().done); // Object < // done: false, // value: "?" // >// Object < // done: false, // value: "?" // >// Object < // done: false, // value: "?" // >// true

Answer by Lilyana Schultz

In Firefox only, you can use the __proto__ property to replace the prototype for an object. Otherwise, you cannot change the type of an object that has already been created, you must create a new object using the new keyword.,The pattern you posted, consists simply on augmenting objects, and the prototype chain is not used at all.,If you really want to use the instanceof operator, you can combine another Crockford’s technique, Prototypal Inheritance with super constructors, basically to inherit from the Bicycle.prototype, even if it’s an empty object, only to fool instanceof:,How can I set or retrieve the type of my new object? I don’t want to create a type attribute if there’s a right way to do it.

If you really want to use the instanceof operator, you can combine another Crockford’s technique, Prototypal Inheritance with super constructors, basically to inherit from the Bicycle.prototype , even if it’s an empty object, only to fool instanceof :

// helper function var createObject = function (o) < function F() <>F.prototype = o; return new F(); >; function Bicycle(tires) < var that = createObject(Bicycle.prototype); // inherit from Bicycle.prototype that.tires = tires; // in this case an empty object that.toString = function () < return 'Bicycle with ' + that.tires + ' tires.'; >; return that; > var bicycle1 = Bicycle(2); bicycle1 instanceof Bicycle; // true 

Answer by Daniel Frederick

Using this for object references,Defining properties for an object type,Alternatively, you can create an object with these two steps:,Define the object type by writing a constructor function. There is a strong convention, with good reason, to use a capital initial letter.

Answer by Houston Jennings

In JavaScript, even if the property has never been set, we can still access it — it’s just going to give us the value undefined. We can just handle undefined specially.,Note that there is currently no way to place type annotations within destructuring patterns. This is because the following syntax already means something different in JavaScript.,We can also read from those properties — but when we do under strictNullChecks, TypeScript will tell us they’re potentially undefined.,Note that this pattern of setting defaults for unspecified values is so common that JavaScript has syntax to support it.

It is possible to support both types of indexers, but the type returned from a numeric indexer must be a subtype of the type returned from the string indexer. This is because when indexing with a `number`, JavaScript will actually convert that to a `string` before indexing into an object. That means that indexing with `100` (a `number`) is the same thing as indexing with `»100″` (a `string`), so the two need to be consistent.

tsinterface Animal < name: string;>interface Dog extends Animal < breed: string;>// Error: indexing with a numeric string might get you a completely separate type of Animal!interface NotOkay

Answer by Ayden Middleton

Summary: in this tutorial, you will learn about the JavaScript object’s properties and their attributes such as configurable, enumerable, writable, get, set, and value.,A property descriptor object that has four properties: configurable, enumerable, writable, and value.,It returns a descriptor object that describes a property. the descriptor object has four properties: configurable, enumerable, writable, and value.,The following example creates a person object which has the firstName and lastName properties with the configurable, enumerable, and writable attributes set to true. Their values are set to ‘John’ and ‘Doe’ respectively:

The following example creates a person object which has the firstName and lastName properties with the configurable, enumerable, and writable attributes set to true. Their values are set to ‘John’ and ‘Doe’ respectively:

.wp-block-code < border: 0; padding: 0; >.wp-block-code > div < overflow: auto; >.shcb-language < border: 0; clip: rect(1px, 1px, 1px, 1px); -webkit-clip-path: inset(50%); clip-path: inset(50%); height: 1px; margin: -1px; overflow: hidden; padding: 0; position: absolute; width: 1px; word-wrap: normal; word-break: normal; >.hljs < box-sizing: border-box; >.hljs.shcb-code-table < display: table; width: 100%; >.hljs.shcb-code-table > .shcb-loc < color: inherit; display: table-row; width: 100%; >.hljs.shcb-code-table .shcb-loc > span < display: table-cell; >.wp-block-code code.hljs:not(.shcb-wrap-lines) < white-space: pre; >.wp-block-code code.hljs.shcb-wrap-lines < white-space: pre-wrap; >.hljs.shcb-line-numbers < border-spacing: 0; counter-reset: line; >.hljs.shcb-line-numbers > .shcb-loc < counter-increment: line; >.hljs.shcb-line-numbers .shcb-loc > span < padding-left: 0.75em; >.hljs.shcb-line-numbers .shcb-loc::before < border-right: 1px solid #ddd; content: counter(line); display: table-cell; padding: 0 0.75em; text-align: right; -webkit-user-select: none; -moz-user-select: none; -ms-user-select: none; user-select: none; white-space: nowrap; width: 1%; >let person = < firstName: 'John', lastName: 'Doe' >;Code language: JavaScript (javascript)

The following example creates a person object with the age property:

let person = <>; person.age = 25;Code language: JavaScript (javascript)

Since the default value of the [[Configurable]] attribute is set to true , you can remove it via the delete operator:

delete person.age; console.log(person.age);Code language: CSS (css)

undefinedCode language: JavaScript (javascript)

The following example creates a person object and adds the ssn property to it using the Object.defineProperty() method:

'use strict'; let person = <>; Object.defineProperty(person, 'ssn', < configurable: false, value: '012-38-9119' >); delete person.ssn;Code language: JavaScript (javascript)

TypeError: Cannot delete property 'ssn' of #Code language: PHP (php)

If you use the Object.defineProperty() method to change any attribute other than the writable, you’ll get an error. For example:

'use strict'; let person = <>; Object.defineProperty(person, 'ssn', < configurable: false, value: '012-38-9119' >); Object.defineProperty(person, 'ssn', < configurable: true >);Code language: JavaScript (javascript)

TypeError: Cannot redefine property: ssnCode language: JavaScript (javascript)

By default, the enumerable attribute of all the properties defined on an object is true. It means that you can iterate over all properties using the for. in loop as shown in the following example:

let person = <>; person.age = 25; person.ssn = '012-38-9119'; for (let prop in person) < console.log(prop); >Code language: JavaScript (javascript)

The following makes the ssn property non-enumerable by setting the enumerable attribute to false .

let person = <>; person.age = 25; person.ssn = '012-38-9119'; Object.defineProperty(person, 'ssn', < enumerable: false >); for (let prop in person) < console.log(prop); >Code language: JavaScript (javascript)

To define an accessor property, you must use the Object.defineProperty() method. For example:

let person = < firstName: 'John', lastName: 'Doe' >Object.defineProperty(person, 'fullName', < get: function () < return this.firstName + ' ' + this.lastName; >, set: function (value) < let parts = value.split(' '); if (parts.length == 2) < this.firstName = parts[0]; this.lastName = parts[1]; >else < throw 'Invalid name format'; >> >); console.log(person.fullName);Code language: JavaScript (javascript)

'John Doe'Code language: JavaScript (javascript)

In ES5, you can define multiple properties in a single statement using the Object.defineProperties() method. For example:

var product = <>; Object.defineProperties(product, < name: < value: 'Smartphone' >, price: < value: 799 >, tax: < value: 0.1 >, netPrice: < get: function () < return this.price * (1 + this.tax); >> >); console.log('The net price of a ' + product.name + ' is ' + product.netPrice.toFixed(2) + ' USD');Code language: JavaScript (javascript)

The net price of a Smartphone is 878.90 USDCode language: CSS (css)

The following example gets the descriptor object of the name property of the product object in the prior example.

let person = < firstName: 'John', lastName: 'Doe' >; let descriptor = Object.getOwnPropertyDescriptor(person, 'firstName'); console.log(descriptor);Code language: JavaScript (javascript)

Answer by Easton Flowers

The following example demonstrates objects created using object literal syntax. , An object can be created using object literal or object constructor syntax. , The object literal is a short form of creating an object. Define an object in the < >brackets with key:value pairs separated by a comma. The key would be the name of the property and the value will be a literal value or a function. ,The properties and methods will be available only to an object where they are declared.

var p1 = < name:"Steve" >; // object literal syntax var p2 = new Object(); // Object() constructor function p2.name = "Steve"; // property 

Answer by Elina Hanna

In this post, we will learn each of these methods.,New operator or constructor.,In the next post, we will dive into other aspects of JavaScript! ,Create an instance of an object using a new operator.

An object literal, also called an object initializer, is a comma-separated set of paired names and values. You can create an object literal as shown below:

var car = < model: 'bmw', color: 'red', price: 2000 >console.log(JSON.stringify(car));

You can add properties dynamically in an object, including after you have created the object. Here we add the dynamic property car.type:

var car = < model: 'bmw', color: 'red', price: 2000 >console.log(JSON.stringify(car)); car.type = 'manual'; // dynamic property console.log(JSON.stringify(car));

The object literal is a simple expression that creates an object each time the statement that it appears in is executed in the code. You can also use Object.defineProperty to create properties in the object literal as shown below:

var car = < model: 'bmw', color: 'red', price: 2000 >Object.defineProperty(car, "type", < writable: true, enumerable: true, configurable: false, value: 'gas' >); console.log(car.type); //gas 

The second way to create an object is to use the constructor function. If you call a function using a new operator, the function acts as a constructor and returns an object. Consider the following code:

function Car(model, color) < this.model = model; this.color = color; >var c1 = new Car('BMW', 'red'); console.log(c1.model);

To create a Student object, first, create a function as shown below. In this example, this represents the object being created, so name and age will be properties of the newly created object.

Next, create instances of the Student object type as shown below:

var s1 = new Student('foo', 7); console.log(s1.name); var s2 = new Student('koo', 9); console.log(s2.name);

You can use the instanceof operator to find types of the instance and determine whether s1 is an instance of the Student object, as shown below:

var s1 = new Student('foo', 9); console.log(s1 instanceof Student);

You can also use Object.defineProperty to create properties in the constructor function, as shown below:

function Car(model) < Object.defineProperty(this, "model", < writable: true, enumerable: true, configurable: false, value: model >); > var myCar = new Car("Audi A3"); console.log(myCar.model); // Audi A3

You can also create new objects using the Object.create() method, which allows you to specify the prototype object and the properties. For example:

You can use the Car object as a prototype to create another object, as shown below:

var ElectricCar = Object.create(Car); console.log(ElectricCar.model); // BMW

In this example, you have created an object called ElectricCar using the Car object as a prototype, so the ElectricCar object will have all the properties of the Car object. You can also add properties as shown below:

var ElectricCar = Object.create(Car, < type: < value: 'Electric', writable: true, configurable: false, enumerable: true >>); console.log(ElectricCar.type); // Electric

ECMAScript 6 introduced the class keyword to create classes in JavaScript. Now you can use the class attribute to create a class in JavaScript instead of a function constructor, and use the new operator to create an instance. Consider the following code:

You can use the Car class to create objects as shown below:

var car1 = new Car("BMW", 100); car1.getInfo(); var car2 = new Car("Audi", 150); car2.getInfo();

Источник