>  기사  >  웹 프론트엔드  >  js에 대한 사양

js에 대한 사양

不言
不言원래의
2018-04-10 11:46:191517검색

이 기사에서 공유한 내용은 js 사양 문제에 관한 것입니다. 이는 특정 참조 값이 있으며 필요한 친구가 이를 참조할 수 있습니다.

...


Attributes

  • Variables

  • Conditions 표현식 및 등호

  • 블록

  • 댓글

  • 공백

  • 쉼표

  • 세미콜론

  • 유형 변환

  • 명명 규칙

  • 접근자

  • Constructor

  • Events

  • Module

  • jQuery

  • 임베딩 규칙

  • Javascript 프로그램이 배치되어야 함 .js 파일에는 최대한, 호출해야 할 페이지에는

    형태로 포함한다. Javascript 코드가 페이지에 특정하지 않은 경우 페이지에 Javascript 코드를 직접 작성하지 않도록 해야 합니다.
  • 들여쓰기 및 줄바꿈 정렬

  • 들여쓰기

  • 동일한 시스템에서는 동일한 들여쓰기 표준을 사용해야 합니다. 이 글에서는 들여쓰기 크기를 4칸으로 권장합니다. 각 컴파일러에는 Tab 키로 대체되는 공간 크기에 대한 정의가 다릅니다. 개발 환경 설정 시 에디터의 탭 단축키를 공백 4개로 재설정하는 것을 권장합니다. 대부분의 컴파일러는 이 기능을 제공합니다. 그렇지 않으면 들여쓰기를 위해 스페이스 4개를 누르는 것이 좋습니다.
  • 줄 바꿈
  • 다음 위치에서 줄 바꿈을 해야 합니다.
  • 각 독립 문이 끝난 후
  • if, else, catch, finally, while 및 기타 키워드; ;

연산자에서 래핑할 때 연산자는 새 줄의 시작 부분에 있어야 합니다.


한 줄의 길이가 한도를 초과할 때 발생하는 줄 바꿈은 줄 길이 분리 전략을 참조하세요. 0baaeecebbe44862882dd0f4f2ad526a

  • 너무 긴 문자열 잘림

    • 각 코드 줄은 80자 미만이어야 합니다. 코드가 길면 새 줄로 바꾸십시오. 줄 바꿈은 연산자와 구두점 뒤에 있어야 하며, 가급적이면 세미콜론 ";" 또는 쉼표 "," 뒤에 와야 합니다. 다음 코드 줄은 이전 줄에 비해 4칸 들여쓰기됩니다. 이를 통해 복사 및 붙여넣기 시 발생하는 코드 누락 등의 오류를 효과적으로 방지하고 가독성을 높일 수 있습니다.

    삼항 연산자가 너무 깁니다

  • 삼항 연산자는 3개의 부분으로 구성되어 있으므로 줄바꿈은 각 부분의 길이에 따라 3가지 상황을 형성해야 합니다.
    <script>    // 无需换行
        var result = condition ? resultA : resultB;    // 条件超长的情况
        var result = thisIsAVeryVeryLongCondition     ? resultA : resultB;    //  结果分支超长的情况
        var result = condition
            ? thisIsAVeryVeryLongCondition
            :resultB;    var result = condition
            ? resultA
            : thisIsAVeryVeryLongCondition;</script>

    다음 상황이 발생하면 안 됩니다. :

    <script>    // 最后一个结果很长,但不建议合并条件和第一个分支
        // 不要这么干
        var result = condition ? resultA
            : thisIsAVeryVeryLongCondition;</script>

  • 논리조건 조합이 너무 깁니다
    • 논리조건의 조합이 복잡하여 80자가 요구사항을 충족할 수 없는 경우 각 조건은 별도의 줄에 배치하고 논리 연산자는 1줄에 배치해야 합니다. 또는 논리의 일부를 논리 조합으로 분리합니다. 마지막으로 오른쪽 대괄호)와 왼쪽 중괄호 {를 별도의 줄에 배치하면 if 내부의 명령문 블록을 시각적으로 쉽게 식별할 수 있습니다. 예:
    • <script>    // 注意逻辑运算符前的缩进
          if (user.isAuthenticated()
              && user.isInRole(&#39;admin&#39;)
              && user.hasAuthority(&#39;add-admin&#39;)
              || user.hasAuthority(&#39;delete-admin&#39;)
          ) {        // code
          }
      </script>
    • JSON 및 배열이 너무 깁니다.
    • 객체 속성이 많고 각 속성이 한 행에서 너무 많은 공간을 차지하는 경우 다음과 같이 의미 체계 또는 논리에 따라 그룹으로 구성할 수 있습니다.
    • <script>    // 引文-数字的映射
          var mapping = {
              one: 1, two: 2, three: 3, four: 4, five: 5,
              six: 6, seven: 7, eight:8, nine: 9, ten: 10,
              eleven: 11
          }
      </script>
    • By 5 그룹의 그룹은 합리적인 범위 내에서 각 라인을 제어하고 논리적으로 나눕니다. 항목이 많은 배열의 경우에도 같은 방법을 사용할 수 있습니다


    • eturn 문
  1. return 표현식의 실행을 반환 값으로 사용하는 경우 새 줄을 피하기 위해 표현식과 return을 같은 줄에 넣어주세요. 문자가 차단됨 문의 끝으로 잘못 해석되어 오류가 반환됩니다. return 키워드 뒤에 반환 표현식이 없으면 undefound가 반환됩니다. 생성자의 기본 반환 값은 다음과 같습니다.

  2. Naming

이름 지정 방법은 일반적으로 다음 범주에 속합니다.

1. 명칭 설명
    - 1).낙타 명명법, thisIsAnApple
  1. 형식 - 2).pascal 명명법(ThisIsAnApple

    형식) - 3).this_is_an_apple 형식의 밑줄 명명법 ·

    - 4) 밑줄 명명법은 this-is-an-apple
  2. 형식입니다. 콘텐츠 유형에 따라 다음 명명법을 엄격히 사용해야 합니다.

변수 이름: Camel 명명법을 사용해야 합니다.
  1. 매개변수 이름: Camel 명명법을 사용해야 합니다.

기능 이름: Camel 명명법을 사용해야 합니다. 사용됨 메서드/속성: 낙타 명명법을 사용해야 합니다.
  1. 비공개(보호되는) 멤버: 밑줄 _로 시작해야 합니다.

상수 이름: IS_DEBUG_ENABLED

    와 같이 모두 대문자 밑줄 명명법을 사용해야 합니다.
  1. 클래스 이름: Pascal 명명법을 사용해야 합니다

열거 이름: 파스칼 명명법을 사용해야 합니다

열거 속성: 모두 대문자 밑줄 명명법을 사용해야 합니다
  • 命名空间:必须使用camel命名法

  • 语义:命名同时还需要关注语义,如:  

    • 变量名应当使用名词;

    • boolean类型的应当使用is、has等起头,表示其类型;·

    • 函数名应当用动宾短语;

    • 类名应当用名词。

    声明

    变量的声明

    尽管 JavaScript 语言并不要求在变量使用前先对变量进行声明。但我们还是应该养成这个好习惯。这样可以比较容易的检测出那些未经声明的变量,避免其变为隐藏的全局变量,造成隐患。

    在函数的开始应先用 var 关键字声明函数中要使用的局部变量,注释变量的功能及代表的含义,且应以字母顺序排序。每个变量单独占一行,以便添加注释。这是因为 JavaScript 中只有函数的 {} 表明作用域,用 var 关键字声明的局部变量只在函数内有效,而未经 var 声明的变量则被视为全局变量。示例:

    <script>    var valueA = "a";    var valueB = "b";    function f1() {
            var valueA = "c";
            alert("valueA=" + valueA); // output: valueA=c
            valueB = "d";
            alert("valueB=" + valueB); // output: valueB=d
        }
        f1();
        alert("valueA=" + valueA); // output: valueA=a
        alert("valueB=" + valueB); // output: valueB=d</script>

    用 var 声明过的变量 valueA 和没有声明的变量 valueB 是有区别的。特别需要注意的是,在函数内部用 var 声明的变量为局部变量,这样可以有效地避免因局部变量和全局变量同名而产生的错误。

    类型

    • 原始值: 相当于传值

      • string

      • number

      • boolean

      • null

      • undefined

    <script>    var foo = 1,
            bar = foo;
        bar = 9;
    console.log(foo, bar); // => 1, 9</script>
    • 复杂类型: 相当于传引用

      • object

      • array

      • function

    <script>    var foo = [1, 2],
            bar = foo;
        bar[0] = 9;
        console.log(foo[0], bar[0]); // => 9, 9</script>

    对象

    • 使用字面值创建对象

    <script>// badvar item = new Object();// goodvar item = {};</script>
    • 不要使用保留字 reserved words 作为键

    <script>// badvar superman = {  class: &#39;superhero&#39;,  default: { clark: &#39;kent&#39; },
      private: true};// goodvar superman = {
      klass: &#39;superhero&#39;,
      defaults: { clark: &#39;kent&#39; },
      hidden: true};</script>

    数组

    • 使用字面值创建数组

    <script>// badvar items = new Array();// goodvar items = [];</script>
    • 如果你不知道数组的长度,使用push

    <script>var someStack = [];// badsomeStack[someStack.length] = &#39;abracadabra&#39;;// goodsomeStack.push(&#39;abracadabra&#39;);</script>
    • 当你需要拷贝数组时使用slice. jsPerf

    <script>var len = items.length,
        itemsCopy = [],
        i;// badfor (i = 0; i < len; i++) {
      itemsCopy[i] = items[i];
    }// gooditemsCopy = items.slice();</script>
    • 使用slice将类数组的对象转成数组

    <script>function trigger() {
      var args = Array.prototype.slice.call(arguments);
      ...
    }
    </script>

    字符串

    • 对字符串使用单引号 ”

    <script>// badvar name = "Bob Parr";// goodvar name = &#39;Bob Parr&#39;;// badvar fullName = "Bob " + this.lastName;// goodvar fullName = &#39;Bob &#39; + this.lastName;</script>
    • 超过80个字符的字符串应该使用字符串连接换行

    • 注: 如果过度使用,长字符串连接可能会对性能有影响

    <script>// badvar errorMessage = &#39;This is a super long error that was thrown because of Batman. When you stop to think about how Batman had anything to do with this, you would get nowhere fast.&#39;;// badvar errorMessage = &#39;This is a super long error that \
    was thrown because of Batman. \
    When you stop to think about \
    how Batman had anything to do \
    with this, you would get nowhere \
    fast.&#39;;// goodvar errorMessage = &#39;This is a super long error that &#39; +  &#39;was thrown because of Batman.&#39; +  &#39;When you stop to think about &#39; +  &#39;how Batman had anything to do &#39; +  &#39;with this, you would get nowhere &#39; +  &#39;fast.&#39;;</script>
    • 编程时使用join而不是字符串连接来构建字符串,特别是IE

    <script>var items,
        messages,
        length, i;
    
    messages = [{
        state: &#39;success&#39;,
        message: &#39;This one worked.&#39;},{
        state: &#39;success&#39;,
        message: &#39;This one worked as well.&#39;},{
        state: &#39;error&#39;,
        message: &#39;This one did not work.&#39;}];
    
    length = messages.length;// badfunction inbox(messages) {
      items = &#39;<ul>&#39;;  for (i = 0; i < length; i++) {
        items += &#39;<li>&#39; + messages[i].message + &#39;</li>&#39;;
      }  return items + &#39;</ul>&#39;;
    }// goodfunction inbox(messages) {
      items = [];  for (i = 0; i < length; i++) {
        items[i] = messages[i].message;
      }  return &#39;<ul><li>&#39; + items.join(&#39;</li><li>&#39;) + &#39;</li></ul>&#39;;
    }
    </script>

    函数

    • 函数表达式:

    <script>// 匿名函数表达式var anonymous = function() {
      return true;
    };// 有名函数表达式var named = function named() {
      return true;
    };// 立即调用函数表达式(function() {
      console.log(&#39;Welcome to the Internet. Please follow me.&#39;);
    })();</script>
    • 绝对不要在一个非函数块里声明一个函数,把那个函数赋给一个变量。浏览器允许你这么做,但是它们解析不同。

    • 注: ECMA-262定义把块定义为一组语句,函数声明不是一个语句.

    <script>// badif (currentUser) {  function test() {
        console.log(&#39;Nope.&#39;);
      }
    }// goodif (currentUser) {  var test = function test() {
        console.log(&#39;Yup.&#39;);
      };
    }
    
    </script>
    • 绝对不要把参数命名为 arguments, 这将会逾越函数作用域内传过来的 arguments 对象.

    <script>// badfunction nope(name, options, arguments) {
      // ...stuff...}// goodfunction yup(name, options, args) {
      // ...stuff...}
    </script>

    属性

    • 当使用变量访问属性时使用中括号.

    <script>var luke = {
      jedi: true,
      age: 28};function getProp(prop) {
      return luke[prop];
    }var isJedi = getProp(&#39;jedi&#39;);</script>

    变量

    • 总是使用 var 来声明变量,如果不这么做将导致产生全局变量,我们要避免污染全局命名空间。

    <script>// badsuperPower = new SuperPower();// goodvar superPower = new SuperPower();</script>
    • 使用一个 var 以及新行声明多个变量,缩进4个空格。

    <script>// badvar items = getItems();var goSportsTeam = true;var dragonball = &#39;z&#39;;// goodvar items = getItems(),
        goSportsTeam = true,
        dragonball = &#39;z&#39;;</script>
    • 最后再声明未赋值的变量,当你想引用之前已赋值变量的时候很有用。

    <script>// badvar i, len, dragonball,
        items = getItems(),
        goSportsTeam = true;// badvar i, items = getItems(),
        dragonball,
        goSportsTeam = true,
        len;// goodvar items = getItems(),
        goSportsTeam = true,
        dragonball,
        length,
        i;</script>
    • 在作用域顶部声明变量,避免变量声明和赋值引起的相关问题。

    <script>// badfunction() {
      test();
      console.log(&#39;doing stuff..&#39;);  //..other stuff..
    
      var name = getName();  if (name === &#39;test&#39;) {    return false;
      }  return name;
    }// goodfunction() {
      var name = getName();
    
      test();
      console.log(&#39;doing stuff..&#39;);  //..other stuff..
    
      if (name === &#39;test&#39;) {    return false;
      }  return name;
    }// badfunction() {
      var name = getName();  if (!arguments.length) {    return false;
      }  return true;
    }// goodfunction() {
      if (!arguments.length) {    return false;
      }  var name = getName();  return true;
    }
    </script>

    条件表达式和等号

    • 适当使用 === 和 !== 以及 == 和 !=

    • 条件表达式的强制类型转换遵循以下规则:

      • 对象 被计算为 true

      • Undefined 被计算为 false

      • Null 被计算为 false

      • 布尔值 被计算为 布尔的值

      • 数字 如果是 +0, -0, or NaN 被计算为 false , 否则为 true

      • 字符串 如果是空字符串 ” 则被计算为 false, 否则为 true


      • javascript 
        <script> 
        if ([0]) { 
        // true 
        // An array is an object, objects evaluate to true 
        } 
        </script>
    • 使用快捷方式

    <script>// badif (name !== &#39;&#39;) {  // ...stuff...}// goodif (name) {  // ...stuff...}// badif (collection.length > 0) {  // ...stuff...}// goodif (collection.length) {  // ...stuff...}
    </script>

    • 给所有多行的块使用大括号

    <script>// badif (test)  return false;// goodif (test) return false;// goodif (test) {  return false;
    }// badfunction() { return false; }// goodfunction() {
      return false;
    }
    </script>

    注释

    注释要尽量简单,清晰明了。着重注释的意思,对不太直观的部分进行注解

    JavaScript 的注释有两种”//” 和”/* …. */”
     - 建议”//”用作代码行注释
     - “/* …. */”形式用作对整个代码段的注销,或较正式的声明中,如函数参数、功能、文件功能等的描述中
     - >另:复制粘贴应注意注释是否与代码对应。

    • 使用 /* … / 进行多行注释,包括描述,指定类型以及参数值和返回值

    <script>// bad// make() returns a new element// based on the passed in tag name//// @param <String> tag// @return <Element> elementfunction make(tag) {
    
      // ...stuff...
    
      return element;
    }// good/**
     * make() returns a new element
     * based on the passed in tag name
     *
     * @param <String> tag
     * @return <Element> element
     */function make(tag) {
    
      // ...stuff...
    
      return element;
    }
    </script>
    • 使用 // 进行单行注释,在评论对象的上面进行单行注释,注释前放一个空行.

    <script>// badvar active = true;  // is current tab// good// is current tabvar active = true;// badfunction getType() {
      console.log(&#39;fetching type...&#39;);  // set the default type to &#39;no type&#39;
      var type = this._type || &#39;no type&#39;;  return type;
    }// goodfunction getType() {
      console.log(&#39;fetching type...&#39;);  // set the default type to &#39;no type&#39;
      var type = this._type || &#39;no type&#39;;  return type;
    }
    </script>
    • 如果你有一个问题需要重新来看一下或如果你建议一个需要被实现的解决方法的话需要在你的注释前面加上 FIXME 或 TODO 帮助其他人迅速理解

    <script>function Calculator() {
    
      // FIXME: shouldn&#39;t use a global here
      total = 0;  return this;
    }function Calculator() {
    
      // TODO: total should be configurable by an options param
      this.total = 0;  return this;
    }
    </script>

    空白

    • 将tab设为4个空格

      // badfunction() {∙∙var name;
      }// badfunction() {∙var name;
      }// goodfunction() {∙∙∙∙var name;
      }
    • 大括号前放一个空格

      // badfunction test(){console.log(&#39;test&#39;);
      }// goodfunction test() {console.log(&#39;test&#39;);
      }// baddog.set(&#39;attr&#39;,{
      age: &#39;1 year&#39;,
      breed: &#39;Bernese Mountain Dog&#39;});// gooddog.set(&#39;attr&#39;, {
      age: &#39;1 year&#39;,
      breed: &#39;Bernese Mountain Dog&#39;});
    • 在做长方法链时使用缩进.

      // bad$(&#39;#items&#39;).find(&#39;.selected&#39;).highlight().end().find(&#39;.open&#39;).updateCount();// good$(&#39;#items&#39;)
      .find(&#39;.selected&#39;)
        .highlight()
        .end()
      .find(&#39;.open&#39;)
        .updateCount();// badvar leds = stage.selectAll(&#39;.led&#39;).data(data).enter().append(&#39;svg:svg&#39;).class(&#39;led&#39;, true)
        .attr(&#39;width&#39;,  (radius + margin) * 2).append(&#39;svg:g&#39;)
        .attr(&#39;transform&#39;, &#39;translate(&#39; + (radius + margin) + &#39;,&#39; + (radius + margin) + &#39;)&#39;)
        .call(tron.led);// goodvar leds = stage.selectAll(&#39;.led&#39;)
        .data(data)
      .enter().append(&#39;svg:svg&#39;)
        .class(&#39;led&#39;, true)
        .attr(&#39;width&#39;,  (radius + margin) * 2)
      .append(&#39;svg:g&#39;)
        .attr(&#39;transform&#39;, &#39;translate(&#39; + (radius + margin) + &#39;,&#39; + (radius + margin) + &#39;)&#39;)
        .call(tron.led);

    逗号

    • 不要将逗号放前面

      // badvar once
      , upon
      , aTime;// goodvar once,
        upon,
        aTime;// badvar hero = {
        firstName: &#39;Bob&#39;, lastName: &#39;Parr&#39;, heroName: &#39;Mr. Incredible&#39;, superPower: &#39;strength&#39;};// goodvar hero = {
      firstName: &#39;Bob&#39;,
      lastName: &#39;Parr&#39;,
      heroName: &#39;Mr. Incredible&#39;,
      superPower: &#39;strength&#39;};
    • 不要加多余的逗号,这可能会在IE下引起错误,同时如果多一个逗号某些ES3的实现会计算多数组的长度。

      // badvar hero = {
      firstName: &#39;Kevin&#39;,
      lastName: &#39;Flynn&#39;,
      };var heroes = [&#39;Batman&#39;,&#39;Superman&#39;,
      ];// goodvar hero = {
      firstName: &#39;Kevin&#39;,
      lastName: &#39;Flynn&#39;};var heroes = [&#39;Batman&#39;,&#39;Superman&#39;];

    分号

    • 语句结束一定要加分号

      // bad(function() {var name = &#39;Skywalker&#39;return name
      })()// good(function() {var name = &#39;Skywalker&#39;;return name;
      })();// good;(function() {var name = &#39;Skywalker&#39;;return name;
      })();

    类型转换

    • 在语句的开始执行类型转换.

    • 字符串:

      //  => this.reviewScore = 9;// badvar totalScore = this.reviewScore + &#39;&#39;;// goodvar totalScore = &#39;&#39; + this.reviewScore;// badvar totalScore = &#39;&#39; + this.reviewScore + &#39; total score&#39;;// goodvar totalScore = this.reviewScore + &#39; total score&#39;;
    • 对数字使用 parseInt 并且总是带上类型转换的基数.

      var inputValue = &#39;4&#39;;// badvar val = new Number(inputValue);// badvar val = +inputValue;// badvar val = inputValue >> 0;// badvar val = parseInt(inputValue);// goodvar val = Number(inputValue);// goodvar val = parseInt(inputValue, 10);// good/**
      * parseInt was the reason my code was slow.
      * Bitshifting the String to coerce it to a
      * Number made it a lot faster.
      */var val = inputValue >> 0;
    • 布尔值:

      var age = 0;// badvar hasAge = new Boolean(age);// goodvar hasAge = Boolean(age);// goodvar hasAge = !!age;

    命名约定

    • 避免单个字符名,让你的变量名有描述意义。

      // badfunction q() {// ...stuff...}// goodfunction query() {// ..stuff..}
    • 当命名对象、函数和实例时使用驼峰命名规则

      // badvar OBJEcttsssss = {};var this_is_my_object = {};var this-is-my-object = {};function c() {};var u = new user({
      name: &#39;Bob Parr&#39;});// goodvar thisIsMyObject = {};function thisIsMyFunction() {};var user = new User({
      name: &#39;Bob Parr&#39;});
    • 当命名构造函数或类时使用驼峰式大写

      // badfunction user(options) {this.name = options.name;
      }var bad = new user({
      name: &#39;nope&#39;});// goodfunction User(options) {this.name = options.name;
      }var good = new User({
      name: &#39;yup&#39;});
    • 命名私有属性时前面加个下划线 _

      // badthis.__firstName__ = &#39;Panda&#39;;this.firstName_ = &#39;Panda&#39;;// goodthis._firstName = &#39;Panda&#39;;
    • 当保存对 this 的引用时使用 _this.

      // badfunction() {var self = this;return function() {
        console.log(self);
      };
      }// badfunction() {var that = this;return function() {
        console.log(that);
      };
      }// goodfunction() {var _this = this;return function() {
        console.log(_this);
      };
      }

    存取器

    • 属性的存取器函数不是必需的

    • 如果你确实有存取器函数的话使用getVal() 和 setVal(‘hello’)

      // baddragon.age();// gooddragon.getAge();// baddragon.age(25);// gooddragon.setAge(25);
    • 如果属性是布尔值,使用isVal() 或 hasVal()

      // badif (!dragon.age()) {return false;
      }// goodif (!dragon.hasAge()) {return false;
      }
    • 可以创建get()和set()函数,但是要保持一致

      function Jedi(options) {options || (options = {});var lightsaber = options.lightsaber || &#39;blue&#39;;this.set(&#39;lightsaber&#39;, lightsaber);
      }
      
      Jedi.prototype.set = function(key, val) {this[key] = val;
      };
      
      Jedi.prototype.get = function(key) {return this[key];
      };

    构造器

    • 给对象原型分配方法,而不是用一个新的对象覆盖原型,覆盖原型会使继承出现问题。

      function Jedi() {console.log(&#39;new jedi&#39;);
      }// badJedi.prototype = {
      fight: function fight() {
        console.log(&#39;fighting&#39;);
      },
      
      block: function block() {
        console.log(&#39;blocking&#39;);
      }
      };// goodJedi.prototype.fight = function fight() {console.log(&#39;fighting&#39;);
      };
      
      Jedi.prototype.block = function block() {console.log(&#39;blocking&#39;);
      };
    • 方法可以返回 this 帮助方法可链。

      // badJedi.prototype.jump = function() {this.jumping = true;return true;
      };
      
      Jedi.prototype.setHeight = function(height) {this.height = height;
      };var luke = new Jedi();
      luke.jump(); // => trueluke.setHeight(20) // => undefined// goodJedi.prototype.jump = function() {this.jumping = true;return this;
      };
      
      Jedi.prototype.setHeight = function(height) {this.height = height;return this;
      };var luke = new Jedi();
      
      luke.jump()
      .setHeight(20);
    • 可以写一个自定义的toString()方法,但是确保它工作正常并且不会有副作用。

      function Jedi(options) {options || (options = {});this.name = options.name || &#39;no name&#39;;
      }
      
      Jedi.prototype.getName = function getName() {return this.name;
      };
      
      Jedi.prototype.toString = function toString() {return &#39;Jedi - &#39; + this.getName();
      };

    事件

    • 当给事件附加数据时,传入一个哈希而不是原始值,这可以让后面的贡献者加入更多数据到事件数据里而不用找出并更新那个事件的事件处理器

      // bad$(this).trigger(&#39;listingUpdated&#39;, listing.id);
      
      ...
      
      $(this).on(&#39;listingUpdated&#39;, function(e, listingId) {// do something with listingId});

      更好:

      // good$(this).trigger(&#39;listingUpdated&#39;, { listingId : listing.id });
      
      ...
      
      $(this).on(&#39;listingUpdated&#39;, function(e, data) {// do something with data.listingId});

    模块

    • 模块应该以 ! 开始,这保证了如果一个有问题的模块忘记包含最后的分号在合并后不会出现错误

    • 这个文件应该以驼峰命名,并在同名文件夹下,同时导出的时候名字一致

    • 加入一个名为noConflict()的方法来设置导出的模块为之前的版本并返回它

    • 总是在模块顶部声明 'use strict';

      // fancyInput/fancyInput.js!function(global) {&#39;use strict&#39;;var previousFancyInput = global.FancyInput;function FancyInput(options) {
        this.options = options || {};
      }
      
      FancyInput.noConflict = function noConflict() {
        global.FancyInput = previousFancyInput;  return FancyInput;
      };
      
      global.FancyInput = FancyInput;
      }(this);

    jQuery

    • 缓存jQuery查询

      // badfunction setSidebar() {$(&#39;.sidebar&#39;).hide();// ...stuff...$(&#39;.sidebar&#39;).css({  &#39;background-color&#39;: &#39;pink&#39;});
      }// goodfunction setSidebar() {var $sidebar = $(&#39;.sidebar&#39;);
      $sidebar.hide();// ...stuff...$sidebar.css({  &#39;background-color&#39;: &#39;pink&#39;});
      }
    • 对DOM查询使用级联的 $('.sidebar ul')$('.sidebar ul'),jsPerf

    • 对有作用域的jQuery对象查询使用 find

      // bad$(&#39;.sidebar&#39;, &#39;ul&#39;).hide();// bad$(&#39;.sidebar&#39;).find(&#39;ul&#39;).hide();
    • // good$(&#39;.sidebar ul&#39;).hide();// good$(&#39;.sidebar > ul&#39;).hide();// good (slower)$sidebar.find(&#39;ul&#39;);// good (faster)$($sidebar[0]).find(&#39;ul&#39;);

    위 내용은 js에 대한 사양의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

    성명:
    본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
    이전 기사:JS의 판단 유형다음 기사:JS의 판단 유형