Home > Web Front-end > JS Tutorial > body text

The most practical answers to questions in JS development

亚连
Release: 2018-05-17 11:26:57
Original
1274 people have browsed it

Maintainability

Writing maintainable code is important because most developers spend a lot of time maintaining other people's code. It is difficult to develop new code from scratch, and in many cases it is based on the work of others. Ensure the maintainability of your own code so that other developers can work better on this basis.

What is maintainable code?

Understandability: Others can take over the code and understand its intent and general approach without requiring a full explanation from the original developer

Intuitiveness: What's in the code Things can be understood at a glance, no matter how complex the operation is

Adaptability: The code is written in a way that changes in data do not require a complete rewrite

Scalability: The code has been architected to allow for future extensions to core functionality

Debuggability: When something goes wrong, the code can give you enough information to pinpoint the problem as directly as possible

codeconvention

Code convention is a simple way to make the code maintainable. It is to form a set of writing conventions for JavaScript code.
Readability: In order for the code to be maintainable, it must first be readable. Much of readability has to do with code indentation, and another aspect is comments. Include the following aspects:

Functions and methods: Each function or method should contain a comment describing its purpose and the algorithms that may be used to complete the task. It is also very important to state prior assumptions, such as what the parameters represent and whether the function has a return value

Long code: Multiple lines of code used to complete a certain task should be preceded by a comment describing the task

Complex algorithms: If you use a unique way to solve a problem, note how you did it in the comments. Not only will this help other people looking at your code, but it will also help you understand it the next time you look at the code yourself.

Hack: Due to browser differences, js code generally contains some hacks. If you need to use something different because a certain browser doesn't support the normal method, please put it in a comment.

Variable and function names

The naming rules are as follows:

The variable name should be a noun such as car or person

The function name should start with a verb, such as getName (). Functions that return Boolean values ​​begin with is, such as isEnable()

Variable names and functions should use logical names, don't worry about the length. Length can be mitigated by post-processing and compression

Variable type transparency

There are three ways to indicate the variabledata type:

Initialization: when defined After a variable is created, it should be initialized to a value that hints at how it will be used in the future.
For example: var found = false;
Initializing to a specific data type can well indicate the type of the variable. But the disadvantage is that it cannot be used for parameters in function declarations.

Use Hungarian notation to specify the variable type
"o" represents object, "s" represents string, "i" represents integer, "f" represents floating point number, and "b" represents Boolean
For example: var bFound;//Boolean type
The advantage of Hungarian notation is that function parameters can also be used. But the disadvantage is that it makes the code somewhat difficult to read, hindering the intuitive and sentence-like qualities of the code without it.

Use type annotations

var found/*:Booldan*/=false;1
Copy after login

The disadvantage of type annotations is that you cannot use multi-line annotations to annotate large blocks of code at once, because type annotations are also multi-line annotations and the two will conflict.

松散耦合

只要应用的某个部分过分依赖于另一部分,代码就是耦合过紧、难于维护。典型的问题如:对象直接引用另一个对象,并且当修改其中一个的同时需要修改另外一个。紧密耦合的软件难于维护并且需要经常重写。

解耦html/javascript

html和javascript各自代表了解决方案中的不同层次:html是数据,javascript是行为。因为他们天生就需要交互,所以有多种不同的方法将这两个技术关联起来。

情况一:直接写在html中的javascript,使用包含内联代码的<script>元素或者使用Html属性来分配<a href="http://www.php.cn/code/5688.html" target="_blank">事件处理</a>程序,都是过于紧密的耦合。 <br/>比如: <br/>从技术上说都是正确的,但是在实践中,它们将表示数据的html和定义行为的JavaScript紧密耦合在了一起。**理想情况是:**html和JavaScript应该完全分离,并通过外部文件和使用DOM附件行为来包含JavaScript。 <br/>当两者耦合在一起时,出现javascript错误时就要先判断错误出现在Html部分还是javascript文件中。还会引入和代码是否可用的相关问题。 <br/>情况二: <br/>html和javascript的机密耦合也可以在相反的关系上成立:javascript包含了Html.这通常会出现在使用innerHtml来插入一段Html。 <br/>将html和JavaScript解耦可以在调试过程中节省实践,更加容易确定错误的来源,也减轻维护的难度,更改行为只需要在JavaScript文件中进行,而更改标记则只要在渲染文件中。</p><p style="text-align: left;">解耦css/javascript</p><p style="text-align: left;">另外一个web层则是css,它主要负责页面的显示。 <br/>最常见的紧密耦合例子是<a href="http://www.php.cn/code/7565.html" target="_blank">使用javascript</a>来更改某些样式,如下所示:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">//css对javascript的紧密耦合 element.style.color = &quot;red&quot;; element.style.backgroundColor = &quot;blue&quot;; 123</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">由于CSS负责页面的显示,当显示出现问题时应该只是查看CSS文件来解决。然而,当使用了JavaScript来更改某些样式的时候,如上面代码所示,就出现了第二个可能已更改的和必须检查的地方。结果是JavaScript也在某种程度上负责了页面的显示,并与CSS紧密耦合了。如果将来需要修改样式,CSS和JavaScript文件可能都需要修改,这会给维护人员带来噩梦。 <br/>解耦合的原则: <br/>虽然不可能完全将css和javascript解耦,但是还是能让耦合更松散的,这是通过动态改变样式类而非特定样式来实现的,如下所示:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">//css对javascript的松散耦合 element.className = &quot;edit&quot;; 12</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">通过只修改某个元素的css类,就可以让大部分样式信息严格保留在css中。JavaScript可以改变样式类,但并不会直接影响到元素的样式,只要使用了正确的类,那么任何显示问题都可以直接追溯到css而非JavaScript。</p><p style="text-align: left;">第二类紧密耦合仅会在IE中出现(标准模式下的IE8不会出现),它可以在css中通过表达式嵌入javascript,例如:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">/*javascript对css的紧密耦合*/ div{ width:expression(document.body.offsetwidth-10+&quot;px&quot;); }1234</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">通常要避免使用表达式,因为他们不能跨浏览器兼容,还因为它们所引入的JavaScript和css之间的紧密耦合。 <br/>好的层次划分是非常重要的。显示问题的唯一来源应该是css,行为问题的唯一来源应该是javascipt.在这些层次之间保持松散耦合可以让你的整个应用更加易于维护。</p><p style="text-align: left;">解耦应用逻辑/事件处理程序</p><p style="text-align: left;">很少有能仔细得将应用逻辑从事件处理程序中分离的。例如:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">fuction handleKeyPress(event){ if(event.keyCode == 13){ var target = eventUtil.getTarget(event); //应用逻辑部分 var value = 5 * parseInt(target.value); if(value &gt;10){ document.getElementById(&quot;error-msg&quot;).style.display = &quot;block&quot;; } } }12345678910</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">这段代码除了包含应用逻辑,还进行了事件的处理。 <br/>这种方式的问题有其双重性:首先,除了通过事件之外就再没有方法执行应用逻辑,让调试变得困难。如果没有发生预想的结果怎么办?是不是表示事件处理程序没有被调用还会死指应用逻辑失败?其次,如果一个后续的事件引发同样的应用逻辑,那就必须复制功能代码或将代码抽取到一个单独的函数中。无论如何,都要做比实际所需更多的改动。</p><p style="text-align: left;">较好的方法是将应用逻辑和时间处理程序分离,这两者分别处理各自的东西。一个事件处理程序应该从事件对象中提取相关信息,并将这些信息传送到处理应用逻辑的某个方法中。例如前面的代码重写为:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">//处理应用逻辑function validateValue(value){ var value = 5 * parseInt(value); if(value &gt;10){ document.getElementById(&quot;error-msg&quot;).style.display = &quot;block&quot;; } } //事件处理函数 fuction handleKeyPress(event){ if(event.keyCode==13){ var target = EventUtil.getTarget(event); validateValue(target.value); } } 1234567891011121314</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">好处:从事件处理程序中分离应用逻辑有几个好处。首先,可以让你更容易更改触发特定过程的事件。如果最开始由鼠标点击事件触发过程,但现在按键也要进行同样处理,这种更改就很容易。其次,可以在不附加到事件的情况下测试代码,使其更容易创建<a href="http://www.php.cn/php/php-tp-unittesting.html" target="_blank">单元测试</a>或者是自动化应用流程。 <br/>以下是要牢记的应用和业务逻辑之间松散耦合的几条原则:</p><p style="text-align: left;">勿将event对象传递给其他方法;只传来自event对象中所需的数据</p><p style="text-align: left;">任何可以在应用层面的动作都应该可以在不执行任何事件处理程序的情况下进行;</p><p style="text-align: left;">任何事件处理程序都应该处理事件,然后将处理转交给应用逻辑。</p><p style="text-align: left;">牢记着几条可以在任何代码中都获得极大的可维护性的改进,并且为进一步的测试和开发制造了很多可能。</p><p style="text-align: left;">js性能</p><p style="text-align: left;">优化DOM交互</p><p style="text-align: left;">在js中,DOM毫无疑问是最慢的一部分。DOM操作与交互要消耗大量时间,因为它们往往需要重新渲染整个页面或者一部分。理解如何优化与DOM的交互可以极大提高脚本完成的速度。</p><p style="text-align: left;">最小化现场更新</p><p style="text-align: left;">一旦你需要访问的DOM部分是已经显示的页面的一部分,那么你就是在进行一个现场更新,因为需要立即对页面对用户的显示进行更新。 <br/>每一个更改,不管是插入单个字符,还是移除整个片段,都有一个性能惩罚,因为浏览器要重新计算无数尺寸以进行更新。现场更新进行得越多,代码完成执行所花的时间就越长,完成一个操作所需的现场更新越少,代码就越快。 <br/>demo1:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">&lt;body&gt;&lt;ul id=&quot;list&quot;&gt;&lt;/ul&gt;&lt;script type=&quot;text/javascript&quot;&gt;var oList = document.getElementById(&quot;list&quot;); console.time(&quot;计时器1&quot;);for(var i=0;i&lt;1000;i++){ var item = document.createElement(&quot;li&quot;); list.appendChild(item); item.appendChild(document.createTextNode(&quot;item&quot;+i)); } console.timeEnd(&quot;计时器1&quot;);&lt;/script&gt;&lt;/body&gt;12345678910111213</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">上面这段代码为列表添加了1000个项目,添加每个项目时,都需要2个现场更新:一个添加<li>元素,另一个给它添加文本节点。这样添加1000个项目,这个操作总共要完成2000个现场更新。 <br/>修正这个瓶颈(需要减少现场更新的数量)有两种方法: <br/>1.将列表从页面上移除,最后进行更新,最后再讲列表插回到同样的位置。这个方法的问题在于:每次页面更新的时候都会出现不必要的闪烁。 <br/>2.使用文档碎片来构建DOM结构,接着将其添加到List元素中。这种方式避免了现场更新和页面闪烁的问题。(请看Demo2) <br/>Demo2:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">&lt;body&gt;&lt;ul id=&quot;list&quot;&gt;&lt;/ul&gt;&lt;script type=&quot;text/javascript&quot;&gt;var oList = document.getElementById(&quot;list&quot;);var fragment = document.createDocumentFragment(); console.time(&quot;计时器2&quot;);for(var i=0;i&lt;1000;i++){ var item = document.createElement(&quot;li&quot;); fragment.appendChild(item); item.appendChild(document.createTextNode(&quot;item&quot;+i)); }//记住,当给appendChild()传入文档碎片时,只有碎片中的子节点被添加到目标,碎片本身不会被添加的list.appendChild(fragment); console.timeEnd(&quot;计时器2&quot;);&lt;/script&gt;&lt;/body&gt;12345678910111213141516</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">在这个例子中只有一次现场更新,它发生在所有项目都创建好之后。文档碎片用作一个临时的占位符,放置新创建的项目,然后使用appendChild()将所有项目添加到列表中。 <br/>一旦需要更新DOM,考虑使用文档碎片来构建DOM结构,然后再将其添加到现在的文档中。 <br/>两个Demo的执行时间比较: </p><p style="text-align: left;">使用innerHTML</p><p style="text-align: left;">在页面上创建DOM节点的方法: <br/>1.使用诸如createElement()和appendChild()之类的DOM方法 <br/>2.使用innerHTML <br/>对于小的DOM更改而言,两种方法效率都差不多,然而,对于大的DOM更改,使用innerHTML要比使用标准DOM方法创建同样的DOM结构快得多。 <br/>原因:当把innerHTML设置为某个值时,后台会创建一个HTML解析器,然后使用内部的DOM调用来创建DOM结构,而非基于JavaScript的DOM调用。由于内部方法是编译好的而非解释执行的,所以执行快得多。 <br/>Demo:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">&lt;body&gt;&lt;ul id=&quot;list&quot;&gt;&lt;/ul&gt;&lt;script type=&quot;text/javascript&quot;&gt;var oList = document.getElementById(&quot;list&quot;), html = &quot;&quot;, i;for(i=0;i&lt;2000;i++){ html += &quot;&lt;li&gt;item &quot; + i +&quot;&lt;/li&gt;&quot;; } oList.innerHTML = html;//这里构建好一个字符串然后一次性调用innerHTML,这样也只发生一次现场更新&lt;/script&gt;&lt;/body&gt;12345678910111213</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">使用事件代理</p><p style="text-align: left;">页面上的事件处理程序的数量和页面响应用户交互的速度之间是负相关。为了减少这种惩罚,最好使用事件代理。 <br/>事件代理:用到了事件冒泡。任何可以冒泡的事件都不仅仅可以在事件目标上进行处理,目标的任何祖先节点上也能处理。利用这一点,就可以将事件处理程序附加到更高层的地方负责多个目标的事件处理。如果在文档级别附加事件处理程序,这样可以处理整个页面的事件。 <br/>Demo:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">&lt;!DOCTYPE html&gt;&lt;html&gt;&lt;head&gt; &lt;meta charset=&quot;utf-8&quot;&gt; &lt;meta http-equiv=&quot;X-UA-Compatible&quot; content=&quot;IE=edge&quot;&gt; &lt;title&gt;事件委托&lt;/title&gt;&lt;/head&gt;&lt;body&gt;&lt;ul id=&quot;list1&quot;&gt; &lt;li&gt;&lt;a href=&quot;#&quot;&gt;正在监听1&lt;/a&gt;&lt;/li&gt; &lt;li&gt;&lt;a href=&quot;#&quot;&gt;正在监听1&lt;/a&gt;&lt;/li&gt; &lt;li&gt;&lt;a href=&quot;#&quot;&gt;正在监听1&lt;/a&gt;&lt;/li&gt; &lt;li&gt;&lt;a href=&quot;#&quot;&gt;正在监听1&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;ul id=&quot;list2&quot;&gt; &lt;li&gt;&lt;a href=&quot;#&quot;&gt;正在监听2&lt;/a&gt;&lt;/li&gt; &lt;li&gt;&lt;a href=&quot;#&quot;&gt;正在监听2&lt;/a&gt;&lt;/li&gt; &lt;li&gt;&lt;a href=&quot;#&quot;&gt;正在监听2&lt;/a&gt;&lt;/li&gt; &lt;li&gt;&lt;a href=&quot;#&quot;&gt;正在监听2&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;a href=&quot;#&quot; id=&quot;add-items&quot;&gt;添加更多节点&lt;/a&gt;&lt;script type=&quot;text/javascript&quot;&gt;var oList1 = document.querySelector(&quot;#list1&quot;);var aList = oList1.querySelectorAll(&quot;li&quot;);var oList2 = document.querySelector(&quot;#list2&quot;);var oBtn = document.querySelector(&quot;#add-items&quot;);for(var i=0,len=aList.length;i&lt;len;i++){ aList[i].onclick = function(){ alert(&quot;正在监听1&quot;); } } oList2.onclick = function(){ alert(&quot;正在监听2&quot;); } var html = &quot;&lt;li&gt;&lt;a href=&amp;#39;#&amp;#39;&amp;#39;&gt;我是动态新增节点&lt;/a&gt;&lt;/li&gt;&quot;; oBtn.onclick = function(){ oList1.innerHTML += html; oList2.innerHTML += html; }&lt;/script&gt;&lt;/body&gt;&lt;/html&gt;123456789101112131415161718192021222324252627282930313233343536373839404142</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">事件委托好处: <br/>1.能够有效减少页面上事件处理程序的数量 <br/>2.对于动态增加的子节点,依旧能够实现事件的绑定</p><p style="text-align: left;">最小化访问HTMLCollection的次数</p><p style="text-align: left;">最小化访问HTMLCollection的次数可以极大地改进脚本的性能</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">&lt;body&gt;&lt;script type=&quot;text/javascript&quot;&gt;//这里关键在于长度length存入了len变量,而不是每次都去访问HTMLCollection的length属性var images = document. getElementsByTagName (&quot;img&quot;), image, i,len;for(i=0,len=images.length;i&lt;len;i++){ image = images[i]; //其他处理}&lt;/script&gt;&lt;/body&gt;123456789101112</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">注意作用域</p><p style="text-align: left;">避免全局查找</p><p style="text-align: left;">可能优化脚本性能最重要的就是注意全局查找。使用全局变量和函数肯定要比局部的开销更大,因为要涉及作用域链上的查找。 <br/>下面的代码包含了3个对于全局document对象的引用。如果在页面上有多个图片,那么for循环中的document引用就会被执行多次甚至上百次,每次都会进行作用域链查找。</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">&lt;script type=&quot;text/javascript&quot;&gt;/* 通过创建一个指向document对象的局部变量,就可以通过限制一次全局查找来提升这个函数的性能。 */function updateUI(){ var imgs = document.getElementsByTagName(&quot;img&quot;); for(var i=0,len=imgs.length;i&lt;len;i++){ imgs[i].title = document.title + &quot;image&quot; +i; } var msg = document.getElementById(&quot;msg&quot;); msg.innerHTML = &quot;Update complete&quot;; }function updateUI(){ //缓存全局变量,减少全局变量的查找。这样就减少了话费在作用域上查找的时间,就能提升脚本的性能。改进后的函数只有一次全局查找。 var doc = document; var imgs = doc.getElementsByTagName(&quot;img&quot;); for(var i=0,len=imgs.length;i&lt;len;i++){ imgs[i].title = doc.title + &quot;image&quot; +i; } var msg = doc.getElementById(&quot;msg&quot;); msg.innerHTML = &quot;Update complete&quot;; }&lt;/script&gt;123456789101112131415161718192021222324</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">下面的例子中通过创建一个指向document对象的局部变量,就可以通过限制一次全局查找来提升这个函数的性能。</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">&lt;script type=&quot;text/javascript&quot;&gt;function updateUI(){ //缓存全局变量,减少全局变量的查找。这样就减少了话费在作用域上查找的时间,就能提升脚本的性能。改进后的函数只有一次全局查找。 var doc = document; var imgs = doc.getElementsByTagName(&quot;img&quot;); for(var i=0,len=imgs.length;i&lt;len;i++){ imgs[i].title = doc.title + &quot;image&quot; +i; } var msg = doc.getElementById(&quot;msg&quot;); msg.innerHTML = &quot;Update complete&quot;; }&lt;/script&gt;123456789101112</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">避免with语句</p><p style="text-align: left;">with语句会创建自己的作用域,因此会增加其中执行的代码的作用域链的长苏。由于额外的作用域链查找,在with语句中执行的代码肯定会比外面执行的代码要慢。 <br/>看下面这个例子:</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">&lt;script type=&quot;text/javascript&quot;&gt;/* 大多数情况下,可以使用局部变量完成相同的事情而不必引入新的作用域 */function updateBody(){ with(document.body){ console.log(tagName);//这里将代码的作用域设置到document.body对象中 innerHTML = &quot;Hello world&quot;; } }function updateBody(){ var body = document.body; console.log(body.tagName);//这里将代码的作用域设置到document.body对象中 body.innerHTML = &quot;Hello world&quot;; }&lt;/script&gt;123456789101112131415161718</pre><div class="contentsignin">Copy after login</div></div><p style="text-align: left;">大多数情况下,可以使用局部变量完成相同的事情而不必引入新的作用域</p><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:js;toolbar:false">&lt;script type=&quot;text/javascript&quot;&gt;function updateBody(){ var body = document.body; console.log(body.tagName);//这里将代码的作用域设置到document.body对象中 body.innerHTML = &quot;Hello world&quot;; }&lt;/script&gt;</pre><div class="contentsignin">Copy after login</div></div><p>上面是我整理给大家的JS开发中最实用的问题解答,希望今后会对大家有帮助。</p> <p>相关文章:</p> <p style="text-align: left;"><a href="http://www.php.cn/js-tutorial-396516.html" target="_blank">重点解答js的几种提交方式</a><br></p> <p style="text-align: left;"><a href="http://www.php.cn/js-tutorial-396514.html" target="_blank">详细讲解JS中Windows对象课程</a><br></p> <p style="text-align: left;"><a href="http://www.php.cn/js-tutorial-396504.html" target="_blank">如何在<script></script>标签中一样可以使用el表达式

The above is the detailed content of The most practical answers to questions in JS development. For more information, please follow other related articles on the PHP Chinese website!

Related labels:
source:php.cn
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
About us Disclaimer Sitemap
php.cn:Public welfare online PHP training,Help PHP learners grow quickly!