토파즈는 다양한 핵심 함수들을 내장으로 제공하여 개발을 효율적으로 만들어줍니다. 모든 함수들은 타입 안전성과 함수형 프로그래밍 패러다임을 지원합니다. 🚀
📝 문자열 함수
기본 문자열 조작
// 문자열 길이 및 기본 정보
let 문자열 = "안녕하세요 Topaz!"
let 길이 = 문자열.length() // 12
let 바이트길이 = 문자열.byteLength() // UTF-8 바이트 길이
let 비어있음 = 문자열.isEmpty() // false
// 대소문자 변환
let 소문자 = 문자열.toLowerCase() // "안녕하세요 topaz!"
let 대문자 = 문자열.toUpperCase() // "안녕하세요 TOPAZ!"
let 제목형식 = 문자열.toTitleCase() // "안녕하세요 Topaz!"
print("원본: {문자열}")
print("길이: {길이}")
print("소문자: {소문자}")문자열 검색 및 확인
let 텍스트 = "Topaz는 현대적인 프로그래밍 언어입니다"
// 문자열 검색
let 포함여부 = 텍스트.contains("현대적인") // true
let 시작확인 = 텍스트.startsWith("Topaz") // true
let 끝확인 = 텍스트.endsWith("언어입니다") // true
// 위치 찾기
let 인덱스 = 텍스트.indexOf("프로그래밍") // Some(9)
let 마지막인덱스 = 텍스트.lastIndexOf("언어") // Some(14)
// 정규표현식 매칭
let 패턴매치 = 텍스트.match(r"\w+") // 첫 번째 단어 매칭
let 모든매치 = 텍스트.matchAll(r"\w+") // 모든 단어 매칭
print("포함 여부: {포함여부}")
print("인덱스: {인덱스}")문자열 변환 및 분할
let 원본문자열 = " Hello, World, Topaz "
// 공백 제거
let 앞뒤공백제거 = 원본문자열.trim() // "Hello, World, Topaz"
let 앞공백제거 = 원본문자열.trimStart() // "Hello, World, Topaz "
let 뒤공백제거 = 원본문자열.trimEnd() // " Hello, World, Topaz"
// 문자열 분할 및 결합
let 분할결과 = "apple,banana,cherry".split(",") // ["apple", "banana", "cherry"]
let 결합결과 = 분할결과.join(" | ") // "apple | banana | cherry"
// 문자열 대체
let 대체결과 = "Hello World".replace("World", "Topaz") // "Hello Topaz"
let 모든대체 = "test test test".replaceAll("test", "code") // "code code code"
print("공백 제거: '{앞뒤공백제거}'")
print("분할 결과: {분할결과}")
print("대체 결과: {대체결과}")문자열 형식화
// 문자열 템플릿
let 이름 = "개발자"
let 나이 = 25
let 포맷문자열 = "안녕하세요, 저는 {이름}이고 {나이}살입니다."
print(포맷문자열)
// 고급 형식화
let 숫자 = 3.14159
let 형식화된숫자 = 숫자.toFixed(2) // "3.14"
let 지수표기 = 숫자.toExponential(2) // "3.14e+0"
// 문자열 패딩
let 패딩문자열 = "42"
let 왼쪽패딩 = 패딩문자열.padStart(5, "0") // "00042"
let 오른쪽패딩 = 패딩문자열.padEnd(5, "0") // "42000"
print("형식화된 숫자: {형식화된숫자}")
print("왼쪽 패딩: {왼쪽패딩}")🔢 숫자 함수
기본 수학 함수
// 기본 수학 연산
let 절댓값 = Math.abs(-42) // 42
let 최대값 = Math.max(10, 20, 30) // 30
let 최소값 = Math.min(10, 20, 30) // 10
let 제곱근 = Math.sqrt(16) // 4.0
// 반올림 함수들
let 소수 = 3.7
let 올림 = Math.ceil(소수) // 4
let 내림 = Math.floor(소수) // 3
let 반올림 = Math.round(소수) // 4
let 버림 = Math.trunc(소수) // 3
print("절댓값: {절댓값}")
print("제곱근: {제곱근}")
print("반올림: {반올림}")고급 수학 함수
// 지수 및 로그 함수
let 자연지수 = Math.exp(1) // e^1 ≈ 2.718
let 거듭제곱 = Math.pow(2, 3) // 2^3 = 8
let 자연로그 = Math.log(Math.E) // 1
let 상용로그 = Math.log10(100) // 2
let 이진로그 = Math.log2(8) // 3
// 삼각함수
let 라디안 = Math.PI / 4 // 45도
let 사인값 = Math.sin(라디안) // √2/2 ≈ 0.707
let 코사인값 = Math.cos(라디안) // √2/2 ≈ 0.707
let 탄젠트값 = Math.tan(라디안) // 1
// 역삼각함수
let 아크사인 = Math.asin(0.5) // π/6
let 아크코사인 = Math.acos(0.5) // π/3
let 아크탄젠트 = Math.atan(1) // π/4
print("자연지수: {자연지수}")
print("사인값: {사인값}")
print("아크사인: {아크사인}")숫자 유틸리티 함수
// 숫자 검증
let 숫자1 = 42
let 숫자2 = 3.14
let 무한대 = 1.0 / 0.0
let 비숫자 = 0.0 / 0.0
let 정수확인 = Number.isInteger(숫자1) // true
let 유한확인 = Number.isFinite(숫자2) // true
let 무한대확인 = Number.isInfinite(무한대) // true
let NaN확인 = Number.isNaN(비숫자) // true
// 숫자 변환
let 정수변환 = Number.parseInt("42") // Ok(42)
let 실수변환 = Number.parseFloat("3.14") // Ok(3.14)
let 진법변환 = Number.parseInt("1010", 2) // Ok(10) - 이진수
print("정수 확인: {정수확인}")
print("진법 변환: {진법변환}")범위 및 제약 함수
// 값 범위 제한
function clamp(값: float, 최소: float, 최대: float) -> float {
return Math.max(최소, Math.min(값, 최대))
}
let 제한된값 = clamp(15, 10, 20) // 15
let 제한된값2 = clamp(5, 10, 20) // 10
let 제한된값3 = clamp(25, 10, 20) // 20
// 선형 보간
function lerp(시작: float, 끝: float, 비율: float) -> float {
return 시작 + (끝 - 시작) * 비율
}
let 보간값 = lerp(0, 100, 0.5) // 50.0
// 값 정규화
function normalize(값: float, 최소: float, 최대: float) -> float {
return (값 - 최소) / (최대 - 최소)
}
let 정규화값 = normalize(150, 100, 200) // 0.5
print("제한된 값: {제한된값}")
print("보간 값: {보간값}")
print("정규화 값: {정규화값}")📚 배열 함수
기본 배열 조작
let 숫자배열 = [1, 2, 3, 4, 5]
// 배열 정보
let 배열길이 = 숫자배열.length() // 5
let 비어있음 = 숫자배열.isEmpty() // false
// 요소 접근
let 첫번째 = 숫자배열.first() // Some(1)
let 마지막 = 숫자배열.last() // Some(5)
let 인덱스접근 = 숫자배열.get(2) // Some(3)
// 요소 추가/제거
let mut 가변배열 = [1, 2, 3]
가변배열.push(4) // [1, 2, 3, 4]
let 제거된요소 = 가변배열.pop() // Some(4), 배열은 [1, 2, 3]
가변배열.unshift(0) // [0, 1, 2, 3]
let 앞요소제거 = 가변배열.shift() // Some(0), 배열은 [1, 2, 3]
print("배열 길이: {배열길이}")
print("첫 번째 요소: {첫번째}")
print("가변 배열: {가변배열}")함수형 배열 메서드
let 숫자들 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
// map - 변환
let 제곱배열 = 숫자들.map(x => x * x) // [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
let 문자열배열 = 숫자들.map(x => x.toString()) // ["1", "2", "3", ...]
// filter - 필터링
let 짝수배열 = 숫자들.filter(x => x % 2 == 0) // [2, 4, 6, 8, 10]
let 큰수배열 = 숫자들.filter(x => x > 5) // [6, 7, 8, 9, 10]
// reduce - 누적
let 합계 = 숫자들.reduce((누적, 현재) => 누적 + 현재, 0) // 55
let 곱 = 숫자들.reduce((누적, 현재) => 누적 * 현재, 1) // 3628800
// find - 검색
let 찾은수 = 숫자들.find(x => x > 5) // Some(6)
let 찾은인덱스 = 숫자들.findIndex(x => x > 5) // Some(5)
print("제곱 배열: {제곱배열}")
print("짝수 배열: {짝수배열}")
print("합계: {합계}")
print("찾은 수: {찾은수}")배열 검증 및 확인
let 테스트배열 = [2, 4, 6, 8, 10]
// every - 모든 요소 확인
let 모두짝수 = 테스트배열.every(x => x % 2 == 0) // true
let 모두큰수 = 테스트배열.every(x => x > 5) // false
// some - 일부 요소 확인
let 일부큰수 = 테스트배열.some(x => x > 5) // true
let 일부홀수 = 테스트배열.some(x => x % 2 == 1) // false
// includes - 포함 확인
let 포함6 = 테스트배열.includes(6) // true
let 포함7 = 테스트배열.includes(7) // false
// indexOf - 인덱스 찾기
let 인덱스6 = 테스트배열.indexOf(6) // Some(2)
let 인덱스7 = 테스트배열.indexOf(7) // None
print("모두 짝수: {모두짝수}")
print("일부 큰수: {일부큰수}")
print("6 포함: {포함6}")배열 정렬 및 변환
let 무작위배열 = [3, 1, 4, 1, 5, 9, 2, 6]
// 정렬
let 오름차순 = 무작위배열.sort() // [1, 1, 2, 3, 4, 5, 6, 9]
let 내림차순 = 무작위배열.sortBy((a, b) => b - a) // [9, 6, 5, 4, 3, 2, 1, 1]
// 중복 제거
let 유니크배열 = 무작위배열.unique() // [3, 1, 4, 5, 9, 2, 6]
// 배열 뒤집기
let 뒤집힌배열 = 무작위배열.reverse() // [6, 2, 9, 5, 1, 4, 1, 3]
// 배열 연결
let 배열1 = [1, 2, 3]
let 배열2 = [4, 5, 6]
let 연결배열 = 배열1.concat(배열2) // [1, 2, 3, 4, 5, 6]
// 배열 분할
let 분할배열 = [1, 2, 3, 4, 5, 6].slice(2, 5) // [3, 4, 5]
print("정렬된 배열: {오름차순}")
print("유니크 배열: {유니크배열}")
print("연결 배열: {연결배열}")🏗️ 객체 함수
객체 검사 및 조작
let 사용자객체 = {
이름: "김개발",
나이: 28,
직업: "개발자",
기술: ["Topaz", "Rust", "TypeScript"]
}
// 객체 키/값 가져오기
let 키배열 = Object.keys(사용자객체) // ["이름", "나이", "직업", "기술"]
let 값배열 = Object.values(사용자객체) // ["김개발", 28, "개발자", [...]]
let 엔트리배열 = Object.entries(사용자객체) // [["이름", "김개발"], ...]
// 속성 존재 확인
let 이름있음 = Object.hasOwnProperty(사용자객체, "이름") // true
let 주소있음 = Object.hasOwnProperty(사용자객체, "주소") // false
// 객체 병합
let 추가정보 = { 주소: "서울", 이메일: "dev@example.com" }
let 병합객체 = Object.assign(사용자객체, 추가정보)
print("키 배열: {키배열}")
print("이름 있음: {이름있음}")객체 변환 및 복사
let 원본객체 = {
데이터: {
숫자: 42,
문자열: "안녕",
배열: [1, 2, 3]
},
설정: {
활성화: true,
버전: "1.0"
}
}
// 얕은 복사
let 얕은복사 = Object.assign({}, 원본객체)
// 깊은 복사
let 깊은복사 = Object.deepClone(원본객체)
// 객체 동결 및 밀봉
let 동결객체 = Object.freeze(원본객체) // 불변 객체
let 밀봉객체 = Object.seal(원본객체) // 속성 추가/삭제 불가
// 객체 속성 정의
let 새객체 = {}
Object.defineProperty(새객체, "읽기전용속성", {
value: "변경불가",
writable: false,
enumerable: true
})
print("깊은 복사: {깊은복사}")
print("동결 상태: {Object.isFrozen(동결객체)}")🎯 유틸리티 함수
JSON 처리
let 데이터객체 = {
이름: "Topaz",
버전: "1.0.0",
기능: ["안전성", "성능", "편의성"]
}
// JSON 직렬화/역직렬화
let JSON문자열 = JSON.stringify(데이터객체)
print("JSON: {JSON문자열}")
match JSON.parse(JSON문자열) {
case Ok(파싱객체) => print("파싱 성공: {파싱객체}")
case Err(오류) => print("파싱 실패: {오류}")
}
// 예쁜 JSON 출력
let 예쁜JSON = JSON.stringify(데이터객체, null, 2)
print("예쁜 JSON:\n{예쁜JSON}")타입 확인 함수
// 패턴 매칭을 활용한 런타임 타입 확인
function getType(값: any) -> string {
match 값 {
case null => "null"
case _: Array<any> => "array"
case _: Date => "date"
case _: int => "int"
case _: float => "float"
case _: string => "string"
case _: bool => "boolean"
case _ => "object"
}
}
let 다양한값들 = [
42,
"문자열",
[1, 2, 3],
{ 키: "값" },
null,
true,
Date.now()
]
for 값 in 다양한값들 {
print("값: {값}, 타입: {getType(값)}")
}동시성 유틸리티
// concurrent 블록을 사용한 병렬 실행 (개념 예시)
function 작업(label: string, ms: int) -> string {
// 작업 시뮬레이션 (구현 의존)
// sleep(ms)
return "{label} 완료"
}
let 결과들 = concurrent(timeout: 3s) {
빠름: 작업("작업1", 1000)
보통: 작업("작업2", 1500)
느림: 작업("작업3", 2000)
} else {
대체: "부분 결과"
}
print("동시 실행 결과: {결과들}")함수형 유틸리티
// 커링
function curry<A, B, C>(함수: (A, B) -> C) -> (A) -> (B) -> C {
return (a: A) => (b: B) => 함수(a, b)
}
let 더하기 = (a: int, b: int) => a + b
let 커링된더하기 = curry(더하기)
let 5더하기 = 커링된더하기(5)
print("5 + 3 = {5더하기(3)}")
// 파이프라인
function pipe<A, B, C>(함수1: (A) -> B, 함수2: (B) -> C) -> (A) -> C {
return (입력: A) => 함수2(함수1(입력))
}
let 두배하기 = (x: int) => x * 2
let 문자열로 = (x: int) => x.toString()
let 처리파이프 = pipe(두배하기, 문자열로)
print("파이프라인 결과: {처리파이프(21)}") // "42"
// 메모이제이션
function memoize<T, R>(함수: (T) -> R) -> (T) -> R {
let mut 캐시: Map<T, R> = Map.new()
return (입력: T) => {
if 캐시.has(입력) {
return 캐시.get(입력).unwrap()
}
let 결과 = 함수(입력)
캐시.set(입력, 결과)
return 결과
}
}
// 피보나치 예제
let 피보나치 = memoize((n: int) => {
if n <= 1 { return n }
return 피보나치(n - 1) + 피보나치(n - 2)
})
print("피보나치 10: {피보나치(10)}")🔧 시스템 함수
환경 및 시간
// 환경 정보
let 현재시간 = Date.now() // 현재 타임스탬프
let 현재날짜 = Date.today() // 오늘 날짜
let ISO문자열 = Date.now().toISOString() // ISO 8601 형식
// 시간 계산
let 하루후 = Date.now().addDays(1)
let 일주일전 = Date.now().subtractWeeks(1)
let 한달후 = Date.now().addMonths(1)
print("현재 시간: {현재시간}")
print("ISO 문자열: {ISO문자열}")
// 환경 변수 (런타임에 따라 다름)
let 환경변수 = System.getEnv("PATH")
let 작업디렉토리 = System.getCurrentDir()
print("작업 디렉토리: {작업디렉토리}")랜덤 함수
// 기본 랜덤
let 랜덤수 = Math.random() // 0.0 ~ 1.0
let 랜덤정수 = Math.randomInt(1, 100) // 1 ~ 100
let 랜덤불린 = Math.randomBool() // true 또는 false
// 배열에서 랜덤 선택
let 색상배열 = ["빨강", "파랑", "초록", "노랑"]
let 랜덤색상 = 색상배열.randomChoice() // 랜덤 색상
// 배열 셞플
let 카드덱 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let 섞인덱 = 카드덱.shuffle()
print("랜덤 수: {랜덤수}")
print("랜덤 정수: {랜덤정수}")
print("랜덤 색상: {랜덤색상}")
print("섞인 덱: {섞인덱}")토파즈의 핵심 함수들은 개발을 더욱 효율적이고 안전하게 만들어줍니다. 모든 함수는 타입 안전성을 보장하며 함수형 프로그래밍 스타일을 지원합니다! 🎯