# 헬퍼
## 소개
Nylo은 정적 유틸리티 클래스 집합 — `Arr`, `Str`, `Number`, `Obj` — 과 일반적인 작업을 위한 전역 헬퍼 함수를 제공합니다. 이것들은 모두 `nylo_framework`에서 내보내집니다:
``` dart
import 'package:nylo_framework/nylo_framework.dart';
Arr.first([1, 2, 3]); // 1
Str.slug('Hello World'); // 'hello-world'
Number.currency(1234.56); // '$1,234.56'
Obj.get(user, 'profile.name'); // 'Anna'
```
> **참고:** `Backpack`, `NyStorage`, `NyCache`, `NyLogger`는 전용 페이지가 있습니다: [Backpack](/docs/7.x/backpack), [Storage](/docs/7.x/storage), [Cache](/docs/7.x/cache), [Logging](/docs/7.x/logging).
## 사용 가능한 메서드
### 배열
### 문자열
### 숫자
### 객체
### 기타
## 배열
#### `Arr.accessible()`
주어진 값이 배열 접근 가능(`List` 또는 `Map`)한지 여부를 판단합니다:
``` dart
Arr.accessible([1, 2, 3]); // true
Arr.accessible({'a': 1}); // true
Arr.accessible('hello'); // false
Arr.accessible(null); // false
```
#### `Arr.average()`
리스트의 산술 평균을 반환합니다. 비어 있으면 `0`을 반환합니다. `by`를 전달하면 각 요소에서 숫자를 추출합니다:
``` dart
Arr.average([2, 4, 6]); // 4.0
Arr.average(orders, by: (o) => o.total); // 총액의 평균
```
#### `Arr.chunk()`
리스트를 주어진 크기의 청크로 분할합니다:
``` dart
Arr.chunk([1, 2, 3, 4, 5], 2);
// [[1, 2], [3, 4], [5]]
```
#### `Arr.collapse()`
리스트의 리스트를 단일 리스트로 평탄화합니다:
``` dart
Arr.collapse([[1, 2], [3, 4], [5]]);
// [1, 2, 3, 4, 5]
```
#### `Arr.countBy()`
리스트에서 발생 횟수를 계산하며, 선택적으로 값 추출기로 그룹화합니다:
``` dart
Arr.countBy(['a', 'b', 'a', 'c']);
// {'a': 2, 'b': 1, 'c': 1}
Arr.countBy(orders, by: (o) => o.status);
// {'paid': 12, 'pending': 3}
```
#### `Arr.crossJoin()`
주어진 리스트를 교차 결합하여 가능한 모든 조합을 반환합니다:
``` dart
Arr.crossJoin([[1, 2], ['a', 'b']]);
// [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
```
#### `Arr.every()`
리스트의 모든 요소가 조건자를 통과할 때 `true`를 반환합니다. 빈 리스트는 항진 명제로 처리됩니다:
``` dart
Arr.every([2, 4, 6], (n) => n.isEven); // true
Arr.every([1, 2, 3], (n) => n.isEven); // false
```
#### `Arr.exceptValues()`
주어진 각 값이 제거된 리스트를 반환합니다:
``` dart
Arr.exceptValues([1, 2, 3, 4], [2, 4]); // [1, 3]
```
#### `Arr.first()`
조건자와 일치하는 첫 번째 요소 또는 기본값을 반환합니다:
``` dart
Arr.first([1, 2, 3]); // 1
Arr.first([1, 2, 3, 4], predicate: (n) => n.isEven); // 2
Arr.first([], defaultValue: 99); // 99
```
#### `Arr.flatMap()`
각 요소를 `fn`으로 매핑하고 결과 이터러블을 평탄화합니다:
``` dart
Arr.flatMap(pages, (p) => p.items); // 모든 페이지의 모든 항목
Arr.flatMap([1, 2, 3], (n) => [n, n * 10]); // [1, 10, 2, 20, 3, 30]
```
#### `Arr.flatten()`
중첩된 이터러블을 단일 레벨 리스트로 평탄화합니다. `depth`는 평탄화할 깊이를 제한하며, `-1`은 무제한을 의미합니다:
``` dart
Arr.flatten([1, [2, [3]]]); // [1, 2, 3]
Arr.flatten([1, [2, [3]]], depth: 1); // [1, 2, [3]]
```
#### `Arr.groupBy()`
`by`가 반환하는 값을 키로 사용하여 리스트를 맵으로 그룹화합니다:
``` dart
Arr.groupBy(messages, (m) => m.date);
// {2024-01-01: [...], 2024-01-02: [...]}
```
#### `Arr.indexed()`
각 요소를 인덱스와 쌍으로 연결하여 `(index, value)` 레코드 리스트를 반환합니다:
``` dart
for (final (i, v) in Arr.indexed(['a', 'b', 'c'])) {
print('$i: $v'); // '0: a', '1: b', '2: c'
}
```
#### `Arr.interleave()`
모든 요소 쌍 사이에 구분자를 삽입합니다. 구분자가 있는 위젯 자식 요소를 구성하는 데 유용합니다:
``` dart
Arr.interleave([1, 2, 3], 0); // [1, 0, 2, 0, 3]
Column(children: Arr.interleave(tiles, const Divider()));
```
#### `Arr.isAssoc()`
값이 `Map`(연관 배열)인 경우 `true`를 반환합니다:
``` dart
Arr.isAssoc({'a': 1}); // true
Arr.isAssoc([1, 2, 3]); // false
```
#### `Arr.isList()`
값이 `List`인 경우 `true`를 반환합니다:
``` dart
Arr.isList([1, 2, 3]); // true
Arr.isList({'a': 1}); // false
```
#### `Arr.join()`
리스트를 문자열로 결합합니다. 마지막 요소는 다른 구분자로 결합할 수 있습니다:
``` dart
Arr.join(['Anna', 'Brad', 'Carol'], ', ', ' and ');
// 'Anna, Brad and Carol'
Arr.join(['a', 'b', 'c']);
// 'a, b, c'
```
#### `Arr.keyBy()`
키의 값으로 리스트를 인덱싱합니다. 해당 키에 `null` 값이 있는 항목은 건너뜁니다:
``` dart
Arr.keyBy([
{'id': 1, 'name': 'Anna'},
{'id': 2, 'name': 'Brad'},
], 'id');
// {1: {'id': 1, 'name': 'Anna'}, 2: {'id': 2, 'name': 'Brad'}}
```
#### `Arr.last()`
조건자와 일치하는 마지막 요소 또는 기본값을 반환합니다:
``` dart
Arr.last([1, 2, 3, 4], predicate: (n) => n.isEven); // 4
Arr.last([1, 2, 3]); // 3
```
#### `Arr.map()`
인덱스도 받는 콜백으로 각 요소를 매핑합니다:
``` dart
Arr.map(['a', 'b'], (v, i) => '$i:$v'); // ['0:a', '1:b']
```
#### `Arr.mapWithKeys()`
각 요소를 `MapEntry`로 매핑하고 결과 맵을 반환합니다:
``` dart
Arr.mapWithKeys(
[{'id': 1, 'name': 'Anna'}, {'id': 2, 'name': 'Brad'}],
(m) => MapEntry(m['id'], m['name']),
);
// {1: 'Anna', 2: 'Brad'}
```
#### `Arr.max()`
`by`의 값이 가장 큰 요소를 반환합니다. `by`가 생략된 경우 가장 큰 요소를 반환합니다:
``` dart
Arr.max([3, 1, 4, 1, 5]); // 5
Arr.max(users, by: (u) => u.age); // 나이가 가장 많은 사용자
```
#### `Arr.median()`
리스트의 중앙값을 반환합니다. 비어 있으면 `0`을 반환합니다:
``` dart
Arr.median([1, 3, 5]); // 3.0
Arr.median([1, 2, 3, 4]); // 2.5
```
#### `Arr.min()`
`by`의 값이 가장 작은 요소를 반환합니다. `by`가 생략된 경우 가장 작은 요소를 반환합니다:
``` dart
Arr.min([3, 1, 4, 1, 5]); // 1
Arr.min(users, by: (u) => u.age); // 나이가 가장 적은 사용자
```
#### `Arr.move()`
`from` 위치의 요소를 `to` 위치로 이동한 새 리스트를 반환합니다. `to`는 유효한 범위로 클램핑됩니다:
``` dart
Arr.move(['a', 'b', 'c', 'd'], 0, 2); // ['b', 'c', 'a', 'd']
```
#### `Arr.onlyValues()`
주어진 값에도 포함된 리스트의 요소를 반환합니다:
``` dart
Arr.onlyValues([1, 2, 3, 4], [2, 4, 9]); // [2, 4]
```
#### `Arr.partition()`
조건자를 기반으로 리스트를 `[일치, 불일치]` 쌍으로 분할합니다:
``` dart
final [evens, odds] = Arr.partition([1, 2, 3, 4], (n) => n.isEven);
// evens: [2, 4], odds: [1, 3]
```
#### `Arr.pluck()`
리스트의 각 맵에서 키의 값을 추출합니다:
``` dart
Arr.pluck([
{'name': 'Anna'},
{'name': 'Brad'},
], 'name');
// ['Anna', 'Brad']
```
#### `Arr.prepend()`
앞에 값을 삽입한 새 리스트를 반환합니다:
``` dart
Arr.prepend([2, 3], 1); // [1, 2, 3]
```
#### `Arr.push()`
끝에 값을 추가한 새 리스트를 반환합니다:
``` dart
Arr.push([1, 2], 3); // [1, 2, 3]
```
#### `Arr.random()`
리스트에서 임의의 요소를 반환합니다. 리스트가 비어 있으면 예외를 발생시킵니다:
``` dart
Arr.random(['rock', 'paper', 'scissors']); // 세 가지 중 하나
```
#### `Arr.randomMany()`
중복 없이 최대 `count`개의 임의 요소를 반환합니다:
``` dart
Arr.randomMany([1, 2, 3, 4, 5], 2); // 예: [3, 1]
```
#### `Arr.reject()`
조건자와 *일치하지 않는* 요소로 리스트를 필터링합니다([`where`](#method-arr-where)의 반대):
``` dart
Arr.reject([1, 2, 3, 4], (n) => n.isEven); // [1, 3]
```
#### `Arr.replaceAt()`
`index`의 요소를 `value`로 교체한 새 리스트를 반환합니다. `index`가 범위를 벗어나면 `RangeError`를 발생시킵니다:
``` dart
Arr.replaceAt(['a', 'b', 'c'], 1, 'B'); // ['a', 'B', 'c']
```
#### `Arr.select()`
리스트의 각 맵을 주어진 키만으로 축소하여 반환합니다:
``` dart
Arr.select([
{'name': 'Anna', 'role': 'admin', 'age': 30},
{'name': 'Brad', 'role': 'user', 'age': 25},
], ['name', 'role']);
// [{'name': 'Anna', 'role': 'admin'}, {'name': 'Brad', 'role': 'user'}]
```
#### `Arr.shuffle()`
리스트의 섞인 복사본을 반환합니다. 결정론적 결과를 위해 `seed`를 전달합니다:
``` dart
Arr.shuffle([1, 2, 3, 4, 5]);
Arr.shuffle([1, 2, 3], seed: 42); // 결정론적
```
#### `Arr.sole()`
조건자와 일치하는 유일한 요소를 반환합니다. 일치하는 요소가 0개 또는 2개 이상이면 예외를 발생시킵니다:
``` dart
Arr.sole([1, 2, 3, 4], predicate: (n) => n == 3); // 3
Arr.sole([1, 2, 3], predicate: (n) => n.isEven); // 2
```
#### `Arr.some()`
적어도 하나의 요소가 조건자를 통과할 때 `true`를 반환합니다:
``` dart
Arr.some([1, 2, 3], (n) => n.isEven); // true
Arr.some([1, 3, 5], (n) => n.isEven); // false
```
#### `Arr.sort()`
리스트의 정렬된 복사본을 반환합니다:
``` dart
Arr.sort([3, 1, 2]); // [1, 2, 3]
Arr.sort(users, compare: (a, b) => a.age - b.age); // 나이 오름차순
```
#### `Arr.sortDesc()`
리스트의 내림차순 정렬된 복사본을 반환합니다:
``` dart
Arr.sortDesc([3, 1, 2]); // [3, 2, 1]
```
#### `Arr.sortRecursive()`
리스트를 재귀적으로 정렬합니다. 중첩 리스트는 모든 깊이에서 정렬됩니다:
``` dart
Arr.sortRecursive([[3, 1, 2], [9, 7, 8]]);
// [[1, 2, 3], [7, 8, 9]]
```
#### `Arr.sum()`
리스트의 합계를 반환합니다. `by`를 전달하면 각 요소에서 숫자를 추출합니다:
``` dart
Arr.sum([1, 2, 3]); // 6
Arr.sum(orders, by: (o) => o.total); // 총액의 합계
```
#### `Arr.swap()`
`i`와 `j`의 요소를 교환한 새 리스트를 반환합니다:
``` dart
Arr.swap(['a', 'b', 'c'], 0, 2); // ['c', 'b', 'a']
```
#### `Arr.take()`
처음 `count`개의 요소를 반환하거나, `count`가 음수이면 마지막 `count`개를 반환합니다:
``` dart
Arr.take([1, 2, 3, 4, 5], 2); // [1, 2]
Arr.take([1, 2, 3, 4, 5], -2); // [4, 5]
```
#### `Arr.unique()`
리스트의 고유 값을 반환합니다:
``` dart
Arr.unique([1, 2, 2, 3, 1]); // [1, 2, 3]
```
#### `Arr.where()`
조건자와 일치하는 요소로 리스트를 필터링합니다:
``` dart
Arr.where([1, 2, 3, 4], (n) => n.isEven); // [2, 4]
```
#### `Arr.whereNotNull()`
`null` 값이 제거된 리스트를 반환합니다:
``` dart
Arr.whereNotNull([1, null, 2, null, 3]); // [1, 2, 3]
```
#### `Arr.wrap()`
값이 아직 `List`가 아닌 경우 `List`로 감쌉니다. 값이 `null`이면 빈 리스트를 반환합니다:
``` dart
Arr.wrap('foo'); // ['foo']
Arr.wrap([1, 2]); // [1, 2]
Arr.wrap(null); // []
```
## 문자열
#### `Str.after()`
`search`가 처음 나타난 이후의 `subject` 부분을 반환합니다:
``` dart
Str.after('hello world hello', 'hello'); // ' world hello'
```
#### `Str.afterLast()`
`search`가 마지막으로 나타난 이후의 `subject` 부분을 반환합니다:
``` dart
Str.afterLast('app/Http/Controllers', '/'); // 'Controllers'
```
#### `Str.before()`
`search`가 처음 나타나기 전의 `subject` 부분을 반환합니다:
``` dart
Str.before('hello world', ' '); // 'hello'
```
#### `Str.beforeLast()`
`search`가 마지막으로 나타나기 전의 `subject` 부분을 반환합니다:
``` dart
Str.beforeLast('app/Http/Controllers', '/'); // 'app/Http'
```
#### `Str.between()`
`from`과 `to` 사이의 `subject` 부분을 반환합니다(최장 일치):
``` dart
Str.between('[a] foo [b]', '[', ']'); // 'a] foo [b'
```
#### `Str.betweenFirst()`
`from`과 `to` 사이의 `subject`에서 가장 짧은 부분을 반환합니다:
``` dart
Str.betweenFirst('[a] foo [b]', '[', ']'); // 'a'
```
#### `Str.camel()`
값을 `camelCase`로 변환합니다:
``` dart
Str.camel('foo_bar'); // 'fooBar'
Str.camel('Hello world'); // 'helloWorld'
```
#### `Str.charAt()`
주어진 인덱스의 문자를 반환합니다. 음수 인덱스는 끝에서부터 계산합니다. 범위를 벗어나면 `null`을 반환합니다:
``` dart
Str.charAt('hello', 1); // 'e'
Str.charAt('hello', -1); // 'o'
Str.charAt('hello', 99); // null
```
#### `Str.contains()`
`haystack`이 `needles` 중 하나라도 포함하는지 여부를 판단합니다:
``` dart
Str.contains('hello world', 'world'); // true
Str.contains('hello world', ['cat', 'world']); // true
Str.contains('Hello', 'hello', ignoreCase: true); // true
```
#### `Str.containsAll()`
`haystack`이 `needles`를 모두 포함하는지 여부를 판단합니다:
``` dart
Str.containsAll('hello world', ['hello', 'world']); // true
Str.containsAll('hello world', ['hello', 'cat']); // false
```
#### `Str.deduplicate()`
`character`의 연속 출현을 단일 인스턴스로 교체합니다:
``` dart
Str.deduplicate('hello world'); // 'hello world'
Str.deduplicate('//path//to//', '/'); // '/path/to/'
```
#### `Str.endsWith()`
`haystack`이 `needles` 중 하나로 끝나는지 여부를 판단합니다:
``` dart
Str.endsWith('app.dart', '.dart'); // true
Str.endsWith('app.dart', ['.dart', '.ts']); // true
```
#### `Str.excerpt()`
`phrase`가 처음 나타나는 위치 주변의 텍스트 스니펫을 추출합니다. 구절이 발견되지 않으면 `null`을 반환합니다:
``` dart
Str.excerpt(
'This is my favorite quote of all time.',
'favorite',
radius: 5,
);
// '...is my favorite quote ...'
```
#### `Str.finish()`
값의 끝에 `cap`의 단일 인스턴스를 추가합니다:
``` dart
Str.finish('hello', '!'); // 'hello!'
Str.finish('hello!!!', '!'); // 'hello!'
```
#### `Str.headline()`
대문자 경계, 밑줄, 하이픈, 공백으로 문자열을 단어로 분할하고 타이틀 케이스로 변환합니다:
``` dart
Str.headline('steve_jobs'); // 'Steve Jobs'
Str.headline('EmailNotificationSent'); // 'Email Notification Sent'
```
#### `Str.is_()`
값이 주어진 패턴과 일치하는지 여부를 판단합니다. 별표는 와일드카드로 작동합니다:
``` dart
Str.is_('foo.*', 'foo.bar'); // true
Str.is_(['admin/*', 'user/*'], 'admin/profile'); // true
Str.is_('foo', 'bar'); // false
```
> **참고:** 후행 밑줄은 Dart의 예약 키워드 `is`를 피하기 위한 것입니다.
#### `Str.isAscii()`
값이 7비트 ASCII 문자만 포함하면 `true`를 반환합니다:
``` dart
Str.isAscii('hello'); // true
Str.isAscii('héllo'); // false
```
#### `Str.isJson()`
값이 유효한 JSON이면 `true`를 반환합니다:
``` dart
Str.isJson('{"a": 1}'); // true
Str.isJson('not json'); // false
```
#### `Str.isUlid()`
값이 ULID(26자, Crockford base32)이면 `true`를 반환합니다:
``` dart
Str.isUlid('01ARZ3NDEKTSV4RRFFQ69G5FAV'); // true
Str.isUlid('not a ulid'); // false
```
#### `Str.isUrl()`
값이 유효한 URL이면 `true`를 반환합니다:
``` dart
Str.isUrl('https://nylo.dev'); // true
Str.isUrl('not a url'); // false
```
#### `Str.isUuid()`
값이 유효한 UUID(임의 버전)이면 `true`를 반환합니다:
``` dart
Str.isUuid('a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'); // true
Str.isUuid('hello'); // false
```
#### `Str.kebab()`
값을 `kebab-case`로 변환합니다:
``` dart
Str.kebab('fooBar'); // 'foo-bar'
Str.kebab('Hello World'); // 'hello-world'
```
#### `Str.lcfirst()`
값의 첫 번째 문자를 소문자로 변환합니다:
``` dart
Str.lcfirst('Hello world'); // 'hello world'
```
#### `Str.length()`
값의 길이를 반환합니다:
``` dart
Str.length('hello'); // 5
```
#### `Str.limit()`
값을 주어진 문자 수로 잘라내고 접미사를 추가합니다:
``` dart
Str.limit('A long sentence', 6); // 'A long...'
Str.limit('A long sentence', 6, '... read'); // 'A long... read'
```
#### `Str.lower()`
값을 소문자로 변환합니다:
``` dart
Str.lower('HELLO'); // 'hello'
```
#### `Str.mask()`
문자열의 일부를 문자로 마스킹합니다. `index`에서 시작하여 `length` 문자 동안(또는 `length`가 생략된 경우 끝까지) 마스킹합니다:
``` dart
Str.mask('user@example.com', '*', 3); // 'use*************'
Str.mask('user@example.com', '*', 3, 5); // 'use*****mple.com'
```
#### `Str.match()`
`subject`에서 `pattern`의 첫 번째 정규식 일치를 반환하거나, 일치가 없으면 `null`을 반환합니다:
``` dart
Str.match(RegExp(r'\d+'), 'item 42 in 99 stock'); // '42'
```
> **참고:** 이것은 정규식 매처로, `Map` 기반 값 조회에 사용되는 전역 [`match`](#method-match) 헬퍼와 구별됩니다.
#### `Str.matchAll()`
`subject`에서 `pattern`의 모든 정규식 일치를 반환합니다:
``` dart
Str.matchAll(RegExp(r'\d+'), 'item 42 in 99 stock'); // ['42', '99']
```
#### `Str.padBoth()`
`length`에 도달할 때까지 양쪽을 `pad`로 패딩합니다:
``` dart
Str.padBoth('5', 5, '0'); // '00500'
```
#### `Str.padLeft()`
값의 왼쪽을 패딩합니다:
``` dart
Str.padLeft('5', 3, '0'); // '005'
```
#### `Str.padNumber()`
숫자 문자열을 앞에 0을 채워 패딩합니다:
``` dart
Str.padNumber('5', 3); // '005'
```
#### `Str.padRight()`
값의 오른쪽을 패딩합니다:
``` dart
Str.padRight('5', 3, '0'); // '500'
```
#### `Str.password()`
암호화적으로 무작위인 비밀번호를 생성합니다. 이름 있는 인수로 문자 클래스를 전환할 수 있습니다:
``` dart
Str.password(12); // 문자 + 숫자 + 기호
Str.password(12, symbols: false); // 문자 + 숫자만
Str.password(8, letters: false, symbols: false); // 숫자만
```
#### `Str.position()`
`haystack`에서 `needle`이 처음 나타나는 인덱스를 반환하거나, 찾지 못하면 `null`을 반환합니다:
``` dart
Str.position('hello world', 'world'); // 6
Str.position('hello world hello', 'hello', offset: 1); // 12
Str.position('hello', 'cat'); // null
```
#### `Str.random()`
주어진 길이의 암호화적으로 무작위인 영숫자 문자열을 생성합니다:
``` dart
Str.random(); // 16자, 예: 'aB3k9XzMq7VnPsRt'
Str.random(8); // 8자
```
#### `Str.remove()`
`subject`에서 `search` 중 하나를 제거합니다:
``` dart
Str.remove('o', 'hello world'); // 'hell wrld'
Str.remove(['e', 'l'], 'hello world'); // 'ho word'
Str.remove('Hello', 'hello world', caseSensitive: false); // ' world'
```
#### `Str.repeat()`
값을 주어진 횟수만큼 반복합니다:
``` dart
Str.repeat('ab', 3); // 'ababab'
```
#### `Str.replace()`
`subject`에서 `search`의 모든 출현을 `replace`로 교체합니다:
``` dart
Str.replace('o', '0', 'hello world'); // 'hell0 w0rld'
Str.replace(['o', 'l'], '*', 'hello world'); // 'he*** w*r*d'
```
#### `Str.replaceFirst()`
`search`의 첫 번째 출현을 `replace`로 교체합니다:
``` dart
Str.replaceFirst('hello', 'hi', 'hello hello'); // 'hi hello'
```
#### `Str.replaceLast()`
`search`의 마지막 출현을 `replace`로 교체합니다:
``` dart
Str.replaceLast('hello', 'hi', 'hello hello'); // 'hello hi'
```
#### `Str.reverse()`
값을 뒤집습니다:
``` dart
Str.reverse('hello'); // 'olleh'
```
#### `Str.slug()`
제목에서 URL 친화적인 슬러그를 생성합니다:
``` dart
Str.slug('Hello World'); // 'hello-world'
Str.slug('Tech & Code', dictionary: {'&': 'and'}); // 'tech-and-code'
Str.slug('Hello World', separator: '_'); // 'hello_world'
```
#### `Str.snake()`
값을 `snake_case`로 변환합니다. 사용자 정의 구분자를 전달하여 `_` 이외의 것을 사용할 수 있습니다:
``` dart
Str.snake('helloWorld'); // 'hello_world'
Str.snake('helloWorld', '-'); // 'hello-world'
```
#### `Str.squish()`
앞뒤 공백을 제거하고 내부 공백을 단일 공백으로 축소합니다:
``` dart
Str.squish(' hello world '); // 'hello world'
```
#### `Str.start()`
값의 시작에 `prefix`의 단일 인스턴스를 추가합니다:
``` dart
Str.start('this/string', '/'); // '/this/string'
Str.start('//this/string', '/'); // '/this/string'
```
#### `Str.startsWith()`
`haystack`이 `needles` 중 하나로 시작하는지 여부를 판단합니다:
``` dart
Str.startsWith('hello world', 'hello'); // true
Str.startsWith('hello world', ['cat', 'hello']); // true
```
#### `Str.studly()`
값을 `StudlyCase` / `PascalCase`로 변환합니다:
``` dart
Str.studly('foo_bar'); // 'FooBar'
Str.studly('hello world'); // 'HelloWorld'
```
#### `Str.substr()`
`start`에서 시작하여 `length` 문자의 부분 문자열을 반환합니다. 음수 `start`는 끝에서부터 계산합니다:
``` dart
Str.substr('profile', 4); // 'ile'
Str.substr('profile', 4, 2); // 'il'
Str.substr('profile', -3); // 'ile'
```
#### `Str.substrCount()`
`haystack`에서 `needle`의 겹치지 않는 출현 횟수를 계산합니다:
``` dart
Str.substrCount('hello hello hello', 'hello'); // 3
```
#### `Str.swap()`
검색 → 교체 쌍의 `Map`을 사용하여 여러 부분 문자열을 교체합니다:
``` dart
Str.swap({'foo': 'bar', 'hello': 'hi'}, 'hello foo'); // 'hi bar'
```
#### `Str.take()`
값의 처음 `limit` 문자를 반환합니다. 음수 제한은 끝에서부터를 의미합니다:
``` dart
Str.take('Build something amazing!', 5); // 'Build'
Str.take('Build something amazing!', -9); // ' amazing!'
```
#### `Str.title()`
값을 `Title Case`로 변환합니다:
``` dart
Str.title('a nice title'); // 'A Nice Title'
```
#### `Str.ucfirst()`
값의 첫 번째 문자를 대문자로 변환합니다:
``` dart
Str.ucfirst('hello world'); // 'Hello world'
```
#### `Str.ucsplit()`
대문자 경계에서 값을 단어로 분할합니다:
``` dart
Str.ucsplit('fooBarBaz'); // ['foo', 'Bar', 'Baz']
```
#### `Str.ulid()`
ULID(Universally Unique Lexicographically Sortable Identifier)를 생성합니다:
``` dart
Str.ulid(); // 예: '01ARZ3NDEKTSV4RRFFQ69G5FAV'
```
#### `Str.unwrap()`
시작에서 `before`의 단일 인스턴스를, 끝에서 `after`(또는 `after`가 null이면 `before`)의 단일 인스턴스를 제거합니다:
``` dart
Str.unwrap('"value"', '"'); // 'value'
Str.unwrap('html
', '', '
'); // 'html'
```
#### `Str.upper()`
값을 대문자로 변환합니다:
``` dart
Str.upper('hello'); // 'HELLO'
```
#### `Str.uuid()`
무작위 UUID v4를 생성합니다:
``` dart
Str.uuid(); // 예: 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'
```
#### `Str.uuid7()`
UUID v7(시간 순서, RFC 9562)을 생성합니다. UUIDv7은 생성 시간으로 정렬 가능합니다:
``` dart
Str.uuid7(); // 예: '018e0dc4-8b3f-7a2c-9d01-b1f6c87a92e3'
```
#### `Str.wordCount()`
값의 단어 수를 반환합니다:
``` dart
Str.wordCount('hello there friend'); // 3
```
#### `Str.words()`
값을 주어진 단어 수로 제한합니다:
``` dart
Str.words('Perfectly balanced, as all things should be.', 3);
// 'Perfectly balanced, as...'
```
#### `Str.wrap()`
값을 `before`와 `after`로 감쌉니다. `after`가 생략되면 양쪽에 `before`가 사용됩니다:
``` dart
Str.wrap('value', '"'); // '"value"'
Str.wrap('html', '', '
'); // 'html
'
```
## 숫자
#### `Number.abbreviate()`
숫자의 약식 형태를 반환합니다(`1K`, `1M`, `1B`):
``` dart
Number.abbreviate(1500); // '2K'
Number.abbreviate(1500, maxPrecision: 1); // '1.5K'
Number.abbreviate(2_500_000); // '3M'
```
#### `Number.average()`
값의 산술 평균을 반환합니다. 비어 있으면 `0`을 반환합니다:
``` dart
Number.average([1, 2, 3, 4]); // 2.5
```
#### `Number.between()`
값이 `min`과 `max` 사이(양 끝 포함)에 있을 때 `true`를 반환합니다:
``` dart
Number.between(5, min: 0, max: 10); // true
Number.between(15, min: 0, max: 10); // false
```
#### `Number.ceil()`
값을 주어진 정밀도로 올림합니다:
``` dart
Number.ceil(1.2); // 2.0
Number.ceil(1.234, 2); // 1.24
```
#### `Number.clamp()`
값을 `min`과 `max` 사이(양 끝 포함)로 클램핑합니다:
``` dart
Number.clamp(5, 0, 10); // 5
Number.clamp(15, 0, 10); // 10
Number.clamp(-1, 0, 10); // 0
```
#### `Number.currency()`
숫자를 통화 값으로 형식화합니다. 구성된 로케일과 통화를 기본으로 사용합니다:
``` dart
Number.currency(1234.56); // '$1,234.56'
Number.currency(1234.56, currency: 'EUR'); // '€1,234.56'
Number.currency(1234.56, locale: 'de_DE', currency: 'EUR');
// '1.234,56 €'
```
#### `Number.defaultCurrency()`
형식화 메서드에서 사용하는 기본 통화 코드를 반환합니다:
``` dart
Number.defaultCurrency(); // 'USD'
```
#### `Number.defaultLocale()`
형식화 메서드에서 사용하는 기본 로케일을 반환합니다:
``` dart
Number.defaultLocale(); // 'en_US'
```
#### `Number.degrees()`
라디안을 도로 변환합니다:
``` dart
Number.degrees(3.14159); // ~180.0
```
#### `Number.duration()`
초 수를 사람이 읽을 수 있는 기간으로 형식화합니다. 짧은 형식은 `'1h 2m 5s'`를, 긴 형식은 `'1:02:05'`를 반환합니다:
``` dart
Number.duration(3661); // '1h 1m 1s'
Number.duration(3661, short: false); // '1:01:01'
Number.duration(45); // '45s'
```
#### `Number.fileSize()`
바이트 수를 사람이 읽을 수 있는 파일 크기로 형식화합니다:
``` dart
Number.fileSize(1024); // '1 KB'
Number.fileSize(1500, maxPrecision: 1); // '1.5 KB'
Number.fileSize(1024 * 1024 * 1024); // '1 GB'
```
#### `Number.floor()`
값을 주어진 정밀도로 내림합니다:
``` dart
Number.floor(1.7); // 1.0
Number.floor(1.234, 2); // 1.23
```
#### `Number.forHumans()`
숫자의 사람이 읽을 수 있는 형태를 반환합니다(`1 thousand`, `1 million`):
``` dart
Number.forHumans(1500); // '2 thousand'
Number.forHumans(1500, maxPrecision: 1); // '1.5 thousand'
Number.forHumans(2_500_000); // '3 million'
```
#### `Number.format()`
로케일 인식 구분자로 숫자를 형식화합니다:
``` dart
Number.format(1234567); // '1,234,567'
Number.format(1234.5, precision: 2); // '1,234.50'
Number.format(1234567, locale: 'de_DE'); // '1.234.567'
```
#### `Number.gcd()`
두 정수의 최대공약수:
``` dart
Number.gcd(12, 18); // 6
```
#### `Number.lcm()`
두 정수의 최소공배수:
``` dart
Number.lcm(4, 6); // 12
```
#### `Number.lerp()`
`t`(`0..1`)로 `a`와 `b` 사이를 선형 보간합니다:
``` dart
Number.lerp(0, 100, 0.25); // 25.0
```
#### `Number.max()`
이터러블에서 가장 큰 값을 반환합니다:
``` dart
Number.max([3, 1, 4, 1, 5, 9, 2, 6]); // 9
```
#### `Number.median()`
값의 중앙값을 반환합니다. 비어 있으면 `0`을 반환합니다:
``` dart
Number.median([1, 3, 5]); // 3.0
Number.median([1, 2, 3, 4]); // 2.5
```
#### `Number.min()`
이터러블에서 가장 작은 값을 반환합니다:
``` dart
Number.min([3, 1, 4, 1, 5, 9, 2, 6]); // 1
```
#### `Number.ordinal()`
숫자의 서수 형태를 반환합니다(`1st`, `2nd`, `3rd`, `4th`):
``` dart
Number.ordinal(1); // '1st'
Number.ordinal(2); // '2nd'
Number.ordinal(21); // '21st'
Number.ordinal(112); // '112th'
```
#### `Number.pairs()`
`to`까지의 범위에서 `by`로 단계를 밟는 쌍(하위 범위)을 생성합니다:
``` dart
Number.pairs(25, 10); // [[0, 9], [10, 19], [20, 25]]
Number.pairs(25, 10, offset: 0); // [[0, 10], [10, 20], [20, 25]]
```
#### `Number.parseFloat()`
로케일 인식 문자열을 `double`로 파싱합니다. 실패하면 `null`을 반환합니다:
``` dart
Number.parseFloat('1,234.56'); // 1234.56
Number.parseFloat('1.234,56', locale: 'de_DE'); // 1234.56
Number.parseFloat('not a number'); // null
```
#### `Number.parseInt()`
로케일 인식 문자열을 `int`로 파싱합니다. 실패하면 `null`을 반환합니다:
``` dart
Number.parseInt('1,234'); // 1234
Number.parseInt('1.234', locale: 'de_DE'); // 1234
```
#### `Number.percentage()`
숫자를 퍼센트로 형식화합니다. 숫자는 전체 퍼센트 값으로 처리됩니다:
``` dart
Number.percentage(10); // '10%'
Number.percentage(10.5, precision: 1); // '10.5%'
```
#### `Number.radians()`
도를 라디안으로 변환합니다:
``` dart
Number.radians(180); // ~3.14159
```
#### `Number.random()`
`[min, max]`(양 끝 포함)에서 무작위 정수를 반환합니다. 결정론적 시퀀스를 위해 `seed`를 전달합니다:
``` dart
Number.random(min: 1, max: 100); // 1..100의 임의 정수
Number.random(min: 0, max: 9, seed: 42); // 결정론적
```
#### `Number.range()`
`start`(포함)부터 `end`(포함)까지 `step`으로 단계를 밟는 정수 리스트를 생성합니다:
``` dart
Number.range(1, 5); // [1, 2, 3, 4, 5]
Number.range(0, 10, step: 2); // [0, 2, 4, 6, 8, 10]
Number.range(5, 1, step: -1); // [5, 4, 3, 2, 1]
```
#### `Number.round()`
값을 주어진 정밀도로 반올림합니다:
``` dart
Number.round(1.5); // 2.0
Number.round(1.234, 2); // 1.23
```
#### `Number.scale()`
값을 한 범위에서 다른 범위로 재매핑합니다:
``` dart
Number.scale(0.5, fromMin: 0, fromMax: 1, toMin: 0, toMax: 100); // 50.0
Number.scale(75, fromMin: 0, fromMax: 100, toMin: -1, toMax: 1); // 0.5
```
#### `Number.spell()`
숫자를 영어로 표기합니다:
``` dart
Number.spell(0); // 'zero'
Number.spell(123); // 'one hundred twenty-three'
Number.spell(1_234_567); // 'one million two hundred thirty-four thousand five hundred sixty-seven'
```
#### `Number.spellOrdinal()`
숫자의 서수 형태를 영어로 표기합니다:
``` dart
Number.spellOrdinal(1); // 'first'
Number.spellOrdinal(2); // 'second'
Number.spellOrdinal(21); // 'twenty-first'
```
#### `Number.sum()`
값의 합계를 반환합니다:
``` dart
Number.sum([1, 2, 3]); // 6
```
#### `Number.toBytes()`
파일 크기를 바이트로 변환합니다. [`fileSize`](#method-number-filesize)의 역함수입니다. 파싱 가능한 문자열 또는 `unit`이 있는 숫자를 전달합니다:
``` dart
Number.toBytes('1.5 KB'); // 1536
Number.toBytes(1.5, 'KB'); // 1536
Number.toBytes(1, 'GB'); // 1073741824
Number.toBytes('not bytes'); // null
```
#### `Number.trim()`
값의 소수 부분에서 후행 0을 제거합니다:
``` dart
Number.trim(12.0); // '12'
Number.trim(12.30); // '12.3'
Number.trim(12.345); // '12.345'
```
#### `Number.useCurrency()`
형식화 메서드에서 사용하는 기본 통화 코드를 설정합니다:
``` dart
Number.useCurrency('EUR');
Number.currency(99); // '€99.00'
```
#### `Number.useLocale()`
형식화 메서드에서 사용하는 기본 로케일을 설정합니다:
``` dart
Number.useLocale('de_DE');
Number.format(1234567); // '1.234.567'
```
## 객체
`Obj`는 **점 표기법** 경로를 사용하여 맵을 작업하는 유틸리티를 제공합니다. 리스트 요소는 정수 인덱스로 주소를 지정할 수 있습니다(예: `'users.0.name'`).
#### `Obj.add()`
현재 값이 없는 경우에만 `key`에 값을 추가합니다:
``` dart
final user = {'name': 'Anna'};
Obj.add(user, 'role', 'admin');
// user: {'name': 'Anna', 'role': 'admin'}
Obj.add(user, 'name', 'Brad'); // 무동작 — name이 이미 설정됨
```
#### `Obj.deepEquals()`
두 값이 구조적으로 동일할 때(`Map`과 `List`의 재귀 비교) `true`를 반환합니다:
``` dart
Obj.deepEquals({'a': [1, 2]}, {'a': [1, 2]}); // true
Obj.deepEquals({'a': 1}, {'a': 2}); // false
```
#### `Obj.divide()`
맵을 `[keys, values]` 쌍으로 분할합니다:
``` dart
Obj.divide({'name': 'Desk', 'price': 100});
// [['name', 'price'], ['Desk', 100]]
```
#### `Obj.dot()`
중첩된 맵을 점 경로를 키로 하는 단일 레벨 맵으로 평탄화합니다:
``` dart
Obj.dot({'a': {'b': 1, 'c': 2}});
// {'a.b': 1, 'a.c': 2}
```
#### `Obj.except()`
주어진 키를 제외한 모든 항목을 포함하는 새 맵을 반환합니다:
``` dart
Obj.except({'name': 'Anna', 'role': 'admin', 'age': 30}, ['age']);
// {'name': 'Anna', 'role': 'admin'}
```
#### `Obj.exists()`
맵이 최상위 레벨에서 주어진 키를 가질 때 `true`를 반환합니다(점 표기법 탐색 없음):
``` dart
Obj.exists({'a.b': 1}, 'a.b'); // true
Obj.exists({'a': {'b': 1}}, 'a.b'); // false (탐색은 `has` 사용)
```
#### `Obj.flip()`
키와 값을 교환합니다. 값이 충돌하면 마지막 항목이 우선합니다:
``` dart
Obj.flip({'one': 1, 'two': 2}); // {1: 'one', 2: 'two'}
```
#### `Obj.forget()`
맵에서 키(점 표기법)를 제거합니다. 체이닝을 위해 맵을 반환합니다:
``` dart
final user = {'profile': {'name': 'Anna', 'email': 'a@b'}};
Obj.forget(user, 'profile.email');
// user: {'profile': {'name': 'Anna'}}
```
#### `Obj.get()`
점 표기법을 사용하여 `key`의 값을 반환하거나, 경로가 없으면 기본값을 반환합니다. 리터럴 점이 포함된 최상위 키는 탐색보다 우선합니다:
``` dart
final user = {'profile': {'name': 'Anna', 'age': 30}};
Obj.get(user, 'profile.name'); // 'Anna'
Obj.get(user, 'profile.email'); // null
Obj.get(user, 'profile.email', 'unknown'); // 'unknown'
// 리스트 인덱스:
Obj.get({'users': [{'name': 'A'}]}, 'users.0.name'); // 'A'
```
#### `Obj.getBool()`
`key`의 값을 `bool`로 변환하여 반환하거나, 기본값을 반환합니다. 숫자는 0이 아닌 경우 참. 문자열은 `'true'`/`'false'`/`'1'`/`'0'`/`'yes'`/`'no'`/`'on'`/`'off'`를 인식합니다(대소문자 무시):
``` dart
Obj.getBool({'flag': 'yes'}, 'flag'); // true
Obj.getBool({'flag': 0}, 'flag'); // false
Obj.getBool({}, 'flag', false); // false
```
#### `Obj.getDouble()`
`key`의 값을 `double`로 변환하여 반환하거나, 기본값을 반환합니다:
``` dart
Obj.getDouble({'price': '9.99'}, 'price'); // 9.99
Obj.getDouble({'price': 10}, 'price'); // 10.0
```
#### `Obj.getInt()`
`key`의 값을 `int`로 변환하여 반환하거나, 기본값을 반환합니다:
``` dart
Obj.getInt({'count': '42'}, 'count'); // 42
Obj.getInt({'count': 3.7}, 'count'); // 3 (잘림)
Obj.getInt({}, 'count', 0); // 0
```
#### `Obj.getList()`
`key`의 값이 `List`이면 반환하고, 그렇지 않으면 기본값을 반환합니다:
``` dart
Obj.getList({'items': [1, 2, 3]}, 'items'); // [1, 2, 3]
Obj.getList({'items': 'oops'}, 'items', []); // []
```
#### `Obj.getMap()`
`key`의 값이 `Map`이면 반환하고, 그렇지 않으면 기본값을 반환합니다:
``` dart
Obj.getMap({'meta': {'a': 1}}, 'meta'); // {'a': 1}
Obj.getMap({'meta': null}, 'meta', {}); // {}
```
#### `Obj.getString()`
`key`의 값을 `String`으로 변환하여 반환하거나, 기본값을 반환합니다:
``` dart
Obj.getString({'name': 'Anna'}, 'name'); // 'Anna'
Obj.getString({'count': 42}, 'count'); // '42'
Obj.getString({}, 'name', 'Guest'); // 'Guest'
```
#### `Obj.has()`
점 표기법을 사용하여 `key`에 값이 있을 때 `true`를 반환합니다:
``` dart
final user = {'profile': {'name': 'Anna'}};
Obj.has(user, 'profile.name'); // true
Obj.has(user, 'profile.email'); // false
```
#### `Obj.hasAll()`
주어진 모든 키가 맵에서 해결될 때 `true`를 반환합니다:
``` dart
Obj.hasAll({'a': 1, 'b': 2}, ['a', 'b']); // true
Obj.hasAll({'a': 1, 'b': 2}, ['a', 'c']); // false
```
#### `Obj.hasAny()`
주어진 키 중 하나라도 맵에서 해결될 때 `true`를 반환합니다:
``` dart
Obj.hasAny({'a': 1}, ['a', 'b']); // true
Obj.hasAny({'a': 1}, ['x', 'y']); // false
```
#### `Obj.mapKeys()`
각 키를 `fn`으로 변환한 새 맵을 반환합니다:
``` dart
Obj.mapKeys({'firstName': 'Anna'}, (k) => k.toLowerCase());
// {'firstname': 'Anna'}
```
#### `Obj.mapValues()`
각 값을 `fn`으로 변환한 새 맵을 반환합니다:
``` dart
Obj.mapValues({'a': 1, 'b': 2}, (v) => v * 10);
// {'a': 10, 'b': 20}
```
#### `Obj.merge()`
`source`를 `target`에 재귀적으로 병합합니다. 키 충돌 시 `source`가 우선하며, 중첩 맵은 병합됩니다:
``` dart
Obj.merge(
{'a': {'x': 1}, 'b': 2},
{'a': {'y': 9}, 'b': 22},
);
// {'a': {'x': 1, 'y': 9}, 'b': 22}
```
#### `Obj.only()`
주어진 키의 항목만 포함하는 새 맵을 반환합니다:
``` dart
Obj.only({'name': 'Anna', 'role': 'admin', 'age': 30}, ['name', 'role']);
// {'name': 'Anna', 'role': 'admin'}
```
#### `Obj.prependKeysWith()`
맵의 모든 최상위 키에 주어진 접두사를 붙입니다:
``` dart
Obj.prependKeysWith({'name': 'Anna', 'age': 30}, 'user_');
// {'user_name': 'Anna', 'user_age': 30}
```
#### `Obj.pull()`
`key`의 값을 반환하고 맵에서 제거합니다:
``` dart
final user = {'name': 'Anna', 'temp': 'token'};
final temp = Obj.pull(user, 'temp'); // 'token'
// user: {'name': 'Anna'}
```
#### `Obj.query()`
맵을 URL 쿼리 문자열로 인코딩합니다:
``` dart
Obj.query({'name': 'Anna', 'tags': ['a', 'b']});
// 'name=Anna&tags%5B0%5D=a&tags%5B1%5D=b'
Obj.query({'filter': {'role': 'admin'}});
// 'filter%5Brole%5D=admin'
```
#### `Obj.set()`
`key`에 값을 설정하고, 경로를 따라 중첩 맵을 생성합니다. 맵을 제자리에서 변경하고 체이닝을 위해 반환합니다:
``` dart
final user = {};
Obj.set(user, 'profile.email', 'a@b');
// user: {'profile': {'email': 'a@b'}}
```
#### `Obj.undot()`
점 키 맵을 중첩된 구조로 확장합니다([`dot`](#method-obj-dot)의 역함수):
``` dart
Obj.undot({'a.b': 1, 'a.c': 2});
// {'a': {'b': 1, 'c': 2}}
```
#### `Obj.whereNotEmpty()`
값이 `null` 또는 비어 있는(빈 `String`, `Iterable`, 또는 `Map`) 항목이 제거된 새 맵을 반환합니다:
``` dart
Obj.whereNotEmpty({'name': 'Anna', 'tags': [], 'bio': ''});
// {'name': 'Anna'}
```
#### `Obj.whereNotNull()`
값이 `null`인 항목이 제거된 새 맵을 반환합니다:
``` dart
Obj.whereNotNull({'name': 'Anna', 'email': null});
// {'name': 'Anna'}
```
## 기타
이 전역 함수들은 `helper.dart`에 있으며 `nylo_framework`를 임포트하면 어디서든 사용할 수 있습니다.
#### `api()`
`NyApiService`를 통해 API 요청을 보내는 편의 헬퍼입니다. 전체 옵션은 [Networking](/docs/7.x/networking) 페이지를 참조하세요:
``` dart
await api((request) =>
request.get('https://jsonplaceholder.typicode.com/posts'));
```
#### `dataToModel()`
`config/decoders.dart`에 등록된 모델로 원시 데이터(일반적으로 JSON `Map`)를 변환합니다. 타입 파라미터가 필요합니다:
``` dart
final user = dataToModel(data: {'name': 'Anna', 'age': 30});
```
#### `dump()`
값을 콘솔에 덤프합니다. `alwaysPrint: true`가 아닌 한 앱의 `APP_DEBUG` 플래그를 따릅니다:
``` dart
dump('Hello World');
dump(user, tag: 'current user');
dump(payload, alwaysPrint: true);
```
#### `event()`
`Nylo.events()`를 사용하여 주어진 타입의 이벤트를 발생시킵니다. 전체 사용법은 [Events](/docs/7.x/events)를 참조하세요:
``` dart
await event(data: {'user': 'Anna'});
```
#### `getAsset()`
`/assets` 디렉토리의 에셋에 대한 전체 경로를 반환합니다:
``` dart
final path = getAsset('videos/welcome.mp4');
// 'assets/videos/welcome.mp4'
```
#### `getEnv()`
생성된 env(`env.g.dart`)에서 값을 반환합니다. 키가 설정되지 않은 경우 기본값을 반환합니다:
``` dart
final apiUrl = getEnv('API_URL');
final debug = getEnv('APP_DEBUG', defaultValue: false);
```
#### `getImageAsset()`
`/assets/images/`의 이미지에 대한 전체 경로를 반환합니다:
``` dart
Image.asset(getImageAsset('logo.png'));
```
#### `loadJson()`
에셋 번들에서 JSON 파일을 로드합니다. 결과는 기본적으로 캐시됩니다:
``` dart
final config = await loadJson>('config/app.json');
```
#### `match()`
값을 케이스 `Map`과 대조하여 해당하는 값을 반환합니다. 일치하는 케이스가 없고 `defaultValue`가 제공되지 않으면 예외를 발생시킵니다:
``` dart
final color = match(
status,
() => {
'active': 'green',
'inactive': 'red',
'pending': 'orange',
},
defaultValue: 'grey',
);
```
> **참고:** 이것은 `Map` 기반 값 조회로, 정규식 매칭을 수행하는 [`Str.match`](#method-str-match)와 구별됩니다.
#### `now()`
현재 `DateTime`을 반환합니다:
``` dart
final timestamp = now();
```
#### `nyHexColor()`
16진수 색상 문자열을 `Color`로 변환합니다. 선행 `#` 유무에 관계없이 6자리 또는 8자리 값을 허용합니다:
``` dart
final brand = nyHexColor('#FF6B35');
final translucent = nyHexColor('80FF6B35'); // 8자리 (알파 우선)
```
#### `printDebug()`, `printError()`, `printInfo()`, `printWarning()`, `printSuccess()`, `printVerbose()`, `printAlert()`, `printEmergency()`
심각도 태그가 붙은 콘솔 로거입니다. 출력 형식과 `alwaysPrint` 플래그에 대해서는 [Logging](/docs/7.x/logging) 페이지를 참조하세요:
``` dart
printInfo('User signed in');
printError('Payment failed', context: {'order_id': 42});
printDebug({'state': state});
```
#### `setBadgeNumber()`, `clearBadgeNumber()`
앱 아이콘 배지 수를 설정하거나 지웁니다. 플랫폼 설정 세부사항은 [Local Notifications](/docs/7.x/local-notifications)를 참조하세요:
``` dart
await setBadgeNumber(3);
await clearBadgeNumber();
```
#### `showNextLog()`
`APP_DEBUG`가 `false`인 경우에도 다음 `NyLogger` 로그를 강제로 표시합니다. 릴리스 빌드에서 일회성 진단에 유용합니다:
``` dart
showNextLog();
NyLogger.info('This will print regardless of APP_DEBUG');
```
#### `sleep()`
주어진 기간 동안 실행을 지연합니다. 첫 번째 인수는 초이며, 선택적 두 번째 인수는 마이크로초를 추가합니다:
``` dart
await sleep(2); // 2초
await sleep(0, 500_000); // 500밀리초
```
#### `trans()`
키로 번역된 문자열을 반환합니다. 설정에 대해서는 [Localization](/docs/7.x/localization)을 참조하세요:
``` dart
final greeting = trans('home.welcome');
final personalized = trans('home.hello', arguments: {'name': 'Anna'});
```