/*--------------------------------------------------------------------------------*\

    *  JavaScript framework, version 2.0
    *
    *  Date : 2006. 08. 15.
    *  Copyright 1998-2007 by Vricks Studio All right reserved.
    *  @author Jeff Yang routine@vricks.com
    *  자주 쓰이는 스트링 관련 prototype관련 정리
    *--------------------------------------------------------------------------------*/
/**
 * 문자의 좌, 우 공백 제거
 * @return : String
 */
String.prototype.trim = function() {
    return this.replace(/(^\s*)|(\s*$)/g, "");			// 모든글자(/ /g)에서 문자의 앞쪽공백(^\s*) 맨뒤공백(\s*$) 제거
}

/**
 * 문자의 좌 공백 제거                                                                                                                     
 * @return : String
 */
String.prototype.ltrim = function() {
    return this.replace(/(^\s*)/, "");                   // 문자열이 공백(\s)으로 시작되면 제거
}

/**
 * 문자의 우 공백 제거                                                                                                                     
 * @return : String                                                                                                                        
 */
String.prototype.rtrim = function() {
    return this.replace(/(\s*$)/, "");					//문자열 마지막($)이 공백(\s)으로 시작되면 제거
}

/**
 * 문자열의 getByte 길이 반환
 * @return : int
 */
String.prototype.getByte = function() {
    var cnt = 0;
    for (var i = 0; i < this.length; i++) {
        if (this.charCodeAt(i) > 127)					//문자열 내의 특정 문자의 문자코드 값이 127을 넘을 경우(ex.한국어입력)
           	cnt += 2;									//한 글자에 +2씩 증가
        else 											//그렇지 않을경우                                                                                   
            cnt++;										//한 글자에 +1씩 증가
    }
	return cnt;
}

/**
 * 정수형으로 변환
 * @return : String
 */
String.prototype.convInt = function() {
    if(!isNaN(this)) {									//  숫자일 경우("숫자형 문자 포함") true
        return parseInt(this);							//  정수형으로 변환하여 리턴
    }
    else {												// false일 경우 null 리턴
        return null;
    }
}

/**
 * 숫자만 가져 오기
 * @return : String 
 */
String.prototype.num = function() {                                                                                                                                                                                                      
    return (this.trim().replace(/[^0-9]/g, ""));		// 공백을 뺀 모든문자(/ /g)에서 숫자만 리턴
}

/**
 * 숫자에 3자리마다 , 를 찍어서 반환 
 * @return : String 
 */
String.prototype.money = function() {
    var num = this.trim();                                      //공백 제거 후 변수 num에 추가
    while((/(-?[0-9]+)([0-9]{3})/).test(num)) {        			// 바로앞의 문자(?) - 가 있거나 없는 반드시 하나 이상의 숫자와 숫자가 3개가 있을 경우 true
        num = num.replace((/(-?[0-9]+)([0-9]{3})/), "$1,$2");	// 3번째 자리에 콤마 추가
    }
    return num;
}
/**
 * 숫자의 자리수(cnt)에 맞도록 반환
 * @return : String
 */
String.prototype.digits = function(cnt) {
    var digit = "";
    if (this.length < cnt) {                               		// 입력받은 숫자의 길이보다 입력받은 숫자가 크면 true
        for(var i = 0; i < cnt - this.length; i++) {			// for문이용하여 0부터 해당길이만큼 반복
            digit += "0";                                       // "0"은 문자형이어서 해당길이만큼 0이 붙는다 ex)000
        }
    }                                                                                                                                  
    return digit + this;                                        // digit값 + this 값 리턴  ex)0003
}

/**
 * " -> &#34; ' -> &#39;로 바꾸어서 반환
 * @return : String
 */
String.prototype.quota = function() {
    return this.replace(/"/g, "&#34;").replace(/'/g, "&#39;");    //정규식이용하여 값 변환 후 리턴
}

/**
 * 파일 확장자만 가져오기
 * @return : String
 */
String.prototype.ext = function() {
	// "."이 들어있는 위치가 0보다 작다면,즉 없다면 "" 리턴 그렇지 않다면 "."이하의 스트링을 잘라서 리턴
    return (this.indexOf(".") < 0) ? "" : this.substring(this.lastIndexOf(".") + 1, this.length);
}

/**
 * URL에서 파라메터 제거한 순수한 url 얻기
 * @return : String
 */
String.prototype.uri = function() {
    var arr = this.split("?");						//"?" 이하는 자른값 변수 arr에 추가
    arr = arr[0].split("#");						// 변수 arr에 #이하 저장
    return arr[0];                                  // 저장된 값 리턴
}

/**
 * 정규식에 쓰이는 특수문자를 찾아서 이스케이프 한다.
 * @return : String
 */
 String.prototype.meta = function() {
    var str = this;
    var result = "";
                                                                                                                     
    for(var i = 0; i < str.length; i++) {
        if((/([\$\(\)\*\+\.\[\]\?\\\^\{\}\|]{1})/).test(str.charAt(i))) {  						//입력받은 글에 ([\$\(\)\*\+\.\[\]\?\\\^\{\}\|]{1}) 존재하면 true
            result += str.charAt(i).replace((/([\$\(\)\*\+\.\[\]\?\\\^\{\}\|]{1})/), "\\$1"); 	//해당하는 특수문자 앞에 \\추가
        }
        else {																					//false 일경우
            result += str.charAt(i);															//str인덱스에 해당하는 문자를 result에 반환
        }
    }
    return result;
}
                                                                                                                                           
/**
 * 정규식에 쓰이는 특수문자를 찾아서 이스케이프 한다.
 * @return : String 
 */
String.prototype.remove = function(pattern) {
	//넘겨받은 값이 null일경우 본래의 값을 리턴 그렇지 않을 경우 JScript 코드를 평가하고 실행하는 eval 함수를 이용하여
	// 정규식 검사 후 ""을 리턴한다.
    return (pattern == null) ? this : eval("this.replace(/[" + pattern.meta() + "]/g, \"\")");

}

/**
 * 최소 최대 길이인지 검증
 * str.isLength(min [,max])
 * @return : boolean
 */
String.prototype.isLength = function() {
    var min = arguments[0];         				// 넘어받은 첫번째 파라미터의 값[0]을 min변수에 추가
    var max = arguments[1] ? arguments[1] : null;	// 변수max에 두번째 파라미터 값(존재할 경우) 혹은 null(파라미터 값 없을경우)추가
    var success = true;

    if(this.length < min) {                         //넘어온 값의 길이가 min보다 작을경우
        success = false;							//success에 false
    }

    if(max && this.length > max) {					//max 그리고 넘어온 값의 길이가 max값보다 클경우(논리곱&&에 의해 하나라도 false되면 if문 빠져나가게 된다)
        success = false;							//success에 false
    }
    return success;
}
/**
 * 최소 최대 바이트인지 검증
 * str.isByteLength(min [,max])
 * @return : boolean
 */
String.prototype.isByteLength = function() {
    var min = arguments[0];
    var max = arguments[1] ? arguments[1] : null;
    var success = true;

    if(this.getByte() < min) {                      //넘어온 값의 바이트 수가 min보다 작을경우
        success = false;
    }

    if(max && this.getByte() > max) {               //max 그리고 넘어온 값의 바이트 수가 max보다 클경우
        success = false;
    }
    return success;
}
/**
 * 공백이나 널인지 확인
 * @return : boolean
 */
String.prototype.isBlank = function() {
    var str = this.trim();                													//넘어온 값 공백제거
    for(var i = 0; i < str.length; i++) {       										    //0부 터길이만큼 조건반복으로 검사
        if ((str.charAt(i) != "\t") && (str.charAt(i) != "\n") && (str.charAt(i)!="\r")) {  // \t(탭문자), \n(줄바꿈), \r(캐리지 리턴 문자) 존재 할 경우
            return false;                                                                   //false 리턴
        }
    }
    return true;
}
/**
 * 숫자로 구성되어 있는지 학인
 * arguments[0] : 허용할 문자셋
 * @return : boolean
 */
String.prototype.isNum = function() {
    return (/^[0-9]+$/).test(this.remove(arguments[0])) ? true : false;			//파라미터를 제외하고 넘어온 값이 숫자이면 true 아니면 false 리턴
}

/**
 * 영어만 허용 - arguments[0] : 추가 허용할 문자들
 * @return : boolean
 */
String.prototype.isEng = function() {
    return (/^[a-zA-Z]+$/).test(this.remove(arguments[0])) ? true : false;     //파라미터를 제외하고 넘어온 값이 영어면 true 아니면 false 리턴
}

/**
 * 숫자와 영어만 허용 - arguments[0] : 추가 허용할 문자들
 * @return : boolean
 */
String.prototype.isEngNum = function() {
    return (/^[0-9a-zA-Z]+$/).test(this.remove(arguments[0])) ? true : false;   //파라미터를 제외하고 넘어온 값이 숫자와 영어면 true 아니면 false 리턴
}

/**
 * 숫자와 영어만 허용 - arguments[0] : 추가 허용할 문자들
 * @return : boolean
 */
String.prototype.isNumEng = function() {
    return this.isEngNum(arguments[0]);                                        // 파라미터로 넘어온 값 허용하여 숫자와 영어만으로 되어있는지 검사
}

/**
 * 아이디 체크 영어와 숫자만 체크 첫글자는 영어로 시작 - arguments[0] : 추가 허용할 문자들
 * @return : boolean
 */
String.prototype.isUserid = function() {
    return (/^[a-zA-z]{1}[0-9a-zA-Z]+$/).test(this.remove(arguments[0])) ? true : false;   //파라미터를 제외하고 넘어온 값이 첫 글자는 영문자이어야하고 나머지는 숫자또는 영문자 일때 true 아니면 false
}

/**
 * 한글 체크 - arguments[0] : 추가 허용할 문자들
 * @return : boolean
 */
String.prototype.isKor = function() {
    return (/^[가-힣]+$/).test(this.remove(arguments[0])) ? true : false;					//파라미터를 제외하고 넘어온 값이 한글이면 true 아니면 false
}
                                                                                                                                           
/**
 * 주민번호 체크 - arguments[0] : 주민번호 구분자
 * arguments[0] 구분자 받아서 처리 확인 안됨.
 *XXXXXX-XXXXXXX
 *@return : boolean                                                                                            
 */
String.prototype.isJumin = function() {
    var arg = arguments[0] ? arguments[0] : "";                                                                 //파라미터로 넘어온 값이 있으면 arg에 넣어준다.
    var jumin = eval("this.match(/[0-9]{2}[01]{1}[0-9]{1}[0123]{1}[0-9]{1}" + arg + "[1234]{1}[0-9]{6}$/)");    //넘어온 값을 이용하여 정규식과 일치여부 확인 후 값 변수에 전달
    if(jumin == null) {
        return false;                                                                                           // jimin이 null일경우
    }                                                                                                           // false 리턴
    else {
        jumin = jumin.toString().num().toString();                                                              //문자로 변형 후 숫자반 받아서 스트링처리
    }

    // 생년월일 체크
    var birthYY = (parseInt(jumin.charAt(6)) == (1 ||2)) ? "19" : "20";                                         //넘겨받은값의 인덱스 6의 값이 1이나 2일경우 19(1900년대에 출생)
    birthYY += jumin.substr(0, 2);                                                                              //년도뒤에 두자리 받아서 총 4자리 만듬
    var birthMM = jumin.substr(2, 2) - 1;                                                                       //월 잘라서 받아옴
    var birthDD = jumin.substr(4, 2);                                                                           //일 잘라서 받아옴
    var birthDay = new Date(birthYY, birthMM, birthDD);	                                                        // birthDay 생성

    if(birthDay.getYear() % 100 != jumin.substr(0,2) || birthDay.getMonth() != birthMM || birthDay.getDate() != birthDD) {
        return false;
    }

    var sum = 0;
    var num = [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5]
    var last = parseInt(jumin.charAt(12));

    for(var i = 0; i < 12; i++) {
        sum += parseInt(jumin.charAt(i)) * num[i];
    }
    return ((11 - sum % 11) % 10 == last) ? true : false;                                                         //계산식에따라 true/false 리턴
}

/**
 * 외국인 등록번호 체크 - arguments[0] : 등록번호 구분자
 * XXXXXX-XXXXXXX
 * @return : boolean
 */
/*                                                                                                                                           
String.prototype.isForeign = function() {                                                                                                  
    var arg = arguments[0] ? arguments[0] : "";                                                                                            
    var jumin = eval("this.match(/[0-9]{2}[01]{1}[0-9]{1}[0123]{1}[0-9]{1}" + arg + "[5678]{1}[0-9]{1}[02468]{1}[0-9]{2}[6789]{1}[0-9]{1}$/

    if(jumin == null) {                                                                                                                    
        return false;                                                                                                                      
    }                                                                                                                                      
                                                                                                                                           
    else {                                                                                                                                 
        jumin = jumin.toString().num().toString();                                                                                         
    }                                                                                                                                      
                                                                                                                                           
    // 생년월일 체크                                                                                                                       
    var birthYY = (parseInt(jumin.charAt(6)) == (5 || 6)) ? "19" : "20";                                                                   
    birthYY += jumin.substr(0, 2);                                                                                                         
    var birthMM = jumin.substr(2, 2) - 1;                                                                                                  
    var birthDD = jumin.substr(4, 2);                                                                                                      
    var birthDay = new Date(birthYY, birthMM, birthDD);                                                                                    
                                                                                                                                           
    if(birthDay.getYear() % 100 != jumin.substr(0,2) || birthDay.getMonth() != birthMM || birthDay.getDate() != birthDD) {                 
        return false;                                                                                                                      
    }                                                                                                                                      
                                                                                                                                           
    if((parseInt(jumin.charAt(7)) * 10 + parseInt(jumin.charAt(8))) % 2 != 0) {                                                            
        return false;                                                                                                                      
    }                                                                                                                                      
                                                                                                                                           
    var sum = 0;                                                                                                                           
    var num = [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5]                                                                                         
    var last = parseInt(jumin.charAt(12));                                                                                                 

    for(var i = 0; i < 12; i++) {                                                                                                          
        sum += parseInt(jumin.charAt(i)) * num[i];                                                                                         
    }                                                                                                                                      
                                                                                                                                           
    return (((11 - sum % 11) % 10) + 2 == last) ? true : false;                                                                            
}                                                                                                                                          
*/                                                                                                                                           

/**                                                            
 *사업자번호 체크 - arguments[0] : 등록번호 구분자
 * arguments[0] 구분자 받아서 처리 확인 안됨.                                                                                        
 *XX-XXX-XXXXX                                                                                                                            
 *@return : boolean     
*/
String.prototype.isBiznum = function() {
    var arg = arguments[0] ? arguments[0] : "";
    var biznum = eval("this.match(/[0-9]{3}" + arg + "[0-9]{2}" + arg + "[0-9]{5}$/)");                          //정규식 검사 후 값 변수에 전달

    if(biznum == null) {
        return false;                                                                                            //변수에 값이 없을 경우
    }                                                                                                            //false 리턴
    else {
        biznum = biznum.toString().num().toString();                                                             //문자로 변형 후 숫자만 받아서 스트링처리
    }

    var sum = parseInt(biznum.charAt(0));                                                                        //0번째 인덱스의 값을 받아서 정수처리
    var num = [0, 3, 7, 1, 3, 7, 1, 3];

    for(var i = 1; i < 8; i++)
    	sum += (parseInt(biznum.charAt(i)) * num[i]) % 10;
    	sum += Math.floor(parseInt(parseInt(biznum.charAt(8))) * 5 / 10);
    	sum += (parseInt(biznum.charAt(8)) * 5) % 10 + parseInt(biznum.charAt(9));
    return (sum % 10 == 0) ? true : false;                                                                       //계산식에 따라  true/false 리턴
}

/**
 * 법인 등록번호 체크 - arguments[0] : 등록번호 구분자
 * arguments[0] 구분자 받아서 처리 확인 안됨.
 * XXXXXX-XXXXXXX
 * @return : boolean
 */
String.prototype.isCorpnum = function() {
    var arg = arguments[0] ? arguments[0] : "";
    var corpnum = eval("this.match(/[0-9]{6}" + arg + "[0-9]{7}$/)");                                            //정규식에 해당하는 값 변수에 넣는다

    if(corpnum == null) {                                                                                        //변수에 값이 없을 경우
        return false;                                                                                            //false 리턴
    }
    else {                                                                                                       //값이 있을 경우
        corpnum = corpnum.toString().num().toString();                                                           //문자로 변형 후 숫자만 받아서 스트링처리
    }

    var sum = 0;
    var num = [1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
    var last = parseInt(corpnum.charAt(12));

    for(var i = 0; i < 12; i++) {
        sum += parseInt(corpnum.charAt(i)) * num[i];
    }
    return ((10 - sum % 10) % 10 == last) ? true : false;                                                        //계산식에 따라 true/false 리턴
}

/**
 * 이메일의 유효성을 체크
 * @return : boolean
 */
String.prototype.isEmail = function() {
	// 모든단어문자를 찾는다(\w)
	// 바로앞에 문자는 최소 한개이상 존재(+)
	// ()그룹화	// 바로앞에 문자(-)는 최소 한개이상 존재(+) // 어떤문자건 임의의 한글자(.) 
	// 그룹화된 문자가 1이상 있거나 없거나(*)
	// "."을 찾는다.(\.)
	// 영문자[a-zA-Z]를 최소 2개에서 최대 4개까지 찾는다 
	// 문자열의 마지막($)                             
    return (/\w+([-+.]\w+)*@\w+([-.]\w+)*\.[a-zA-Z]{2,4}$/).test(this.trim()); 	//정규식을 검사하여 공백을 뺀 문자열에 패턴이 있는지 여부를  true/false 리턴
}
/**
 * 이메일의 유효성을 체크
 * @return : boolean
 */
String.prototype.isEmailLast = function() {
	// 모든단어문자를 찾는다(\w)
	// 바로앞에 문자는 최소 한개이상 존재(+)
	// ()그룹화	// 바로앞에 문자(-)는 최소 한개이상 존재(+) // 어떤문자건 임의의 한글자(.) 
	// 그룹화된 문자가 1이상 있거나 없거나(*)
	// "."을 찾는다.(\.)
	// 영문자[a-zA-Z]를 최소 2개에서 최대 4개까지 찾는다 
	// 문자열의 마지막($)                             
    return (/\w+([-.]\w+)*\.[a-zA-Z]{2,4}$/).test(this.trim()); 	//정규식을 검사하여 공백을 뺀 문자열에 패턴이 있는지 여부를  true/false 리턴
}

/**
 * 전화번호 체크 - arguments[0] : 전화번호 구분자
 * arguments[0] 구분자 받아서 처리 확인 안됨.
 * @return : boolean
 */
String.prototype.isPhone = function() {
    var arg = arguments[0] ? arguments[0] : "";
    return eval("(/(02|0[3-9]{1}[0-9]{1})" + arg + "[1-9]{1}[0-9]{2,3}" + arg + "[0-9]{4}$/).test(this)");       //정규식에 해당하는 값 true/false로 바뀌어서 리턴
}

/**
 * 핸드폰번호 체크 - arguments[0] : 핸드폰 구분자
 * arguments[0] 구분자 받아서 처리 확인 안됨.
 * @return : boolean
 */
String.prototype.isMobile = function() {
    var arg = arguments[0] ? arguments[0] : "";
    return eval("(/01[016789]" + arg + "[1-9]{1}[0-9]{2,3}" + arg + "[0-9]{4}$/).test(this)");                   //정규식에 해당하는 값 true/false로 바뀌어서 리턴
}



	//checkbox 선택 체크 여부 조회(2009.10.30 by ksd )
	function CheckRadio(obj) {
		if (obj) {
			if (obj.length){
				var j = 0;
				for (i=0;i < obj.length; i++){
					if (obj[i].checked == true) {
						j++;
					}
				}
				if ( j == 0) {
					return false;
				}
			} else {
				if (obj.checked == true) {
				} else {
					return false;
				}
			}
		} else {
			return false;
		}
		return true;
	}
	
	//Checkbox 값 합치기 (2009.10.30 by ksd )
	function checkValueMerge(obj, split_str){
	  var mergeValue = "";
	  if (obj) {
		  if (obj.length) {
			  for(var i=0; i < obj.length; i++){
			  	if(obj[i].checked){
		  			mergeValue = mergeValue + obj[i].value + split_str;
			  	}
			  }
		  }  else {
			  mergeValue = mergeValue + obj.value + split_str;
		  }
	  } else {
	  
	  }
	  return mergeValue;
	}		