Shulou(Shulou.com)05/31 Report--

This article mainly introduces the relevant knowledge of "how to achieve basic types and objects with attributes and methods in JavaScript". The editor shows you the operation process through actual cases, which is simple, fast and practical. I hope this article "how to achieve basic types and objects with attributes and methods in JavaScript" can help you solve the problem.

The preface of "attribute method" of basic types

In other object-oriented programming languages, such as Java and Cellular programming, attributes are unique concepts of objects, and basic types are basic types, and there is no concept of attribute methods.

Yes, it's JavaScript's bad idea again, whose engine allows us to manipulate underlying types of data using attribute methods like Operand objects.

Before we explain this strange feature, we need to make clear what is the difference between the base type and the object type.

What is the basic type

One of the values in the JavaScript base type

There are seven basic types in JavaScript, namely: String, Number, Boolean, BigInt, Symbol, null and undefined

What is the object type

A packet, created with {}, can store multiple values

JavaScript also has other types of objects, such as functions

As will be mentioned in object-oriented, one of the key features of introducing objects is encapsulation, which can store a variety of messy data and methods in a single object, thus reducing the complexity of use.

For example:

Let user = {name: "xiaoming", hello () {console.log (`Hello, I am ${this.name} `);}} user.hello ()

We encapsulate the properties and methods of the object user into an object, so it is very easy to use it. We only need to use obj.attr to call methods or properties.

However, this is done with additional overhead (object-oriented has extra overhead), which is where the object-oriented language C++ is slower than C.

Problems in using basic types as objects

There are two irreconcilable problems with the use of underlying types as objects:

We want to operate on base types like objects, such as "abc" .toUpperCase ()

Object has additional overhead, and we want to keep the simple and efficient features of the underlying type

The solution

The way JavaScript solves the above problems is quite "gentle and muddy":

The base type is the base type, which provides independent, single values.

Allow access to methods and properties of String, Number, Boolean, and Symbol types

In order to ensure the integrity of the theory, when using methods and properties of the underlying type, they are first packaged into objects, and then destroyed

The above rule means that the base type is still the base type, but if we want to access the methods and properties of the base type, we will wrap the base type as an object (object wrapper) and destroy it after the access. To be honest, it sounds a little crazy.

The events behind it

For example:

Let name = "Trump"; console.log (name.toUpperCase ()); / / access methods of the underlying type

The execution result of the above code is as follows:

It doesn't seem like a big problem, but there are a lot of things that have happened, and we need to know the following:

Name is a basic type of string, and there is nothing special about it.

When you access the name property method, you create a special object that contains the string value, which has the toUpperCase method

Call the method toUpperCase of a special object to return a new string

Special objects are destroyed after use.

The value of the variable itself has not changed, as follows:

The result of a compromise

Although the solution is full of compromises (bad ideas), the result is good, and the achievements are as follows:

The basic type keeps itself simple and efficient.

The base type has properties and methods through special objects.

Keep the integrity of the theory, that is, only objects have properties and methods.

In theory, but in practice the JavaScript engine highly optimizes the process, and I suspect it doesn't create additional objects at all. Just verbally said that he followed the norms, as if he really had a temporary date.

Examples of common methods

This article only briefly introduces the concept of basic type method, and does not explain various methods. With the deepening of the tutorial, a large number of methods will be involved step by step. Here is a simple list of some of the common methods and properties of the base type.

Different base types have different attribute methods. The following categories are listed:

String

The length property, which returns the string length

Console.log ("abc" .length)

The result of the above code is as follows:

The indexOf (ch) method, which returns the subscript of the first character ch in the string

Console.log ("abc" .indexOf ('b')); console.log ("abc" .indexOf ('d'))

The result of code execution is as follows:

Returns the subscript (starting at 0) when the character exists in the string, and returns-1 if it cannot be found.

Concat (str) method to concatenate two strings

Let str1 = "hello"; let str2 = "world!"; console.log (str1.concat (str2)); console.log (str1); console.log (str2)

The result of code execution is as follows:

Replace (str1,str2) method to replace str1 with str2

Let str = "javascript"; console.log (str.replace ('java','996')); console.log (str)

The result of code execution is as follows:

Number

The toFixed (num) method, which rounds the decimal to the specified precision

Console.log (9.3333333.toFixed (3)); console.log (9.3333333.toFixed (0))

The result of code execution is as follows:

ToString () method, which converts a number to a string

3.14.toString (); / to '3.14'console.log ((8). ToString (2)); / to binary' 1000'console.log ((9). ToString (2)); / to binary '1001'console.log ((996). ToString (16)); / / to hexadecimal string' 3e4'

The result of code execution is as follows:

ToExponential () method, converted to exponential counting method

Console.log (3.1415926.toExponential ()); console.log (3.1415926.toExponential (2)); console.log (3.1415926.toExponential (3))

The result of code execution is as follows:

Follow-up chapters will show more methods, but I will only repeat them here.

Base type constructor (deprecated feature)

Like Java, JavaScript can explicitly create "object wrappers" for base types through the new operator, which is highly deprecated and is proposed here for the sake of knowledge integrity.

There are problems with this approach, for example:

Let num = new Number (0); console.log (typeof num); console.log (typeof 0)

The result of code execution is as follows:

Or there may be confusion in judgment:

Let zero = new Number (0); if (zero) {/ / zero is true because it is an object console.log ('true');}

The result of code execution is as follows:

At the same time, don't forget that the String/Number/Boolean function without new (keyword) can convert a value to the appropriate type: a string, a number, or a Boolean (primitive type).

For example:

Console.log (typeof Number ('123'))

Note:

There is no method for null and undefined.

This is the end of the introduction to "how JavaScript implements basic types, objects have properties and methods". Thank you for reading. If you want to know more about the industry, you can follow the industry information channel. The editor will update different knowledge points for you every day.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.