javascript object usage

JavaScript is a widely used programming language that is dynamic and flexible. In JavaScript, objects are one of its most powerful and commonly used language constructs. This article will introduce the usage, characteristics and common applications of JavaScript objects.

1. Introduction to JavaScript objects

JavaScript objects are a data type used to encapsulate multiple attributes and form a set of data. Its syntax can be created using object literals, constructors, or the Object.create() method.

1. Object literal method

Object literal method is the simplest and most commonly used method to create objects in JavaScript. The syntax is as follows:

var obj = {
  propertyName1: value1,
  propertyName2: value2,
  ...
  propertyNameN: valueN
};

Among them, propertyName is the property name and value is the property value. Object literals can be thought of as a JSON-like way of creating objects.

2. Constructor method

The constructor method is a method of creating an object by defining a constructor. The syntax is as follows:

function Object(propertyName1, propertyName2, ..., propertyNameN) {
  this.propertyName1 = propertyName1;
  this.propertyName2 = propertyName2;
  ...
  this.propertyNameN = propertyNameN;
}
var obj = new Object(value1, value2, ..., valueN);

Among them, the this keyword represents the current object, and the attribute value is passed in through parameters.

3. Object.create() method

Object.create() is a method to create an object. It can be used to create a new object and specify the prototype of the object. object. The syntax is as follows:

var obj = Object.create(proto, [propertiesObject])

Among them, proto represents the prototype object, and propertiesObject represents the properties to be added to the object and their property values.

2. JavaScript object characteristics

JavaScript objects have the following characteristics:

1. Object properties

JavaScript objects consist of a set of Attribute composition. Property names can be strings or symbols, and property values ​​can be any type of data, including simple types and object types. Use the property name to access the property value, for example:

var obj = {name: "Tom", age: 20};
console.log(obj.name); // 输出："Tom"

2. Property descriptor

Each object property has some descriptors, including enumerable, writable, Configurable and values ​​etc. These property descriptors can be obtained using the Object.getOwnPropertyDescriptor() method.

3. Object methods

JavaScript objects can also contain methods, which are a special type of object property whose value is a function. Methods can be used to manipulate objects and their properties. For example:

var obj = {
  name: "Tom",
  age: 20,
  sayHello: function() {
    console.log("Hello, my name is " + this.name + ", I am " + this.age + " years old.");
  }
};
obj.sayHello(); // 输出："Hello, my name is Tom, I am 20 years old."

4. Object prototype

Objects in JavaScript can inherit properties and methods through prototypes. Every object has a prototype object, and you can use the Object.getPrototypeOf() method to get the prototype of the object.

var parent = {x: 1};
var child = Object.create(parent);
console.log(child.x); // 输出：1

3. Common applications of JavaScript objects

1. Batch creation of objects

Using the object literal method, objects can be created in batches.

var arrOfObj = [
   {name: "Tom", age: 20},
   {name: "Jerry", age: 21},
   {name: "Mickey", age: 22}
];

2. Accessing and modifying object properties

Use . and [] to access and modify object properties.

var obj = {name: "Tom", age: 20};
console.log(obj.name); // 输出："Tom"
obj.age = 21;
console.log(obj["age"]); // 输出：21

3. Passing objects as function parameters

JavaScript objects can be used as function parameters to pass information. For example:

function printObjInfo(obj) {
  console.log("Object name is " + obj.name + ", and age is " + obj.age);
}
var obj = {name: "Tom", age: 20};
printObjInfo(obj);
// 输出："Object name is Tom, and age is 20"

4. Inheritance

Through prototypal inheritance, objects can share properties and methods. For example:

function Person(name, age) {
  this.name = name;
  this.age = age;
}
Person.prototype.sayHello = function() {
    console.log("Hello, my name is " + this.name + ", I am " + this.age + " years old.");
};
function Student(name, age, grade) {
  Person.call(this, name, age);
  this.grade = grade;
}
Student.prototype = Object.create(Person.prototype);
Student.prototype.constructor = Student;
Student.prototype.study = function() {
  console.log(this.name + " is studying in grade " + this.grade);
};

var stu = new Student("Tom", 20, 3);
stu.sayHello(); // 输出："Hello, my name is Tom, I am 20 years old."
stu.study(); // 输出："Tom is studying in grade 3"

4. Summary

JavaScript object is a very important language structure used to encapsulate data and behavior. Object literals, constructors, and Object.create() are the three ways to create objects. Objects have many characteristics, including properties, methods, property descriptors, prototypes, etc. Objects can be used to create, access and modify properties in batches, pass parameters and implement inheritance, etc. Proficient in basic object-related knowledge can help developers quickly create, manipulate, and manage complex data structures in JavaScript code.

The above is the detailed content of javascript object usage. For more information, please follow other related articles on the PHP Chinese website!