> 웹 프론트엔드 > H5 튜토리얼 > H5가 사용자 등록 자동 인증을 완료한 상세 예시

H5가 사용자 등록 자동 인증을 완료한 상세 예시

Y2J
풀어 주다: 2017-05-24 13:27:07
원래의
2572명이 탐색했습니다.

Html5 사용자 등록자동 확인 기능 구현 예시 코드

05-24 10:49:46 작성자: php 중국어 사이트

자동 확인 기능이 포함된 HTML5 사용자 등록 데모를 작성하는 시간을 가졌습니다. 검증에는 한dlebars템플릿 기술과 휴대폰인증코드가 사용됩니다.

다음은 효과 스크린샷입니다:

1. 페이지 코드: usersRegister.hbs

XML /HTML 코드클립보드에 콘텐츠 복사
  1. >     

  2.      

  3.      

  4.      

  5. <html lang="en">     

  6.      

  7. <머리>     

  8.     <meta http-equiv="Content-Type" content="text/html; charset =utf-8">     

  9.     <메타 http-equiv="X-UA 호환" 콘텐츠="IE=edge" />     

  10.     <제목>용户注册제목 >     

  11.          

  12.         <양식  id="my-form" class="myform">     

  13.             <div>     

  14.                <라벨>용도명:라벨><입력 id="사용자 이름" 이름="사용자 이름" 유형 ="텍스트" />     

  15.            div >     

  16.             <div>     

  17.                     

  18.                <레이블>密码:레이블><입력 id="pass" 이름="비밀번호" 유형="텍스트" />     

  19.            div>     

  20.              div & gt;

  21. & lt; 레이블 & gt; 邮箱:라벨><입력 ID="이메일" 이름="이메일"     

  22.                         
  23. 데이터에 이상적

    ="필수이메일" 입력="이메일" />     

  24.            
  25. div>     
  26.             <div>     

  27.                <라벨>电话:라벨><입력 ID="전화" 유형="텍스트" 이름= "전화" 데이터에 이상적="전화" />     

  28.             div>     

  29.            <div >     

  30.                <라벨>供应商V码:라벨><입력 id="vCode " 유형="텍스트" 이름="vCode" 데이터 이상적="vCode" />     

  31.             div>     

  32.             <div>     

  33.                 <라벨>真实姓name:라벨><입력 id="trueName" type="text" name="trueName" 데이터 이상적="trueName" />     

  34.            div>     

  35.             div>     

  36.                <레이블>핸드机验证码:라벨><입력 ID= "telCode" 유형="텍스트" 이름="telCode" 데이터 이상적="telCode" />     

  37.             div>     

  38.             & lt; div 스타일="여백-하단:5px;">     

  39.                <버튼 id="getTelCode" type="버튼" 스타일="왼쪽 여백:160px; 오른쪽 여백:auto;"  >获取机校验码버튼>     

  40.               

    < ;시간 스타일="margin-top:5px; margin-bottom:5px;" /> ;     

  41.             

    div>     

  42.                 

  43.     div>     

  44. < ;스크립트 유형="text/javascript">     

  45. var 옵션 = {     

  46.         onFail : function() {     

  47.             alert($myform.getInvalid(). 길이 + ' 잘못된 필드.')     

  48.         },     

  49.         입력 : {     

  50.             '비밀번호 ' : {     

  51.                필터 : '필수 패스'     

  52.             },     

  53.             '사용자 이름' : {     

  54.                필터 : '필수 사용자 이름'     

  55.             },     

  56.             '이메일' : {     

  57.                 필터 : '필수 이메일'     

  58.             },     

  59.             '전화' : {

  60.                필터 : '필수 전화'     

  61.            },    

  62.             'trueName' : {     

  63.                 필터 : '필수'     

  64.            },     

  65.             'vCode' : {     

  66.                필터 : '필수'     

  67.            },     
  68.             'telCode' : {     
  69.                필터 : '필수'     
  70.           }     
  71.             / *     
  72.             '연령': {     
  73.                필터 : '필수 digit',     

  74.                데이터 : {     

  75.                  분 : 16,     

  76.                 최대 : 70     

  77.                 }     
  78.             },     
  79.             '파일' : {     
  80.                필터 : '확장자',     
  81.                 데이터 : {     

  82.                    확장자: [ 'jpg' ]     

  83.                }     

  84.             },     

  85.            '댓글' : {     

  86.               필터 : '최소 최대',     

  87.                 데이터 : {     

  88.                   분 : 50,     

  89.                  최대 : 200     

  90.                 }     

  91. },     

  92.            '상태' : {     

  93.               필터 : '제외',     
  94.                 데이터 : {     
  95.                   제외 : [ 'default' ]     
  96.                },     
  97.                 
  98. 오류
  99.  : {     

  100.                   제외 : '选择國籍.'     

                   }     
  101.            },    

  102.            'langs[]' : {     

  103.                 필터 : '최소 최대',     

  104.                데이터 : {     

  105.                  분 : 2,     

  106.                    최대 : 3     

  107.                },     

  108.                오류 : {     

  109.                     분 : '최소 
  110. <

    <🎜 이상 확인하세요. >강함>2강함> 옵션.',                       최대 : '

  111. <
  112. 강함>3강함 > 옵션 모두갚아야 합니다.'                    }     

  113.            }     

  114.            */     

  115.         }     

  116.     };     

  117.     $('#getTelCode').click(function() {     

  118.         var 

    전화
  119.  = 
  120. 문서.getElementById("telephone").value;    // 手机号码             if (전화

     == 
  121. null
  122.  || 

    전화 == ""){                alert("手机号码不能为空!");     

  123.         }     
  124.         
  125. else

    {     

  126.             $.ajax({    

                   유형 : "GET",     
  127.                dataType : "

    json
  128. ",     
  129.                 url : " ../
  130. api

    /getTelCode?전화="+ 전화,     

  131.                성공 : 함수(msg) {                     },     

  132.               오류: 기능(e) {     

  133.                     alert("获取手机校验码失败!" + e);     
  134.                                                                 🎜>

  135. }) ; 
  136.  var $
  137. myform

    = $('#my -form').idealforms(options).data('idealforms'); 

  138. $('#submit').click(function() {

  139. var 사용자 이름 =

    문서
  140. .getElementById("username").value; //사용자 이름
  141. var
  142. 비밀번호

    = 문서.getElementById("pass") .value; //비밀번호

  143. var
  144. 이메일

    = 문서 .getElementById("email").value; //이메일 주소

  145. var
  146. telephone

    = document.getElementById("telephone ").value; //휴대폰번호

  147. var
  148. vCode

    = document.getElementById("vCode").value; // V사 코드

  149. var
  150. telCode

    = document.getElementById("telCode").value //휴대폰 인증 코드

  151. var
  152. trueName

    = document.getElementById("trueName").value; //실명

  153. $.ajax({ GET", 
  154.                                                                         >="+ 비밀번호 +"

    이메일
  155. =
  156. "+ 이메일 + "

    전화
  157. =
  158. "+전화 +"

    vCode
  159. =
  160. "+ vCode +"

    telCode= "+ telCode +"trueName="+ trueName ,                                                                    | > ~ // 호스트 주소 뒤의 디렉터리: uimcardprj/share/meun.jsp                                       🎜> window.document.location.pathname

  161. var pos = curWwwPath.indexOf(pathName);

  162. // 호스트 주소를 가져옵니다. 예: http://localhost:8083

  163. var localhostPaht = curWwwPath.substring(0, pos) ;                                                     // "/"를 사용하여 프로젝트 이름을 가져옵니다. 예: /uimcardprj                                                           > =

    pathName
  164. .
  165. substr

    ing(0, pathName.substr(1).indexOf(' /') + 1); window.location.href

    =
  166. 프로젝트 이름
  167. + "/login";

    🎜> },                                                            ert( "등록 실패!" + e);

  168. }                                                      >
  169. $('#reset').click(function() {

    $myform.reset().fresh().focusFirst()
  170. });                                     🎜>
  171. < ;/

  172. 본문
  173. >

     
  174. html

    >
  175.  

  176. 2.jq 입력 확인: jquery .idealforms.js

  177. 이 js 검증의 초기 버전은 Cedric Ruiz에서 가져온 것이며 약간 수정했습니다.

    부분 확인 규칙은 다음과 같습니다.
  178. 필수: '필수입니다.'

    숫자: '숫자여야 합니다.',
  179. 자리 : '고유한 숫자여야 합니다.'

    name: '3자 이상이어야 하며 문자만 포함할 수 있습니다.'username: '사용자 이름은 5자리 이상이어야 합니다. 최대 길이는 30자이며, 영문, 숫자, 한자, 밑줄을 사용하시기 바랍니다. 🎜>pass: ' 비밀번호는 6~15자 사이여야 하며 숫자, 대문자, 소문자를 각각 하나씩 포함해야 합니다. 'strongpass: '8자 이상이어야 합니다. 하나 이상의 대문자, 소문자,

    숫자 또는 특수 문자
  180. 를 포함해야 합니다.'
  181. email: '유효한 이메일 주소여야 합니다. 🎜>'">사용자 @gmail.com)'phone: '유효한 휴대전화 번호여야 합니다. (예: 18723101212)전체 코드 파일은 다음과 같습니다.

  182. XML/HTML 코드

    클립보드에 내용 복사

    1. /*-------------------------------------- --------------------------------------    

    2. JQ-IDEALFORMS 2.1

    3. *저자 : Cedric Ruiz <🎜
    4. *라이센스 : gpl 또는 mit <🎜
    5. <🎜 🎜 >  * 데모: http://elclanrs.github.com/jq-idealforms/    

    6.   *    

    7. ------- ------------------------------------- -----------------*/     

    8. ;(함수 ( $, 창, 문서, 정의되지 않음 ) {     

    9.   '엄격한 사용';     

    10.   // 전역 이상적인 양식 네임스페이스     

    11.   $

      .idealforms = {}     

    12.   $

      .idealforms.filters = {}     

    13.   $

      .idealforms.errors = {}     

    14.   $

      .idealforms.flags = {}     

    15.   $

      .idealforms. ajaxRequests = {}     

    16. /*----------------------------- --------------------------------*/     

    17. /**    

    18.  * @namespace 다양한 유틸리티를 담는 상자    

    19.  */     

    20. var 

      Utils = {     

    21.   /**    

    22.    * 컬렉션에서 가장 넓은 요소의 너비를 가져옵니다.    

    23.    * @memberOf Utils    

    24.    * @param {jQuery 

      객체} $elms    

    25.    * @

      반환s {number}    

    26.    */     

    27.   getMaxWidth: function( $elms ) {     

    28.     var 

      maxWidth = 0     

    29.     $elms.

      (function() {     

    30.       var 

      width = $(this).outerWidth()     

    31.       if ( width 

      > maxWidth ) {     

    32.        

      최대 너비 = 너비     

    33.       }     

    34.     })     

    35.     maxWidth 반환     

    36.   },     

    37.   /**    

    38.    * 더 적은 변수를 가져오는 해키 방식    

    39.    * @memberOf Utils    

    40.    * @param {string} 이름 LESS 클래스의 이름입니다.    

    41.    * @param {string} prop 데이터가 저장되는 CSS 속성입니다.    

    42.    * @returns {숫자, 문자열}    

    43.    */     

    44.   getLessVar: function( name, prop ) {     

    45.     var  = $('<p 클래스="' + 이름 + '">p>').hide().appendTo('body ').css( prop )     

    46.     $('.' + name).remove()     

    47.     반환 ( /^d+/. test( value ) ? parseInt( value, 10 ) : value )     

    48.   },     

    49.   /**    

    50.    * ES5 객체와 같습니다.

      keys    

    51.    */     

    52.   getKeys: function( obj ) {     

    53.     var 

      keys = []     

    54.     for(var key in obj) {     

    55.       if ( obj.hasOwnProperty( key ) ) {     

    56.         keys.p 어( 키 )
    57.       }     
    58.     }     
    59.     반환 키     
    60.   },     
    61.   // 객체의 길이 가져오기     
    62.   getObjSize: function( obj ) {     
    63.     var 
    64. size

       = 0, key;     

    65.     for ( key in obj ) {     
    66.       if ( obj.hasOwnProperty( key ) ) {     
    67.         크기++;     
    68.       }     
    69.     }     
    70.     반품 크기;     
    71.   },     
    72.   isFunction: function( obj ) {     
    73.     반환 유형 
    74. obj
    75.  === nbsp;'function'     

        },     
    76.   isRegex: function( obj ) {     
    77.     RegExp의 obj 인스턴스 반환     
    78.   },     
    79.   isString: function( obj ) {     
    80.     반환 유형:
    81. obj
    82.  === 'string'     

        },     
    83.   getByNameOrId: 함수 ( str ) {     
    84.     var $
    85. el
    86.  = $('[

      이름="'+ str +'"]').length     

            ? $('[
    87. 이름
    88. =

      "'+ str +'"]') // 이름별     

            : $('#' + str) // ID별     
    89.     $el.length를 반환     
    90.       ? $el     
    91.       : $.error('''+ str + '" 필드가 존재하지 않습니다.')     
    92.   },     

    93.   getFieldsFromArray: function( fields ) {     

    94.     var f = []     

    95.     for ( var i = 0l = fields.length;  i < l;  i++ ) {     

    96.       f.push( Utils.getByNameOrId( fields [i] ).get(0) )     

    97.     }     

    98.     반환 $( f )     

    99.   },     

    100.   convertToArray: function( obj ) {     

    101.     return Object.prototype.toString.call( obj ) === ' [객체 배열]'     

    102.       ? obj : [ obj ]     

    103.   },     

    104.   /**    

    105.    * 이상적인 양식 요소의 유형 결정    

    106.    * @param $input jQuery $input 객체    

    107.    */     

    108.   getIdealType: function( $el ) {     

    109.     var 

      type = $el.attr('type') || $el[0].tagName.toLowerCase()     

    110.     return (     

    111.       /(text|password|email|number|search|url |tel|textarea)/.test( type ) && 'text' ||     

    112.       /file/.test( type ) && 'file' ||     

    113.       /select/.test( type ) && 'select' ||     

    114.       /(radio|checkbox)/.test( type ) && 'radiocheck' ||    

    115.       /(버튼|제출|재설정)/.test( 유형 ) && '버튼'||     

    116.       /hd/.test( 유형 ) && '제목' ||    

    117.       /hr/.test( type ) && '구분 기호' ||    

    118.       /hidden/.test ( 유형 ) && '숨김'     

    119.     )     

    120.   },     

    121.   /**    

    122.    * 입력 을 생성    

    123.    * @param name `name` 속성을 입력의    

    124.    * @param 입력의 'type' 또는 'tagName' 유형   

    125.    */     

    126.   makeInput: function( name, value, type, list, placeholder) {     

    127.     var 마크업,

      항목  = [], item, i, len     

    128.     function splitValue( str ) {     

    129.       var item, value, arr     

    130.       if ( /::/.test( str ) ) {     

    131.         arr = str.split('::')     

    132.         항목 = arr[ 0 ]     

    133.          = arr[ 1 ]     

    134.       } else {     

    135.         항목 =  = str     

    136.       }     

    137.       반품 { 항목: 항목, 값: 값 }     

    138.    }     

    139.     // 텍스트 & 파일     

    140.     if ( /^(text|password|email|number|search|url|tel|file|hidden)$/.test(type) )     

    141.       마크업 = '<입력 '+     

    142.         '유형= "'+ 유형 +'" '+     

    143.         'ID="'+ 이름 +'" '+     

    144.         '이름="'+ 이름 +'" '+     

    145.         '="'+ 값 +'" '+     

    146.         (자리 표시자 && '자리 표시자="'+ 자리표시자 +'"') +     

    147.         '/>'     

    148.     // 텍스트 영역     

    149.     if ( /textarea/.test( type ) ) {     

    150.       마크업 = '+ 이름 +'" 이름="'+ 이름 +'" ="'+ 값 +'" >텍스트 영역>'     

    151.     }     

    152.     // 선택     

    153.     if ( /select/.test( type ) ) {     

    154. 항목 = []    

    155.       for ( i = 0len = 목록.length; 나 < len; i++ ) {     

    156.         항목 = splitValue( list[ i ] ).item     

    157.  = splitValue( list[ i ] ).value     

    158.         items.push('<옵션 ="'+ 값 +'" >'+ 항목 +'옵션>')     

    159.       }     

    160.       마크업 =     

    161.         '+ 이름 +'" 이름="'+ 이름 +'">'+     

    162.          items.join( '') +     

    163.         '선택>'     

    164.     }     

    165.     // Radiocheck     

    166.     if ( /(radio|checkbox)/.test( type ) ) {     

    167.       항목 = []     

    168.       for ( i = 0, len = list.length; i < len;  i++ ) {     

    169. 항목 = splitValue( list[ i ] ).item     

    170.          = splitValue ( list[ i ] ).value     

    171.         items.push(     

    172.          '<label>'+     

    173.             '<입력 유형="'+ 유형 +'" 이름="'+ 이름 +'" ="'+ 값 +'"  />'+     

    174.             항목 +     

    175.           ' 라벨>'     

    176.         )     

    177.       }     

    178.       마크업 = 항목.join('')     

    179.     }     

    180. 반환 마크업     

    181.   }     

    182. }     

    183. /**    

    184.  * 이상적인 양식을 위한 맞춤 탭    

    185.  */     

    186. $.fn.idealTabs = 기능 (컨테이너) {     

    187.   var     

    188.   // 요소     

    189.   $내용 = ,     

    190.   $컨테이너컨테이너  = 컨테이너,     

    191.   $래퍼 = $('<ul 클래스="ideal-tabs-wrap"/>'),     

    192.   $ = ( 함수 () {     

    193.     var  = []     

    194.     $contents.each(function () {     

    195.       var 이름 = $(this).attr('name')     

    196.       var html =     

    197.         ''+     

    198.           '<스팬>' + 이름 + '스팬>'+     

    199.           '<i class="ideal-tabs-tab-counter ideal-tabs-tab-counter-zero">0i> '+     

    200.         '>'     

    201.       tabs.push(html)     

    202.     })     

    203.     return $(tabs.join(''))     

    204.   }()),     

    205.   액션s = {     

    206. getCuridx : function () {

    207. return $ tabs

    208. .filter ( '. 이상적인 tabs-tab-Active ')     

    209.         .index()     

    210.     },     

    211.     getTabIdxByName: 함수 (이름) {     

    212.       var 

      re = new RegExp(이름, 'i')     

    213.       var $

      tab = $tabs.filter(function () {     

    214.         return re.test($(this).text())

      }))
    215. return $ tab.index ()

    216. }

    217.   },     

    218.   /**    

    219.    * 공개 방법    

    220.    */     

    221.   

      방법

       = {     
    222.     /**    

    223.      * 스위치 탭    

    224.      */     

    225.     switchTab: function (nameOrId 엑스) {     

    226.       var idx = Utils.isString(nameOrIdx)     

    227.         ? Actions.getTabIdxByName(nameOrIdx)     

    228.         : nameOrIdx     

    229.       $tabs.removeClass('ideal-tabs-tab-active')    

    230.       $tabs.eq(idx).addClass('ideal-tabs-tab-active')     

    231.       $contents.hide().eq( idx).show()     

    232.     },     

    233.     다음탭: 함수 () {     

    234.       var idx = 작업.getCurIdx() + 1     

    235.       idx > $tabs.length - 1     

    236.         ? methods.firsttab ()

    237. : methods.witchtab (idx)

    238. },

    239. 이전탭: 함수 () {     

    240.       Methods.switchTab(Actions.getCurIdx() - 1)     

    241.     } ,     

    242.     firstTab: function () {     
    243.       Methods.switchTab(0)     
    244.     } ,     
    245.     lastTab: function () {     
    246.       Methods.switchTab($tabs.length - 1)     
    247.     },     
    248.     updateCounter: 함수(nameOrIdx, text) {     
    249.       var 
    250. idx
    251.  = !isNa 엔 (nameOrIdx) ? nameOrIdx : Actions.getTabIdxByName(이름),     

               $
    252. counter
    253.  = $tabs.eq(idx).find('.ideal-tabs-tab-counter' )     

            $counter.removeClass('ideal-tabs-tab-counter-zero')     
    254.       if (!text) {     
    255.         $counter.addClass('ideal-tabs-tab-counter-zero')     
    256.       }     
    257.   for (var m in Methods)     

    258.     $contents[m] = Methods[m]     

    259.   // 초기화     

    260.   $tabs.first()     

    261.     .addClass('ideal-tabs-tab-active')

    262.     .end()     

    263.     .click(function () {     

    264.       var 

      이름
    265.  = $(this).text()     
    266.       $contents.switchTab(이름)     

    267.     })     

    268.   // DOM 및 이벤트에 삽입     

    269.   $wrapper.append($tabs).appendTo($container)     

    270.   $contents.addClass('ideal-tabs-content')

    271.   $contents.each(function () {     

    272.     var $this = $(this), name = $(this).attr('name')     

    273.     $this.data('ideal-tabs-content-name', name)     

    274.       .removeAttr('name')     

    275.   })     

    276.   $contents.hide().first( ).show() // 새로 시작     

    277.   $contents 반환     

    278. }     

    279. / **    

    280.  * 맞춤 <선택> 메뉴 jQuery 플러그인    

    281.  * @example `$('select').idealSelect()`    

    282.  */     

    283. $.fn.idealSelect = 기능 () {     

    284.   return this.each(function () {     

    285.     var     

    286.     $선택 = $(this) ,     

    287.     $옵션&nbnbsp;= $select.find('option')     

    288.     /**    

    289.      * 마크업 생성 및 맞춤 선택 요소 반환   

    290.     * @memberOf $.fn.toCustomSelect    

    291.      * @returns {object} 새로운 선택 대체의 모든 요소    

    292.      >/ >

            $
    293. wrap
    294.  = $('

      <ul

       
    295. class
    296. =

      "ideal-select '+ $select .attr('이름') +'"

    297. />

    298. '),     

            $메뉴 = $(             '<

    299. >

    300. <스팬

       
    301. class
    302. =

      "ideal-select-title">' +              $options.filter(':selected ').text() +             '범위>

    303. li

      >
    304. '     

            ),           항목 = (함수() {     

              var 
    305. 항목
    306.  = []     

    307.         $options.each(함수 ( ) {     

    308.           var $this = $(this)     

    309.           items.push('<li class="ideal-select-item">' + $this.text() + 'li>')     

    310.         })     

    311.         반품 항목     

    312.       }())     

    313.       $menu.append('<ul  class="ideal-select-sub">' + items.join('') + 'ul >')     

    314.       $wrap.append($menu)     

    315.       반환 {     

    316.         선택: $wrap,     

    317.         제목: $menu.find('.ideal-select-title'),     

    318.         하위: $menu.find('.ideal-select-sub'),     

    319.         항목: $menu.find('.ideal-select-item')

    320.       }     

    321.     }())     

    322.     /**    

    323.      * @namespace 사용자 정의 선택 방법    

    324.      * @memberOf $.fn.toCustomSelect    

    325.      */     

    326.     var 작업 = {     

    327.       getSelectedIdx: 함수() {     

    328.         return IdealSelect.items     

    329.           .filter('.ideal-select-item-selected').index()     

    330.       },     

    331.       /**    

    332.        * @private    

    333.        */     

    334.       init: (함수 () {     

    335. $select.css({     

    336.           위치: '절대',     

    337.           왼쪽: '-9999px'     

    338.         })     

    339.         idealSelect.sub.hide()     

    340.         idealSelect.select.insertAfter( $ 선택)     

    341.         idealSelect.select.css(     

    342.          '

      최소 너비',     

    343.           Utils.getMaxWidth(idealSelect.items)     

    344.        )     

    345.         idealSelect.items    

    346.           .eq($options.filter(':selected').index())     

    347.           .addClass('ideal-select-item-selected ')     

    348.       }()),     

    349.       noWindowScroll: 기능(e) {     

    350. if (e.which === 40 || e.which === 38 || e.which === 13) {     

    351.           e.preventDefault()     

    352.         }    

    353.       },     

    354.       // 스크롤할 때 포커스가 사라지는 문제 수정     

    355.       // 키보드로 항목 선택    

    356.       focusHack: 함수() {     

    357.         설정

      Timeout(function () {     

    358.          $select.trigger('focus')     

    359.         }, 1)     

    360.       },     

    361.       초점: 기능 () {     
    362.         idealSelect.select.addClass('ideal-select-focus')     
    363.         $(document).on('keydown.noscroll', Actions.noWindowScroll)     
    364.       },     
    365.       흐림: () {     
    366.         idealSelect.select     
    367.           .removeClass('ideal-select-open ideal-select-focus')     
    368.         $(document).off('.noscroll')     
    369.       },     
    370.       scrollIntoView: 기능 (
    371. dir

      ) {     

    372.         var     
    373.         $
    374. 선택됨

       = idealSelect.items.filter('.ideal-select-item-selected'),     

    375.         
    376. itemHeight

       = idealSelect.items.outerHeight(),     

    377.         
    378. menuHeight

       =  IdealSelect.sub.outerHeight(),     

    379.         
    380. isInView

       =(함수 () {     

    381.          // 하위 메뉴의 상대적 위치     
    382.          var 
    383. elPos

       = $selected.position().top + itemHeight     

                반품 
    384. dir
    385.  === '아래로'     

                  ? elPos 
    386. <
    387. = menuHeight     

    388.             : elPos > 0     

    389.        }())     

    390.         만약에 ( !isInView) {     

    391.           

      itemHeight = (dir === 'down')     

    392.             ? itemHeight // 아래로 이동     

    393.             : -itemHeight // 위로 이동     

    394.          idealSelect.sub     

    395. >>

    396.       scrollToItem: function () {     
    397.         var 
    398. idx

       = 

      Actions
    399. .getSelectedIdx(),     
    400.             
    401. 높이

       = idealSelect.items.outerHeight(),     

    402.             
    403. n항목

       = 이상적인 선택 .items.length,     

    404.            
    405. allHeight

       = height * nItems,     

    406. curHeight
    407.  = 

      높이 * (nItems - idx)     

              idealSelect.sub.scrollTop(allHeight - curHeight)     
    408.       },     

            showMenu: 기능 () {     
    409.         idealSelect.sub.fadeIn('fast')     

    410.         idealSelect.select.addClass('ideal-select-open')     

    411.         Actions.select(Actions.getSelectedIdx())     

    412.         Actions.scrollToItem()     

    413.       },     

    414.       hideMenu: 기능 () {     

    415.         idealSelect.sub.hide()     

    416.         idealSelect.select.removeClass('ideal-select-open')     

    417.       },     

    418.       선택: 기능 (idx) {     

    419.         idealSelect.items     

    420.           . RemoveClass('ideal-select-item-selected')     

    421.         idealSelect.items     

    422.           .eq(idx).addClass('ideal- 항목 선택')     

    423.       },     

    424.       변경: 기능(idx) {     

    425.         var text = idealSelect.items.eq(idx).text()     

    426.         작업. select(idx)     

    427.         idealSelect.title.text(text)     

    428.         $options.eq(idx).prop('selected', true)

    429. $ select.trigger ( 'change')

    430. },
    431. 키 다운 : 함수 (키) {     
    432.         var     
    433.        

      idx
    434.  = 
    435. Actions

      .getSelectedIdx( ) ,             

      isMenu
    436.  = 
    437. idealSelect

      .select.is('.ideal-select-menu'),             

      isOpen
    438.  = 
    439. idealSelect

      .select.is('.ideal-select-open')             /**    

    440.          * @namespace 키를 누름    

    441.          */     

    442.         var 

    443.  = {     
    444.           9: 기능 () { // TAB     

    445.            if (isMenu) {     

    446.              Actions.blur()     
    447.               Actions.hideMenu()     
    448.             }     
    449.          },    
    450.           13: 기능 () { // 입력     
    451.             if (isMenu)     
    452.              isOpen    
    453.                 ? Actions.hideMenu()     

    454.                : Actions.showMenu()     

    455.            Actions.change(idx)     

    456.           },     

    457.           27: 기능 () { // ESC     

    458.             if (isMenu) Act ions.hideMenu()     

    459.           },     

    460.           40: 기능 () { // DOWN     

    461.             if (idx 

      <

       $options.length - 1) {     
    462.              isOpen     
    463.                  ? Actions.select(idx + 1)     

    464.                : Actions.change(idx + 1)     

    465.            }     

    466.             Actions.scrollIntoView('down' )     

    467.           },     

    468.           38: 기능 () { // UP     

    469.             만약 ( idx > 0) {     

    470.               isOpen     

    471.                 ? Actions.select(idx - 1)     

    472.                : Actions.change(idx - 1)     

    473.            }     

    474.            Actions.scrollIntoView('up')     

    475.          },    

    476.           '기본값': 기능 () { // 편지     

    477.             var     

    478.            letter = String.fromCharCode(key),     

    479.            $일치 = idealSelect.items     

    480.              .filter(function () {     

    481.                return /^w+$/i.test( letter ) && // 수정자 키( ctrl, cmd, meta, super... )     

    482.                  new RegExp('^' + letter, 'i').test( $(this).text() ) // 첫 번째 일치 찾기     

    483.               }),

    484.             n일치 = $matches.length,     

    485.             카운터 = 이상적인 선택.select.data('counter') + 1 || 0,     

    486.            curKey = idealSelect.select.data('key') || 키,     

    487.            newIdx = $matches.eq(counter).index()     

    488.             if (!nM 어치) // 일치 항목 없음     

    489.               false 반환     

    490.           // 동일 문자와 일치하는 항목이 더 많은 경우     

    491. if (

      curKey === key) {     

    492.              if (카운터 < n일치) {     

    493.               idealSelect.select .data('카운터' , 카운터)     

    494.               }     

    495.               그 외 {     

    496.                idealSelect.select.data('counter ', 0)     

    497.                newIdx = $matches.eq(0).index()    

    498.              }     

    499.             }     

    500.           // 새 편지인 경우     

    501.             그렇지 않으면 {     

    502.              &nnbsp;idealSelect.data('counter', 0)     

    503.              

      newIdx = $matches.eq(0).index()     

    504.             }     

    505.            (isOpen)인 경우    

    506.              Actions.select(newIdx)     
    507.             else     
    508.              Actions.change(newIdx)     
    509.             idealSelect.select.data('key', 키 )     
    510.            Actions.scrollToItem()     
    511.           Actions.focusHack()     
    512.           }     
    513.         }     
    514.         키[키]     
    515.           ? 키[키]()     
    516.           : 키['기본값']()     
    517.       }     
    518.     }     
    519.     /**    
    520.      * @namespace '메뉴 모드' 및 '목록 모드'에 대한 맞춤 선택의 모든 이벤트를 보관합니다.   
    521.      * @memberOf $.fn. toCustomSelect    
    522.      */     
    523.     var 
    524. 이벤트
    525.  = {     

            초점: Actions.focus,     
    526.       'blur.menu': 기능 () {     
    527.         Actions.blur ()     
    528.         Actions.hideMenu()     
    529.      },     
    530.       '흐림 .목록' : 함수 () {     

    531.         Actions.blur()     

    532.       },     

    533.       keydown: 기능 (e) {     

    534.         Actions.keydown(e.which)     

    535.       },     

    536.       'clickItem.menu': 기능 () {     

    537.         Actions.change($(this).index())     

    538.         Actions.hideMenu()     

    539.       },     

    540.       'clickItem.list': function () {     

    541.         Actions.change($(this ).index())     

    542.       },     

    543.       'clickTitle.menu': 기능 () {     

    544.         Actions.focus()     

    545.         Actions.showMenu()     

    546.         $select.trigger('focus')     

    547.       },     

    548.       'hideOutside.menu': 기능 () {     

    549.         $select.off( 'blur.menu')     

    550.         $(document).on('mousedown.ideal', function (evt) {     

    551.           if ( !$(evt.target).closest(idealSelect.select).length) {     

    552.             $(document).off('mousedown.ideal')     

    553.            $select.on('blur.menu', events['blur.menu'])     

    554.           } else {     

    555.            Actions.focusHack()     

    556.           }     

    557.         })    🎜>

            },     

    558.       'mousedown.list': function () {     

    559.         Actions.focusHack()     

    560.       }

    561.     }     

    562.     // 이벤트 재설정     

    563.     var 

      disableEvents

       =
    564. 기능
    565.  () {     

            idealSelect.select.removeClass('ideal-select-menu ideal-select-list')     

    566.       $select.off('.menu .list')     

    567.       idealSelect.items.off('.menu .list')     

    568.       idealSelect.select.off('.menu .list')     

    569.       idealSelect.title.off('.menu .list')     

    570.     }     

    571.     // 메뉴 모드     

    572.     idealSelect.select.on('메뉴', 기능 () {     

    573.       disableEvents()     

    574.       idealSelect.select.addClass('ideal-select-menu')     

    575.       Actions.hideMenu()     

    576.       $select.on({     

    577.         'blur.menu': events['blur.menu'],     

    578.         '초점. menu': events.focus,     

    579.         'keydown.menu': events.keydown     

    580.       })     

    581.       idealSelect.select.on('mousedown.menu', events['hideOutside.menu'])     

    582.       idealSelect.items.on('click.menu', events ['clickItem.menu'])     

    583.       idealSelect.title.on('click.menu', events['clickTitle.menu'])     

    584.     })     

    585.     // 목록 모드     

    586.     idealSelect.select.on('list', function () {     

    587.       disableEvents()     

    588.       idealSelect.select.addClass('ideal-select-list')     

    589. Actions.showMenu()     

    590.       $select.on({     

    591.         'blur.list': 이벤트['blur.list'],

    592.         'focus.list': events.focus,     

    593.         'keydown.list': events.keydown     

    594.       })     

    595.       idealSelect.select.on('mousedown.list', events['mousedown.list'])     

    596.       idealSelect.items.on('mousedown.list', events['clickItem.list'])     

    597.     })     

    598.     $ select.keydown(function (e) {     

    599.       // 기본 키다운 이벤트 방지     

    600.       // 이상적인 선택 이벤트로 버그를 방지하기 위해     

    601.       if (e.which !== 9) e.preventDefault()     

    602.     })     

    603.     // 재설정     

    604.     idealSelect.select.on('reset', function(){     

    605.       Actions.change(0)     

    606.     })     

    607.     idealSelect.select.trigger('menu') // 기본값은 '메뉴 모드'입니다.     

    608.   })     

    609. }     

    610. /*    

    611.  * idealRadioCheck: jQuery plguin 체크박스 및 라디오 교체용    

    612.  * 사용법: $('input[

      type=checkbox], input[type=라디오]').idealRadioCheck()    

    613.  */     

    614. $

      .fn.idealRadioCheck  = 함수() {     

    615.   return this.each(function() {     

    616.     var $

      이것 = $(이것)     

    617.     var $span = $('<span/>')     

    618.     $span.addClass('ideal-'+ ( $this.is(':checkbox') ? 'check': 'radio' ) )     

    619.     $this.is(':checked') && $span.addClass('checked') // init     

    620.     $span.insertAfter($this)     

    621.     $this.parent('label').addClass('ideal-radiocheck-label')     

    622.       .attr('onclick','') // iOS에서 라벨 클릭 수정     

    623.     $this.css({ position: 'absolute', left: '-9999px' }) // Shift로 숨기기 왼쪽     

    624.     // 이벤트     

    625.     $this.on({     

    626.       변경: 기능( ) {     

    627.         var $this = $(this)     

    628.         if ( $this.is('input[ 유형="라디오"]') ) {     

    629.           $this.parent().siblings('label').find( '.ideal-radio').removeClass('checked')     

    630.         }     

    631.         $span.toggleClass( 'checked', $this .is(':checked') )     

    632.       },     

    633.      초점: function() { $span.addClass('focus') },     

    634.       흐림: function() { $span.removeClass('focus') },     

    635.       클릭: function() { $ (this).trigger('focus') }     

    636.     })     

    637.   })     

    638. }     

    639. ;(function( $ ) {     

    640.   // 브라우저는 HTML5 여러 파일을 지원합니까?     

    641.   var 다중 지원 = 유형 $('<입력/ >')[0].multiple !== '정의되지 않음',     

    642.       isIE = /msie/i.test( navigator.userAgent )

    643.   $.fn.idealFile = 함수() {     

    644.     return this.each (function() {     

    645.       var $file = $(this).addClass('ideal-file'), //원본 파일 입력     

    646.           // IE 해킹에 사용될 라벨     

    647.          $wrap = $('<div class="ideal-file-wrap">'),     

    648.           $입력 = $('<입력 입력="text"  클래스="ideal-file-filename" />'),     

    649.           // IE 이외의 브라우저에서 사용되는 버튼     

    650.          $버튼 = $('<버튼 유형="버튼" 클래스="이상적인 파일 업로드">열기< ;/버튼>'),     

    651.          // IE 해킹     

    652.          $라벨 = $('<라벨 클래스="ideal-file-upload" for="'+ $file[0].id +'">열기라벨>')     

    653.       // 왼쪽으로 이동하여 숨기세요. 이벤트 트리거     

    654.       $file.css({     

    655.         위치: '절대',     

    656. 왼쪽: '-9999px'     

    657.       })     

    658.       $wrap.append( $input, ( isIE ? $label : $button ) ) .insertAfter( $file )     

    659.       // 포커스 방지     

    660.       $file.attr('tabIndex', -1)     

    661.       $button.attr('tabIndex', -1)     

    662.       $button.click(function () {     

    663.         $file.focus().click() // 대화상자 열기     

    664.       })     

    665.       $file.change(function( ) {     

    666.         var 

      files
    667.  = [], fileArr, filename     
    668.         // 여러 개가 지원되는 경우  

      추출
    669.      
    670.         //파일 배열에서 모든 파일 이름     

    671.         if ( multipleSupport ) {     

    672.          

      fileArr
    673.  = $file[0].files     
    674.           for ( var 

      i
    675.  = 
    676. 0

      , len = fileArr.length; 나 < len; i++ ) {     

    677.             files.push( fileArr[i].name )     

    678.          }     

    679.           파일 이름 = files.join(', ')     

    680.         // 지원되지 않는 경우 그냥 값을 사용하세요.     

    681.        // 경로를 삭제하여 파일 이름만 표시     

    682.        } 그렇지 않으면 {     

    683.          파일 이름 = $file. val().split('\').pop()     

    684.         }     

    685.         $input.val( 파일 이름 ) // 설정 값     

    686.           .attr( 'title', filename ) // 제목에 파일 이름 표시     

    687.       })     

    688.       $input.on({     

    689.         초점: 기능 () { $file.trigger('change') },     

    690.         blur: function () { $file.trigger('blur') },     

    691.         keydown: function( e ) {     

    692. if ( 

      e.which === 13 ) { // Enter     

    693.            if ( !isIE ) { $file.trigger('click') }     

    694.           } 그렇지 않으면 ( 

      e.which === 8 || e.which === 46 ) { // Backspace & Del     

    695.             // 일부 브라우저에서는 값이 읽기 전용입니다     

    696.            // 이 트릭을 사용하면 이전 입력을 제거하고     

    697.           // 모든 원본 이벤트가 첨부된 깨끗한 클론     

    698.            $file.replaceWith( $

      file = $file.val('').clone( true ) )     

    699.             $file.trigger('change' )     

    700.            $input.val('')     

    701.          } if if ( 

      e.which === 9 ){ // TAB     

    702.             return     

    703.          } 그 외 { // 다른 모든 키     
    704. false 반환     
    705.           }     
    706.         }     
    707.       })     
    708. }) 

    709. }(jQuery)) 

    710. /**    

    711.  * @namespace 오류    

    712.  * @locale en    

    713.  */ 

    714. $.idealforms.errors = { 

    715. 필수: '필수입니다.',  

    716. number: '숫자여야 합니다.',  

    717. digits: '고유한 숫자여야 합니다.' , 

    718. 이름: '3자 이상이어야 하며 문자만 포함할 수 있습니다.', 

    719. 사용자 이름: ' 사용자 이름은 5자, 최대 30자까지 가능합니다. 영문, 숫자, 한자, 밑줄을 사용하세요. 사용자 이름의 첫 글자는 영문자, 숫자, 한자여야 하며 최대 길이는 숫자일 수 없습니다. 한자는 21자입니다.', 

    720. pass: '비밀번호는 6~15자리여야 하며 숫자, 대문자, 소문자를 각각 하나씩 포함해야 합니다.', 

    721. Strongpass: '8자 이상이어야 하며 대문자 1개, 소문자 1개, 숫자 또는 특수 문자 1개 이상을 포함해야 합니다.',  

    722. 이메일: '유효한 이메일 주소여야 합니다. <em>(예: user@gmail.com)< /em>', 

    723. 전화: '유효한 휴대폰 번호여야 합니다. <em >(예: 18723101212)em>', >

      zip: '유효한 미국 우편번호여야 합니다. ;/
    724. em

      >', url: ' 유효한 URL이어야 합니다. <em>(예: www.google.com)

    725. em

      >', minChar: '적어도 /강해야 합니다> 자 길이입니다.',  

    726. minOption: '최소  

      < 강함>{0} 이상을 선택하세요. 강함> 옵션.', 

    727. maxChar: '최대

      < ;강하게>{0}강하게>자 길이입니다.' , 

    728. maxOption: '최대

      <강함>{0}< /강함> 옵션이 허용됩니다.', 

    729. 범위: '다음 사이의 숫자여야 합니다. {0} 및 {1}.', 날짜: '유효한 날짜여야 합니다. 🎜><em> (예: {0})

      em
    730. >

      ', 

    731.   dob: '유효한 생년월일이어야 합니다.',     

    732.   제외: ''{0}'은(는) 사용할 수 없습니다.',     

    733.   excludeOption: '{0}',     

    734.   equalto: '<와 동일한 값이어야 함 강함>"{0}"강함>',     

    735.   확장자: '파일에는 유효한 확장자가 있어야 합니다. <em>(예: "{0}")em >',     

    736.   ajaxSuccess: '<강함>{0}강함> 을(를) 사용할 수 없습니다.',     

    737.   ajaxError: '서버 오류...'     

    738. }     

    739. /**    

    740.  * 모든 기본 필터 가져오기    

    741.  * @returns 객체    

    742.  */     

    743. var getFilters = 함수() {     

    744.   var 필터 = {     

    745.     필수: {

    746.       정규식: /.+/,     

    747.       오류: $.idealforms.errors.required     

    748. },

    749. 숫자 : {

    750. regex : function (i, v) {return! isnan (v)},
    751.       오류: $.idealforms.errors.number     
    752.     },     
    753.     숫자: {     
    754.       정규식: /^d+$/,     
    755.       오류: $.idealforms.errors.digits     
    756.     },     
    757.     이름: {     
    758.       정규식: /^[A-Za-z]{3,}$/,     
    759.       오류: $.idealforms.errors.name     
    760.     },     
    761.     사용자 이름: {     
    762.       정규식: /^[a-z](?=[w.]{4,30}$)w*.?w*$/i,     
    763.       오류: $.idealforms.errors.username     
    764.     },     
    765.     통과: {     
    766.       정규식: /(?=.*d)(?=.*[a-z])(?=.*[A-Z]).{6,}/,     
    767. 오류: $.idealforms.errors.pass     
    768.     },     
    769.     strongpass: {     
    770. 정규식: /(?=^.{8,}$)((?=.*d)|(?=.*W+))(?![.n])(?=.*[A-Z])(? =.*[a-z]).*$/,     
    771.       오류: $.idealforms.errors.strongpass     
    772.     },     
    773.     이메일: {     
    774.       정규식: /^([a-zA-Z0-9]*[-_.]?[a-zA-Z0-9]+)*@([a-zA-Z0 -9]*[-_]?[a-zA-Z0-9]+)+[\.][A-Za-z]{2,3}([\.][A-Za-z]{ 2})?$/,     

    775.       오류: $.idealforms.errors.email     

    776.     },     

    777.     전화: {     

    778.       //regex: /^((13[0-9])|(15[0-9])|(17[0-9 ])|(18[0-9]))\d{8}$/,     

    779.       정규식: /^(0|86|17951)?(13[0-9 ]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$/,     

    780.       오류: $ .idealforms.errors.phone

    781. },
    782. zip : {

    783. regex :/ ^d{5}$|^d{5}-d{4}$/,     

    784.       오류: $.idealforms.errors.zip     

    785.     },     

    786.     url: {     

    787.       정규식: /^(?:(ftp|http|https)://) ?(?:[w-]+.)+[a-z]{2,6}([:/?#].*)?$/i,     

    788.       오류: $ .idealforms.errors.url

    789. },

    790. min : { Regex : 기능 : 기능 (입력, 값) {     
    791.         var $
    792. input
    793. input = input.input,     

                  
    794.  = 

      입력.userOptions.data.min,     

                 
    795. isRadioCheck
    796.  = $input.is('[

      유형="체크박스"], [유형="라디오"]')     

              if ( isRadioCheck ) {     
    797.          
    798. this.error
    799.  = $.idealforms.errors.minOption.replace('{0}', min )     

                return $input.filter(':checked').length 
    800. >
    801. = min     

              }     
    802.         
    803. this.error
    804.  = $.idealforms.errors.minChar.replace('{0}', min )     

              반환 값. 길이
    805. >
    806. = 분     

            }     
    807.     },     
    808. 최대: {     
    809.       정규식: 함수( 입력, 값 ) {     
    810.         var $
    811. 입력
    812. 입력 = input.input,     

                  
    813. max
    814.  = 

      input.userOptions.data.max,     

                 
    815. isRadioCheck
    816.  = $input.is('[

      type="checkbox"], [type=" 라디오"]')     

    817.         if ( isRadioCheck ) {     

    818.          this.error = $.idealforms.errors.maxOption.replace('{0} ', 최대 )     

    819.           return $input.filter(':checked').length <= max     

    820.         }     

    821.         this.error = $.idealforms.errors.maxChar.replace( '{0}', max )     

    822.         반환 값 길이 <= 최대     

    823.       }     

    824.     },     

    825. <🎜 🎜>
    826. 범위 : {<🎜 🎜>

      <🎜

    827. regex : 함수 (입력, 값) {<🎜 🎜> <🎜
    828. var
    829. range
    830.  = 

      입력.userOptions.data.range,     

                  
    831. val
    832.  = +값     

    833. this.error
    834.  = $.idealforms.errors.range     

                .replace( '{0}', range[0] )     
    835.           .replace( '{1}', range[1] )     
    836.         return val 
    837. >
    838. = range[0] && val 

      <= 범위[1]     

            }     
    839.     },     
    840. 날짜: {     
    841.       정규식: 함수( 입력, 값 ) {     
    842.         var     
    843.         
    844. userFormat
    845.  =     

               
    846. 입력
    847. .userOptions.data && input.userOptions.data.date     

      ? input.userOptions.data.date     
    848.             : 'mm/dd/yyyy', // 기본 형식     
    849.         
    850. 구분자
    851.  = /[^mdy]/.exec( userFormat )[0],     

              
    852. theFormat
    853.  = 

      userFormat.split(구분자),

              
    854. theDate
    855.  = 

      value.split(delimiter),     

              
    856. isDate
    857.  = 

      함수( 날짜, 형식 ) {     

               var m, d, y     
    858.           에 대해 ( 변수
    859. i
    860.  = 

      0len = format.length;  i < len; i++ ) {     

    861.             if ( /m/.test( 형식[i]) ) m = 날짜[i]     

    862.             if ( /d/.test( 형식[i]) ) d = 날짜[i]     

    863.             if ( / y/.test( 형식[i]) ) y = 날짜[i]     

    864.          }     

    865.           반환 (     

    866.             m 

      > 0 && m < 13 &&    

    867.             y && 

      y.length === 4 &&     

    868.             >

    869.  0 && ㄷ 

      <= ( new Date( y, m, 0 ) ).getDate()     

                )     
    870.         }     
    871.         
    872. this.error
    873.  = $.idealforms.errors.date.replace( '{0}', userFormat )     

              return isDate( theDate, theFormat )     
    874.       }     
    875.     },     
    876.     dob: {     
    877.       정규식: 함수( 입력, 값 ) {     
    878.         var     
    879.        
    880. userFormat
    881.  =     

               
    882. 입력
    883. .userOptions.data && input.userOptions.data.dob     

                  ? input.userOptions.data.dob     
    884.             : 'mm/dd/yyyy', // 기본 형식     
    885.         // 날짜 입력 시뮬레이션
    886.         
    887. 날짜 입력
    888.  = {     

                입력: input.input,     
    889. <🎜

    890.         },

    891.         // 내부 날짜 필터를 사용하여

      확인

      날짜를 확인하세요. 🎜>필터
    892. .date.regex( dateInput, value ),     
    893.         // DOB     
    894.         연도 = /d{4}/.exec( 값 ),     

    895.         maxYear = new Date().getFullYear(), //현재 연도     

    896.         minYear = maxYear - 100     

    897.         this.error = $.idealforms.errors.dob     

    898.         return isDate && theY 귀 >

    899. = minYear && theYear <= maxYear     

    900.       }     

    901.     },     

    902.     제외: {     

    903.      정규식: function( input, value ) {     

    904.         var $ 입력입력 = input.input,     

    905.             제외 = 입력.userOptions.data.exclude,

    906.             isOption = $input.is('[type="checkbox"], [ 유형="라디오"], 선택')     

    907.         this.error = isOption     

    908.           ? $.idealforms.errors.excludeOption.replace( '{0}', value )     

    909.           : this.error = $.idealforms.errors.exclude.replace ('{0}', 값 )     

    910.         return $.inArray( value, exclude ) ===-1     

    911.       }     

    912.     },     

    913.     같음: {     

    914.       정규식: 함수( 입력, 값) {     

    915.         var $같음 = $( input.userOptions.data.equalto ),     

    916.            $입력입력 = input.input,     

    917.            이름 = $equals.attr('name') || $equals.attr('id'),     

    918.            isValid = $equals.parents('.ideal-field')     

    919.              .filter(function(){ return $(this).data('ideal-isvalid') === true })     

    920.              .length     

    921.         if ( !isValid ) { 반환 false }     

    922.         this.error = $.idealforms.errors.equalto.replace('{0}', name )     

    923.         반환 $input.val() === $equals.val()     

    924.       }     

    925.     },     

    926.     확장자: {     

    927.       정규식: 함수( 입력, 값 ) {     

    928.         nbsp;var 파일입력.input[0].files || [{ 이름: 값 }],     

    929.            확장 = 입력.userOptions.data.extension,     

    930.             re = new RegExp( '\.'+ extensions.join('|') +'$', 'i' ),     

    931.            유효함 = 거짓     

    932.         for ( var i = 0len = 파일.length;  i < len;  i++ ) {     

    933.          유효 = .test( files[i].name );     

    934.         }     

    935.         this.error = $.idealforms.errors.extension.replace('{0}' , extensions.join ( ' ","')

    936. 반환 유효
    937. }

    938.     },     

    939.     ajax: {     

    940.       regex: function( input, value, showOrHideError ) {     

    941.         var self = 이것     

    942.         var $입력입력 = 입력. 입력     

    943.         var 

      userOptions = input.userOptions     

    944.         var 

      이름 = $input.attr('name')     

    945.         var $

      필드 = $input.parents('.ideal-field')     

    946.         var 

      유효 = false     

    947.         var 
    948. customErrors

       = userOptions.errors && userOptions.errors.ajax     

    949.         
    950. self.error

       = {}     

    951.         
    952. 자신. error.success

       = customErrors && customErrors.success     

    953.           ? customErrors.success     

    954.           : $.idealforms.errors.ajaxSuccess.replace('{0}', value )     

    955.         self .error.fail = customErrors && customErrors.error     

    956.           ? customErrors.error     

    957.           : $.idealforms.errors.ajaxError     

    958.        // 입력 이름을 $_POST[이름]으로 보내기     

      < 🎜 🎜> <🎜 🎜>
    959. var
    960. data

      = {} <🎜 🎜>

      데이터 [name] = $.
    961. trim
    962. (value)

              // 사용자가 정의한 Ajax 옵션     
    963.        var 
    964. userAjaxOps
    965.  =

      input.userOptions .data .ajax     

              var 
    966. ajaxOps
    967.  = {     

                유형: 'post',     
    968.           dataType: 'json',     
    969.           data: data,    
    970.           성공: 함수( resp, text, x시간 ) {     
    971.           console.log(resp)     
    972.            showOrHideError( self.error.success, true )     
    973.             $input.data({     
    974.             'ideal-ajax-resp': resp,     
    975.              'ide al-ajax-error': 자신 .error.success     
    976.             })     
    977.            $input.trigger('change') // 카운터 업데이트     
    978.            $field.removeClass('ajax')     
    979.            // 맞춤 성공 콜백 실행     
    980.             if( userAjaxOps._success ) {     

    981.              userAjaxOps._success( resp, text, xhr )     

    982.            >

    983.           }  

    984.               showOrHideError( self.error.fail, false )     

    985.              $input.data('ideal-ajax-error', self.error.fail )     

    986.              $field.removeClass('ajax')     

    987.               // 사용자 정의 오류 콜백 실행     

    988.               if ( userAjaxOps._error ) {     

    989.                 userAjaxOps. _error( xhr, text, error )     

    990.              }     

    991.            }     

    992.           }     

    993.         }     

    994.         $.extend( ajaxOps, userAjaxOps )     

    995.         // 초기화     

    996.         $input.removeData('ideal-ajax-error')     

    997.         $input.removeData('ideal-ajax-resp')     

    998.         $field.addClass('ajax')     

    999.         // 요청을 실행하고 저장하여 취소할 수 있도록     

    1000.         // 그러므로 요청이 버블링되지 않음     

    1001.         $.idealforms.ajaxRequests[ name ] = $.ajax( ajaxOps )     

    1002. }     

    1003.     }     

    1004.   }     

    1005.   반환 필터     

    1006. }     

    1007. $

      .idealforms.flags = {     

    1008.   오류 없음: 기능 (i) {     

    1009.     i.parent().siblings('.ideal-error').hide()     

    1010.   },     

    1011.   noicons: 기능 (i) {     

    1012.     i.siblings('.ideal-icon-valid, .ideal-icon-invalid').hide()     

    1013.   },     

    1014.   novalidicon: function (i) {     

    1015.     i.siblings('.ideal -icon-valid').hide()     

    1016.   },     

    1017.   noinvalidicon: function (i) {     

    1018.     i.siblings('.ideal-icon-invalid').hide()     

    1019.   },     

    1020.   noclass: 함수(i) {     

    1021.     i.parents('.ideal-field').removeClass('valid invalid')     

    1022.   },

    1023.   novalidclass: function (i) {     

    1024.     i.parents('.ideal-field').removeClass('valid')     

    1025.   },     

    1026.   noinvalidclass: function (i) {     

    1027.     i.parents('. Ideal-field').removeClass('invalid')     

    1028.   }     

    1029. }     

    1030. /*    

    1031.  * Ideal Forms 플러그인    

    1032.  */     

    1033. var _defaults = {     

    1034.   입력: {},     

    1035.   customFilters: {},     

    1036.   customFlags: {},     

    1037.   globalFlags: '',     

    1038.   onSuccess : function(e) { alert('감사합니다...') },     

    1039.   onFail: function() { alert('잘못됨!') },     

    1040.   반응형At: 'auto',     

    1041.   disableCustom: ''     

    1042. }     

    1043. // 생성자     

    1044. var IdealForms = function( element, options ) {     

    1045.   var self = 이것     

    1046.   self.$form = $( element )     

    1047.   self.opts = $.extend( {}, _defaults, options )     

    1048.   self.$ = self.$form.find('section')     

    1049.   // 현지화된 필터 설정     

    1050.   $. 확장( $.idealforms.filters, getFilters() )     

    1051.   self._init()     

    1052. }     

    1053. // 플러그인     

    1054. $.fn.idealforms = 기능( 옵션 ) {     

    1055.   return this.each(function() {     

    1056.     if ( !$.data( this, 'idealforms' ) ) {     

    1057. <

    1058. }     

    1059. // 더 적은 변수 가져오기     

    1060. var 

      LessVars

       = {     
    1061.   fieldWidth: Utils.getLessVar( 'ideal-field-width', 'width' )     
    1062. }     

    1063. /*    

    1064.  * 비공개 방법    

    1065.  */     

    1066. $.extend ( IdealForms.prototype, {     

    1067.   _init: function() {     

    1068.     var 

      self

       = 
    1069.      

    1070.     var 

      o = self.opts     

    1071.     var 

      formElements = self._getFormElements()     

    1072.     self.$form.css('

      visibility', 'visible' )     

            .addClass('ideal-form')     
    1073.       .attr('novalidate', 'novalidate') // HTML5 검증 비활성화     

    1074.     // 마크업 수행     

    1075.     formElements.inputs     

    1076.       .add( formElements.headings )     

    1077.       .add( formElements.separators )     

    1078.       .each(function(){ self._doMarkup( $(this) ) })     

    1079.     // 탭 생성     

    1080.     if ( self.$tabs.length ) {     

    1081.       var $tabContainer = $('<div class="ideal-wrap ideal-tabs ideal-full-width"/>')     

    1082.       self.$form.prepend( $tabContainer )     

    1083.       self.$tabs.idealTabs( $tabContainer )     

    1084.     }

    1085.     // 항상 입력 아래에 날짜 선택기를 표시    

    1086.     if( jQuery.ui ) {     

    1087.       $.datepicker._checkOffset = 함수( a,b,c ) { return b }     

    1088.     }     

    1089.     //data-ideal로 지정된 입력을 추가합니다.    

    1090.    // 사용자 입력 목록에    

    1091.     self.$ form.find('[data-ideal]').each(function() {     

    1092.       var userInput = o.inputs[ this.name ]     

    1093.       o.inputs[ this.name ] = userInput ||  { 필터: $(this).data('ideal') }     

    1094.     })     

    1095.    // 반응형     

    1096.     if ( o.반응형At ) {     

    1097.       $(window).resize(function(){ self._반응() })     

    1098.       self._반응()     

    1099. }     

    1100.     // 양식 이벤트     

    1101.     self.$form.on({     

    1102.       keydown : 함수( e ) {     

    1103.         // Enter 키를 누를 때 제출을 방지     

    1104.         // 텍스트 영역은 제외     

    1105.         if ( e.which === 13 && e.target.nodeName !== 'TEXTAREA' ) {     

    1106.           e.preventDefault()

    1107.         }     

    1108.       },     

    1109.       제출: 기능( e ) {     

    1110.         if ( !self.isValid() ) {     

    1111.          e.preventDefault()     

    1112.           o.onFail ()     
    1113.           self.focusFirstInvalid()     
    1114.        } 그 외 {     
    1115.           o.onSuccess( e)     
    1116.         }     
    1117. }

    1118. })

    1119. self._adjust ()

    1120.     self._attachEvents()     

    1121.     self.fresh() // 새로 시작     

    1122.   },     

    1123.   _getFormElements: function() {     

    1124.     return {     

    1125.       입력: this.$form.find('input, select , textarea, :button'),     

    1126.       labels: this.$form.find('div 

      > label:first-child '),     

    1127.       text: this.$form.find('input:not([

      type="checkbox"], [ 유형="라디오"], [유형="제출"]), textarea'),     

    1128.       선택: this.$form.find('select'),     

    1129.       radiocheck: this.$form.find('input[

      유형="라디오"], 입력[유형="체크박스"]'),     

    1130.       버튼: this.$form.find(':button'),     

    1131.       파일: this.$form.find('input[

      type="file "]'),     

    1132.       제목: this.$form.find('h1, h2, h3, h4, h5, h6'),     

    1133.       구분자: this.$form.find('hr'),     

    1134.       hidden: this.$form.find('input:hidden')     

    1135.     }     

    1136.   },     

    1137.   _getUserInputs: function() {     

    1138.     return this.$form.find('[

      name="'+ Utils.getKeys( this.opts.inputs ).join('"], [이름="') +'"]')     

    1139.   },     

    1140.   _getTab: 함수( nameOrIdx ) {     

    1141.     var 

      self = this     

    1142.     var 

      isNumber  = !isNaN( nameOrIdx )     

    1143.     if ( isNumber ) {     

    1144.       return self.$tabs.eq( nameOrIdx )    
    1145.     }     
    1146.     return self.$tabs.filter(function() {     
    1147.       var 
    1148. re

       = new RegExp( nameOrIdx, 'i' )     

            return re.test( nbsp;$(this).data('ideal- 탭 콘텐츠 이름') )    
    1149.     })     
    1150.   },     
    1151.   _getCurrentTabIdx: function() {     
    1152.     return this.$tabs.index( this.$form.find('.ideal-tabs-content:visible') )     
    1153.   },     
    1154.   _updateTabsCounter: function() {     

    1155.     var self = this     

    1156.     self.$tabs.each(function( i ) {     

    1157.       var invalid = self.getInvalidInTab( i ) .length     

    1158.       self.$tabs.updateCounter( i, invalid )     

    1159.     })     

    1160.   },     

    1161.   _adjust: function() {     

    1162.     var self = 이것     

    1163.     var o = self.opts     

    1164.     var formElements = self._getFormElements()     

    1165.     var curTab = self._getCurrentTabIdx()     

    1166.     // 자동 완성으로 인해 일부 문제가 발생함...     

    1167.     formElements.inputs.attr('autocomplete', 'off')     

    1168.     // 치수 계산을 위한 탭 표시     

    1169.     if ( self.$tabs.length ) { self.$tabs.show() }     

    1170.     // 라벨 조정     

    1171.     var labels = formElements.labels     

    1172.     레이블 s. RemoveAttr('style').width( Utils.getMaxWidth( labels ) )     

    1173.     // 제목 및 구분 기호 조정     

    1174.     if ( self. $tabs.length ) {     

    1175.       this.$tabs.each(function(){     

    1176.         $( this ).find('. Ideal-heading:first').addClass('first-child')     

    1177.       })     

    1178.     } else {     

    1179.       self.$form.find('.ideal-heading:first').addClass('first-child')     

    1180.     }     

    1181.     self._setDatepicker()     

    1182.     // 숨기기 탭 계산 완료     

    1183.     if ( self.$tabs.length ) {     

    1184.       self.$tabs.hide()     

    1185.       self.switchTab( curTab )     

    1186.     }     

    1187.   },     

    1188.   _setDatepicker: function() {     

    1189.     var 

      o = .opts     

    1190.     var $

      datepicker = .$form.find( 'input.datepicker')     

    1191.     if ( jQuery.ui && $datepicker.length ) {     

    1192.       $datepicker.each(function() {     

    1193.         var userInput = o.inputs[ this.name ]     

    1194.         var data = userInput && userInput.data && userInput.data.date     

    1195.         var format = data ? data.replace('yyyy', 'yy' ) : 'mm/dd/yy'     

    1196.         $(this).datepicker({     

    1197.          dateFormat: 형식,     

    1198.          표시: 기능( 입력 ) {     

    1199.             $( 입력 ).addClass ('열기')     

    1200.           },     

    1201.          변경 시월 연도: function() {     

    1202.            // 크기가 조정되지 않는 IE9 수정     

    1203.           var $

      this =$(this)     

    1204.            var 

      w = $this.outerWidth() // 캐시 먼저!     

    1205.             setTimeout(function() {     

    1206.              $this.datepicker('widget').css( 'width', w )     

    1207.             }, 1)     

    1208.           },     

    1209.           onClose: function() { $(this).removeClass('open') }     

    1210.         } )
    1211.       })     
    1212.       // 너비 조정     
    1213.       $datepicker.on('focus keyup ', function() {     
    1214.         var 
    1215. t

       = $(this), w = t.outerWidth( )     

    1216.         t.datepicker('widget').css( 'width', w )     
    1217.       })     
    1218.       $datepicker.parent().siblings('.ideal-error').addClass('hidden')     
    1219.     }     
    1220.   },     
    1221.   _doMarkup: function( $element ) {     
    1222.     var 
    1223. o

       =  this.opts     

    1224.     var 
    1225. elementType

       = Utils.getIdealType( $element )     

    1226.     // 검증 요소     
    1227.     var $필드 = $('<span class="이상적 -필드"/>')     

    1228.     var $오류 = $('< 스팬 클래스="이상 오류" />')     

    1229.     var $유효 = $('<i class="ideal-icon ideal-icon-valid" />')     

    1230.     var $잘못됨 = $('<i class="ideal-icon ideal-icon-invalid"/>')     

    1231.       . click(function(){     

    1232.         $(this).parent().find('input:first, textarea, select').focus()     

    1233.       })     

    1234.     // 기본 마크업     

    1235.     $element.closest('div').addClass('ideal- Wrap')     

    1236.       .children('label:first-child').addClass('ideal-label')     

    1237.     var idealElements = {     

    1238.       _defaultInput: function() {     

    1239.         $element.wrapAll( $field ).after( $valid , $invalid )     

    1240.           .parent().after($error )     

    1241.       },     

    1242.       텍스트: function() { idealElements._defaultInput() },     

    1243.       radiocheck: function() {     

    1244.        // 확인 입력한 경우 이미 포장되었으므로 우리는 라디오를 포장하고 두 번 이상 확인하지 않습니다. 🎜> = $element.parents('.ideal-field').length     

    1245.         if ( !isWrapped ) {     

    1246.          $element.parent() .nextAll().andSelf().wrapAll( $field.addClass('ideal-radiocheck') )     

                $element.parents('.ideal-field').append( $valid, $invalid ).after( $error )     
    1247.         }    
    1248.         if ( !/radiocheck/.test( o.disableCustom ) ) {     
    1249.          $element.idealRadioCheck()     
    1250.         }     

    1251.       },     

    1252.       선택: function() {     

    1253.         idealElements._defaultInput()     

    1254.         if ( !/select/.test( o.disableCustom ) ) {     

    1255.          $element.idealSelect()     

    1256.         }     

    1257.       },     

    1258.       파일: function() {     

    1259.         이상적인 요소 ._defaultInput()     

    1260.         if ( !/file/.test( o.disableCustom ) ) {     

    1261.           $element.idealFile()     

    1262.         }     

    1263.       },     

    1264.       버튼: function() {     

    1265.         if ( !/button/.test( o.disableCustom ) ) {     

    1266.          $element.addClass('ideal-button')     

    1267.         }     

    1268.       },     

    1269.       숨김: function() {     

    1270.         $element.closest('div').addClass('ideal-hidden')     

    1271.       },     

    1272.       제목: function() {     

    1273.         $element.closest('div').addClass('ideal-full-width')     

    1274.         $element.parent( ).children().wrapAll('<span class="ideal-heading"/>')     

    1275.       },     

    1276.       구분 기호: function() {     

    1277.         $요소 .closest('div').addClass('ideal-full-width')     

    1278.         $element.wrapAll('

      <div class="이상적인 구분자"/>')     

    1279.       }     

    1280.     }     

    1281.     // 현재 요소 유형에 대한 마크업 생성     

    1282.     idealElements[ elementType ] ? IdealElements[ elementType ]() : $.noop()     

    1283.     $error.add( $valid ).add( $invalid ).hide() // 새로 시작     

    1284.   },     

    1285.   /** 입력을 확인하고 오류 및 아이콘을 표시하거나 숨깁니다.   

    1286.    * @memberOf Actions    

    1287.    * @param {object} $input jQuery object    
    1288.    * @param {string} e JavaScript 이벤트    
    1289.    */     
    1290.   _validate: function( $input, e ) {     
    1291.     var 
    1292. self

       =      

    1293.     var 
    1294. o

      이것.opts     

    1295.     var userOptions = o.inputs[ $input.attr('name') ]     

    1296.     var userFilters = userOptions.filters && userOptions.filters.split(/s/)     

    1297.     var name = $input.attr(' 이름')     

    1298.     var value = $input.val()     

    1299.     var ajaxRequest = $.idealforms.ajaxRequests[ name ]     

    1300.     var isRadioCheck = $input.is('[type="checkbox "], [유형="라디오"]')     

    1301.     var inputData = {     

    1302.       // 라디오 또는 체크가 이름별로 관련된 모든 입력의 유효성을 검사하는 경우    

    1303.       입력: isRadioCheck ? self.$form.find('[이름="' + 이름 + '"]') : $input,     

    1304.       userOptions : userOptions     

    1305.     }     

    1306.     // 검증 요소    

    1307.     var $

      분야 = $input.parents('.ideal-field')     

    1308.     var $

      오류 = $field.siblings('.ideal-error')     

    1309.     var $

      잘못됨 = isRadioCheck     

    1310.       ? $input.parent().siblings('.ideal-icon-invalid')     

    1311.       : $input.siblings('.ideal-icon-invalid')     

    1312.     var $

      유효 = isRadioCheck     

    1313.       ? $input.parent().siblings('.ideal-icon-valid')     

    1314.       : $input.siblings('.ideal-icon-valid')     

    1315.     함수 resetError() {     

    1316.       $field.removeClass('valid invalid').removeData('ideal-isvalid')     

    1317.       $error.add( $invalid ).add( $valid ).hide()     

    1318.     }     

    1319.     함수 showOrHideError (오류, 유효함) {     

    1320.       resetError()     

    1321.       유효합니까? $valid.show() : $invalid.show()     

    1322.       $field.addClass( 유효한 ? '유효' : '유효하지 않은' )     

    1323.       $field.data( 'ideal-isvalid', valid )     

    1324.       if ( !valid ) {     

    1325.         $error.html( error ).toggle( $field.is('.ideal-field-focus') )     

    1326.       }     

    1327.     }     

    1328.     // 입력할 때 유효성 검사를 방지하지만 새 문자를 도입하지 않음     

    1329.    // 주로 여러 AJAX 요청을 방지하기 위한 것입니다     

    1330.     var oldValue = $input.data('ideal-value') || 0     

    1331.     $input.data( '이상적인 가치', 값 )     

    1332.     if ( e.type = =='keyup'&& ( userFilters ) {     

            $.each( userFilters, function( i, filter ) {     
    1333.         var 
    1334. theFilter
    1335.  = $.idealforms.filters[ 필터 ]     

    1336.         var 

      customError

       = 
    1337. userOptions
    1338. .errors && userOptions.errors[ 필터 ]     

              var 
    1339. 오류
    1340.  = 

      ''            // 필드가 비어 있고 필수가 아닌 경우     

    1341. >      false를 반환
    1342.         }     

    1343.        if ( theFilter ) {     
    1344.           // Ajax를 중단하고 재설정합니다. 요청 대기 중     
    1345.           if ( 
    1346. e.type
    1347.  ==='keyup' && ajaxRequest ) {     

    1348.             ajaxRequest. 중단()     
    1349.            $field.removeClass('ajax')     
    1350.           }     
    1351.           / / AJAX     
    1352.           if ( 
    1353. 필터
    1354.  === 'ajax' ) {     

       nbsp;           showOrHideError( error, false ) // 응답이 돌아올 때까지 무효로 설정     
    1355.           $error.hide()    
    1356.            if ( 

      e .type
    1357.  === 'keyup' ) {     
    1358.              theFilter.regex( inputData, value, showOrHideError ) // ajax 콜백 실행     
    1359.            } else {     
    1360.               var 

      ajaxError
    1361.  = $input.data('ideal-ajax-error')     
    1362.              if ( ajaxError ) {     

    1363.               showOrHideError( ajaxError, $input.data('ideal-ajax-resp') || false )     

    1364.              }     

    1365.            }     

    1366.           }     

    1367.           // 기타 모든 필터     

    1368.           그 외 {     

    1369.            var 

      유효 = 유틸 .isRegex( theFilter. 정규식 ) && theFilter.regex.test( 값 ) ||     

    1370.                       Utils.isFunction( theFilter.regex ) && theFilter.regex( inputData, value )     

    1371.             

      오류 = customError || theFilter.error ///regex() 호출 후 오류 지정 유효함 ) { 반환 false } 🎜>

    1372.     }     
    1373.     // 필터가 없으면 재설정     
    1374.     else {     
    1375. ResetError()     
    1376.     }     
    1377.     // 플래그     
    1378.     var 
    1379. 플래그

       = (함수(){     

    1380.       var 

      f
    1381.  = 
    1382. userOptions

      .flags && userOptions.flags.split(' ') || [ ]     

    1383.       if ( o.globalFlags ) {     

    1384.         $.each( o.globalFlags.split(' '), function( i, v ) { f.push(v) })     

    1385.       }     

    1386.       반환 f     
    1387. }())     

    1388.     if ( flags.length ) {     
    1389.       $.each(flags, function( i,f) {     
    1390.         var 
    1391. theFlag

       = $.idealforms.flags[f]     

    1392.         if ( theFlag ) { theFlag( $input, e .type ) }     

    1393.       })     

    1394.    }     

    1395.     // 업데이트 카운터     

    1396.     if ( self.$tabs.length ) {     

    1397.       self._updateTabsCounter( self._getCurrentTabIdx() )     

    1398.     }     

    1399.   },     

    1400.   _attachEvents: function() {     

    1401.     var self = this     

    1402.     self._getUserInputs().on('keyup change focus blur', function(e) {     

    1403.       var $this = $(this)

    1404.       var $필드 = $this.parents('.ideal-field')     

    1405.       var  isFile = $this.is('input[type=file]')     

    1406.       // 변경 시 트리거 type=file custom file     

    1407.      // 원래 파일 입력에 초점을 비활성화합니다 (tabIndex = -1)     

    1408.       if ( e.type === 'focus' || isFile && e.type ==='change') {     

    1409.         $field.addClass('ideal-field-focus')     

    1410.      }     

    1411.       if ( e.type === 'blur' ) {     

    1412.         $field.removeClass('ideal-field-focus')     

    1413.       }     

    1414.       self._validate( $this, e )     

    1415.     })     

    1416.   },     

    1417.   _반응: function() {     

    1418.     var formElements = 이것._getFormElements()     

    1419.     var maxWidth = LessVars.fieldWidth + formElements.labels.outerWidth()     

    1420.     var $emptyLabel = formElements.labels.filter(function() {     

    1421.       return $(this).html () === ' '     

    1422.     })     

    1423.     var $customSelect = 이것 ... >

            ? this.$form.toggleClass( 'stack', this.$form.width() 
    1424. <
    1425.  

      maxWidth )     

    1426.       : this. $form.toggleClass( 'stack', $(window).width() 

      < this.opts.ResponseAt )     

    1427.     var

      isStack = 이것.$form.is('.stack')     

    1428.     $emptyLabel.toggle( !isStack )     

    1429.     $customSelect.trigger( isStack ? 'list' : 'menu' )     

    1430.     // datePicker 숨기기     

    1431.     var $datePicker = this.$form.find('input.hasDatepicker')     

    1432.     if ( $datePicker.length ) { $datePicker.datepicker('hide') }    

    1433.   }     

    1434. })     

    1435. /*    

    1436.  * 공개 방법    

    1437.  */     

    1438. $.extend( IdealForms.prototype , {     

    1439.   getInvalid: function() {     

    1440.     return this.$form.find('.ideal-field').filter( function() {     

    1441.       return $(this).data('ideal-isvalid') === false     

    1442.     })     

    1443.   },     

    1444.   getInvalidInTab: function( nameOrIdx ) {     

    1445.     return this._getTab( nameOrIdx ) .find('.ideal-field').filter(function() {     

    1446.       return $(this).data('ideal-isvalid') === false     

    1447.     })     

    1448.   },     

    1449.   isValid: function() {     

    1450.     반환 !this.getInvalid().length     

    1451.   },     

    1452.   isValidField: 함수( 필드) {     

    1453.     var $input = Utils.getByNameOrId( field )     

    1454.     return $input.parents(' .ideal-field').data('ideal-isvalid') === true     

    1455.   },     

    1456.   focusFirst: function() {     

    1457.     if ( this.$tabs.length ) {     

    1458.       this.$tabs.filter(':visible')     

    1459.         .find('.ideal-field:first')     

    1460.         .find('input:first, select, textarea').focus()

    1461.     } else {     

    1462.       this.$form.find('.ideal-field:first')     

    1463. <
    1464.   },     
    1465.   focusFirstInvalid: function() {     
    1466.     var $
    1467. first

       = 

      this
    1468. .getInvalid().first().find('input:first, select, textarea')     
    1469.     var 
    1470. tabName

       = $first.parents('.ideal-tabs-content').data('ideal-tabs-content-name')         if ( this.$tabs.length ) {     

    1471.       this.switchTab( tabName )     

    1472.    }     
    1473.     $first.focus()
    1474.     반환 이     
    1475.   },     
    1476. <<>
    1477. switchTab : function (nameoridx) {<🎜 🎜>

    1478. this. $ tabs.switchtab (nameoridx)
    1479. return return this     
    1480.   },     
    1481.   nextTab: function() {     
    1482.     this.$tabs. NextTab () <((>
    1483. >이 <🎜 🎜 <🎜
    1484. }},

    1485. prevTab : function () {{<{<{ 🎜>

    1486.     this.$tabs.prevTab()     

    1487.     return this     

    1488.   },     

    1489.   firstTab: function() {     

    1490.     this.$tabs.firstTab()     

    1491.     return this     

    1492.   },     

    1493.   lastTab: function() {     

    1494.     this.$tabs.lastTab( )) <🎜 🎜>

    1495. this
    1496. }, <🎜
    1497. <🎜 🎜> fresh : function () {
    1498.     this._getUserInputs().change().parents('.ideal-field')     
    1499.       .removeClass('valid invalid')     
    1500.     return 이것     
    1501.   },     
    1502.   freshFields: function( fields ) {     
    1503.     
    1504. 필드
    1505.  = 

      유틸리티

      .convertToArray( fields )     
    1506.     $.each( 필드, 함수( i ) {

            var $
    1507. 입력
    1508.  = 

      Utils

      .getByNameOrId( fields[ i ] )     
    1509.       $ input.change().parents('.ideal-field').removeClass('valid invalid')     

          })     
    1510.     return this     
    1511.   },     
    1512.   reload: function() {     
    1513.     this._adjust()
    1514. <<>
    1515. this._attachevents () <🎜 🎜>

    1516. this

    1517. },

      <🎜 🎜 🎜 >

    1518.   재설정: function() {     
    1519.     var 
    1520. formElements

       = 

      this
    1521. ._getFormElements()     
    1522. >

    1523.     // 선택 및 맞춤 선택     

          formElements.select.find('option').first().prop( 'selected', true )

    1524.     this.$form.find('.ideal-select').trigger('reset')     

    1525.     if ( this.$ tabs.length ) { this.firstTab() }     

    1526.     this.focusFirst().fresh()     

    1527.     return this     

    1528.   },     

    1529.   resetFields: function( fields ) {     

    1530.     필드 = Utils.convertToArray( fields )     

    1531.     var formElements = this._getFormElements()     

    1532.     $.each( fields, function( i, v ) {     

    1533.       var $ 입력 = 유틸리티.getByNameOrId( v )     

    1534.       var 유형 = 유틸.getIdealType ( $input )     

    1535.       if ( 유형 ==='text' || 유형 ==='파일' ) {     

    1536.         $input.val('')     

    1537.       }     

    1538.       if ( 유형 === 'radiocheck' ) {     

    1539.         $input.removeAttr('checked') // 라디오 & 체크     

    1540.       }    

    1541.       if ( 

      입력 === '선택' ) {     

    1542.         $input.find('옵션'). first().prop( 'selected', true )     

    1543.         $input.next('.ideal-select').trigger('reset')     

    1544.       }     

    1545.       $input.change()     

    1546.     })     

    1547. this.freshFields( fields )     

    1548.     return this     
    1549.   },     
    1550.   toggleFields: 함수( 필드 ) {     
    1551.     
    1552. 필드
    1553.  = 

      Utils.convertToArray( fields )     

          var 
    1554. self
    1555.  = 

           

          var $
    1556. fields
    1557.  = 

      Utils.getFieldsFromArray( fields )     

          $fields.each(function() {     
    1558.       var $
    1559. this
    1560.  = $(this)     

            var 
    1561. 이름
    1562.  = $this.attr('name') || $this.attr('id')     

            var 
    1563. input
    1564.  = 

      self.opts.inputs[ name ]     

            var 
    1565. 필터
    1566.  = 

      입력 && input.filters     

            var 
    1567. dataFilters
    1568.  = $this. data('이상적인 필터') || ''     

            $this.data( 'ideal-filters', filters )     
    1569.       $this.closest('.ideal-wrap' ).toggle()     
    1570.       self.setFieldOptions( name, { filters: dataFilters } )     
    1571.     })     
    1572.     return 이것     

    1573.   },     

    1574.   setOptions: function( options ) {     

    1575.     $.extend( true, this.opts, options )     

    1576.     this.reload().fresh()     

    1577. <🎜
    1578. }}, <🎜 🎜>

    1579. setfieldOptions : 함수 (이름, 옵션) {<🎜 🎜>

    1580. 를 반환합니다. $.extend( true, this.opts.inputs[ name ], options )     
    1581.     this.reload().freshFields([ 이름 ])     
    1582. 반환 <🎜 🎜>
    1583. }, <🎜 🎜>
    1584. addfields : function (fields) {

      <🎜 🎜
    1585. <🎜 🎜>
    1586. fields

       = 

      Utils
    1587. .convertToArray( fields )     
    1588.     var self = 

      this
    1589.      
    1590.     // 모든 입력의 이름을 배열에 저장    

    1591.     // 이름을 취하는 메서드를 사용하려면 fresh()     
    1592.     var 
    1593. allNames

       = []     

    1594.     // DOM에 입력 추가     

    1595.     함수 추가( ops ) {     
    1596.       var 
    1597. name

       = 

      ops
    1598. .name     
    1599.  nbsp;     var userOptions = {     

    1600.         필터: ops.filters || '',     

    1601.         데이터: ops.data || {},     
    1602.         오류: ops.errors || {},     
    1603.         플래그: ops.flags || ''     
    1604.       }     
    1605.       var 
    1606. label

       = 

      ops
    1607. .label || ''     
    1608.       var type = 

      ops
    1609. .type     
    1610.       var list = 

      ops
    1611. .list || []     
    1612.       var placeholder = 

      ops
    1613. .placeholder || ''     
    1614.       var  = 

      ops
    1615. .value || ''     
    1616.       var $필드 = $('

      <
    1617. div

      > '+               '<

      라벨
    1618. >

      '+ 라벨 +':레이블>'+               Utils.makeInput( 이름, 값, 유형, 목록, 자리 표시자) +     

    1619.         'div>')     

    1620.       var $ 입력 = $field.find('input, select, textarea, :button')     

    1621.       // 목록에 필터가 포함된 입력 추가     

    1622. // 사용자 입력의 //

    1623. if (useroptions.filters) {self.opts.inputs [name] = useroptions}
    1624. >

            self._doMarkup( $input )     
    1625.       // DOM에 삽입    
    1626.       if ( ops.addAfter ) {     
    1627.         $field.insertAfter(     
    1628.          $( Utils.getByNameOrId( ops.addAfter ) ).parents('.ideal-wrap')     
    1629.         )     
    1630.      } else if ( ops.addBefore ) {     
    1631.         $field.insertBefore(
    1632.           $(Utils.getByNameOrId( ops.addBefore ))     
    1633.           .parents('.ideal-wrap')     
    1634. >    

    1635.           self._getTab( ops.appendToTab ).find('.ideal-wrap:last-child')     

    1636.         )     

    1637.       } else {     

    1638.         $field.insertAfter( self.$form.find('.ideal-wrap').last() )     

    1639.       }     

    1640.       // 이름 목록에 현재 필드 이름 추가     

    1641.       allNames.push(이름)     
    1642.     }     
    1643.     // 각 입력을 통해 실행     
    1644.     $.each( fields, function( i, ops ) { add( ops ) })     
    1645.     self.reload()     
    1646.     self.freshFields( allNames )     
    1647.     self._Response()     
    1648.     이것을 반환하세요     
    1649.   },     
    1650.   removeFields: function( fields ) {     
    1651.     
    1652. fields

       = 

      Utils
    1653. .convertToArray( fields )     
    1654.     var $
    1655. 필드

       = 

      유틸리티
    1656. .getFieldsFromArray(필드 )     
    1657.     $fields.parents('.ideal-wrap').remove ) 🎜>})     

    1658. }( jQuery, window, document ))

    【관련 추천】

    1.Html5 무료 동영상 튜토리얼

    2.

    HTML5 로컬 데이터베이스 인스턴스에 대한 자세한 설명

    3.

    H5 마이크로 시나리오 구현 방법을 가르쳐줍니다

    4 .

    H5의 사용자 정의 속성 데이터에 대한 자세한 설명-*

    5.

    텍스트 상자 프롬프트 구현을 위한 H5 코드 예시

위 내용은 H5가 사용자 등록 자동 인증을 완료한 상세 예시의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

관련 라벨:
원천:php.cn
본 웹사이트의 성명
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
최신 이슈
인기 튜토리얼
더>
최신 다운로드
더>
웹 효과
웹사이트 소스 코드
웹사이트 자료
프론트엔드 템플릿