jQuery Performance Optimization Guide (1)_jquery
The fastest selector in jQuery is the ID selector, because it comes directly from JavaScript's getElementById() method.
For example, there is a piece of HTML code:
If the following selector is used, the efficiency is inefficient.
var traffic_button = $("#content .button");
Because the button already has an ID, we can use the ID selector directly. As shown below:
var traffic_button = $("#traffic_button");
Of course this is only for a single element. If you need to select multiple elements, this will inevitably involve DOM traversal and looping.
In order to improve performance, it is recommended to inherit from the nearest ID.
As shown below:
var traffic_lights = $("#traffic_light input");
2, use tag (tag name) before class
The second fastest selector in jQuery is the tag selector (eg: $("head") ).
When compared to the ID selector, it comes from the native getElementsByTagName() method.
Continue to look at the HTML code just now:
For example, you need to choose red and green radio button,
then you can use a tag name to limit (modify) the class, as shown below:
var active_light = $("input.on");
Of course, you can also combine it with the nearest ID, As shown below:
var active_light = $("#traffic_light input.on");
When using tags to modify classes, we need to pay attention to the following points:
(1) Do not use tag to modify ID, as shown below:
var content = $("div#content");
In this way, the selector will first traverse all div elements , and then match #content.
(It seems that this problem no longer exists after jQuery changed the core of the selector from 1.3.1. It cannot be verified for the time being.)
(2) Don’t use ID to modify the ID, as shown below :
var traffic_light = $("#content #traffic_light");
Note: If you use attribute selectors, please try to use tags to modify them, as shown below:
$ ('p[row="c3221"]').html(); instead of: $('[row="c3221"]').html();
3. Cache jQuery objects
Caching jQuery objects tells us to develop the habit of caching jQuery objects into variables.
The following is a piece of code written by a jQuery newbie:
$("#traffic_light input.on").bind("click", function(){ ... });
$("#traffic_light input.on").css( "border", "1px dashed yellow");
$("#traffic_light input.on").css("background-color", "orange");
$("#traffic_light input.on" ).fadeIn("slow");
But remember not to do this.
We should cache the object into a variable first and then operate as follows:
var $active_light = $("#traffic_light input.on")
$active_light.bind("click", function(){ ... })
$active_light.css ("테두리", "1px 점선 노란색");
$active_light.css("Background-color", "orange")
$active_light.fadeIn("slow");
동일한 선택기가 코드에 여러 번 표시되지 않도록 하세요.
참고: (1) 일반 JavaScript 개체와 jQuery 개체를 구별하기 위해 변수의 첫 문자 앞에 추가할 수 있습니다. $ 기호.
(2) 위 코드는 jQuery의 체인 연산을 이용하여 개선할 수 있습니다. 아래와 같습니다.
.css("border", "1px dashed yellow")
.css( "Background-color", "orange")
.fadeIn("slow");
다음 코드는 다음과 같습니다.
head : $("head"),
traffic_light : $("#traffic_light") ,
traffic_button : $ ("#traffic_button")
};
function do_something(){
// 이제 저장된 결과를 참조하고 조작할 수 있습니다.
var script = document.createElement ("script");
$my.head.append(script);
// 함수 내부에서 작업할 때 전역 개체에 쿼리를 계속 저장할 수 있습니다. = $("#some_ul li ");
$my.other_results = $("#some_table td")
// 전역 함수를 일반 jquery 개체로 사용합니다.
$my.other_results. css("border-color", "red");
$my.traffic_light.css("border-color", "green")
}
//다음을 사용할 수도 있습니다.
jQuery 성능 최적화 가이드(1)는 여기서 끝납니다. 가이드(2)를 확인하세요.

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics











In order to improve the performance of Go applications, we can take the following optimization measures: Caching: Use caching to reduce the number of accesses to the underlying storage and improve performance. Concurrency: Use goroutines and channels to execute lengthy tasks in parallel. Memory Management: Manually manage memory (using the unsafe package) to further optimize performance. To scale out an application we can implement the following techniques: Horizontal Scaling (Horizontal Scaling): Deploying application instances on multiple servers or nodes. Load balancing: Use a load balancer to distribute requests to multiple application instances. Data sharding: Distribute large data sets across multiple databases or storage nodes to improve query performance and scalability.

C++ performance optimization involves a variety of techniques, including: 1. Avoiding dynamic allocation; 2. Using compiler optimization flags; 3. Selecting optimized data structures; 4. Application caching; 5. Parallel programming. The optimization practical case shows how to apply these techniques when finding the longest ascending subsequence in an integer array, improving the algorithm efficiency from O(n^2) to O(nlogn).

Nginx performance tuning can be achieved by adjusting the number of worker processes, connection pool size, enabling Gzip compression and HTTP/2 protocols, and using cache and load balancing. 1. Adjust the number of worker processes and connection pool size: worker_processesauto; events{worker_connections1024;}. 2. Enable Gzip compression and HTTP/2 protocol: http{gzipon;server{listen443sslhttp2;}}. 3. Use cache optimization: http{proxy_cache_path/path/to/cachelevels=1:2k

The performance of Java frameworks can be improved by implementing caching mechanisms, parallel processing, database optimization, and reducing memory consumption. Caching mechanism: Reduce the number of database or API requests and improve performance. Parallel processing: Utilize multi-core CPUs to execute tasks simultaneously to improve throughput. Database optimization: optimize queries, use indexes, configure connection pools, and improve database performance. Reduce memory consumption: Use lightweight frameworks, avoid leaks, and use analysis tools to reduce memory consumption.

Effective techniques for quickly diagnosing PHP performance issues include using Xdebug to obtain performance data and then analyzing the Cachegrind output. Use Blackfire to view request traces and generate performance reports. Examine database queries to identify inefficient queries. Analyze memory usage, view memory allocations and peak usage.

Exception handling affects Java framework performance because when an exception occurs, execution is paused and the exception logic is processed. Tips for optimizing exception handling include: caching exception messages using specific exception types using suppressed exceptions to avoid excessive exception handling

By building mathematical models, conducting simulations and optimizing parameters, C++ can significantly improve rocket engine performance: Build a mathematical model of a rocket engine and describe its behavior. Simulate engine performance and calculate key parameters such as thrust and specific impulse. Identify key parameters and search for optimal values using optimization algorithms such as genetic algorithms. Engine performance is recalculated based on optimized parameters to improve its overall efficiency.

Profiling in Java is used to determine the time and resource consumption in application execution. Implement profiling using JavaVisualVM: Connect to the JVM to enable profiling, set the sampling interval, run the application, stop profiling, and the analysis results display a tree view of the execution time. Methods to optimize performance include: identifying hotspot reduction methods and calling optimization algorithms
