Standard Built In Object

MINIMI·2023년 2월 9일

JavaScript(Core : 기본)

목록 보기

10/10

10-1. Global Object

global object는 코드가 실행되기 이전 단계에 자바스크립트 엔진에 의해 어떤 객체보다 먼저 생성되는 특수한 객체

Node.js 환경에서는 global이 전역 객체이고, 브라우저 환경에서는 window가 전역 객체이다.

전역 객체는 계층 구조상 어떤 객체에도 속하지 않는 최상위 객체이다(프로토타입 상속의 의미 X)

1) built in global property

Infinity
- 무한대를 나타내는 숫자
- 전역 프로퍼티는 global을 생략하고 참조할 수 있다.

console.log(global.Infinity == Infinity);
console.log(10/0);  //양의 무한대
console.log(-10/0)  //음의 무한대
console.log(typeof Infinity);   //Number

NaN
- 숫자가 아님(Not a Number)을 나타내는 숫자 값
- Number.NaN 프로퍼티와 같다

console.log(global.NaN);        //global.NaN은 Number.NaN과 같음
console.log(Number('abc'));
console.log(10 * 'abc');        //NaN
console.log(typeof NaN);        //number

Undefined
- 원시 타입 undefined

console.log(global.undefined);
let nothing;
console.log(nothing);
console.log(typeof undefined);

2) built in global function

빌트인 전역 함수
isFinite
- 전달 받은 인수가 정상적인 유한수인지 검사하여 유한수이면 true를 반환하고, 무한수이면 false를 반환.
- 전달 받은 인수가 숫자가 아닌 경우 숫자로 타입 변환 후 검사를 수행하며, NaN으로 평가되는 값이면 false를 반환

console.log(isFinite(10));              // true
console.log(isFinite('10'));            // true
console.log(isFinite(null));            // true

console.log(isFinite(Infinity));        // false
console.log(isFinite(-Infinity));       // false

console.log(isFinite(NaN));             // false
console.log(isFinite('abc'));           // false

isNaN
- 전달 받은 인수가 NaN인지 검사하여 그 검사 결과를 불리언 타입으로 변환
- 전달 받은 인수가 숫자가 아닌 경우 숫자로 타입 변환 후 검사를 수행

console.log(isNaN(NaN));                // true
console.log(isNaN(10));                 // false

console.log(isNaN('abc'));              // true
console.log(isNaN('10'));               // false
console.log(isNaN(''));                 // false ('' => 0)

console.log(isNaN(true));               // false (true => 1)
console.log(isNaN(false));              // false (false => 0)

console.log(isNaN(undefined));          // true 

console.log(isNaN({}));                 // true

parseFloat
- 전달 받은 문자열 인수를 부동 소수점 숫자, 실수로 해석하여 반환
parseInt
- 전달 받은 문자열 인수를 정수로 해석하여 반환

// parseFloat : 전달받은 문자열 인수를 부동 소수점 숫자, 실수로 해석하여 반환
console.log(parseFloat('10.01'));       // 10.01
console.log(parseFloat('10'));          // 10
// 공백으로 구분 된 문자열은 첫 번째 문자열만 변환
console.log(parseFloat('10 20 30'));    // 10
// 숫자가 아닌 문자열은 제외하고 변환
console.log(parseFloat('10cm'));        // 10
// 첫 번째 문자열을 숫자로 변환할 수 없다면 변환 불가
console.log(parseFloat('GS25'));        // NaN
// 앞뒤 공백은 무시
console.log(parseFloat('  1004  '));    // 1004

// parseInt : 전달받은 문자열 인수를 정수로 해석하여 반환
console.log(parseInt('10'));            // 10
console.log(parseInt('10.01'));         // 10
console.log('-------------------------------');

encodeURI
- URI(인터넷에 있는 자원을 나타내는 유일한 주소)를 문자열로 전달 받아 이스케이프 처리를 위해 인코딩한다.
- 네트워크를 통해 정보를 공유할 때 어떤 시스템에서도 읽을 수 있는 아스키 문자 셋으로 변경

const uri = 'http://greedy.com?name=홍길동&job=student';
const enc = encodeURI(uri);         
console.log(enc);                   // http://greedy.com?name=%ED%99%8D%EA%B8%B8%EB%8F%99&job=student

decodeURI
- 인코딩 된 URI를 인수로 전달 받아 이스케이프 처리 이전으로 디코딩한다.

const dec = decodeURI(enc);
console.log(dec);                   // http://greedy.com?name=홍길동&job=student

encodeURIComponent
- URI 구성 요소를 인수로 전달 받아 알파벳, 0~9의 숫자, -_ . ! ~ * ' () 문자는 제외하고 인코딩한다.
- 쿼리 스트링 구분자로 사용 되는 =, ?, & 까지 인코딩한다.

const uriComp = 'name=홍길동&job=student';
const encComp = encodeURIComponent(uriComp);
console.log(encComp);               // name%3D%ED%99%8D%EA%B8%B8%EB%8F%99%26job%3Dstudent

// decodeURIComponent
const decComp = decodeURIComponent(encComp);
console.log(decComp);               // name=홍길동&job=student

10-2. Number

1) Number

표준 빌트인 객체인 Number는 원시 타입인 숫자를 다룰 때 유용한 프로퍼티와 메서드를 제공
생성자 함수

const obj = new Number();       // Number 인스턴스 생성
console.log(obj);               // 인수 전달하지 않을 경우 0을 할당

const obj2 = new Number(1);
console.log(obj2);              // 인수로 전달 받은 숫자 할당

const obj3 = new Number('1');
console.log(obj3);              // 인수로 전달 받은 문자 숫자로 형변환

const obj4 = new Number('number');
console.log(obj4);              // 숫자 형변환 불가 시 NaN

new 연산자를 사용하지 않고 호출하면 Number 인스턴스가 아닌 숫자를 반환하므로 명시적 타입 형변환에 활용 가능
new 연산자를 통해 호출하지 않아도 prototype을 상속받아 사용할 수 있다.

2) Number-property

Number.MAX_VALUE
- 자바스크립트에서 표현할 수 있는 가장 큰 양수 값
Number.MIN_VALUE
- 자바스크립트에서 표현할 수 있는 가장 작은 양수 값

console.log(Number.MIN_VALUE);
console.log(Number.MIN_VALUE > 0);          // 0보다 크다

Number.MAX_SAFE_INTEGER
- 자바스크립트에서 안전하게 표현할 수 있는 가장 큰 정수 값
  (MAX_VALUE 안의 값 = 안전하게 표현할 수 있는 값)
Number.MIN_SAFE_INTEGER
- 자바스크립트에서 안전하게 표현할 수 있는 가장 작은 정수 값
Number.POSITIVE_INFINITY
- 양의 무한대를 나타내는 숫자값 Infinity와 같다
Number.NEGATIVE_INFINITY
- 음의 무한대를 나타내는 숫자값 -Infinity와 같다
Number.NaN
- 숫자가 아님을 나타내는 숫자값
Number.EPSILON
- 부동 소수점으로 인해 발생하는 오차를 해결하기 위해 사용한다

console.log(Number.EPSILON);    // 1과 1보다 큰 숫자 중에서 가장 작은 숫자와의 차이와 같다
console.log(0.1 + 0.2);         // 부동소수점 표현은 2진법으로 변환했을 때 무한소수가 되어 미세한 오차가 발생할 수 밖에 없다
console.log(0.1 + 0.2 === 0.3);             // false
console.log(isEqual(0.1 + 0.2, 0.3));       // true

function isEqual(a, b) {
    // a - b의 절대값이 Number.EPSILON 보다 작으면 같은 수로 인정한다
    return Math.abs(a - b) < Number.EPSILON;
}

3) Number-method

Number.isFinite
- 인수로 전달 된 숫자값이 정상적인 유한수인지 검사하여 결과를 불리언으로 반환

console.log(Number.isFinite(10));           // true
console.log(Number.isFinite(-10));          // true
console.log(Number.isFinite(Infinity));     // false
console.log(Number.isFinite(-Infinity));    // false
console.log(Number.isFinite(NaN));          // false

console.log(Number.isFinite(null));         // false(Number.isFinite(null)에서는 null을 암묵적 타입변환 하지 않기 때문에 유한수로 판단하지 않는다.)

console.log(isFinite(null));            // 빌트인 전역함수 isFinite는 암묵적 타입변환을 한다

Number.isInteger
- 인수로 전달 된 숫자값이 정수인지 검사하여 결과를 불리언으로 반환

console.log(Number.isInteger(10));          // true
console.log(Number.isInteger(-10));         // true
console.log(Number.isInteger(10.10));       // false
console.log(Number.isInteger(-10.10));      // false
console.log(Number.isInteger('10'));        // false
console.log(Number.isInteger(false));       // false
console.log(Number.isInteger(Infinity));    // false
console.log(Number.isInteger(-Infinity));   // false

Number.isNaN
- 인수로 전달 된 숫자값이 NaN인지 검사하여 결과를 불리언으로 반환

console.log(Number.isNaN(NaN));             // true
console.log(Number.isNaN(undefined));       // false
console.log(isNaN(undefined));              // 빌트인 전역함수 isNaN은 암묵적 타입변환을 한다

Number.isSafeInteger
- 인수로 전달 된 숫자값이 안전한 정수인지 검사하여 결과를 불리언으로 반환
- safe한 범위 안에 들어오는 Integer 값인지를 판단(Integer의 최소값, 최대값을 벗어나는지 판단)

console.log(Number.isSafeInteger(10));          // true
console.log(Number.isSafeInteger(1000000000000000000000));         // false
console.log(Number.isSafeInteger(10.10));       // false
console.log(Number.isSafeInteger('10'));        // false
console.log(Number.isSafeInteger(false));       // false
console.log(Number.isSafeInteger(Infinity));    // false

Number.prototype.toExponential
- 숫자를 지수 표기법으로 변환하여 문자열로 반환
- e 앞에 있는 숫자에 10의 n승을 곱하는 형식으로 수를 나타낸다

console.log((1.23456).toExponential());         // 1.23456e+0
// 소수점 이하로 표현할 자리수 전달한다.
console.log((1.23456).toExponential(3));        // 1.235e+0
console.log((1.23456).toExponential(1));        // 1.2e+0

Number.prototype.toFixed
- 숫자를 반올림하여 문자열로 반환한다
- 반올림 하는 소수점 이하 자리수를 나타내는 0~20 사이의 정수값을 인수로 전달할 수 있다

console.log((1.23456).toFixed());               // 1
console.log((1.23456).toFixed(3));              // 1.235
console.log((1.23456).toFixed(1));              // 1.2

Number.prototype.toPrecision
- 인수로 전달 받은 전체 자릿수까지 유효하도록 나머지 자릿수를 반올림하여 문자열로 반환
- 0~21사이의 정수 값을 인수로 전달할 수 있으며 생략하면 기본값 0이 지정된다

console.log((123.456).toPrecision());           // 123.456
console.log((123.456).toPrecision(5));          // 123.46
console.log((123.456).toPrecision(3));          // 123
console.log((123.456).toPrecision(1));          // 1e+2

Number.prototype.toString
- 숫자를 문자열로 변환하여 반환한다
- 진법을 나타내는 2~36 사이의 정수값을 인수로 전달할 수 있다

console.log((100).toString());                  // 100
console.log((100).toString(2));                 // 1100100
console.log((100).toString(8));                 // 144
console.log((100).toString(16));                // 64

10-3. Math

1) Math property

표준 빌트인 객체 Math는 수학적인 상수와 함수를 위한 프로퍼티와 메서드를 제공한다.
Math는 생성자 함수가 아니므로 정적 프로퍼티와 정적 메서드만 제공한다.
Math 프로퍼티
- Math.PI
  - 원주율 PI 값 반환

2) Math method

Math.abs
- 인수로 전달된 숫자의 절대값을 반환

console.log(Math.abs(-10));                     // 10
console.log(Math.abs('-10'));                   // 10
console.log(Math.abs(''));                      // 0
console.log(Math.abs([]));                      // 0
console.log(Math.abs(null));                    // 0
console.log(Math.abs(undefined));               // NaN
console.log(Math.abs({}));                      // NaN
console.log(Math.abs('math'));                  // NaN
console.log(Math.abs());                        // NaN

Math.round
- 인수로 전달된 숫자의 소수점 이하를 반올림한 정수를 반환

console.log(Math.round(10.1));                  // 10             
console.log(Math.round(10.9));                  // 11
console.log(Math.round(-10.1));                 // -10
console.log(Math.round(-10.9));                 // -11
console.log(Math.round(10));                    // 10
console.log(Math.round());                      // NaN

Math.ceil
- 인수로 전달된 숫자의 소수점 이하를 올림한 정수를 반환

console.log(Math.ceil(10.1));                   // 11             
console.log(Math.ceil(10.9));                   // 11
console.log(Math.ceil(-10.1));                  // -10
console.log(Math.ceil(-10.9));                  // -10
console.log(Math.ceil(10));                     // 10
console.log(Math.ceil());                       // NaN

Math.floor
- 인수로 전달된 숫자의 소수점 이하를 내림한 정수를 반환

console.log(Math.floor(10.1));                  // 10             
console.log(Math.floor(10.9));                  // 10
console.log(Math.floor(-10.1));                 // -11
console.log(Math.floor(-10.9));                 // -11
console.log(Math.floor(10));                    // 10
console.log(Math.floor());                      // NaN

Math.sqrt
- 인수로 전달된 숫자의 제곱근을 반환

console.log(Math.sqrt(4));                      // 2             
console.log(Math.sqrt(-4));                     // NaN
console.log(Math.sqrt(2));                      // 1.4142135623730951
console.log(Math.sqrt(1));                      // 1
console.log(Math.sqrt(0));                      // 0
console.log(Math.sqrt());                       // NaN

Math.random
- 임의의 난수(0에서 1 미만의 실수) 반환

console.log(Math.random());               
// 1~100 범위의 난수 추출       
const random = Math.floor((Math.random() * 100) + 1);
console.log(random);

Math.pow
- 첫번째 인수를 밑으로 두번째 인수를 지수로 거듭제곱한 결과 반환
- ES7에서 도입 된 지수 연산자를 사용할 수 있다

console.log(Math.pow(2, 2));                    // 4             
console.log(Math.pow(2, -2));                   // 0.25
console.log(Math.pow(2));                       // NaN
// ES7에서 도입 된 지수 연산자를 사용할 수 있다
console.log(2 ** 2);                            // 4 
console.log(2 ** -2);                           // 0.25

Math.max
- 전달받은 인수 중 가장 큰 수를 반환

console.log(Math.max(10));                      // 10             
console.log(Math.max(10, 20));                  // 20
console.log(Math.max(10, 20, 30));              // 30
// 값을 비교할 요소가 없어서 초기값인 -Infinity 반환
console.log(Math.max());                        // -Infinity

Math.min
- 전달받은 인수 중 가장 작은 수를 반환

console.log(Math.min(10));                      // 10             
console.log(Math.min(10, 20));                  // 10
console.log(Math.min(10, 20, 30));              // 10
console.log(Math.min());                        // Infinity

10-4. Date

1) Date

표준 빌트인 객체인 Date는 날짜와 시간을 위한 메서드를 제공하는 빌트인 객체이면서 생성자 함수다.
UTC(협정 세계시)
- 국체 표준시로 기술적인 표기에서 사용
GMT(그리니치 표준시)
- UTC와 초의 소수점 단위에서만 차이가 나기 때문에 일상에서는 혼용되어 사용
KST(한국 표준시)
- UTC에 9시간을 더한 시간
Date 객체는 내부적으로 날짜와 시간을 나타내는 정수 값을 가진다.
- 1970년 1월 1일 00:00:00(UTC)를 기점으로 Date 객체가 나타내는 날짜와 시간까지의 밀리초를 나타낸다
new Date()
- 현재 날짜와 시간을 가지는 Date 객체 반환
new Date(millisecond)
- 1979년 01월 01일 00:00:00(UTC)를 기점으로 인수로 전달 된 밀리초만큼 경과한 날짜와 시간을 나타낸다

console.log(new Date(0));
// 하루가 지난 만큼의 millisecond 인자로 전달
console.log(new Date(24 * 60 * 60 * 1000));

new Date(dateString)
- 날짜와 시간을 나타내는 문자열을 인수로 전달하면 지정 된 날짜와 시간을 나타내는 Date 객체 반환

console.log(new Date('Jul 26, 2022 09:00:00'));
console.log(new Date('2022/07/26/09:00:00'));

new Date(year, month[, day, hour, minute, second, millisecond])
- 연, 월, 일, 시, 분, 초, 밀리초를 의미하는 숫자를 인수로 전달하면 지정 된 날짜와 시간을 나타내는 Date 객체 반환
- 연, 월은 반드시 지정해야 하며 지정하지 않은 정보는 0 또는 1로 초기화 된다
- month(0~11)에 주의한다

console.log(new Date(2022, 1));                 //UTC 기준(KST는 + 9시간으로 22-02-01) 2022-01-31T15:00:00.000Z
console.log(new Date(2022, 1, 1, 9, 0, 0, 0));  //2022-02-01T00:00:00.000Z

2) Date method

Date.now
- 1970년 1월 1일 00:00:00(UTC)을 기점으로 현재 시간까지 경과한 밀리초를 숫자로 반환한다

const now = Date.now();
console.log(now);
console.log(new Date(now));

Date.parse
- 1970년 1월 1일 00:00:00(UTC)을 기점으로 인수로 전달된 지정 시간(new Date(dateString)의 인수와 동일한 형식)까지의 밀리초를 숫자로 반환한다

console.log(Date.parse('Jan 1, 1970 09:00:00'));        //KST 0
console.log(Date.parse('Jan 1, 1970 09:00:00 UTC'));    //UTC 32400000
console.log(Date.parse('1970/01/01/09:00:00')); 
console.log(Date.parse('1970/01/01/09:00:00 UTC'));

Date.UTC
- 1970년 1월 1일 00:00:00(UTC)을 기점으로 인수로 전달 된 지정 시간까지의 밀리초를 숫자로 반환한다
- new Date(year, month[, day, hour, minute, second, millisecond])와 같은 형식의 인수를 사용한다
- 인수는 로컬 타임(KST)이 아닌 UTC로 인식된다

console.log(Date.UTC(1970, 0, 1)); 
console.log('------------------------');

// 연, 월, 일, 시, 분, 초, 밀리초 반환 및 설정
const date = new Date();
console.log(date.getFullYear());
console.log(date.getMonth());
console.log(date.getDate());
console.log(date.getDay());                 // 일요일부터 월요일을 0~6으로 반환
console.log(date.getHours());
console.log(date.getMinutes());
console.log(date.getSeconds());
console.log(date.getMilliseconds());

date.setFullYear(2020);
date.setMonth(0);
date.setDate(1);
date.setHours(9);
date.setMinutes(10);
date.setSeconds(10);
date.setMilliseconds(10);
console.log(date);
console.log('------------------------');

Date.getTime, Date.setTime
- 1970년 1월 1일 00:00:00(UTC)을 기점으로 경과된 밀리초 반환, 설정

const date2 = new Date();
console.log(date2.getTime());
date2.setTime(5 * 24 * 60 * 60 * 1000);
console.log(date2);

Date.prototype.getTimezoneOffset
- UTC와 Date 객체에 지정된 로케일 시간과의 차이를 분 단위로 반환한다

const today = new Date();
console.log(today.getTimezoneOffset());
console.log(today.getTimezoneOffset() / 60);

Date.prototype.to___String
- 사람이 읽을 수 있는 형식의 문자열로 Date 객체의 날짜 반환한다

console.log(today.toString());                  //Thu Feb 09 2023 12:49:01 GMT+0900 (대한민국 표준시)
console.log(today.toDateString());              //Thu Feb 09 2023
console.log(today.toTimeString());              //12:49:01 GMT+0900 (대한민국 표준시)
console.log(today.toISOString());               //2023-02-09T03:49:01.530Z
console.log(today.toLocaleString());            //2023. 2. 9. 오후 12:49:01
console.log(today.toLocaleTimeString());        //오후 12:49:01

10-5. RegExp

1) RegExp

정규 표현식은 일정한 패턴을 가진 문자열의 집합을 표현하기 위해 사용하는 형식언어(format language)
정규 표현식 리터럴
- let 변수명 = /패턴/플래그;
생성자 함수
- new RegExp(pattern[, flag]);
- 플래그는 꼭 넣지 않아도 됨

const target = 'JavaScript';

regexp = new RegExp('j', 'i');
regexp = new RegExp(/j/, 'i');
regexp = new RegExp(/j/i);  //ES6부터 가능한 표현

test 메서드
- target 문자열에 대해 정규 표현식 regexp의 패턴을 검색하여 매칭 결과를 불리언으로 반환

2) RegExp method

RegExp.prototype.exec
- 인수로 전달 받은 문자열에 대해 정규 표현식의 패턴을 검색하여 매칭 결과를 배열로 반환
- /검색할 키워드/

const target = 'Java JavaScript';

console.log(/va/.exec(target));
console.log(/va/g.exec(target));    // 문자열 내의 모든 패턴을 검색하는 g 플래그를 지정해도 첫 번째 매칭 결과만 반환
console.log(/hello/.exec(target));  // 매칭 결과가 없을 경우 null 반환

RegExp.prototype.test
- 인수로 전달 받은 문자열에 대해 정규 표현식의 패턴을 검색해서 매칭 결과를 불리언으로 변환

const target = 'Java JavaScript';

console.log(/va/.test(target));
console.log(/hello/.test(target));

String.prototype.match
- String 표준 빌트인 객체가 제공하는 메서드로 대상 문자열과 인수로 전달 받은 정규 표현식과의 매칭 결과를 배열로 반환

console.log(target.match(/va/));
console.log(target.match(/va/g));   // 문자열 내의 모든 패턴을 검색하는 g 플래그를 지정하면 모든 매칭 결과가 배열로 반환
console.log(target.match(/hello/));

3) flag and patterns

flag의 종류
- i(ignore case)
  - 대소문자 구별 않고 패턴 검색
- g(global)
  - 대상 문자열 내에서 패턴과 일치하는 모든 문자열을 전역 검색
- flag는 옵션이므로 선택적으로 사용할 수 있고, 순서와 상관 없이 하나 이상의 플래그를 동시에 설정할 수 있다.

   let target = "Java JavaScript";

   console.log(target.match(/VA/));		
   console.log(target.match(/VA/i));
   console.log(target.match(/VA/ig));

패턴

특별한 의미를 가지는 메타문자 또는 기호로 표현할 수 있다
임의의 문자열
문자열을 하나의 덩어리가 아니라 char 처럼 한글자씩 취급

let target = "Java JavaScript";

target = 'abcdefg';
console.log(target.match(/../g));           // 임의의 두자리 문자열 전역 검색

{m,n}
- 최소 m번 최대 n 번 반복되는 문자열(반복검색)
- {m, n}처럼 공백 넣으면 오류

 target = 'a aa aaa b bb bbb ab aab abb';
console.log(target.match(/a{2,3}/g));       // a 최소 2번 ~ 최대 3번 반복
console.log(target.match(/b{2}/g));         // b 두 번 반복
console.log(target.match(/b{3,}/g));        // 3번 이상 반복
console.log(target.match(/b{1,2}/g));

- 앞선 패턴이 최소 한 번 이상 반복되는 문자열(반복 검색)
- {1,}과 같다

console.log(target.match(/b+/g));

?
- 앞선 패턴이 최대 한번(0번 포함) 이상 반복 되는 문자열(반복 검색)
- {0,1}과 같다

target = 'soul seoul';
// 중간의 e 문자가 있어도 되고 없어도 되는 패턴 검색
console.log(target.match(/se?oul/g));       //soul, seoul

or
- |

target = 'aa bb cc dd 123 456 _@';
console.log(target.match(/a|b/g));
// 분해 되지 않은 단어 레벨로 검색
console.log(target.match(/a+|b+/g));
// [] 내의 문자는 or로 동작
console.log(target.match(/[abc]+/g));
// 범위를 지정하려면 - 사용
console.log(target.match(/[a-z]+/g));
// 대소문자 범위
console.log(target.match(/[A-Za-z]+/g));
// 숫자범위
console.log(target.match(/[0-9]+/g));

d / D
- \d : 숫자
- \D : 숫자가 아닌 문자
w / W
- \w : 알파벳, 숫자, 언더스코어
- \W : 알파벳, 숫자, 언더스코어가 아닌 문자
[..] 내의 ^ : not

console.log(target.match(/[^0-9]+/g));
console.log(target.match(/[^a-z]+/g));

[..] 밖의 ^ : 시작 위치 검색
$ : 마지막 위치 검색
예시

target = 'https://www.google.com';
// 주소값에 다른 문자열이 포함 되었을 때, ^ 혹은 $ 없이 검색하면 포함하는 경우를 검색하여 true를 반환하므로
// 시작 위치와 마지막 위치를 정확하게 검색해야 함
console.log(/^https/.test(target));
console.log(/com$/.test(target));

4) example

특정 단어로 시작하는지 검사

const url = 'https://www.googl.com';

console.log('=====================');
console.log(/^https?:\/\//.test(url));

특정 단어로 끝나는지 검사

// 파일 확장자가 js인지 검사
const fileName = 'test.js';

console.log(/js$/.test(fileName));

숫자로만 이루어진 문자열인지 검사

// const target = '12345';     true
const target = '123*45';     //false
// 처음과 끝이 숫자이고 최소 한 번 이상 반복 되는 문자열과 매칭
console.log(/^\d+$/.test(target));

아이디로 사용 가능한지 검사

// 알파벳  대소문자 또는 숫자로 시작하고 끝나며 6~12 자리인지 검사
const id = 'hello123';

console.log(/^[A-Za-z\d]{6,12}$/.test(id));

한글 범위 설정
- [가-힣]
  - 완성 된 자음 모음 형태만 허용
    -[가-ㅎㅏ-ㅣ-가-힣]
  - 자음 모음 완성 된 형태 모두 포함
핸드폰 번호 형식에 맞는지 검사

const phone = '010-1234-5678';

console.log(/^\d{3}-\d{3,4}-\d{4}$/.test(phone));

특수문자 포함 여부

const target2 = 'hello#world';
console.log(/[^A-Za-z0-9가-힣]/.test(target2));

10-5. String

1) String

표준 빌트인 객체인 String은 원시 타입인 문자열을 다룰 때 유용한 프로퍼티와 메서드를 제공한다
String은 생성자 함수 객체
- new 연산자와 함께 호출하여 String 인스턴스를 생성

const obj = new String();
console.log(obj);                   // 인수 전달하지 않으면 빈 문자열을 할당한 객체 생성

const obj2 = new String('홍길동');
console.log(obj2);                  // 인수로 문자열 전달 시 전달 받은 문자열 할당

String은 length 프로퍼티(문자열의 문자 개수)와 인덱스를 나타내는 숫자 형식의 문자열을 프로퍼티 키로, 각 문자를 프로퍼티 값으로 가진다.

const obj2 = new String('홍길동');

console.log(obj2.length);
console.log(obj2[0]);

문자열은 원시값이므로 변경 불가

obj2[0] = '김';         // 에러는 발생하지 않음
console.log(obj2);

문자열이 아닌 값을 인수로 전달했을 경우 문자열로 강제 변환된다

const obj3 = new String(100);
const obj4 = new String(null);
console.log(obj3[0]);
console.log(obj4[0]);

2) String method

문자열은 변경 불가능한 원시 값이기 때문에 String 래퍼 객체도 읽기 전용 객체로 제공된다.

const obj = new String('홍길동');
console.log(Object.getOwnPropertyDescriptors(obj));   // writable : false 새롭게 값 입력 불가(읽기 전용)
console.log('--------------------------------');

String 객체의 모든 메서드는 String 래퍼 객체를 직접 변경할 수 없고, String 객체의 메서드는 언제나 새로운 문자열을 생성하여 반환한다.
String.prototype.indexOf

const str = 'JavaScript';
console.log(str.indexOf('a'));      // 문자열에서 a 검색하여 첫번째 인덱스 반환
console.log(str.indexOf('b'));      // 검색에 실패하면 -1 반환
console.log(str.indexOf('a', 2));   // 검색 시작 인덱스 지정

// 특정 문자열 존재 유무 확인에 사용
if(str.indexOf('a') !== -1) console.log('a가 있다');
console.log('--------------------------------');

String.prototype.includes

console.log(str.includes('a'));     // 문자열에서 a 검색하여 포함 여부 반환
console.log(str.includes('b'));     // 검색에 실패하면 false 반환
console.log(str.includes('a', 2));  // 검색 시작 인덱스 지정

// 특정 문자열 존재 유무 확인에 사용
if(str.includes('a')) console.log('a가 있다');  
console.log('--------------------------------');

String.prototype.search
- 인수로 전달 받은 정규 표현식과 매치하는 문자열을 검색하여 일치하는 문자열의 인덱스를 반환

console.log(str.search(/a/));
console.log(str.search(/b/));       // 검색에 실패하면 -1 반환
console.log('--------------------------------');

String.prototype.startsWith
String.prototype.endsWith

console.log(str.startsWith('Ja'));
console.log(str.startsWith('va', 2));   // 검색 시작 인덱스 지정
console.log(str.endsWith('pt'));
console.log(str.endsWith('va', 4));     // 'Java'가 va로 끝나는지(endsWith(찾을문자, 끝나는 인덱스))
console.log('--------------------------------');

String.prototype.charAt
- 인덱스에 위치한 문자 검색하여 반환

for(let i = 0; i < str.length; i++)
    console.log(str.charAt(i));

String.prototype.substring
- 부분 문자열 반환

console.log(str.substring(1,4));    // 두번째 인덱스 위치 바로 이전 문자까지
console.log(str.substring(1));      // 두번째 인수 생략 시 문자열 끝까지
console.log(str.substring(4,1));    // 인수 교환하여 기능
console.log(str.substring(-1));     // 음수는 0으로 취급
console.log(str.substring(1,20));   // length보다 크면 length로 취급

String.prototype.slice
- substring과 동일하게 동작하지만 음수인 인수를 전달하면 가장 뒤에서부터 시작하여 잘라내 반환

console.log(str.slice(1,4));        // substring 동일
console.log(str.slice(1));          // substring 동일
console.log(str.slice(4,1));        // 인수 교환하여 기능하지 않음
console.log(str.slice(-1));         // 음수는 뒤에서부터
console.log(str.slice(1,20));       // substring 동일

String.prototype.toUpperCase
String.prototype.toLowerCase
String.prototype.trim
- 문자열 앞뒤 공백 문자 제거 후 반환
- 아이디 저장 시 공백 문자 제거에 유용

const str2 = '   JavaScript   ';
console.log(str2.trim());

String.prototype.repeat
- 전달받은 정수만큼 반복해 연결한 새로운 문자열을 반환

console.log(str.repeat());          // 빈 문자열    
console.log(str.repeat(0));         // 빈 문자열
console.log(str.repeat(1));
console.log(str.repeat(2));
console.log(str.repeat(2.5));       // 실수는 정수로 처리
// console.log(str.repeat(-1));     // 음수는 에러 RangeError: Invalid count value

String.prototype.replace
- 첫번째 인수로 전달 받은 문자열 또는 정규표현식을 검색하여 두번째 인수로 전달한 문자열로 치환한 문자열 반환

console.log(str.replace('Java', 'Type'));
console.log(str.replace('a', 'b'));         // 검색 된 문자열이 여럿 존재할 경우 첫번째로 검색된 문자열만 치환
console.log(str.replace(/j/i,'Z'));         // 첫번째 인수로 정규표현식 전달

String.prototype.split
- 첫번째 인수로 전달한 문자열 또는 정규식을 검색하여 문자열을 구분한 후 분리 된 각 문자열로 이루어진 배열 반환

const str3 = 'Hello, Everyone! Nice to see you again.';
console.log(str3.split(' '));       // 공백을 구분하여 배열로 반환
console.log(str3.split(''));        // 인수로 빈 문자열을 전달하면 각 문자를 모두 분리
console.log(str3.split());          // 인수를 생략하면 문자열 전체를 단일 요소로 하는 배열 반환
console.log(str3.split(' ', 5));    // 공백문자로 자르고 배열의 길이 지정

MINIMI

DREAM STARTER

이전 포스트