5.27 String

String 레퍼 객체

String 객체는 원시 타입인 문자열을 다룰 때 유용한 프로퍼티와 메소드를 제공하는 레퍼(wrapper) 객체이다. 변수 또는 객체 프로퍼티가 문자열을 값으로 가지고 있다면 String 객체의 별도 생성없이 String 객체의 프로퍼티와 메소드를 사용할 수 있다.

원시 타입이 wrapper 객체의 메소드를 사용할 수 있는 이유는 원시 타입으로 프로퍼티나 메소드를 호출할 때 원시 타입과 연관된 wrapper 객체로 일시적으로 변환되어 프로토타입 객체를 공유하게 되기 때문이다.

const str = 'Hello world!';
console.log(str.toUpperCase()); // 'HELLO WORLD!'

위에서 원시 타입 문자열을 담고 있는 변수 str이 String.prototype.toUpperCase() 메소드를 호출할 수 있는 것은 변수 str의 값이 일시적으로 wrapper객체로 변환되었기 때문이다.

사용 빈도가 높은 String 객체의 프로퍼티와 메소드에 대해 살펴보도록 하자.

1. String Constructor

String 객체는 String 생성자 함수를 통해 생성할 수 있다. 이때 전달된 인자는 모두 문자열로 변환된다.

new String(value);

let strObj = new String('Lee');
console.log(strObj); // String {0: 'L', 1: 'e', 2: 'e', length: 3, [[PrimitiveValue]]: 'Lee'}

strObj = new String(1);
console.log(strObj); // String {0: '1', length: 1, [[PrimitiveValue]]: '1'}

strObj = new String(undefined);
console.log(strObj); // String {0: 'u', 1: 'n', 2: 'd', 3: 'e', 4: 'f', 5: 'i', 6: 'n', 7: 'e', 8: 'd', length: 9, [[PrimitiveValue]]: 'undefined'}

new 연산자를 사용하지 않고 String 생성자 함수를 호출하면 String 객체가 아닌 문자열 리터럴을 반환한다. 이때 형 변환이 발생할 수 있다.

var x = String('Lee');

console.log(typeof x, x); // string Lee

일반적으로 문자열을 사용할 때는 원시 타입 문자열을 사용한다.

const str = 'Lee';
const strObj = new String('Lee');

console.log(str == strObj);  // true
console.log(str === strObj); // false

console.log(typeof str);    // string
console.log(typeof strObj); // object

2. String Property

2.1 String.length

문자열 내의 문자 갯수를 반환한다. String 객체는 length 프로퍼티를 소유하고 있으므로 유사 배열 객체이다.

const str1 = 'Hello';
console.log(str1.length); // 5

const str2 = '안녕하세요!';
console.log(str2.length); // 6

3. String Method

String 객체의 모든 메소드는 언제나 새로운 문자열을 반환한다. 문자열은 변경 불가능(immutable)한 원시 값이기 때문이다.

3.1 String.prototype.charAt(pos: number): string ES1

인수로 전달한 index를 사용하여 index에 해당하는 위치의 문자를 반환한다. index는 0 ~ (문자열 길이 - 1) 사이의 정수이다. 지정한 index가 문자열의 범위(0 ~ (문자열 길이 - 1))를 벗어난 경우 빈문자열을 반환한다.

index

const str = 'Hello';

console.log(str.charAt(0)); // H
console.log(str.charAt(1)); // e
console.log(str.charAt(2)); // l
console.log(str.charAt(3)); // l
console.log(str.charAt(4)); // o
// 지정한 index가 범위(0 ~ str.length-1)를 벗어난 경우 빈문자열을 반환한다.
console.log(str.charAt(5)); // ''

// 문자열 순회. 문자열은 length 프로퍼티를 갖는다.
for (let i = 0; i < str.length; i++) {
  console.log(str.charAt(i));
}

// String 객체는 유사 배열 객체이므로 배열과 유사하게 접근할 수 있다.
for (let i = 0; i < str.length; i++) {
  console.log(str[i]); // str['0']
}

3.2 String.prototype.concat(…strings: string[]): string ES3

인수로 전달한 1개 이상의 문자열과 연결하여 새로운 문자열을 반환한다.

concat 메소드를 사용하는 것보다는 +, += 할당 연산자를 사용하는 것이 성능상 유리하다.

/**
 * @param {...string} str - 연결할 문자열
 * @return {string}
 */
str.concat(str1[,str2,...,strN])

console.log('Hello '.concat('Lee')); // Hello Lee

3.3 String.prototype.indexOf(searchString: string, fromIndex=0): number ES1

인수로 전달한 문자 또는 문자열을 대상 문자열에서 검색하여 처음 발견된 곳의 index를 반환한다. 발견하지 못한 경우 -1을 반환한다.

/**
 * @param {string} searchString - 검색할 문자 또는 문자열
 * @param {string} [fromIndex=0] - 검색 시작 index (생략할 경우, 0)
 * @return {number}
 */
str.indexOf(searchString[, fromIndex])

const str = 'Hello World';

console.log(str.indexOf('l'));  // 2
console.log(str.indexOf('or')); // 7
console.log(str.indexOf('or' , 8)); // -1

if (str.indexOf('Hello') !== -1) {
  // 문자열 str에 'hello'가 포함되어 있는 경우에 처리할 내용
}

// ES6: String.prototype.includes
if (str.includes('Hello')) {
  // 문자열 str에 'hello'가 포함되어 있는 경우에 처리할 내용
}

3.4 String.prototype.lastIndexOf(searchString: string, fromIndex=this.length-1): number ES1

인수로 전달한 문자 또는 문자열을 대상 문자열에서 검색하여 마지막으로 발견된 곳의 index를 반환한다. 발견하지 못한 경우 -1을 반환한다.

2번째 인수(fromIndex)가 전달되면 검색 시작 위치를 fromIndex으로 이동하여 역방향으로 검색을 시작한다. 이때 검색 범위는 0 ~ fromIndex이며 반환값은 indexOf 메소드와 동일하게 발견된 곳의 index이다.

/**
 * @param {string} searchString - 검색할 문자 또는 문자열
 * @param {number} [fromIndex=this.length-1] - 검색 시작 index (생략할 경우, 문자열 길이 - 1)
 * @return {number}
 */
str.lastIndexOf(searchString[, fromIndex])

const str = 'Hello World';

console.log(str.lastIndexOf('World')); // 6
console.log(str.lastIndexOf('l'));     // 9
console.log(str.lastIndexOf('o', 5));  // 4
console.log(str.lastIndexOf('o', 8));  // 7
console.log(str.lastIndexOf('l', 10)); // 9

console.log(str.lastIndexOf('H', 0));  // 0
console.log(str.lastIndexOf('W', 5));  // -1
console.log(str.lastIndexOf('x', 8));  // -1

lastIndexOf

lastIndexOf

3.5 String.prototype.replace(searchValue: string | RegExp, replaceValue: string | replacer: (substring: string, …args: any[]) => string): string): string ES3

첫번째 인수로 전달한 문자열 또는 정규표현식을 대상 문자열에서 검색하여 두번째 인수로 전달한 문자열로 대체한다. 원본 문자열은 변경되지 않고 결과가 반영된 새로운 문자열을 반환한다.

검색된 문자열이 여럿 존재할 경우 첫번째로 검색된 문자열만 대체된다.

/**
 * @param {string | RegExp} searchValue - 검색 대상 문자열 또는 정규표현식
 * @param {string | Function} replacer - 치환 문자열 또는 치환 함수
 * @return {string}
 */
str.replace(searchValue, replacer)

const str = 'Hello world';

// 첫번째로 검색된 문자열만 대체하여 새로운 문자열을 반환한다.
console.log(str.replace('world', 'Lee')); // Hello Lee

// 특수한 교체 패턴을 사용할 수 있다. ($& => 검색된 문자열)
console.log(str.replace('world', '<strong>$&</strong>')); // Hello <strong>world</strong>

/* 정규표현식
g(Global): 문자열 내의 모든 패턴을 검색한다.
i(Ignore case): 대소문자를 구별하지 않고 검색한다.
*/
console.log(str.replace(/hello/gi, 'Lee')); // Lee Lee

// 두번째 인수로 치환 함수를 전달할 수 있다.
// camelCase => snake_case
const camelCase = 'helloWorld';

// /.[A-Z]/g => 1문자와 대문자의 조합을 문자열 전체에서 검색한다.
console.log(camelCase.replace(/.[A-Z]/g, function (match) {
  // match : oW => match[0] : o, match[1] : W
  return match[0] + '_' + match[1].toLowerCase();
})); // hello_world

// /(.)([A-Z])/g => 1문자와 대문자의 조합
// $1 => (.)
// $2 => ([A-Z])
console.log(camelCase.replace(/(.)([A-Z])/g, '$1_$2').toLowerCase()); // hello_world

// snake_case => camelCase
const snakeCase = 'hello_world';

// /_./g => _와 1문자의 조합을 문자열 전체에서 검색한다.
console.log(snakeCase.replace(/_./g, function (match) {
  // match : _w => match[1] : w
  return match[1].toUpperCase();
})); // helloWorld

첫번째 인자에는 문자열 또는 정규표현식이 전달된다. 문자열의 경우 첫번째 검색 결과만이 대체되지만 정규표현식을 사용하면 다양한 방식으로 검색할 수 있다.

위 예제에서 /hello/는 패턴이라하며 검색할 문자열을 의미한다. gi는 flag라 하는데 g(global)는 문자열 내에 패턴과 일치하는 모든 문자열을 검색하라는 의미이고 i(ignore)는 대소문자를 구분하지 않는다는 의미이다.

자세한 내용는 RegExp를 참조 바란다.

3.6 String.prototype.split(separator: string | RegExp, limit?: number): string[] ES3

첫번째 인수로 전달한 문자열 또는 정규표현식을 대상 문자열에서 검색하여 문자열을 구분한 후 분리된 각 문자열로 이루어진 배열을 반환한다. 원본 문자열은 변경되지 않는다.

인수가 없는 경우, 대상 문자열 전체를 단일 요소로 하는 배열을 반환한다.

/**
 * @param {string | RegExp} [separator] - 구분 대상 문자열 또는 정규표현식
 * @param {number} [limit] - 구분 대상수의 한계를 나타내는 정수
 * @return {string[]}
 */
str.split([separator[, limit]])

const str = 'How are you doing?';

// 공백으로 구분(단어로 구분)하여 배열로 반환한다
console.log(str.split(' ')); // [ 'How', 'are', 'you', 'doing?' ]

// 정규 표현식
console.log(str.split(/\s/)); // [ 'How', 'are', 'you', 'doing?' ]

// 인수가 없는 경우, 대상 문자열 전체를 단일 요소로 하는 배열을 반환한다.
console.log(str.split()); // [ 'How are you doing?' ]

// 각 문자를 모두 분리한다
console.log(str.split('')); // [ 'H','o','w',' ','a','r','e',' ','y','o','u',' ','d','o','i','n','g','?' ]

// 공백으로 구분하여 배열로 반환한다. 단 요소수는 3개까지만 허용한다
console.log(str.split(' ', 3)); // [ 'How', 'are', 'you' ]

// 'o'으로 구분하여 배열로 반환한다.
console.log(str.split('o')); // [ 'H', 'w are y', 'u d', 'ing?' ]

3.7 String.prototype.substring(start: number, end=this.length): string ES3

첫번째 인수로 전달한 start 인덱스에 해당하는 문자부터 두번째 인자에 전달된 end 인덱스에 해당하는 문자의 바로 이전 문자까지를 모두 반환한다. 이때 첫번째 인수 < 두번째 인수의 관계가 성립된다.

substring

substring

  • 첫번째 인수 > 두번째 인수 : 두 인수는 교환된다.
  • 두번째 인수가 생략된 경우 : 해당 문자열의 끝까지 반환한다.
  • 인수 < 0 또는 NaN인 경우 : 0으로 취급된다.
  • 인수 > 문자열의 길이(str.length) : 인수는 문자열의 길이(str.length)으로 취급된다.
/**
 * @param {number} start - 0 ~ 해당문자열 길이 -1 까지의 정수
 * @param {number} [end=this.length] - 0 ~ 해당문자열 길이까지의 정수
 * @return {string}
 */
str.substring(start[, end])

const str = 'Hello World'; // str.length == 11

console.log(str.substring(1, 4)); // ell

// 첫번째 인수 > 두번째 인수 : 두 인수는 교환된다.
console.log(str.substring(4, 1)); // ell

// 두번째 인수가 생략된 경우 : 해당 문자열의 끝까지 반환한다.
console.log(str.substring(4)); // o World

// 인수 < 0 또는 NaN인 경우 : 0으로 취급된다.
console.log(str.substring(-2)); // Hello World

// 인수 > 문자열의 길이(str.length) : 인수는 문자열의 길이(str.length)으로 취급된다.
console.log(str.substring(1, 12)); // ello World
console.log(str.substring(11)); // ''
console.log(str.substring(20)); // ''
console.log(str.substring(0, str.indexOf(' '))); // 'Hello'
console.log(str.substring(str.indexOf(' ') + 1, str.length)); // 'World'

3.8 String.prototype.slice(start?: number, end?: number): string ES3

String.prototype.substring과 동일하다. 단, String.prototype.slice는 음수의 인수를 전달할 수 있다.

const str = 'hello world';

// 인수 < 0 또는 NaN인 경우 : 0으로 취급된다.
console.log(str.substring(-5)); // 'hello world'
// 뒤에서 5자리를 잘라내어 반환한다.
console.log(str.slice(-5)); // 'world'

// 2번째부터 마지막 문자까지 잘라내어 반환
console.log(str.substring(2)); // llo world
console.log(str.slice(2)); // llo world

// 0번째부터 5번째 이전 문자까지 잘라내어 반환
console.log(str.substring(0, 5)); // hello
console.log(str.slice(0, 5)); // hello

3.9 String.prototype.toLowerCase(): string ES1

대상 문자열의 모든 문자를 소문자로 변경한다.

console.log('Hello World!'.toLowerCase()); // hello world!

3.10 String.prototype.toUpperCase(): string ES1

대상 문자열의 모든 문자를 대문자로 변경한다.

console.log('Hello World!'.toUpperCase()); // HELLO WORLD!

3.11 String.prototype.trim(): string ES5

대상 문자열 양쪽 끝에 있는 공백 문자를 제거한 문자열을 반환한다.

const str = '   foo  ';

console.log(str.trim()); // 'foo'

// String.prototype.replace
console.log(str.replace(/\s/g, ''));   // 'foo'
console.log(str.replace(/^\s+/g, '')); // 'foo  '
console.log(str.replace(/\s+$/g, '')); // '   foo'

// String.prototype.{trimStart,trimEnd} : Proposal stage 3
console.log(str.trimStart()); // 'foo  '
console.log(str.trimEnd());   // '   foo'

3.12 String.prototype.repeat(count: number): string ES6

인수로 전달한 숫자만큼 반복해 연결한 새로운 문자열을 반환한다. count가 0이면 빈 문자열을 반환하고 음수이면 RangeError를 발생시킨다.

console.log('abc'.repeat(0));   // ''
console.log('abc'.repeat(1));   // 'abc'
console.log('abc'.repeat(2));   // 'abcabc'
console.log('abc'.repeat(2.5)); // 'abcabc' (2.5 → 2)
console.log('abc'.repeat(-1));  // RangeError: Invalid count value

3.13 String​.prototype​.includes(searchString: string, position?: number): boolean ES6

인수로 전달한 문자열이 포함되어 있는지를 검사하고 결과를 불리언 값으로 반환한다. 두번째 인수는 옵션으로 검색할 위치를 나타내는 정수이다.

const str = 'hello world';

console.log(str.includes('hello')); // true
console.log(str.includes(' '));     // true
console.log(str.includes('wo'));    // true
console.log(str.includes('wow'));   // false
console.log(str.includes(''));      // true
console.log(str.includes());        // false

// String​.prototype​.indexOf 메소드로 대체할 수 있다.
console.log(str.indexOf('hello')); // 0

Reference

Back to top

HTML5

10 lessons
  1. 1 프런트엔드 개발자 학습 방향
  2. 2 HTML5 기본 문법
  3. 3 시맨틱 요소와 검색 엔진
  4. 4 웹페이지의 구성하는 기본 태그
  5. 5 텍스트 관련 태그
  6. 6 HTML의 핵심 개념인 Hyperlink
  7. 7 목록(List)와 표(Table) 형식 표현을 위한 태그
  8. 8 이미지의 표현과 동영상, 음악 등 멀티미디어를 지원하는 태그
  9. 9 사용자와의 커뮤니케이션을 위한 폼 태그
  10. 10 웹페이지의 레이아웃을 구성하기 위해 공간을 분할하는 태그

CSS3

22 lessons
  1. 1 CSS 기본 문법
  2. 2 셀렉터
  3. 3 CSS 프로퍼티 값의 단위
  4. 4 박스 모델
  5. 5 display, visibility, opacity 프로퍼티
  6. 6 백그라운드
  7. 7 폰트와 텍스트
  8. 8 요소의 위치 정의
  9. 9 요소 정렬
  10. 10 스타일의 상속과 적용 우선 순위
  11. 11 벤더 프리픽스
  12. 12 그림자
  13. 13 그레이디언트
  14. 14 트랜지션
  15. 15 애니메이션
  16. 16 트랜스폼
  17. 17 웹디자인 타이포그래피(Typography)
  18. 18 레이아웃
  19. 19 반응형 레이아웃
  20. 20 플렉스 박스 레이아웃
  21. 21 수평/수직 중앙 정렬
  22. 22 image 요소 아래에 패딩된 여분의 공간 제거하기

JavaScript

36 lessons
  1. 1 기본 개념과 동작 원리 이해의 중요성
  2. 2 자바스크립트란?
  3. 3 자바스크립트 개발 환경과 실행 방법
  4. 4 브라우저 동작 원리
  5. 5 자바스크립트의 기본 문법
  6. 6 데이터 타입과 변수
  7. 7 연산자
  8. 8 제어문
  9. 9 타입 변환과 단축 평가
  10. 10 객체
  11. 11 객체와 변경불가성(Immutability)
  12. 12 함수
  13. 13 타입 체크
  14. 14 프로토타입
  15. 15 스코프
  16. 16 보다 안정적인 자바스크립트 개발 환경을 위한 Strict mode
  17. 17 함수 호출 방식에 의해 결정되는 this
  18. 18 클로저
  19. 19 자바스크립트 객체지향 프로그래밍
  20. 20 빌트인 객체
  21. 21 전역 객체
  22. 22 Number 레퍼 객체
  23. 23 수학 상수와 함수를 위한 Math 객체
  24. 24 날짜와 시간을 위한 Date 객체
  25. 25 정규표현식
  26. 26 String 레퍼 객체
  27. 27 배열
  28. 28 자바스크립트 배열은 배열이 아니다
  29. 29 배열 고차 함수
  30. 30 문서 객체 모델(Document Object Model)
  31. 31 동기식 처리 모델 vs 비동기식 처리 모델
  32. 32 이벤트
  33. 33 디바이스의 방향 정보를 다루는 자바스크립트 이벤트
  34. 34 비동기식 처리 모델과 Ajax
  35. 35 REST(Representational State Transfer) API
  36. 36 Single Page Application & Routing

ECMAScript6

14 lessons
  1. 1 let, const와 블록 레벨 스코프
  2. 2 템플릿 리터럴
  3. 3 화살표 함수
  4. 4 매개변수 기본값, Rest 파라미터, Spread 문법, Rest/Spread 프로퍼티
  5. 5 객체 리터럴 프로퍼티 기능 확장
  6. 6 디스트럭처링
  7. 7 클래스
  8. 8 모듈
  9. 9 프로미스
  10. 10 7번째 타입 심볼(Symbol)
  11. 11 이터레이션과 for...of 문
  12. 12 제너레이터와 async/await
  13. 13 Babel과 Webpack을 이용한 ES6 환경 구축 ①
  14. 14 Babel과 Webpack을 이용한 ES6 환경 구축 ②

Angular

13 lessons
  1. 1 Angular의 소개와 특징
  2. 2 Angular CLI를 사용한 프로젝트의 생성, 구성요소 추가와 빌드
  3. 3 컴포넌트 소개와 기본 구조
  4. 4 템플릿과 템플릿 문법
  5. 5 데이터 바인딩
  6. 6 빌트인 디렉티브
  7. 7 서비스와 의존성 주입
  8. 8 Reactive Programming과 RxJS
  9. 9 Cold observable과 Hot observable
  10. 10 Token 기반 인증
  11. 11 Angular CLI 환경에서 jQuery 플러그인 사용하기
  12. 12 Angular 파일 업로드
  13. 13 Firebase를 사용한 Angular 애플리케이션 배포

Tools

12 lessons
  1. 1 ESLint
  2. 2 Jekyll와 GitHub Pages를 사용한 Static WebSite 구축
  3. 3 JSON Server
  4. 4 Docker를 사용하여 MySQL 설치하고 접속하기
  5. 5 Docker를 사용하여 MongoDB 설치하고 접속하기
  6. 6 Parcel
  7. 7 Storybook
  8. 8 Jest에서 import/export를 사용하기
  9. 9 JSDoc을 사용하여 자바스크립트에 타입 힌트 제공하기
  10. 10 폐지된 @babel/polyfill 대신 @babel/plugin-transform-runtime을 사용해 폴리필 추가하기
  11. 11 Webpack DevServer
  12. 12 tailwindcss + PostCSS + Webpack
Close