▶들어가기 전

자바스크립트는 느슨한 타입을 가진 언어이기 때문에 관대한 타입 변환을 수행합니다.

이런 부분은 많은 개발자가 자바스크립트를 이해하기 힘들어하고 싫어하는 이유이기도 합니다.

앞으로 자바스크립트의 타입 변환 규칙을 ECMAScript에 명시된 명세를 기준으로 알아볼 것입니다.

이 내용들은 어떤 식으로 타입 변환을 제어하는 것이 좋을지 판단할 때 큰 도움이 될 것입니다.

또한, 자바스크립트의 꽃이라고도 할 수 있는 함수의 선언과 호출 방법 그리고 this 바인딩에 대해 다룰 것입니다.

언급한 내용 모두 자바스크립트에서 혼란스럽게 여겨지지만, 알아보고 나면 생각보다 간단한 규칙이 있다는 것을 이해할 수 있을 것입니다.

 

▶타입 변환

자바스크립트에서 타입 변환을 이해하는 것은 매우 중요합니다.

어떤 경웨 데이터 타입 변환이 발생하는지를 알아야, 의도한 대로 동작하는 코드를 작성할 수 있습니다.

 

자바스크립트의 타입 변환은 명시적 강제 변환, 암시적 강제 변환 두 가지가 있습니다.

둘의 차이는 명확합니다.

명시적 강제 변환은 의도적인 타입 변환을 나타내는 것이고, 암시적 강제 변환은 표현식의 평가 중 타입이 변환되는 것입니다.

 

1) 명시적 강제 변환

명시적 강제 변환은 명확하게 의도를 갖고 타입을 변환하는 것입니다.

문자열, 숫자, 불리언 타입 별로 몇 가지 방법이 있습니다.

▷문자열로 변환

문자열로 변환하는 가장 간단한 방법은 [랩퍼 객체]에서 보았던 String() 함수를 호출하는 것입니다.

new 키워드를 붙이지 않고 String() 함수를 호출하면 랩퍼 객체를 생성하는 것이 아니라 타입 변환 함수로 동작합니다.

console.log(String(3)); // '3'
console.log(String(false)); // 'false'
console.log(String(null)); // 'null'

그렇다면 다른 타입에서 문자열 타입으로의 변환은 어떤 기준으로 이뤄지는 것일까요?

다음 표에서 볼 수 있듯이 타입별로 문자열 변환 방법이 정해져 있습니다.

ECMAScript에서는 이 규칙을 ToString() 추상 연산이라고 명시하고 있으며, 명시적이든 암시적이든 문자열로 변환될 때 수행됩니다.

 

[NOTE]

정확히 말하면 String() 함수는 심볼 이외의 타입에 대해서 ToString 추상 연산을 따릅니다.

심볼 타입의 경우 SymbolDescriptiveString 연산을 통해 변환됩니다.

타입 문자열 변환 결과
undefined 'undefined'
null 'null'
boolean true → 'true', false → 'false'
number Number.toString() 변환 결과(3 → '3')
Symbol 문자열로 변환을 시도하는 경우 TypeError 발생
BigInt BigInt.toString()의 결과 반환(3n → '3n')
object 객체를 원시 타입으로 변환한 후 다시 한번 ToString 추상 연산을 수행한 값을 반환합니다.
객체를 원시 타입으로 변환하는 과정을 정확히는 ToPrimitive 추상 연산이라고 합니다.
const boolVal = true;
const numVal = 2;

console.log(String(boolVal)); // 'true'
console.log(String(numVal)); // '2'

 

[NOTE]

심볼은 연산을 통해 문자열 또는 숫자로 변환될 경우 TypeError가 발생합니다.

이는 심볼이 변환되어 객체의 다른 프로퍼티에 접근하는 것을 방지하기 위해서입니다.

myobject['__' + Symbol('key')]; // TypeError

또 다른 문자열 변환 방법은 toString() 메서드를 사용하는 것입니다.

const num = 4;
console.log(num.toString()); // '4'
  • String()과 toString()의 차이점

앞서 살펴본 String()과 toString()은 대부분 동일한 결과를 반환하지만, 그렇지 않은 경우도 있습니다.

null undefined 타입이 그에 해당합니다.

console.log(String(null)); // 'null'
console.log(String(undefined)); // 'undefined'

undefined.toString(); // TypeError 발생
null.toString(); // TypeError 발생

예제 코드의 결과는 당연합니다.

null과 undefined 타입은 값이 비어 있음, 할당되지 않은 상태를 나타내는 원시 타입이므로  toString() 메서드를 호출할 수 있다는 논리상 말이 되지 않습니다.

또한 이 타입들은 객체가 아니기 때문에 객체에서 사용할 수 있는 프로퍼티들을 사용할 수 없는 것이 옳습니다.

반면, String() 함수의 경우에 심볼 이외의 모든 타입이 위에서 정의된 규칙을 정확하게 따르기 때문에 문자열로 명시적 강제 변환을 하고 싶은 경우에는 toString() 메서드보다는 String() 함수를 사용하는 것이 더 적합합니다.

 

▷숫자로 변환

숫자로의 변환도 문자열과 유사하게 Number() 함수를 호출하여 변환하는 방법이 있으며, BigInt 타입을 제외한 데이터는 ECMAScript의 ToNumber 추상 연산 명세를 기준으로 변환됩니다.

 

[NOTE]

숫자로의 변환 시 정확히는 ToNumber 추상 연산 명세를 기준으로 하여, 여기서 몇 가지 단계를 거쳐 ToNumber 추상 연산을 실행합니다.

타입 숫자 변환 결과
undefined NaN
null +0
string 숫자로 변경이 불가능한 값 → NaN, 숫자형 문자열 → 숫자
boolean true → 1, false → 0
Symbol 숫자로 변환을 시도하는 경우 TypeError 발생
BigInt 숫자로 변환을 시도하는 경우 TypeError 발생
object 객체를 원시 타입으로 변환한 후 다시 한번 ToNumber 추상 연산을 수행한 값을 반환
console.log(Number('3')); // 3
console.log(Number(true)); // 1
console.log(Number(null)); // 0

[NOTE]

BigInt 타입은 연산 중 숫자로 변환되는 것을 방지하기 위해 TypeError를 발생시킵니다.

BigInt 타입은 숫자 타입과는 다르게 큰 정수(안전한 숫자 타입의 범위를 벗어나는 정수)의 연산을 위해 나온 타입이기 때문에 숫자와는 타입이 구분되어야 합니다.

  • parseInt() 함수

숫자로 변환하는 또 다른 방법으로는 parseInt() 함수를 이욯하는 방법이 있습니다.

다만, parseInt() 함수는 문자열만 대상으로 변환합니다.

값이 문자열이 아닌 경우에는 해당 값을 문자열로 변환한 후 사용합니다.

문자열의 변환 과정은 ToString 추상 연산 과정을 따릅니다.

console.log(parseInt('10', 10)); // 10
console.log(parseInt('-1', 10)); // -1

parseInt() 함수의 두 번재 인자는 기수를 의미합니다.

예제 코드는 기수를 10으로 지정하였디 깨문에 10진수를 기준으로 문자열을 숫자로 변환합니다.

기수를 생략하면 첫 번째 인자를 기준으로 추정하여 변환하므로 의도하지 않은 결과가 나올 수 있습니다.

버그를 만들고 싶지 않다면 반드시 기수를 지정하여 사용하길 권장합니다.

 

parseInt() 함수는 Number() 함수와는 달리 인내심을 가지고 끝까지 변환을 수행합니다.

console.log(Number('10A', 10)); // NaN
console.log(parseInt('10A', 10)); // 10

Number() 함수의 경우는 숫자로 변경 불가능한 문자가 있으면 곧바로 NaN을 반환하지만, parseInt() 함수는 변경 불가능한 문자가 나타날 때까지 최대한 숫자로 변환하여 결과를 반환합니다.

 

▷불리언으로 변환

Boolean도 ECMAScript의 ToBoolean 추상 연산에 따라 타입을 변환합니다.

타입 불리언 변환 결과
undefined false
null false
string 빈 문자열 → false, 그 외 문자열 → true
number +0, -0, NaN → false, 그 외 숫자 → true
Symbol true
BigInt 0n → false, 그 외 BigInt 정수 → true
object true

[논리 연산자]에서 살펴본 falsy 값이 기억나시나요?

falsy 값의 기준은 위의 표에 정의된 규칙을 그대로 따른 것입니다.

불리언 타입으로의 변환은 Boolean() 함수를 호출하는 방법과 이중 부정 연산자를 사용하는 방법이 있으며, 두 연산은 모두 동일한 결과를 반환합니다.

const a = null;
const b = 0;
const c = '';
const d = {};
const e = [];

console.log(Boolean(a)); // false
console.log(Boolean(b)); // false
console.log(Boolean(c)); // false
console.log(Boolean(d)); // true
console.log(Boolean(d)); // true

console.log(!!a); // false
console.log(!!b); // false
console.log(!!c); // false
console.log(!!d); // true
console.log(!!d); // true

 

2) 객체의 원시 타입 변환

암시적 강제 변환을 살펴보기 전에 객체의 원시 타입 변환에 대해 먼저 알아보겠습니다.

객체의 원시 타입 변환은 문자열로 변환, 숫자로 변환 두 가지로 나눌 수 있습니다.

그리고 이 과정에서 valueOf() toString() 메서드가 중요한 역할을 합니다.

▷문자열로 변환

객체가 문자열로 변환되는 과정을 아래와 같은 단계로 진행됩니다.

1단계

객체에 정의된 toString() 메서드를 호출합니다. 별도로 정의한 toString() 메서드가 없다면 기본적으로 Object.prototype.toString() 메서드를 실행합니다. Object.prototype.toString() 메서드는 결과 값으로 '[Object object]' 문자열을 반환합니다.

2단계

1단게의 결과가 원시 타입이라면 그 결과를 문자열로 변환하여 반환하고, 그렇지 않다면 valueOf() 메서드를 호출합니다. valueOf() 메서드 역시 객체에 별도로 정의한 valueOf() 메서드가 없다면 기본적으로 Object.prototype.valueOf() 메서드를 실행합니다.

3단계

valueOf() 메서드의 결과 값이 원시 타입이라면 그 결과를 문자열로 변환하여 반환하고, 그렇지 않다면 TypeError가 발생합니다.

console.log(String({})); // '[Object object]'

빈 객체가 '[Object object]' 문자열로 변환되었습니다.

'[Object object]'가 어떻게 나온 결과 값인지 의아할 수 있을 것입니다.

하지만 이 결과는 위의 단계를 정확하게 따른 결과입니다.

1단계

빈 객체를 문자열로 변환하기 위해 객체의 toString() 메서드를 호출합니다. 직접 정의한 toString() 메서드가 없기 때문에 Object.prototype.toString() 메서드를 실행합니다.

2단계

1단계의 결과값은 '[Object object]' 문자열이며 원시 타입이기 때문에 이 결과를 반환합니다.

 

빈 객체의 toString() 메서드의 결과값이 '[Object object]' 문자열 원시 타입이기 때문에 이 결과를 반환하는 것입니다.

또한 toString() 메서드의 결과값이 원시 타입이기 때문에 valueOf() 메서드는 호출되지 않습니다.

 

▷숫자로 변환

객체가 숫자로 변환되는 과정 역시 단계별로 보겠습니다.

1단계

객체에 정의된 valueOf() 메서드를 호출합니다. 별도로 정의한 valueOf() 메서드가 없다면 기본적으로 Object.prototype.valueOf() 메서드를 실행합니다. Object.prototype.valueOf() 메서드는 결과 값으로 객체를 그대로 반환합니다.

2단계

1단계의 결과가 원시 타입이라면 그 결과를 숫자로 변환하여 반환하고, 그렇지 않다면 toString() 메서드를 호출합니다. 별도로 정의한 toString() 메서드가 없다면 기본적으로 Object.prototype.toString() 메서드를 실행합니다.

3단계

toString() 메서드의 결과 값이 원시 타입이라면 그 결과를 숫자로 변환하여 반환하고, 그렇지 않다면 TypeError가 발생합니다.

 

valueOf() 메서드를 먼저 호출한 후 toString() 메서드를 호출하는 것을 제외하면 객체를 문자열로 변환하는 과정과 유사합니다.

console.log(Number({})); // NaN

1단계

빈 객체를 숫자로 변환하기 위해 객체의 valueOf() 메서드를 호출합니다. 직접 정의한 valueOf() 메서드가 없기 때문에 Object.prototype.valueOf() 메서드를 실행합니다.

2단계

1단계의 결과값은 원시 타입이 아닌 빈 객체를 그대로 반환하기 때문에 toString() 메서드를 호출합니다.

3단계

toString() 메서드의 결과값은 '[Object object]' 문자열이며 원시 타입이기 때문에 이 결과를 숫자로 변환합니다. '[Object object]' 문자열은 숫자로 변환할 수없는 값이기 때문에 최종적으로 NaN을 반환합니다.

 

▷객체의 valueOf()와 toString()

만약 valueOf()와 toString() 메서드를 직접 정의한 경우는 어떤 결과 값을 반환할까요?

const obj = {
	valueOf() {
   		return 1;
    },
   	toString() {
    		return 'toString';
    }
}

console.log(String(obj)); // 'toString'
console.log(Number(obj)); // 1

객체의 valueOf()와 toString() 메서드를 직접 정의하면 타입 변환의 결과도 달라짐을 알 수 있습니다.

그렇기 때문에 valueOf()와 toString() 메서드를 재정의할 때는 주의해야 합니다.

 

배열, Date, 정규식과 같은 특수한 객체들은 자체적인 toString() 또는 valueOf() 메서드를 가지고 있습니다.

예를 들어 배열을 문자열로 변경하면 배열의 원소를 콤마(,)로 구분하여 문자열로 병합합니다.

 

3) 암시적 강제 변환

암시적 강제 변환은 연산 중에 내부적으로 타입을 변환하는 것입니다.

명시적 강제 변환과 달리 코드에서 명확하게 타입을 변환하는 것인지 알기 어렵습니다.

많은 개발자가 자바스크립트를 좋아하지 않는 이유 중 하나이며, 초보 개발자들이 가장 헷갈려 하는 부분이기도 합니다.

하지만 암시적 강제 변환 역시 ECMAScript 명세의 기준대로 정확하게 동작하고 있습니다.

이 글에서 자바스크립트의 타입 변환은 명확한 기준이 있다는 점이 전달되기 바랍니다.

 

암시적 강제 변환은 타입이 아닌 연산자를 기준으로 살펴보겠습니다.

▷덧셈 연산자

덧셈 연산자는 숫자 연산이나 문자열을 병합할 때 사용하는 것이라고 생각할 수 있습니다.

하지만 덧셈 연산자는 몇 가지 특징이 있습니다.

 피연산자 중 하나가 문자열 타입인 경우 나머지 타입도 문자열로 변환하여 병합합니다.

// 문자열과 숫자의 덧셈 연산은 숫자를 문자로 변환하여 병합합니다.
console.log(1 + ''); // '1'

[NOTE]

String()과 a + ''의 문자열 변환은 차이가 있습니다. 피연산자의 타입이 객체인 경우 String() 함순느 객체의 toString(), valueOf()의 순서로 메서드를 호출하여 결과를 변환하며, a+''는 valueOf(), toString()의 순서로 호출된 결과를 반환합니다.

 

 피연산자 중 하나가 객체이며 문자열로 변환 가능한 경우 문자열로 변환하여 연산합니다.객체의 문자열 변환 과정은 문자열로 변환에서 설명한 과정과 동일합니다.

// 빈 객체는 '[Object object]' 문자열로 변환이 가능하므로 숫자 1을 문자열로 변환하여 두 문자열을 병합합니다.
console.log(1 + {}); // '1[Object object]'

 

 피연산자가 모두 문자열과 객체가 아닌 경우 숫자로 변환하여 연산합니다. 만약 변환 결과의 타입이 각각 다른 경우 TypeError가 발생합니다.

// 피연산자 중 객체나 문자열이 없기 때문에 true를 숫자로 변환하여 연산합니다.
console.log(1 + true); // 2

보통 숫자 연산에 사용하던 덧셈 연산자에 생각보다 많은 타입 변환 규칙이 존재한다는 것을 알 수 있습니다.

처음 보면 이게 뭐지? 라고 생각할 수 있지만 위의 세 가지 규칙만 이해하면 어떻게 동작할지 알 수 있습니다.

ECMAScript 명세에는 더 세부적인 단계가 있지만, 위의 세 가지 규칙만 잘 이해해도 덧셈 연산자를 올바르게 사용하는데 큰 문제가 없을 것입니다.

 

▷동등 연산자

앞서 [관계형 연산자]에서 동등 연산자의 가장 큰 특징은 암시적 강제 변환을 허용하는 것이라고 하였습니다.

물론 피연산자의 타입이 서로 같은 경우에는 변환하지 않습니다.

 

동등 연산자가 어떤 규칙에 의해 동작하는지 살펴봅시다.

 피연산자 중 하나는 문자열, 하나는 숫자인 경우 문자열을 숫자로 변환하여 동등함을 비교합니다.

// 문자열 '1'을 숫자로 변환하여 동등함을 판단합니다.
console.log(1 == '1') // true

 

 피연산자 중 하나는 문자열, 다른 하나는 BigInt인 경우 문자열을 BigInt로 변환하여 동등함을 비교합니다.

// 문자열 '1'을 BigInt로 변환하여 동등함을 판단합니다.
console.log(1n == '1'); // true

 

 피연산자 중 하나는 null, 다른 하나는 undefined인 경우 동등하게 판단합니다.

console.log(null == undefined); // true
console.log(undefined == null); // true

 

 피연산자 중 하나가 불리언일 경우 불리언을 숫자로 변환하여 동등함을 비교합니다.

// 불리언 true를 숫자로 변환하여 비교합니다.
console.log(true == 1); // true

 

 피연산자 중 하나는 객체, 다른 하나가 문자열, 숫자, BigInt, 심볼 중 하나일 경우 객체를 원시 타입으로 변환하여 동등함을 비교합니다.

// 빈 객체를 원시 타입으로 변환한 후 비교합니다.
console.log('[Object object]' == {}); // true

 

 피연산자 중 하나는 숫자, 다른 하나는 BigInt인 경우 내부적인 숫자 비교 알고리즘에 따라 비교한 결과를 반환합니다.

console.log(1 == 1n); // true

 

동등 비교를 하는 과정에서 다양한 암시적 강제 변환이 일어나는 것을 알 수 있습니다.

규칙들을 하나하나 살펴보면 명확한 기준이 있고 이해하기 어렵지 않지만, 타입 변환으로 인해 가독성이 떨어지는 경우가 있습니다.

console.log(true == '1'); // true

true와 문자열 '1'은 전혀 다른 타입으로 동등 비교 시 false가 나올 것 같지만 그렇지 않습니다.

불리언 true는 숫자 1로 변환되어 문자열 '1'과 비교하게 되고, 이 과정에서 문자열 '1'은 숫자 1로 변환되어 최종적으로 숫자 1과 1을 비교하게 됩니다.

위에서 설명한 변환 규칙을 충실히 따른 결과이지만 확실히 가독성이 떨어집니다.

이런 경우에는 명확하게 엄격한 동등 연산자를 사용하는 것이 가독성에 훨씬 좋습니다.

그럼 헷갈리게 동등 연산자를 사용하지 말고 엄격한 동등 연산자만 사용하는게 좋은 것 아닌가요?

하지만 동등 연산자도 무조건 나쁜 것만은 아닙니다.

function isEmpty(a) {
	if (a == null) {
    		//...
    }
}

특정 값의 비어 있음을 판단하기 위해 동등 연산자를 사용하였습니다.

동등 연산자는 null과 undefined를 동등하게 보기 때문에 두 경우의 수를 모두 편리하게 찾아낼 수 있습니다.

 

동등 연산자는 코드 가독성을 위해 팀원들과 컨벤션을 정하여 사용하는 것이 좋습니다.

"우리 팀에서는 암시적 강제 변환을 허용하지 않겠다!"는 결정이 나면 안전하게 엄격한 동등 연산자만 사용하면 됩니다.

반면, 만약 팀 내에서 명확한 기준을 가지고 동등 연산자를 효율적으로 사용할 수 있다면 동등 연산자도 그 팀에서는 충분히 좋은 역할을 할 수 있습니다.

그리고 이러한 판단을 할 수 있으려면 적어도 앞서 설명한 규칙들은 알고 있어야 합니다.

 

▷비교 연산자

비교 연산자는 숫자 데이터의 대소 비교에서 사용하는 경우가 대부분일 것입니다.

하지만 비교 연산자 역시 동등 연산자처럼 피연산자가 서로 다른 타입인 경우 암시적 강제 변환이 발생합니다.

ECMAScript 명세는 a < b 연산 기준으로 설명하고 있기 때문에 이 글에서도 이 기준을 따라 알아보겠습니다.

비교 연산자는 크게 문자열 데이터의 비교, 그 이외의 경우 두 가지로 나누어져 있습니다.

다만, 피연산자가 객체인 경우 먼저 객체를 원시 타입으로 변환한 후 비교합니다.

변환된 결과가 모두 문자열이라면 문자열 비교를 하고 이외에는 문자열 외의 비교 규칙에 따라 비교합니다.

  • 문자열 비교

문자열 비교는 각 문자를 알파벳 순서로 비교합니다.

또한 왼쪽에서부터 문자 단위로 비교합니다. 즉 '1'과 '04' 로 보았을 때, 왼쪽 가장 처음 문자열 '1'과 '0'을 비교했을 때 이미 왼쪽이 더 큼을 알 수 있습니다.

console.log('a' < 'b'); // true

// 왼쪽에서부터 문자 단위로 비교한다는 것을 주의하세요. 왼쪽부터 '1'과 '0'을 먼저 비교하고 그 다음 문자를 비교합니다.
console.log('1' < '04') // false

피연산자가 배열인 경우를 알아봅시다.

console.log(['a'] < ['b']); // true

배열은 각각 'a', 'b' 문자열로 변환되기 때문에 문자열끼리의 비교를 수행합니다.

 

  • 문자열 외의 비교

문자열끼리의 비교가 아닌 그 외의 경우는 아래와 같은 규칙으로 동작합니다.

① 피연산자 중 하나는 문자열, 다른 하나는 BigInt인 경우 문자열을 BigInt로 변환하여 비교합니다.

// 문자열 '1'을 BigInt로 변환하여 비교합니다.
console.log('1' < 2n); // true

 

② 피연산자를 모두 숫자로 변환하여 비교합니다. 만약 피연산자 중 하나는 숫자, 다른 하나는 BigInt인 경우 내부적인 숫자 비교 알고리즘에 의해 비교를 수행합니다.

// 불리언 true를 숫자로 변환합니다.
console.log(1 < true); // false

// 숫자와 BigInt는 내부 숫자 비교 알고리즘에 의해 비교됩니다.
console.log(1n < 2); // true

 

  • 비교 연산과 타입 변환

비교 연산은 동등 연산과 달리 엄격한 비교 연산자 같은 표현식은 존재하지 않습니다.

 다른 타입 간의 비교 연산에서 암시적인 강제 연산을 막을 수 없습니다.

하지만 동등 연산과 달리 비교 연산은 서로 다른 타입에 대해 사용할 일이 드물고, 객체나 배열을 원시 타입과 비교하는 일도 거의 없습니다.

// 아래와 같은 비교 연산 코드는 실제로 거의 사용하지 않을 것입니다.
const a = '1';
const b = ['02'];

if (a < b) {
	// ...
}

만약 서로 다른 타입을 대상으로 비교 연산자를 사용한다면, 명시적 강제 변환을 통해 변환한 후 사용하는 것이 안전합니다.

const a = '1';
const b = ['02'];

if (Number(a) < Number(b)) {
	// ...
}

Number() 함수를 사용하여 모두 숫자로 변환한 후 비교합니다.

이처럼 다른 타입의 비교 연산 명시적 타입 변환을 통해 동일한 타입으로 변환한 후 실행하는 것이 안전합니다.

 

▷조건 표현식과 논리 연산자

조건 표현식에서 암시적 강제 변환은 아주 흔하게 사용됩니다.

모든 값은 불리언으로 변환되어 조건 표현식에서 평가됩니다.

빈 문자열, null, undefined 등 falsy한 값을 필터링하기 위해 많이 사용하며 명시적 강제 변환보다 더 많이 사용됩니다.

const a = 0;
const b = 'javascript';
const c = null;

if (a) {
	console.log('호출되지 않음');
}

while (b) {
	console.log('thuthy');
   	break;
}

console.log(c ? 'truthy' : 'falsy'); // 'falsy'

조건 표현식에서의 암시적 강제 변환은 Boolean() 함수나 이중 부정 연산자를 사용하여 명시적 강제 변환을 수행하는 것보다 훨씬 간결하게 조건식을 표현할 수 있습니다.

  • 논리 연산자(&&, ||)

자바스크립트의 논리 연산자는 단락 평가 방식을 따릅니다.

이는 다른 프로그래밍 언어에서도 쉽게 볼 수 있는 동작입니다.

하지만 자바스크립트의 논리 연산자는 특이한 점이 있습니다.

논리 연산자의 결과 값이 불리언 타입이 아닐 수 있다는 것입니다.

그럼 어떤 값이 결과 값이 되는 걸까요?

결과 값은 아래와 같은 규칙을 따라 반환됩니다.

 

&& 논리 연산자는 첫 번째 피연산자의 값이 true로 평가되는 경우 두 번째 피연산자의 값을 반환하고, false로 평가되면 첫 번째 피연산자의 값을 반환합니다.

|| 논리 연산자는 첫 번째 피연산자의 값이 true로 평가되는 경우 첫 번째 피연산자의 값을 반환하고, false로 평가되면 두 번째 피연산자의 값을 반환합니다.

const a = null;
const b = 'javascript';
const c = 1;

console.log(a && b); // null
console.log(b || c); // 'javascript'

&& 연산의 결과 값이 null인 이유부터 단계별로 알아보겠습니다.

 

1단계

&& 논리 연산자는 첫 번째 피연산자 a부터 평가합니다.

2단계

첫 번째 피연산자 a는 불리언 값이 아니므로 암시적 타입 변환을 통해 불리언 값으로 변환됩니다. null은 falsy 값이기 때문에 false로 변환됩니다.

3단계

a의 평가 결과가 false이기 때문에 단락 평가 방식에 따라 다음 피연산자인 b는 평가하지 않습니다.

4단계

최종적으로 피연산자 a의 값을 반환합니다.

 

&& 연산자의 첫 번째 피연산자가 false로 평가되어 첫 번째 피연산자의 값인 null을 반환합니다.

이 과정은 위에서 설명한 && 논리 연산자의 규칙과 동일함을 알 수 있습니다.

|| 연산의 결과 값이 나온 이유도 단계별로 알아보겠습니다.

 

1단계

|| 논리 연산자는 첫 번째 피연산자 b부터 평가합니다.

2단계

첫 번째 피연산자 b는 불리언 값이 아니므로 암시적 타입 변환을 통해 불리언 값으로 변환됩니다. 'javascript' 문자열은 truthy 값이기 때문에 true로 변환됩니다.

3단계

b의 평가 결과가 true이기 때문에 단락 평가 방식에 따라 다음 피연산자인 c는 평가하지 않습니다.

4단계

최종적으로 피연산자 b의 값을 반환합니다.

 

마찬가지로 위에서 설명한 || 논리 연산자의 규칙과 동일한 결과를 반환합니다.

 

  • 논리 연산자의 활용

앞서 설명한 논리 연산자의 특징은 디폴트 값을 설정하거나 조건에 따라 함수를 실행할 때 유용합니다.

function setDefault(a) {
	return a || 'default string';
}

setDefault() 함수는 a의 값이 falsy 값이 경우 'default string'이라는 문자열을 디폴트 값으로 설정합니다.

const a = 'javascript';

function doSomething() {
	// ...
}

a && doSomething();

위 예제 코드는 피연산자 a가 truthy 값인 경우에만 doSomething() 함수를 실행합니다.

만약 React를 사용해 보았다면 이런 코드가 익숙할 것입니다.

컴포넌트를 조건에 따라 렌더링할 때 자주 사용하는 표현식입니다.

 

falsy 값이 아닌 null, undefined처럼 값이 비어 있는 경우에만 디폴트 값을 설정하고 싶을 때도 있을 것입니다.

그런 경우에는 || 연산자가 아닌 ES2020에서 등장한 null 병합(nullish coalescing) 연산자를 사용할 수 있습니다.

const a = '';

// a가 null, undefined인 경우만 'default' 문자열이 b의 값으로 할당됩니다.
const b = a ?? 'default';

 

 

출처: http://doeunn.tistory.com/31

Posted by useways
,

1. slice(시작인덱스, 종료인덱스) : 시작인덱스부터 종료인덱스-1까지 반환

* slice의 시작 인덱스 값 > 종료 인덱스 값 이면 작동하지 않는 것에 주의하자!

 <script>
    let txt = "My name is Hyeppy";

    console.log(txt.slice(1, 3)); //name
    console.log(txt.slice(3, 1)); // 작동하지 않는다.
    console.log(txt.slice(2)); // name is Hyeppy
    console.log(txt.slice()); // My name is Hyeppy
 </script>

 


2. substring(시작인덱스, 종료인덱스) : 시작인덱스부터 종료인덱스-1까지 반환

* slice와 달리 substring은 시작 인덱스 값 > 종료 인덱스 값 이여도 작동한다!

<script>
    let txt = "My name is Hyeppy";

    console.log(txt.substring(0, 3)); // My 
    console.log(txt.substring(7, 3)); // name
    console.log(txt.substring(2)); // name is Hyeppy
</script>

 

3. substr(시작위치, 길이) : 시작인덱스부터 길이만큼 반환

* substr()은 명세에서 사라질 수 있기 때문에 slice, substring 사용을 권장한다고 한다!

<script>
    let txt = "My name is Hyeppy";

    console.log(txt.substr(3, 4)); // name
    console.log(txt.substr(txt.indexOf("n"), 4)); // name
</script>


4. replace(바꿀문자열, 바뀔문자열) : 문자열을 대체할 수 있다. 그러나 처음 나온 문자열 1개만 바꿀 수 있다.

 * 만약 모든 문자열을 대체하고 싶다면?

    1) /문자열/ => 정규표현식을 사용해 문자열을 슬래쉬로 감싸고, g(전역탐색,RegExp.prototype.global)을 사용한다.

       (정규 표현식 뒤의 "g"는 전체 문자열을 탐색해서 모든 일치를 반환하도록 지정하는 전역 탐색 플래그입니다.)

    2) repalceAll을 사용한다!

<script>
    let txt = "My name is Hyeppy Hyeppy";

    console.log(txt.replace("Hyeppy", "큐티")); // My name is 큐티 Hyeppy
    console.log(txt.replace(/"Hyeppy"/g, "큐티")); // My name is Hyeppy Hyeppy
    console.log(txt.replace(/Hyeppy/g, "큐티")); // My name is 큐티 큐티
    console.log(txt.replaceAll("Hyeppy", "큐티")); // My name is 큐티 큐티
</script>

5. includes(찾으려는 문자 or 문자열) : 문자 또는 문자열을 포함하고 있는지 확인할 수 있다.

* 찾는 문자열이 있다면 true, 없다면 false를 반환한다.

<script>
    let txt = "My name is Hyeppy Hyeppy";
     
    console.log(txt.includes("H")); // true
    console.log(txt.includes("Z")); // false
</script>

6. split(구분하려는 문자) : 문자열을 구분하려는 문자 기준으로 split 쪼개준다.

* split(" ") : 공백을 기준으로 문자열을 쪼개준다.

* split("-") : - 문자를 기준으로 문자열을 쪼개준다.

<script>
    let txt = "My name is Hyeppy Hyeppy";

    console.log(txt.split(" ")); // ['My', 'name', 'is', 'Hyeppy', 'Hyeppy']
    console.log("010-5044-2903".split("-")); // ['010', '5044', '2903']
</script>

7. trim() : 문자열 양 끝의 공백을 제거한다.

</script>        
    console.log("         abc"); //          abc
    console.log("         abc".trim()); // abc
    console.log("         a b c".trim()); // a b c
    console.log("         a b c              ".trim()); // a b c
</script>

 

출처 : https://always-hyeppy.tistory.com/27

Posted by useways
,


출처 http://smartjuho.tistory.com/40



자바스크립트에서 parseInt를 사용 시 주의사항입니다.

특히 자바를 사용하셨던 분은 더 혼동이 될 수도 있습니다. 

자바에서는 Integer.parseInt(String s)를 사용하여 문자를 숫자로 형 변환시 10진수로 변환이 됩니다.

하지만 자바스크립트에서는 무조건 10진수로 변경되지는 않습니다.

자바스크립트에서 parseInt('08')를 하시고 결과 값을 확인하시면 결과는 0이 나옵니다.

이유는 입력되는 문자열이 0으로 시작되었기 때문에 8진수로 변환이 되는 것 입니다.

당연히 8이겠지 하고 결과값을 예측하시고 코딩을 하셨다면 큰 낭패일 수 있습니다.

간단한 예로 
document.write(parseInt("010")+ "<br />"); //8진수 변환
document.write(parseInt("0x10")+ "<br />"); //16진수 변환
해결 방법은 간단합니다.
1번째 인수 다음 2번째 인수에 변환될 진수를 적어 주시면 됩니다.
document.write(parseInt("10",10)+ "<br />"); //10진수 변환
document.write(parseInt("10",8)+ "<br />"); //8진수 변환
document.write(parseInt("10",16)+ "<br />");  //16진수 변환



또는 Number("08")를 사용하시면 10진수로 변환됩니다.

parseInt로 게시판 검색해 봤는데 해당 내용이 없어서 올림니다.


가볍게 넘길수 있는지만 결과에 큰 오류를 가져올 수 있는 오류입니다.

Posted by useways
,


// 문자열을 대문자로 변환
s = s.toUpperCase();
document.write(s + '<br />');
// 출력 결과: ABC ABCD ADOBE PHOTOSHOP



// 문자열을 소문자로 변환
document.write(s.toLowerCase() + '<br />');
// 출력 결과: abc abcd adobe photoshop


===내가 사용하는 방법

<input name="b00_002" type="text" class="css_InputBox" style="ime-mode:inactive; width: 90px" value=""  onkeyup='keyToUpperCase(this);'>

영문자 입력을 받고  ime-mode:inactive;
대문자로 변환 onkeyup='keyToUpperCase(this);'  onkeyup 이벤트일때만 정상작동한다.


.js부분에

function keyToUpperCase(obj){   //영문을때만가능하다 한글로 입력되면 깨진다....
obj.value = obj.value.toUpperCase();
}

Posted by useways
,


function replaceAll(str,orgStr,repStr)
{
    return str.split(orgStr).join(repStr);



[JavaScript] 는 replace 함수 사용 시 한번 만 치환된다.
ex)
var a = "2008-08-28";
var b = a.replace("-","");
alert(b);

결과 값 : 200808-28

아래와 같이 split 함수와 join 함수를 쓰면 이러한 문제가 해결 된다.
ex)
var a = "2008-08-28";
var b = a.split("-").join("");
alert(b);

결과 값 : 20080828

Posted by useways
,

어디서 가져왔더라... 찾기 편하게....등록..

//===================================================================
// DateUtil
//===================================================================
// DateCmp(date1, date2)
// date_Format(ymd, formatmask)
// date_FormatYM(ym, formatmask)
// format_YYYYMM(object)
// format_YYYYMMDD(object)
// getCurrentTime()
// getDay()
// getDayInterval(time1,time2)
// getHour()
// getHourInterval(time1,time2)
// getMMDD( separator)
// getMonth()
// getMonthInterval(time1,time2)
// getRelativeTime(y,m,d,h)
// getYear()
// getYYYYMM( separator)
// getYYYYMMDD( separator)
// isDate(y,m,d)
// isDateYM(ym)
// isDateYMD(ymd)
// isDateYYYY(yyyy)
// isDateYYYYMM( yyyymm )
// isFormatDate(ymd, formatmask)
// isFormatDateYM(ym, formatmask)
// isFutureTime(time)
// isPastTime(time)
// isValidDay(yyyy, mm, dd)
// isValidHour(hh)
// isValidMin(mi)
// isValidMonth(mm)
// isValidTime(time)
// isValidTimeFormat(time)
// isYM(y,m)
// isYunNyun(y)
// shiftTime(time,y,m,d,h)
// toTimeObject(time)
// toTimeString(date)
// offMoneyFormat( obj ) 
// onMoneyFormat( obj )
// cala_day(year, month, day)
// cala_weekday( x_nMonth, x_nDay, x_nYear)
// day_display(x_nDayOfWeek)

/////////////////////////////////////////////////////
function isValidMonth(num) {
/////////////////////////////////////////////////////
//유효한(존재하는) 월(月)인지 체크
    if(num == "") return;
 try{
  //object.value = object.value.replace(/./gi,'');
  if(isNaN(num)) { 
   throw Exception;
  }
  var m = parseInt(num,10);
  if(! (m >= 1 && m <= 12)){
   throw Exception;
  }
  if(num.length == 1){
   num = "0"+num;
  }
 }catch(Exception){
  window.alert("월 입력 오류입니다.");
  num="";
  num.focus();
 }
}


/////////////////////////////////////////////////////
function isValidMonthCheck(num) {
/////////////////////////////////////////////////////
//입력된 문자열이 유효한 월(月)인지 체크, 여부리턴
    if(num == "" || num == null)
  return false;

 if(isNaN(num)) { 
  return false;
 }

 var m = parseInt(num,10);
 
 if(! (m >= 1 && m <= 12)) {
  return false;
 }

 return true;
}


/////////////////////////////////////////////////////
function isValidDay(yyyy, mm, dd) {
/////////////////////////////////////////////////////
//유효한(존재하는) 일(日)인지 체크
    var m = parseInt(mm,10) - 1;
    var d = parseInt(dd,10);

    var end = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
    if ((yyyy % 4 == 0 && yyyy % 100 != 0) || yyyy % 400 == 0) {
        end[1] = 29;
    }

    return (d >= 1 && d <= end[m]);
}


/////////////////////////////////////////////////////
function getCurrentTime() {
/////////////////////////////////////////////////////
// 현재 시각을 Time 형식으로 리턴
    return toTimeString(new Date());
}

/////////////////////////////////////////////////////
function getYear() {
/////////////////////////////////////////////////////
// 현재 年을 YYYY형식으로 리턴
    return getCurrentTime().substr(0,4);
}

/////////////////////////////////////////////////////
function getMonth() {
/////////////////////////////////////////////////////
// 현재 月을 MM형식으로 리턴
    return getCurrentTime().substr(4,2);
}

/////////////////////////////////////////////////////
function getDay() {
/////////////////////////////////////////////////////
// 현재 日을 DD형식으로 리턴
    return getCurrentTime().substr(6,2);
}

/////////////////////////////////////////////////////
function getYYYYMM( separator) {
/////////////////////////////////////////////////////
// 현재 年月을 separator 로 구분하여 리턴
    return getYear() + separator + getMonth();
}


/////////////////////////////////////////////////////
function getMMDD( separator) {
/////////////////////////////////////////////////////
// 현재 月日을 separator 로 구분하여 리턴
    return getMonth() + separator + getDay();
}


/////////////////////////////////////////////////////
function getYYYYMMDD( separator) {
/////////////////////////////////////////////////////
// 현재 年月日을 separator 로 구분하여 리턴
    return getYear() + separator + getMonth() + separator + getDay();
}

/////////////////////////////////////////////////////
function getHour() {
/////////////////////////////////////////////////////
// 현재 時를 HH형식으로 리턴
    return getCurrentTime().substr(8,2);
}

/////////////////////////////////////////////////////
function format_YYYYMM(object) {
/////////////////////////////////////////////////////
/**
 * 연월(YYYYMM)의 유효성을 체크하고 표준 날짜 포맷 (YYYY/MM) 으로 변환하여 리턴
 * (주의 : 이 함수의 파라미터는 객체임 (input object))
 */
    var num, year, month;
    num=object.value;   
    while (num.search("/") != -1) { 
  num = num.replace("/","");
 }
 if (isNaN(num)) {        
     window.alert("숫자로만 작성하셔야 합니다.");
  object.focus();
  return "";
 }  
    if( num != 0 && (num.length >= 5 && num.length <= 6)) {
        year = num.substring(0,4);
        month = num.substring(4);
        if (isValidMonthYYYYMM(object, month)==false){
            alert("월을 다시 한번 확인하시고 입력해 주세요.");
          object.focus();
          return "";
        }
        if (num.length==6) {
         num = year+"/"+month;
        } else if (num.length==5) { 
         num = year+"/"+"0"+month;
        } 
    } else {
        num = "";
  window.alert("년월을 다시 한번 확인하시고 입력해 주세요.");
  object.focus();
        return "";
    } 
    return num;
}

/////////////////////////////////////////////////////
function isValidMonthYYYYMM(object, num) {
/////////////////////////////////////////////////////
//유효한(존재하는) 월(月)인지 체크 -- format_YYYYMM 에서만 사용
    if(num == "") return false;
 if(isNaN(num)) { 
  return false;
 }

 var m = parseInt(num,10);
 if(! (m >= 1 && m <= 12)){
  return false;
 } 
}

/////////////////////////////////////////////////////
function format_YYYYMMDD(object) {
/////////////////////////////////////////////////////
// 연월일(YYYYMMDD)의 유효성을 체크하고 표준 날짜 포맷 (YYYY/MM/DD) 으로 변환하여 리턴 (주의 : 이 함수의 파라미터는 객체임 (input object))

    var num, year, month, day;
    num=object.value;
    
    while (num.search("/") != -1){ 
      num = num.replace("/","");
 }
 
 if (isNaN(num)) {        
     window.alert("숫자로만 작성하셔야 합니다");
     object.focus();
     return "";
 }
    if( num != 0 && num.length == 8 ) {
        year = num.substring( 0, 4 );
        month = num.substring( 4, 6 );  
        day = num.substring(6);
        if(isValidDay(year,month,day)==false) {
         num = "";
         window.alert("유효하지 않는 일자입니다. 다시 한번 확인하시고 입력해 주세요.");
         object.focus();
         return "";
  }          
        num = year+"/"+month + "/" + day;
    } 
    else {
        num = "";
        window.alert("날짜 입력형식 오류입니다. 다시 한번 확인하시고 입력해 주세요.");
        object.focus();
        return "";
    } 
    return num;
}
/////////////////////////////////////////////////////
function format_YYYYMMDDHHMM(object) {
/////////////////////////////////////////////////////

    var num, year, month, day;
    num=object.value;
    
    while (num.search("/") != -1){ 
      num = num.replace("/","");
      num = num.replace(":","");
      num = num.replace(" ","");
 }
  
  if (isNaN(num)) {        
      window.alert("숫자로만 작성하셔야 합니다");
      object.focus();
      return "";
  }
   
    if( num != 0 && num.length == 12 ) {
        year = num.substring( 0, 4 );
        month = num.substring( 4, 6 );  
        day = num.substring(6,8);
  if(isValidDay(year,month,day)==false) {
         num = "";
         window.alert("유효하지 않는 일자입니다. 다시 한번 확인하시고 입력해 주세요.");
         object.focus();
         return "";
  }          
  hh = num.substring(8,10);
  if(isValidHour(hh)==false) {
         num = "";
         window.alert("유효하지 않는 시간입니다. 다시 한번 확인하시고 입력해 주세요.");
         object.focus();
         return "";
  }
  mm = num.substring(10,12);
  if(isValidMin(mm)==false) {
         num = "";
         window.alert("유효하지 않는 분입니다. 다시 한번 확인하시고 입력해 주세요.");
         object.focus();
         return "";
  }
  
        num = year+"/"+month + "/" + day+" "+hh+":"+mm;
    } 
    else {
        num = "";
        window.alert("날짜 입력형식 오류입니다. 다시 한번 확인하시고 입력해 주세요.");
        object.focus();
        return "";
    } 
    return num;
}


/////////////////////////////////////////////////////
function isDate(y,m,d)
/////////////////////////////////////////////////////
{
 var yy,mm,dd;

// if (!isNumber(y) || !isNumber(m) || !isNumber(d)) return false;
 yy = parseInt(y, 10);
 mm = parseInt(m, 10);
 dd = parseInt(d, 10);

 if (yy < 1900 || yy > 2200 ) return false;

 if (mm < 1 || mm > 12) return false;
 if (dd < 1) return false;
 if (mm == 1 || mm == 3 || mm == 5 || mm == 7 || mm == 8 || mm==10 || mm==12)
 {
  if (dd > 31) return false;
 }
 else if (mm==2)
 {
  if (isYunNyun(yy))
  {
   if (dd > 29) return false;
  }
  else {
   if (dd > 28) return false;
  }

 }
 else if (dd > 30) return false;
 return true;
}

/////////////////////////////////////////////////////
function isYM(y,m){
/////////////////////////////////////////////////////
// 날짜인지 체크 (년, 월)

 var yy,mm;
 if (!isNumber(y) || !isNumber(m)) return false;
 yy = parseInt(y, 10);
 mm = parseInt(m, 10);

 if (yy < 1900 ) return false;

 if (mm < 1 || mm > 12) return false;
 
 return true;
}

//=============================================================================
// Function  : setDateFormat(obj, index, obj2)
// Parameter : Obj     현재의 입력 객체      
//      index   객체의 인텍스 
//      obj2    타겟객체 
// Return    : NONE
// 기능      : 날짜format을 check  하고 두번째 객체의 값으로 할당한다.
//      obj[index]의 값을 yyyy/mm/dd 형식으로 변경하고 원래 입력값은 obj2[index]의 value로 할당한다.
//=============================================================================
function setDateFormat(obj, index, obj2) {
    val = delChar(obj.value, '/'); //comma filtering
    obj.value = val;
    
    a = isNumber(obj);
    var no = "";
    if (a == 1) {        
        if (obj2.length == "undefined" || obj2.length == null) {
            obj2.value = "";
        } else {
            obj2[index].value = "";
        }        
        return;
    }

    val = obj.value;
    len = val.length;
    
    if (len == 6) {
  no = format_YYYYMM(obj);  
 } else if (len == 8) {
  no = format_YYYYMMDD(obj);  
 }
        
 if (no == "") {
  obj.value = no;
 }
            
 if (obj2.length == "undefined" || obj2.length == null) {
  obj2.value = obj.value;
 } else {
  obj2[index].value = obj.value;
 }
 obj.value = no;
}


/////////////////////////////////////////////////////
function date_FormatYM(ym, formatmask){
/////////////////////////////////////////////////////
 // 날짜인지 체크 (년, 월)
 
  var fcount = formatmask.length;
  var len = trim(ym).length;
 var rv = "";
 ym = trim(ym);

 if (len == 6)
 {
  if (ym.substring(4, 5) == "/")
  {
   return  ym;
  }

  y = ym.substring(0, 4);
  m = ym.substring(4, 6);
 }
 else if (len == 7)
 {
  if (ym.substring(4, 5) != "/")
  {
   return  -1;
  }
  y = ym.substring(0, 4);
  m = ym.substring(5, 7);
 }
 else 
 {
  return ym; 
 }
 
 var ym_concat = y + m;
 var ret_ = -1;
 
 if((fcount == 7) && (formatmask == "????/??"))
 {
  if (isDateYM(ym_concat))
  {
   ret_ = y + "/" + m;
  }
  else
  {
   ret_ = -1;
  }
 }
 else
 {
  alert('Format["????/??"] 형식을 다시 한번 확인하시고 입력해 주세요.');
  ret_ = -1; 
 }
 
 return ret_;
}

/////////////////////////////////////////////////////
function isDateYM(ym){
/////////////////////////////////////////////////////
 var yy,mm;
 var y = "";
 var m = "";
 ym = trim(ym);
 y = ym.substring(0, 4);
 m = ym.substring(4, 6);

 if ( isYM(y, m) == true )
 {
  return true;
 }
 else
 {
  return false; 
 }
}

/////////////////////////////////////////////////////
function isYunNyun(y){
/////////////////////////////////////////////////////
// 운년인지 check.
 if ( (y % 4) == 0 )
 {
  if ((y % 100) != 0) return true;
  if ((y % 400) == 0) return true;
 }
 return false;
}

/////////////////////////////////////////////////////
function date_Format(ymd, formatmask){
/////////////////////////////////////////////////////
//  "20020204"의 날짜 문자열에 대한 formatting하기. 
  var fcount = formatmask.length;
  var len = trim(ymd).length;
 var rv = "";
 ymd = trim(ymd);

 if (len == 8)
 {
  if (ymd.substring(4, 5) == "/" )
  {
   return  ymd;
  }
  y = ymd.substring(0, 4);
  m = ymd.substring(4, 6);
  d = ymd.substring(6, 8);
 }
 else if (len == 9)
 {
  if (ymd.substring(4, 5) == "/")
  {
   if (ymd.substring(7, 8) == "/" )
   {
    return  ymd;
   }
   else  //yyyy/mmdd 형식
   {
    y = ymd.substring(0, 4);
    m = ymd.substring(5, 7);
    d = ymd.substring(7, 9);
   }
  }
  else
  {
   return  -1;
  }
 }
 else if (len == 10)
 {
  if (ymd.substring(4, 5) != "/" || ymd.substring(7, 8) != "/" )
  {
   return  -1;
  }
  y = ymd.substring(0, 4);
  m = ymd.substring(5, 7);
  d = ymd.substring(8, 10);
 }
 else 
 {
  return ymd; 
 }
 
 var ymd_concat = y + m + d;
 var ret_ = -1;
 
 if((fcount == 10) && (formatmask == "????/??/??"))
 {
  if (isDateYMD(ymd_concat))
  {
   ret_ = y + "/" + m + "/" + d;
  }
  else
  {
   ret_ = -1;
  }
 }
 else
 {
  alert('Format["????/??/??"] 형식을 다시 한번 확인하시고 입력해 주세요.');
  ret_ = -1; 
 }

 return ret_;
}

/////////////////////////////////////////////////////
function isDateYMD(ymd){
/////////////////////////////////////////////////////
// "20020204"의 날짜 문자열에 대한 formatting하기. 
 var yy,mm,dd;
 var y = "";
 var m = "";
 var d = "";

 y = ymd.substring(0, 4);
 m = ymd.substring(4, 6);
 d = ymd.substring(6, 8);

 if(isNaN(y) || isNaN(m) || isNaN(d)){
  return false; 
 }

 if ( isDate(y, m, d) == true )
 {
  return true;
 }
 else
 {
  return false; 
 }
}

/////////////////////////////////////////////////////
function isDateYYYY(yyyy){
/////////////////////////////////////////////////////
//년도 체크
 var yyyymmdd = yyyy + "0101";
 return isDateYMD(yyyymmdd);
}
/////////////////////////////////////////////////////
function isDateYYYYMM( yyyymm ){
/////////////////////////////////////////////////////
//년-월 체크

 var returnValue = false;
 var len = trim(yyyymm).length;
 yyyymm = trim(yyyymm);
 
 if( len == 7 )
 {
  if( yyyymm.substring(4, 5) == "/" )
  {
   returnValue = isYM( yyyymm.substring(0, 4), yyyymm.substring(5, 7) );
  }
 }
 else if( len == 6 )
 {
  returnValue = isYM( yyyymm.substring(0, 4), yyyymm.substring(4, 6) );
 }

 return returnValue;
}

/////////////////////////////////////////////////////
function isValidHour(hh) {
/////////////////////////////////////////////////////
// 유효한(존재하는) 시(時)인지 체크
    var h = parseInt(hh,10);
    return (h >= 1 && h <= 24);
}

/////////////////////////////////////////////////////
function isValidMin(mi) {
/////////////////////////////////////////////////////
// 유효한(존재하는) 분(分)인지 체크
    var m = parseInt(mi,10);
    return (m >= 1 && m <= 60);
}

/////////////////////////////////////////////////////
function isValidTimeFormat(time) {
/////////////////////////////////////////////////////
// Time 형식인지 체크(느슨한 체크)
    return (!isNaN(time) && time.length == 12);
}

/////////////////////////////////////////////////////
function isValidTime(time) {
/////////////////////////////////////////////////////
// 유효하는(존재하는) Time 인지 체크 년/월/일 만을(시간,분 제외) 검사. 
    var year  = time.substring(0,4);
    var month = time.substring(4,6);
    var day   = time.substring(6,8);
    //var hour  = time.substring(8,10);
    //var min   = time.substring(10,12);

    if (parseInt(year,10) >= 1900  && isValidMonth(month) &&isValidDay(year,month,day)){
     //&& isValidHour(hour)   && isValidMin(min)) {
        return true;
    }
    return false;
}

/////////////////////////////////////////////////////
function toTimeObject(time) { //parseTime(time)
/////////////////////////////////////////////////////
// Time 스트링을 자바스크립트 Date 객체로 변환  parameter time: Time 형식의 String
    var year  = time.substr(0,4);
    var month = time.substr(4,2) - 1; // 1월=0,12월=11
    var day   = time.substr(6,2);
    var hour  = time.substr(8,2);
    var min   = time.substr(10,2);

    return new Date(year,month,day,hour,min);
}

 

/////////////////////////////////////////////////////
function toTimeString(date) { //formatTime(date)
/////////////////////////////////////////////////////
// 자바스크립트 Date 객체를 Time 스트링으로 변환 
// parameter date: JavaScript Date Object
    var year  = date.getFullYear();
    var month = date.getMonth() + 1; // 1월=0,12월=11이므로 1 더함
    var day   = date.getDate();
    var hour  = date.getHours();
    var min   = date.getMinutes();

    if (("" + month).length == 1) { month = "0" + month; }
    if (("" + day).length   == 1) { day   = "0" + day;   }
    if (("" + hour).length  == 1) { hour  = "0" + hour;  }
    if (("" + min).length   == 1) { min   = "0" + min;   }

    return ("" + year + month + day + hour + min)
}

/////////////////////////////////////////////////////
function isFutureTime(time) {
/////////////////////////////////////////////////////
// Time이 현재시각 이후(미래)인지 체크
    return (toTimeObject(time) > new Date());
}

/////////////////////////////////////////////////////
function isPastTime(time) {
/////////////////////////////////////////////////////
// Time이 현재시각 이전(과거)인지 체크
    return (toTimeObject(time) < new Date());
}

/////////////////////////////////////////////////////
function shiftTime(time,y,m,d,h) { //moveTime(time,y,m,d,h)
/////////////////////////////////////////////////////
// 주어진 Time 과 y년 m월 d일 h시 차이나는 Time을 리턴
    var date = toTimeObject(time);
    date.setFullYear(date.getFullYear() + y); //y년을 더함
    date.setMonth(date.getMonth() + m);       //m월을 더함
    date.setDate(date.getDate() + d);         //d일을 더함
    date.setHours(date.getHours() + h);       //h시를 더함
    return toTimeString(date);
}

/////////////////////////////////////////////////////
function getMonthInterval(time1,time2) { //measureMonthInterval(time1,time2)
/////////////////////////////////////////////////////
// 두 Time이 몇 개월 차이나는지 구함
    var date1 = toTimeObject(time1);
    var date2 = toTimeObject(time2);

    var years  = date2.getFullYear() - date1.getFullYear();
    var months = date2.getMonth() - date1.getMonth();
    var days   = date2.getDate() - date1.getDate();

    return (years * 12 + months + (days >= 0 ? 0 : -1) );
}

/////////////////////////////////////////////////////
function getDayInterval(time1,time2) {
/////////////////////////////////////////////////////
// 두 Time이 며칠 차이나는지 구함
    var date1 = toTimeObject(time1);
    var date2 = toTimeObject(time2);
    var day   = 1000 * 3600 * 24; //24시간

    return parseInt((date2 - date1) / day, 10) + 1;
}

/////////////////////////////////////////////////////
function getHourInterval(time1,time2) {
/////////////////////////////////////////////////////
// 두 Time이 몇 시간 차이나는지 구함
    var date1 = toTimeObject(time1);
    var date2 = toTimeObject(time2);
    var hour  = 1000 * 3600; //1시간

    return parseInt((date2 - date1) / hour, 10);
}

/////////////////////////////////////////////////////
function getRelativeTime(y,m,d,h) {
/////////////////////////////////////////////////////
// 현재 시각과 y년 m월 d일 h시 차이나는 Time을 리턴
    return shiftTime(getCurrentTime(),y,m,d,h);
}

/////////////////////////////////////////////////////
function isFormatDate(ymd, formatmask){
/////////////////////////////////////////////////////
//9999/99/99 가 날짜인지
  var len_ymd = trim(ymd).length;
  var fcount = formatmask.length;

 if (len_ymd != 10)
 {
  return -1; 
 }
 
 if((fcount == 10) && (formatmask == "????/??/??"))
 {
  if (ymd.substring(4, 5) != "/" || ymd.substring(7, 8) != "/" )
  {
   return  -1;
  }
  y = ymd.substring(0, 4);
  m = ymd.substring(5, 7);
  d = ymd.substring(8, 10);

  var ymd_concat = y + m + d;
  var ret_value = -1;

  if (isDateYMD(ymd_concat))
  {
   ret_value = y + "/" + m + "/" + d;
  }
  else
  {
   ret_value = -1;
  }
 }
 else
 {
  alert('Format["????/??/??"] 형식을 다시 한번 확인하시고 입력해 주세요.');
  ret_value = -1; 
 }
 
 return ret_value;
}

/////////////////////////////////////////////////////
function isFormatDateYM(ym, formatmask) {
/////////////////////////////////////////////////////
//9999/99 가 날짜인지
  var len_ym = trim(ym).length;
  var fcount = formatmask.length;

 if (len_ym != 7)
 {
  return -1; 
 }
 
 if((fcount == 7) && (formatmask == "????/??"))
 {
  if (ym.substring(4, 5) != "/")
  {
   return  -1;
  }
  y = ym.substring(0, 4);
  m = ym.substring(5, 7);

  var ymd_concat = y + m + "01";
  var ret_value = -1;

  if (isDateYMD(ymd_concat))
  {
   ret_value = y + "/" + m;
  }
  else
  {
   ret_value = -1;
  }
 }
 else
 {
  alert('Format["????/??"] 형식을 다시 한번 확인하시고 입력해 주세요.');
  ret_value = -1; 
 }
 
 return ret_value;

}

 

/////////////////////////////////////////////////////
function DateCmp(date1, date2){
/////////////////////////////////////////////////////
//날자 크기 비교 입력형식 yyyy/mm/dd 또는 yyyymmdd
//ret = 0  if date1 == date2
//ret = 1  if date1 >  date2
//ret = -1 if date1 <  date2
 var s_date1 = date1 + ""; 
 var s_date2 = date2 + ""; 
 var ret = -2;
 
 if (s_date1 == s_date2)
 {
  ret = 0;
 }
 else if (s_date1 > s_date2)
 {
  ret = 1;
 }
 else if (s_date1 < s_date2)
 {
  ret = -1;
 }
 
 if (ret == -2)
 {
  alert("날자 비교가 잘못 되었습니다. 다시 한번 확인하시고 입력해 주세요.");
 }
 
 return ret;
}
// 해당 년월일의 요일 가져오기
function cala_day(year, month, day) {
 var nDayOfWeek = cala_weekday(month, day, year); 
 return day_display(nDayOfWeek)


// 해당 년월일에 따른 요일 계산하기
function cala_weekday( x_nMonth, x_nDay, x_nYear) {
  

        if(x_nMonth >= 3){         
                x_nMonth -= 2; 
        } 
        else { 
                x_nMonth += 10; 
        } 

        if( (x_nMonth == 11) || (x_nMonth == 12) ){ 
                x_nYear--; 
        } 

        var nCentNum = parseInt(x_nYear / 100); 
        var nDYearNum = x_nYear % 100; 

        var g = parseInt(2.6 * x_nMonth - .2); 

        g +=  parseInt(x_nDay + nDYearNum); 
        g += nDYearNum / 4;         
        g = parseInt(g); 
        g += parseInt(nCentNum / 4); 
        g -= parseInt(2 * nCentNum); 
        g %= 7; 
         
        if(x_nYear >= 1700 && x_nYear <= 1751) { 
                g -= 3; 
        } 
        else { 
   if(x_nYear <= 1699) { 
     g -= 4; 
   } 
        } 
         
        if(g < 0){ 
                g += 7; 
        } 
         
        return g; 


//요일 보여주기
function day_display(x_nDayOfWeek) { 

 if(x_nDayOfWeek == 0) return "일"; 
 if(x_nDayOfWeek == 1) return "월"; 
 if(x_nDayOfWeek == 2) return "화"; 
 if(x_nDayOfWeek == 3) return "수"; 
 if(x_nDayOfWeek == 4) return "목"; 
 if(x_nDayOfWeek == 5) return "금"; 
 if(x_nDayOfWeek == 6) return "토"; 




//년월일 포멧을 맞춰 준다.
//예 2000년 3월 2일 ====> 2000년 03월 02일
function convertDate(sfrYear, sfrMonth, sfrDay) {

 var sYear = sfrYear.value ;
 var sMonth = sfrMonth.value ;
 var sDay = sfrDay.value ;
 
 
 if ((sYear == null || sYear == "") && (sMonth == null || sMonth == "" )&& (sDay == null || sDay == "" ))
  return;


 if (isNaN(sYear))
  sYear = "";
 if (isNaN(sMonth))
  sMonth = "";
 if (isNaN(sDay))
  sDay = "";
 
 if (sYear == null || sYear == "" ) {
  sfrYear.value = "";
  return;
 }
 if (sMonth == null || sMonth == "" ) {
  sfrMonth.value = "";
  return;
 }
 if (sDay == null || sDay == "" ) {
  sfrDay.value = "";
  return;
 }
  

 var iYear=parseInt(sYear,10);
 var iMonth=parseInt(sMonth,10);
 var iDay=parseInt(sDay,10);

 if( iMonth<10 ) sMonth="0"+iMonth;
 else sMonth=""+iMonth;
 if( iDay<10)sDay="0"+iDay;
 else if( iDay<29)sDay=""+iDay;
 if(iYear<10 ){
  sYear="000"+iYear;
 } else if(iYear<100 ){
  sYear = "00"+iYear;
 } else if(iYear<1000 ){
  sYear = "0"+iYear;
 }else sYear = ""+iYear;
 
 sfrYear.value = sYear;
 sfrMonth.value = sMonth;
 sfrDay.value = sDay; 
}


//유효한 날짜 인지 체크 한다.
function checkDate(sfrYear, sfrMonth, sfrDay) {

 var sYear = sfrYear.value ;
 var sMonth = sfrMonth.value ;
 var sDay = sfrDay.value ;

 if (sYear == null || sYear == "" || sMonth == null || sMonth == "" || sDay == null || sDay == "" ){
  return "false";
 }

 var iYear=parseInt(sYear,10);
 var iMonth=parseInt(sMonth,10);
 var iDay=parseInt(sDay,10);

 if( iMonth<1 || iMonth>12 ){
   return "false";
 }
  
 if( iDay<1 || iDay > 31){
  return "false";
 }
 
 if( iMonth<10 ) sMonth="0"+iMonth;
 else sMonth=""+iMonth;
 if( iDay<10)sDay="0"+iDay;
 else if( iDay<29)sDay=""+iDay;
 else {
  if(iMonth==2){
   if  (( ( iYear%400 == 0 ) || ( ( iYear%100 != 0 ) && ( iYear%4 == 0 ) ) ) ) { if (iDay>29) { return "false";}}
   else if (iDay>28) return "false";
  }else if(iMonth==4 || iMonth==6 || iMonth==9 || iMonth==11){
   if(iDay>30 ) return "false";
  }else{
   if(iDay>31 ) return "false";
  }
 }
 if(iYear<10 ){
  sYear="000"+iYear;
 } else if(iYear<100 ){
  sYear = "00"+iYear;
 } else if(iYear<1000 ){
  sYear = "0"+iYear;
 }else sYear = ""+iYear;
 sfrYear.value = sYear;
 sfrMonth.value = sMonth;
 sfrDay.value = sDay;
 return "true";
  
}


// 쓰여진 공백을 제거하고, 생년월일의 입력이 올바른지 체크
// (2004.07.13 for KNTO by 고상원)
// 매개변수 : year,month,date (form의 input type=text 객체)
//
// 입력이 틀린부분이 있으면
// 1. 메시지를 출력하고
// 2. 해당부분에 focus()를 호출하고
// 3. false를 return한다.
// 입력이 모두 맞으면 true를 리턴한다.
// (자릿수가 1자리인 월,일에는 앞에 0을 붙인다.)
function isValidBirthdateInput(year, month, date) {

 // 공백제거
 year.value = year.value.replace(/ /gi,"");
 month.value = month.value.replace(/ /gi,"");
 date.value = date.value.replace(/ /gi,"");

 // 년
 if (year.value.length != 4 || isNaN(year.value)) {
  alert("해당 년을 다시 한번 확인하시고 입력해 주세요.");
  year.focus();
  return false;
 }

 // 월
 if (!isValidMonthCheck(month.value)) {
  alert("해당 월을 다시 한번 확인하시고 입력해 주세요.");
  month.focus();
  return false;
 }
 else if (month.value.length == 1)
  month.value = "0" + month.value;

 // 일
 if (!isValidDay(year.value, month.value, date.value)) {
  alert("해당 날짜를 다시 한번 확인하시고 입력해 주세요.");
  date.focus();
  return false;
 }
 else if (date.value.length == 1)
  date.value = "0" + date.value;

 return true;
}

// 선택한 포맷으로 날짜형식을 정한다.
function make_date_format(strDate, strformat){

 if(strDate != null) {
  if ( strDate.length == 8) {
   str = strDate.substring(0,4) + strformat + strDate.substring(4,6) + strformat + strDate.substring(6,8); //날짜
  }
 }

 return str ;
}

Posted by useways
,

두 날짜사이의 지난 시간을 계산합니다.

 

일,시간,분,초

 

==========================================================================================================

  var strFromDate = "201012011500"; //시작시간
  var strToDate   = "201012021501"; //종료시간
  
  var fromDate = new Date(strFromDate.substring(0,4),
        strFromDate.substring(4,6)-1,
        strFromDate.substring(6,8),
        strFromDate.substring(8,10),
        strFromDate.substring(10,12)
       );
       
  var toDate = new Date(strToDate.substring(0,4),
        strToDate.substring(4,6)-1,
        strToDate.substring(6,8),
        strToDate.substring(8,10),
        strToDate.substring(10,12)
       );
    
  daysAfter = (toDate.getTime() - fromDate.getTime()) / (1000*60*60*24);
  hourAfter = (toDate.getTime() - fromDate.getTime()) / (1000*60*60);
  minAfter = (toDate.getTime() - fromDate.getTime()) / (1000*60);
  secAfter = (toDate.getTime() - fromDate.getTime()) / (1000);
  
  daysAfter = Math.round(daysAfter);
  hourAfter = Math.round(hourAfter);
  minAfter = Math.round(minAfter);
  secAfter = Math.round(secAfter);
  
  document.write(daysAfter + "일 지났습니다."); // 지난 날짜 출력
  document.write("<br>" + hourAfter + "시간 지났습니다."); // 지난 시간 출력
  document.write("<br>" + minAfter + "분 지났습니다."); // 지난 분 출력
  document.write("<br>" + secAfter + "초 지났습니다."); // 지난 초 출력

==========================================================================================================

[출처] [DATE] 날짜간 지난 시간 계산 자바스크립트|작성자 싸커마

'12 Javascript > 30 각종 함수' 카테고리의 다른 글

30 replace 문제점  (0) 2021.07.16
31 날자관련 각종 utils  (0) 2021.07.16
31 날자관련 날자계산  (0) 2021.07.16
인코더(Encoder), Eval함수 ,숫자변환함수  (0) 2021.07.15
31 날자관련 var d = new Date();  (0) 2018.07.18
Posted by useways
,

오늘 날짜를 기준으로 1주일,2주일,1개월이전날짜를 찍는걸로 만들었지만 버튼에 함수로 전달하는 파라메터를 조절하면 얼마든지 임의로 변경할 수 있겠습니다..^^

<html>
<head>
<title> 날짜 </title>
<script language="javascript">
<!--
function time(){
 var now = new Date;
 document.all.oo.innerText = "오늘은 " + now.getYear() + "년 " + (now.getMonth()+1) + "월 " + now.getDate() + "일 " + now.getHours() + "시 " + now.getMinutes() + "분 " + now.getSeconds() + "초 입니다.";

setTimeout("time()", 1000);

}

 

function setDay(t){// 일차를 파라메터로 받는다
 var now = new Date;
 var today = now.getYear() + "/" + (now.getMonth()+1) + "/" + now.getDate();//현재날짜
 document.date.date2.value = today; 
 document.date.date1.value = getThatday(today,t); //현재날짜와 일차를 파라미터로 보내서 결과리턴한다.
}

function getThatday(today,t){ //날짜, 일차를 파라메터로 받는다.
 var pdate=new Array(); 
 var pday=today.split("/"); //날짜를 구분자로 나누어 배열로 변환한다.
 var ptoday=new Date(pday[0],pday[1]-1,pday[2]); //데이트객체 생성한다.
 var ptimestamp=ptoday.valueOf()+1000*60*60*24*t; //t일후의 타임스탬프를 얻는다. 음수라면 이전날짜를 얻는다.
 var thatday=new Date(ptimestamp); //t일후의 날짜객체 생성한다.
 
 pdate[pdate.length]=thatday.getYear(); //년
 pdate[pdate.length]=thatday.getMonth()+1; //월
 pdate[pdate.length]=thatday.getDate(); //일
 return pdate.join("/"); //배열을 / 구분자로 합쳐 스트링으로 변환후 반환
}

 

//-->
</script>
</head>

<body onload="time()" >
<span id=oo></span>

<FORM METHOD=POST name="date" ACTION="">
 <INPUT TYPE="button" onclick="setDay(-7)" value="1주일">
 <INPUT TYPE="button" onclick="setDay(-14)" value="2주일">
 <INPUT TYPE="button" onclick="setDay(-30)" value="1개월">
 <br>
 <INPUT TYPE="text" NAME="date1">~<INPUT TYPE="text" NAME="date2">

</FORM>
</body>
</html>

 

출처 : 

https://blog.naver.com/PostView.nhn?isHttpsRedirect=true&blogId=basketyj&logNo=30129949743 

http://kimjongyeol.tistory.com/54

 

Posted by useways
,

인코더와 디코더

 

script type="text/javascript">

var URI='http:\\hanb.co.kr?test=한글입니다.';

var output='';

output+= 'escape()\n';

output+=escape(URI)+'\n\n';

 

output+= 'escape()URi\n';

output+=encodeURI(URI)+'\n\n';

 

output+= 'escape()URIComponent()\n';

output+=encodeURIComponent(URI)+'\n\n';

 

alert(output);

console.log(output);

</script>

 

 

 

Eval 코드 실행함수

문자열이나 코드스트링을 실행문으로 바꿔주는함수

문자열을 실행시킨다. '1+1' 이나

var number=10;

alert(number);

 실행시킨다.

 

<script type="text/javascript">

 

console.log('1+1');

 

//문자열 => 표현식

console.log(eval('1+1'));

 

 

// 실행코드로 바꿔줌

var willEval ='';

willEval += 'var number=10;';

willEval+= 'alert(number);';

eval(willEval);

 

</script>

 

 

 

 

숫자변환함수

 

<script type="text/javascript">

 

var won = '1000';

var dollar ='1.5$';

alert(Number(won)+' : '+Number(dollar));

</script>

<script type="text/javascript">

 

var won = '1000';

var dollar ='1.5$';

alert(parseInt(won)+' : '+parseInt(dollar));

alert(parseFloat(won)+' : '+parseFloat(dollar));

</script>

 

숫자로 변환할수있는것만 바꿔준다.

그러나 parse도 여러 개 이상현상이 있으니 확인하고 바꿔서 사용해야한다.

 

출처

https://blog.naver.com/PostView.naver?blogId=skawo32167&logNo=220452876237&parentCategoryNo=&categoryNo=50&viewDate=&isShowPopularPosts=false&from=postList

Posted by useways
,

var d = new Date(0;

var yyyymmdd = d.getFullYear() + (d.getMonth()+1).setDigit(2) +d.getDate().setDigit(2);

var hhmmss = d.getHours().setDigit(2) + d.getMinutes().setDigit(2) + d.getMilliseconds();



참고 사이트:

http://blog.naver.com/PostView.nhn?blogId=zeze3731&logNo=221313992348



Posted by useways
,

1. substring : 어디서부터 어디까지 잘라내겠다

(java의 substring과 같다)

2. substr : 어디서부터 몇번째까지 잘라내겠다

 


예제) "abcdefg" 라는 문자열이 있으면

substring(2, 4) 를 하면 "cd"의 결과가 나오고

substr(2, 4) 를 하면 "cdef"가 나온다.

 


substring의 뜻은 인덱스 2번째 문자에서 인덱스 4번째 문자까지를 가져오겠다는 뜻.

substr의 뜻은 인덱스 2번째 문자에서부터 뒤로 4개를 가져오겠다.

 

뒤에서 부터 4자리 가져오기

var _str = 'kimsungho';

var str = _str.substr(_str.length - 4, 4);

 

출처 http://useways.tistory.com/entry/

Posted by useways
,

출처: http://coding-start.tistory.com/35


JavaScript 타이머 함수

자바스크립트에서 타이머함수란 전역객체인 window 객체 안에 있는 함수들입니다. 그렇다면 타이머 함수가 할수 있는 일은 무엇이 있을까요?

 

1. 특정시간마다 특정 함수를 계속 호출해서 실행 시킬 수 있다. => setInterval(function, duration)

참고 http://gemuse.tistory.com/28

예제 :         window.setInterval( function(){
                                             scope.setColhead();
                                          },1000);

2. 특정시간 이후에 딱 한번만 특정함수를 호출해 실행시킨다. => setTimeOut(function, duration)

예제 : setTimeout(function(){self.doSearch();},300);

참고 http://travelfacebook.tistory.com/2260

3. 특정 타이머 id값을 가진 타이머 함수를 종료시킨다. => clearInterval(timerid)

 참고 http://egloos.zum.com/newkong/v/4088409

 

1. 특정시간마다 특정함수를 호출/실행, setInterval 함수


 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
<!DOCTYPE html PUBLIC "-//W3C//DTD Xhtml 1.0 Transitional//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title></title>
    <style>
        * {
            margin: 0;
            padding: 0;
        }
 
        #output {
            width: 200px;
            height: 200px;
            border: 4px solid #000;
            margin: 50px;
 
            font-size: 100px;
            text-align: center;
            line-height: 200px;
            vertical-align: middle;
 
        }
    </style>
    <script src="../../libs/jquery-1.11.0.min.js"></script>
 
    <script>
        // 예제01: 1초에 한 번씩 변수 값을 1씩 증가시키고 이 값을 #output 영역에 출력해 주세요.
        $(document).ready(function () {
 
            var $output = $("#output");
            var count = 0;
 
            // 여기에 풀이를 입력해주세요.
            // 함수 생성
            function addCount() {
                // 값 증가
                count++;
                // 값을 출력
                $output.text(count);
            }
 
            addCount();
            setInterval(addCount, 1000);
 
        })
 
    </script>
 
 
</head>
 
<body>
<div id="output">
    0
</div>
</body>
</html>
 
cs

 

이 코드는 1초 마다 숫자를 1씩 증가시켜주는 코드입니다. 딱히 어렵지 않은 코드라고 생각합니다. 여기서 하나 알아야 할 것은 setInterval 함수가 어떠한 리턴 값 없이 매개변수안에 있는 실행구문을 실행시켜주고 끝이 아닙니다. setInterval 함수는 코드내 유일한 timer id를 int 형태로 반환하는 함수입니다. (timer id값은 clearInterval 함수로 타이머 함수를 종료시킬 때 사용 될수 있는 유니크 키 값이라고 생각해도 좋습니다.)

 


 

2. 특정시간 이후에 딱 한번만 함수 호출/실행 , setTimeOunt 함수


 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
<!DOCTYPE html PUBLIC "-//W3C//DTD Xhtml 1.0 Transitional//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title></title>
    <style>
        * {
            margin: 0;
            padding: 0;
        }
 
        #output {
            width: 600px;
            height: 200px;
            border: 4px solid #000;
            margin: 50px;
 
 
            text-align: center;
            line-height: 200px;
            vertical-align: middle;
 
        }
    </style>
    <script src="../../libs/jquery-1.11.0.min.js"></script>
 
    <script>
        // 예제02: 3초 후에 “안녕하세요. 환영합니다.” 메시지를 화면에 출력해 주세요.
        $(document).ready(function () {
 
            var $output = $("#output");
 
            // 여기에 풀이를 입력해주세요.
            setTimeout(function () {
                $output.text("안녕하세요. 환영합니다.")
            }, 3000);
 
        })
 
    </script>
 
 
</head>
 
<body>
<div id="output">
 
</div>
</body>
</html>
 
cs
이 코드는 3초 후에 매개변수 안에 있는 익명함수를 호출하여 "안녕하세요. 환영합니다"라는 메시지를 $("#output") 안에 출력하는 기능을 딱 한번만 실행시켜주는 코드입니다.
 

 

3. 특정 타이머 함수를 종료시켜주는 함수 , clearInterval 함수


 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
<!DOCTYPE html PUBLIC "-//W3C//DTD Xhtml 1.0 Transitional//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title></title>
    <style>
        * {
            margin: 0;
            padding: 0;
        }
 
        #output {
            width: 200px;
            height: 200px;
            border: 4px solid #000;
            margin: 50px;
 
            font-size: 100px;
            text-align: center;
            line-height: 200px;
            vertical-align: middle;
 
        }
    </style>
    <script src="../../libs/jquery-1.11.0.min.js"></script>
 
    <script>
        /*
         예제 03: 1초에 한번씩 숫자 값 출력하기
         변수 값을 1초에 한 번 1씩 증가시키고 이 값을 화면에 출력해 주세요.
         단, 정지버튼(#stip)을 누르면 더 이상 실행되지 않게 타이머 함수를 중지시켜 주세요.
 
         */
        $(document).ready(function() {
 
            var $output = $("#output");
            var count = 0;
            var timerID=0;
            timerID = setInterval(function() {
                // 값 증가
                count++;
                // 값을 출력
                $output.text(count);
            }, 1000);
 
 
            $("#stop").click(function() {
                // 여기에 풀이를 입력해주세요.
                clearInterval(timerID);
            });
 
        })
 
    </script>
 
 
</head>
 
<body>
<button id="stop">멈춤</button>
<div id="output">
    0
</div>
</body>
</html>
 
cs

 

이 코드는 setInterval 함수에 의해서 1초마다 1씩 증가되는 값을 출력시켜주는 타이머 함수를 종료시켜주는 코드입니다. 여기에 쓰이는 함수가 clearInterval 함수입니다. 여기서 보이는 것은 setInterval 함수의 리턴 값을 timerID라는 변수에 담아주고 이 변수를 이용해 clearInterval 함수를 사용하여 특정타이머를 종료시켜줍니다. 

 

 

 

 
출처: http://blog.pages.kr/29 좋은 자료들 많이 있다.

1. setTimeout() 메소드 - 일정시간후 코드실행  > setTimeout(code, delay);  code : 일정시간 후 실행시킬 자바스크립트 코드를 포함한 문자열(함수나 alert같은 코드들...)
  delay : 문자열 code 내에 있는 자바스크립트 코드가 실행되기까지 걸리는 시간 (1/1000초 단위)

 

2. setInterval() 메소드 - 일정시간후 코드 반복실행  > setInterval(code, delay);  setTimeout()과 같이 일정시간후에 코드가 실행되지만, 한번실행이 아닌 반복실행된다. 

code : 일정시간 후 실행시킬 자바스크립트 코드를 포함한 문자열(함수나 alert같은 코드들...)

 delay : 문자열 code 내에 있는 자바 크립트 코드가 실행되기까지 걸리는 시간 (1/1000초 단위)

 

3. clearInterval() 메소드 - clearInterval로 setInterval함수로 정해진 반복코드를 멈추게한다.  > clearInterval("setInterval로 생성된 변수")  code : 일정시간 후 실행시킬 자바스크립트 코드를 포함한 문자열(함수나 alert같은 코드들...)
  delay : 문자열 code 내에 있는 자바스크립트 코드가 실행되기까지 걸리는 시간 (1/1000초 단위)
  ex) var intA = setInterval("clock()",50)  // 0.05초마다 clock()함수를 실행한다.
      clearInterval(intA) //setInterval()로 실행된 메소드를 취소한다.

 

 

 

 

 

[ JavaScript ] 일회용 타이머 setTimeout() 메소드

1. setTimeout(함수명, 시간) - '함수명'이라고 되어있는 부분에 일정 시간 뒤에 실행시키고 싶은 함수나 명령 따위를 넣는다. - 주의할 것은, function01() 이라는 함수를 사용한다 할때, setTimeout(function,

egloos.zum.com

 

[ JavaScript ] 일회용 타이머 setTimeout() 메소드

1. setTimeout(함수명, 시간) - '함수명'이라고 되어있는 부분에 일정 시간 뒤에 실행시키고 싶은 함수나 명령 따위를 넣는다. - 주의할 것은, function01() 이라는 함수를 사용한다 할때, setTimeout(function,

egloos.zum.com

 

 

Posted by useways
,