Топаз предоставляет различные основные функции встроенно для эффективной разработки. Все функции поддерживают типобезопасность и парадигмы функционального программирования. 🚀
📝 Строковые функции
Базовые операции со строками
// Длина строки и базовая информация
let текст = "Привет Топаз!"
let длина = текст.length() // 13
let байтДлина = текст.byteLength() // Длина в UTF-8 байтах
let пустая = текст.isEmpty() // false
// Преобразование регистра
let нижнийРегистр = текст.toLowerCase() // "привет topaz!"
let верхнийРегистр = текст.toUpperCase() // "ПРИВЕТ TOPAZ!"
let заглавные = текст.toTitleCase() // "Привет Топаз!"
print("Оригинал: {текст}")
print("Длина: {длина}")
print("Нижний регистр: {нижнийРегистр}")Поиск и проверка строк
let содержимое = "Топаз - это современный язык программирования"
// Поиск в строке
let содержит = содержимое.contains("современный") // true
let начинается = содержимое.startsWith("Топаз") // true
let заканчивается = содержимое.endsWith("программирования") // true
// Поиск позиции
let индекс = содержимое.indexOf("язык") // Some(21)
let последнийИндекс = содержимое.lastIndexOf("а") // Some(41)
// Сопоставление с регулярными выражениями
let совпадениеШаблона = содержимое.match(r"\w+") // Первое слово
let всеСовпадения = содержимое.matchAll(r"\w+") // Все слова
print("Содержит: {содержит}")
print("Индекс: {индекс}")Преобразование и разделение строк
let исходнаяСтрока = " Привет, Мир, Топаз "
// Удаление пробелов
let обрезанная = исходнаяСтрока.trim() // "Привет, Мир, Топаз"
let обрезатьНачало = исходнаяСтрока.trimStart() // "Привет, Мир, Топаз "
let обрезатьКонец = исходнаяСтрока.trimEnd() // " Привет, Мир, Топаз"
// Разделение и объединение строк
let результатРазделения = "яблоко,банан,вишня".split(",") // ["яблоко", "банан", "вишня"]
let результатОбъединения = результатРазделения.join(" | ") // "яблоко | банан | вишня"
// Замена строк
let заменённая = "Привет Мир".replace("Мир", "Топаз") // "Привет Топаз"
let заменитьВсе = "тест тест тест".replaceAll("тест", "код") // "код код код"
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 НеЧисло = 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(х => х * х) // [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
let строки = числа.map(х => х.toString()) // ["1", "2", "3", ...]
// filter - фильтрация
let чётные = числа.filter(х => х % 2 == 0) // [2, 4, 6, 8, 10]
let большие = числа.filter(х => х > 5) // [6, 7, 8, 9, 10]
// reduce - накопление
let сумма = числа.reduce((акк, тек) => акк + тек, 0) // 55
let произведение = числа.reduce((акк, тек) => акк * тек, 1) // 3628800
// find - поиск
let найдено = числа.find(х => х > 5) // Some(6)
let найденИндекс = числа.findIndex(х => х > 5) // Some(5)
print("Квадраты: {квадраты}")
print("Чётные: {чётные}")
print("Сумма: {сумма}")
print("Найдено: {найдено}")Проверка и валидация массивов
let тестовыйМассив = [2, 4, 6, 8, 10]
// every - проверка всех элементов
let всеЧётные = тестовыйМассив.every(х => х % 2 == 0) // true
let всеБольшие = тестовыйМассив.every(х => х > 5) // false
// some - проверка некоторых элементов
let некоторыеБольшие = тестовыйМассив.some(х => х > 5) // true
let некоторыеНечётные = тестовыйМассив.some(х => х % 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((а, б) => б - а) // [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,
работа: "Разработчик",
навыки: ["Топаз", "Rust", "TypeScript"]
}
// Получение ключей/значений объекта
let ключи = Object.keys(объектПользователя) // ["имя", "возраст", "работа", "навыки"]
let значения = Object.values(объектПользователя) // ["Пользователь", 28, "Разработчик", [...]]
let записи = Object.entries(объектПользователя) // [["имя", "Пользователь"], ...]
// Проверка существования свойства
let естьИмя = Object.hasOwnProperty(объектПользователя, "имя") // true
let естьАдрес = Object.hasOwnProperty(объектПользователя, "адрес") // false
// Слияние объектов
let дополнительнаяИнформация = { адрес: "Москва", email: "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 объектДанных = {
имя: "Топаз",
версия: "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) => (б: B) => функция(а, б)
}
let сложить = (а: int, б: int) => а + б
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 удвоить = (х: int) => х * 2
let вСтроку = (х: int) => х.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((н: int) => {
if н <= 1 { return н }
return фибоначчи(н - 1) + фибоначчи(н - 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("Перемешанная колода: {перемешанная}")Основные функции Топаза делают разработку более эффективной и безопасной. Все функции гарантируют типобезопасность и поддерживают стиль функционального программирования! 🎯