7 small details to pay attention to when writing javascript code

1. Simplify the code
It is very simple to define objects and arrays in JavaScript. We want to create an object, which is generally written like this:

The following writing method can achieve the same effect:

The following is much shorter, and you don't need to repeat the object name.
In addition, there is also a concise way to write arrays. In the past, we declared that arrays were written like this:

A more concise way of writing is:

For arrays, there is also a special thing like associated with arrays. You will find that a lot of code defines objects like this:

This is crazy, don't be confused, "association array" is just an alias for the object.
Another way to simplify the code is to use the ternary operator, for example:

We can replace this writing method with the following code:

2. Use JSON as data format
The great Douglas Crockford invented the JSON data format to store data, you can use native javascript methods to store complex data without any additional conversions, for example:

You can use JSON directly in JavaScript, or even as a format returned by APIs, and are applied in many APIs, for example:

Here, call the web service that is delicious to get the latest bookmarks, return them in JSON format, and then display them in an unordered list.
Essentially, JSON is the lightest way to describe complex data, and it runs directly in the browser. You can even use it by calling the json_decode() function in PHP.
3. Try to use javascript native functions
To find the largest number in a set of numbers, we might write a loop, for example:

In fact, the same function can be achieved without looping:

The simplest way to write it is:

You can even use to detect which attribute the browser supports:

If you want to add class style to an element, the original writing might look like this:

And the more elegant way of writing is:

4. Event delegation
Events are a very important part of JavaScript. We want to bind click events to a link in a list. The general approach is to write a loop to bind events to each link object. The HTML code is as follows:

The script is as follows:

A more reasonable way to write it is to only bind events to the parent object of the list, the code is as follows:

5. Anonymous functions
One of the most troublesome things about JavaScript is that its variables have no specific scope of action. Generally, any variable, function, array, or object is global, which means that other scripts on the same page can access and overwrite them. The solution is to encapsulate the variables in an anonymous function. For example, the following definition will produce three global variables and two global functions:

After packaging, it is as follows:

This is called the monolithic pattern, and is a JavaScript design pattern. This pattern is used a lot in YUI. The improved writing method is:

6. The code is configurable
If the code you write wants to make it easier for others to use or modify, it needs to be configurable. The solution is to add a configuration object to the script you write. The key points are as follows:
1. Add a new object called configuration to your script.
2. Store all things that other people may want to change in the configuration object, such as the CSS ID, class name, language, etc.
3. Return this object as a public property so that others can rewrite it.
7. Code Compatibility
Compatibility is a part that beginners are likely to ignore. Usually, when learning Javascript, they are tested in a fixed browser, and this browser is likely to be IE, which is very fatal, because among the major mainstream browsers, IE has the worst support for standards. The result that end users see is that the code you wrote does not run correctly in a browser. You should test your code in mainstream browsers, which may be time-consuming, but you should do it.