ㅎ 한글스크립트0.8 문서

표준 기능 전체

61개 한글 기본 함수의 타입·동작·실행 예제. 기본 이름은 같은 파일의 최상위 선언에서 중복 정의하지 마세요. 타입 표기는 내부 TypeScript 서명이며 실행 예제는 문장형 HGS입니다.

기본

출력

값을 콘솔에 출력합니다.

출력(...값: unknown[]): void

원본을 변경하지 않습니다.

출력("안녕", 1)
실행 화면에서 열기 ↗

기본

길이

문자열·목록의 길이 또는 집합·사전의 항목 수입니다.

길이(값: string | readonly unknown[] | ReadonlySet<unknown> | ReadonlyMap<unknown, unknown>): number

원본을 변경하지 않습니다.

출력(길이(집합([1, 1, 2])))
실행 화면에서 열기 ↗

목록

추가

기존 목록의 끝에 값을 추가합니다.

추가<T>(목록: T[], 값: T): void

원본 변경

값은 [1]이다
추가(값, 2)
출력(값)
실행 화면에서 열기 ↗

기본

포함

목록 또는 집합에 같은 값이 있는지 확인합니다.

포함<T>(목록: readonly T[] | ReadonlySet<T>, 값: T): boolean

SameValueZero 비교: NaN은 같고 객체는 참조로 비교

출력(포함(집합([1, 2]), 2))
실행 화면에서 열기 ↗

문자열

나누기

구분자로 문자열을 나눠 목록을 만듭니다.

나누기(글: string, 구분: string): string[]

원본을 변경하지 않습니다.

출력(나누기("사과,배", ","))
실행 화면에서 열기 ↗

문자열

잇기

목록의 값들을 구분자로 이어 문자열로 만듭니다.

잇기(목록: readonly unknown[], 구분 = ""): string

원본을 변경하지 않습니다.

출력(잇기(["사과", "배"], " · "))
실행 화면에서 열기 ↗

숫자

합계

숫자 목록의 합입니다. 빈 목록의 합은 0입니다.

합계(값: readonly number[]): number

원본을 변경하지 않습니다.

출력(합계([1, 2, 3]))
실행 화면에서 열기 ↗

숫자

숫자로

문자열 또는 숫자를 유한한 숫자로 바꿉니다.

숫자로(값: string | number): number

빈 문자열·숫자가 아닌 값·무한대는 오류

출력(숫자로("42"))
실행 화면에서 열기 ↗

문자열

다듬기

문자열 앞뒤 공백을 제거합니다.

다듬기(글: string): string

원본을 변경하지 않습니다.

출력(다듬기("  한글  "))
실행 화면에서 열기 ↗

숫자

반올림

소수 자릿수를 지정해 반올림합니다.

반올림(값: number, 자리 = 0): number

자리는 -10~10의 정수. JavaScript 부동소수점 규칙 적용

출력(반올림(3.14159, 2))
실행 화면에서 열기 ↗

숫자

평균

숫자 목록의 평균입니다.

평균(목록: readonly number[]): number

빈 목록은 오류

출력(평균([10, 20]))
실행 화면에서 열기 ↗

숫자

최솟값

숫자 목록에서 가장 작은 값을 찾습니다.

최솟값(목록: readonly number[]): number

빈 목록은 오류

출력(최솟값([3, 1, 2]))
실행 화면에서 열기 ↗

숫자

최댓값

숫자 목록에서 가장 큰 값을 찾습니다.

최댓값(목록: readonly number[]): number

빈 목록은 오류

출력(최댓값([3, 1, 2]))
실행 화면에서 열기 ↗

정렬

정렬

새 목록을 숫자 크기 또는 한국어 문자열 순서로 정렬합니다. 비교 함수를 전달할 수도 있습니다.

정렬<T extends number | string>(값: readonly T[]): T[]
정렬<T>(값: readonly T[], 비교: (가: T, 나: T) => number): T[]

원본 유지. 안정 정렬. 서로 다른 타입 혼합·비유한 숫자는 기본 정렬에서 오류

출력(정렬([3, 1, 2]))
실행 화면에서 열기 ↗

목록

범위

시작 이상·끝 미만의 숫자 목록을 만듭니다. 인자 하나면 0부터 시작합니다.

범위(시작: number, 끝?: number, 간격 = 1): number[]

간격 0·비유한 숫자·10만 개 초과는 오류

출력(범위(5, 0, -2))
실행 화면에서 열기 ↗

목록

목록으로

문자열·집합 등 순회 가능한 값을 배열로 바꿉니다.

목록으로<T>(값: Iterable<T>): T[]

새 배열. 문자열은 유니코드 코드 포인트 단위

출력(목록으로(집합([1, 2])))
실행 화면에서 열기 ↗

목록

첫번째

첫 항목을 읽습니다.

첫번째<T>(값: readonly T[]): T | undefined

빈 목록이면 정의안됨

출력(첫번째([10, 20]))
실행 화면에서 열기 ↗

목록

마지막

마지막 항목을 읽습니다.

마지막<T>(값: readonly T[]): T | undefined

빈 목록이면 정의안됨

출력(마지막([10, 20]))
실행 화면에서 열기 ↗

목록

꺼내기

지정 순서의 값을 읽습니다. 음수는 뒤에서 셉니다.

꺼내기<T>(값: readonly T[], 순서: number): T | undefined

삭제하지 않음. 범위 밖이면 정의안됨

출력(꺼내기([10, 20, 30], -1))
실행 화면에서 열기 ↗

목록

각각바꾸기

항목마다 함수를 적용해 새 목록을 만듭니다.

각각바꾸기<T, U>(값: readonly T[], 바꿀: (항목: T, 순서: number) => U): U[]

원본을 변경하지 않습니다.

출력(각각바꾸기([1, 2], 값 => 값 * 2))
실행 화면에서 열기 ↗

목록

골라내기

조건을 만족하는 항목만 남깁니다.

골라내기<T>(값: readonly T[], 조건: (항목: T, 순서: number) => boolean): T[]

원본을 변경하지 않습니다.

출력(골라내기([1, 2, 3], 값 => 값 >= 2))
실행 화면에서 열기 ↗

목록

찾기

조건을 만족하는 첫 항목을 찾습니다.

찾기<T>(값: readonly T[], 조건: (항목: T, 순서: number) => boolean): T | undefined

없으면 정의안됨

출력(찾기([1, 2, 3], 값 => 값 > 1))
실행 화면에서 열기 ↗

목록

순서찾기

조건을 만족하는 첫 항목의 0부터 시작하는 순서를 찾습니다.

순서찾기<T>(값: readonly T[], 조건: (항목: T, 순서: number) => boolean): number

없으면 -1

출력(순서찾기([1, 2, 3], 값 => 값 > 1))
실행 화면에서 열기 ↗

목록

모두만족

모든 항목이 조건을 만족하는지 확인합니다.

모두만족<T>(값: readonly T[], 조건: (항목: T) => boolean): boolean

빈 목록이면 참

출력(모두만족([2, 4], 값 => 값 % 2 === 0))
실행 화면에서 열기 ↗

목록

하나라도만족

하나 이상의 항목이 조건을 만족하는지 확인합니다.

하나라도만족<T>(값: readonly T[], 조건: (항목: T) => boolean): boolean

빈 목록이면 거짓

출력(하나라도만족([1, 2], 값 => 값 % 2 === 0))
실행 화면에서 열기 ↗

목록

누적하기

시작값부터 항목을 차례로 합쳐 하나의 값으로 만듭니다.

누적하기<T, U>(값: readonly T[], 시작: U, 합칠: (누적: U, 항목: T, 순서: number) => U): U

빈 목록이면 시작값

출력(누적하기([1, 2, 3], 0, (합, 값) => 합 + 값))
실행 화면에서 열기 ↗

목록

잘라내기

시작 이상·끝 미만의 구간을 새 목록으로 복사합니다.

잘라내기<T>(값: readonly T[], 시작: number, 끝?: number): T[]

원본 유지. 음수 순서 지원

출력(잘라내기([10, 20, 30], 1, 3))
실행 화면에서 열기 ↗

목록

이어붙이기

여러 목록을 이어 새 목록을 만듭니다.

이어붙이기<T>(...목록들: readonly (readonly T[])[]): T[]

원본을 변경하지 않습니다.

출력(이어붙이기([1, 2], [3]))
실행 화면에서 열기 ↗

목록

뒤집기

역순의 새 목록을 만듭니다.

뒤집기<T>(값: readonly T[]): T[]

원본 유지

출력(뒤집기([1, 2, 3]))
실행 화면에서 열기 ↗

목록

펼치기

한 단계 중첩된 목록을 펼칩니다.

펼치기<T>(값: readonly (readonly T[])[]): T[]

한 단계만 펼침. 재귀 평탄화 아님

출력(펼치기([[1, 2], [3]]))
실행 화면에서 열기 ↗

목록

나눠묶기

정해진 크기의 묶음들로 나눕니다.

나눠묶기<T>(값: readonly T[], 크기: number): T[][]

크기는 1 이상의 안전한 정수. 마지막 묶음은 짧을 수 있음

출력(나눠묶기([1, 2, 3, 4, 5], 2))
실행 화면에서 열기 ↗

목록

짝짓기

두 목록에서 같은 순서의 값끼리 짝을 만듭니다.

짝짓기<T, U>(가: readonly T[], 나: readonly U[]): [T, U][]

짧은 목록의 길이에 맞춤

출력(짝짓기([1, 2], ["가", "나"]))
실행 화면에서 열기 ↗

집합

중복제거

같은 항목을 한 번씩만 남긴 새 목록을 만듭니다.

중복제거<T>(값: Iterable<T>): T[]

첫 등장 순서 유지. 객체는 참조 비교

출력(중복제거([1, 1, 2]))
실행 화면에서 열기 ↗

집합

집합

중복을 허용하지 않는 Set을 만듭니다.

집합<T>(값: Iterable<T> = []): Set<T>

삽입 순서 유지. 중복 기준은 포함과 동일

출력(목록으로(집합([1, 1, 2])))
실행 화면에서 열기 ↗

집합

집합에추가

기존 집합에 항목을 추가합니다.

집합에추가<T>(값: Set<T>, 항목: T): Set<T>

원본 변경

값은 집합([1])이다
집합에추가(값, 2)
출력(목록으로(값))
실행 화면에서 열기 ↗

집합

집합에서삭제

기존 집합에서 항목을 삭제하고 삭제 여부를 돌려줍니다.

집합에서삭제<T>(값: Set<T>, 항목: T): boolean

원본 변경

값은 집합([1, 2])이다
출력(집합에서삭제(값, 1))
실행 화면에서 열기 ↗

집합

합집합

두 집합의 모든 항목으로 새 집합을 만듭니다.

합집합<T>(가: ReadonlySet<T>, 나: ReadonlySet<T>): Set<T>

원본을 변경하지 않습니다.

출력(목록으로(합집합(집합([1, 2]), 집합([2, 3]))))
실행 화면에서 열기 ↗

집합

교집합

두 집합에 공통인 항목으로 새 집합을 만듭니다.

교집합<T>(가: ReadonlySet<T>, 나: ReadonlySet<T>): Set<T>

원본을 변경하지 않습니다.

출력(목록으로(교집합(집합([1, 2]), 집합([2, 3]))))
실행 화면에서 열기 ↗

집합

차집합

첫 집합에서 두 번째 집합에 없는 항목을 남깁니다.

차집합<T>(가: ReadonlySet<T>, 나: ReadonlySet<T>): Set<T>

원본을 변경하지 않습니다.

출력(목록으로(차집합(집합([1, 2]), 집합([2, 3]))))
실행 화면에서 열기 ↗

집합

대칭차집합

둘 중 한 집합에만 있는 항목을 남깁니다.

대칭차집합<T>(가: ReadonlySet<T>, 나: ReadonlySet<T>): Set<T>

원본을 변경하지 않습니다.

출력(목록으로(대칭차집합(집합([1, 2]), 집합([2, 3]))))
실행 화면에서 열기 ↗

집합

부분집합인가

첫 집합의 모든 항목이 두 번째 집합에 있는지 확인합니다.

부분집합인가<T>(가: ReadonlySet<T>, 나: ReadonlySet<T>): boolean

원본을 변경하지 않습니다.

출력(부분집합인가(집합([1]), 집합([1, 2])))
실행 화면에서 열기 ↗

사전

사전

키와 값의 쌍에서 Map을 만듭니다.

사전<K, V>(항목: Iterable<readonly [K, V]> = []): Map<K, V>

키는 문자열 이외 타입도 가능. 같은 키는 마지막 값 사용

표: 사전<문자열, 숫자>는 사전()이다
사전에담기(표, "사과", 3)
출력(사전에서읽기(표, "사과"))
실행 화면에서 열기 ↗

사전

사전에담기

기존 사전에 키와 값을 저장합니다.

사전에담기<K, V>(대상: Map<K, V>, 키: K, 값: V): Map<K, V>

원본 변경. 같은 키의 값은 덮어씀

표: 사전<문자열, 숫자>는 사전()이다
사전에담기(표, "사과", 3)
출력(값목록(표))
실행 화면에서 열기 ↗

사전

사전에서읽기

키에 대응하는 값을 읽습니다.

사전에서읽기<K, V>(대상: ReadonlyMap<K, V>, 키: K): V | undefined

없는 키는 정의안됨

표는 사전([["사과", 3]])이다
출력(사전에서읽기(표, "사과"))
실행 화면에서 열기 ↗

사전

사전에있는가

키의 존재 여부를 확인합니다.

사전에있는가<K, V>(대상: ReadonlyMap<K, V>, 키: K): boolean

원본을 변경하지 않습니다.

표는 사전([["사과", 3]])이다
출력(사전에있는가(표, "사과"))
실행 화면에서 열기 ↗

사전

사전에서삭제

기존 사전의 키와 값을 삭제합니다.

사전에서삭제<K, V>(대상: Map<K, V>, 키: K): boolean

원본 변경. 삭제 여부 반환

표는 사전([["사과", 3]])이다
출력(사전에서삭제(표, "사과"))
실행 화면에서 열기 ↗

사전

키목록

삽입 순서대로 키를 새 목록에 담습니다.

키목록<K, V>(대상: ReadonlyMap<K, V>): K[]

원본을 변경하지 않습니다.

출력(키목록(사전([["사과", 3]])))
실행 화면에서 열기 ↗

사전

값목록

삽입 순서대로 값을 새 목록에 담습니다.

값목록<K, V>(대상: ReadonlyMap<K, V>): V[]

원본을 변경하지 않습니다.

출력(값목록(사전([["사과", 3]])))
실행 화면에서 열기 ↗

사전

항목목록

삽입 순서대로 키·값 쌍을 새 목록에 담습니다.

항목목록<K, V>(대상: ReadonlyMap<K, V>): [K, V][]

원본을 변경하지 않습니다.

출력(항목목록(사전([["사과", 3]])))
실행 화면에서 열기 ↗

사전

기준으로묶기

같은 기준값의 항목들을 Map에 묶습니다.

기준으로묶기<T, K>(값: readonly T[], 기준: (항목: T) => K): Map<K, T[]>

키의 첫 등장 순서와 그룹 안 원래 순서 유지

출력(항목목록(기준으로묶기([1, 2, 3, 4], 값 => 값 % 2)))
실행 화면에서 열기 ↗

복사

얕게복사

바깥 목록·집합·사전·일반 객체를 새로 만듭니다.

얕게복사<T extends object>(값: T): T

중첩 객체 참조는 공유. 클래스·Date 등은 미지원

원본은 [{ 점수: 10 }]이다
복사본은 얕게복사(원본)이다
복사본[0].점수 = 20
출력(원본[0].점수)
실행 화면에서 열기 ↗

복사

깊게복사

중첩된 복제 가능 값까지 독립적으로 복제합니다.

깊게복사<T>(값: T): T

structuredClone 사용. 순환 참조·Set·Map·Date 지원. 함수·DOM 노드 등은 오류

원본은 [{ 점수: 10 }]이다
복사본은 깊게복사(원본)이다
복사본[0].점수 = 20
출력(원본[0].점수)
실행 화면에서 열기 ↗

정렬

오름차순

작은 숫자·앞서는 문자열부터 정렬합니다.

오름차순<T extends number | string>(값: readonly T[]): T[]

원본 유지. 문자열은 한국어 locale, 숫자 문자열 자연 정렬

출력(오름차순([3, 1, 2]))
실행 화면에서 열기 ↗

정렬

내림차순

큰 숫자·뒤서는 문자열부터 정렬합니다.

내림차순<T extends number | string>(값: readonly T[]): T[]

원본 유지. 같은 키의 원래 순서 유지

출력(내림차순([3, 1, 2]))
실행 화면에서 열기 ↗

정렬

기준정렬

각 항목의 기준값으로 정렬합니다.

기준정렬<T>(값: readonly T[], 기준: (항목: T) => number | string, 방향: "오름차순" | "내림차순" = "오름차순"): T[]

기준 함수는 항목마다 한 번 호출. 원본 유지. 세 번째 인자는 오름차순 또는 내림차순

사람들은 [{ 이름: "나", 나이: 30 }, { 이름: "가", 나이: 20 }]이다
출력(기준정렬(사람들, 사람 => 사람.나이))
실행 화면에서 열기 ↗

검증

확인한다

조건을 만족하지 못하면 설명과 함께 오류를 발생시킵니다.

확인한다(조건: unknown, 설명 = "확인 조건을 만족하지 못했습니다."): asserts 조건

참인 조건은 타입을 좁힘. 실행 중 검사이며 정적 증명 아님

나이는 20이다
확인한다(나이 >= 0, "나이는 0 이상이어야 합니다")
출력(나이)
실행 화면에서 열기 ↗

화면

숫자입력

이름과 기본값으로 숫자 입력창을 만듭니다.

숫자입력(이름: string, 기본값 = 0): number

원본을 변경하지 않습니다.

가격은 숫자입력("가격", 10000)이다
보여주기("가격", 가격)
실행 화면에서 열기 ↗

화면

글자입력

문자열 입력창을 만듭니다.

글자입력(이름: string, 기본값 = ""): string

원본을 변경하지 않습니다.

이름은 글자입력("이름", "하늘")이다
보여주기("인사", 이름)
실행 화면에서 열기 ↗

화면

선택입력

선택 항목으로 드롭다운을 만듭니다.

선택입력(이름: string, 항목: string[], 기본값 = 항목[0]): string

원본을 변경하지 않습니다.

선택은 선택입력("과일", ["사과", "배"], "사과")이다
보여주기("선택", 선택)
실행 화면에서 열기 ↗

화면

버튼

누른 버튼인지 확인합니다. 문장형 블록도 사용할 수 있습니다.

버튼(이름: string): boolean

원본을 변경하지 않습니다.

"확인" 버튼을 누르면:
    보여주기("결과", "완료")
실행 화면에서 열기 ↗

화면

보여주기

이름과 값을 UI 결과 항목으로 등록합니다. 데모는 콘솔에 표시합니다.

보여주기(이름: string, 값: unknown): void

원본을 변경하지 않습니다.

보여주기("합계", 합계([1, 2, 3]))
실행 화면에서 열기 ↗