По вашему запросу ничего не найдено :(
Убедитесь, что запрос написан правильно, или посмотрите другие
наши статьи:
Введение
Типы данных
применяются для того, чтобы вы могли классифицировать один конкретный тип данных в языках программирования. Например, число и строка символов – это разные типы данных, которые JavaScript будет обрабатывать по-разному.
Это очень важно, так как тип данных, который вы используете, будет определять, какие значения вы можете присвоить переменной и что вы можете с ней делать. Этим я хочу сказать, что для того, чтобы выполнять операции с переменными в JavaScript, вы должны знать тип данных любой заданной переменной.
В этой статье мы обсудим то, как работают типы данных в JavaScript, а также основные типы данных, которые есть в этом языке. Этот обзор нельзя назвать полноценным, но он поможет вам ознакомиться с дополнительными возможностями JavaScript.
Динамическая типизация
JavaScript работает с динамическими типами данных, а это значит, что проверка соответствия типов выполняется на этапе выполнения программы, а не на этапе ее компиляции. Типы данных Python также имеют динамическую типизацию.
Если мы говорим о динамически типизированных языках, то здесь переменная с одним и тем же именем может хранить разные типы данных.
Например, переменная
t
, которая была определена с помощью ключевого слова
let
(не забывайте, что
let
ограничивает область действия переменной), может хранить разные типы данных, а может быть инициализирована, но не определена:
let t = 16; // t is a number { // t – это число }
let t = "Teresa"; // t is a string { // t – это строка }
let t = true; // t is a Boolean { // t – это логическое значение }
let t; // t is undefined { // t неопределена }
Все переменные, перечисленные выше, могут иметь любой тип данных, который есть в JavaScript; тип этих переменных явно объявлять не требуется.
Числа
В JavaScript есть всего один числовой тип, то есть здесь нет отдельных обозначений для целых чисел и чисел с плавающей точкой. Вследствие этого числа в JavaScript можно записывать как с десятичной точкой, так и без нее:
let num1 = 93;
let num2 = 93.00;
И в том, и в другом случае тип данных – число, и он один и тот же, неважно записано число с десятичной точкой или нет.
В JavaScript можно использовать экспоненциальное представление для того, чтобы сократить очень большие и очень маленькие числа:
let num3 = 987e8; // 98700000000
let num4 = 987e-8; // 0.00000987
Точность чисел в JavaScript составляет 15 цифр. Это значит, что после того, как запись числа дойдет до 16-ой цифры, число будет округлено:
let num5 = 999999999999999; // remains as 999999999999999 { // остается как 999999999999999 }
let num6 = 9999999999999999; // rounded up to 10000000000000000 { // округляется до 10000000000000000 }
Помимо обычного представления чисел, у числового типа данных в JavaScript есть три символьных значения:
Infinity
– числовое значение, которое символизирует
положительное
число, близкое к бесконечности.
-Infinity
– числовое значение, которое символизирует
отрицательное
число, близкое к бесконечности.
NaN
– числовое значение, которое символизирует
нечисло
, обозначающее не числовое значение.
Вы получите в качестве результата
Infinity
или
-Infinity
, если вычислите число, которое находится за пределами диапазона доступных чисел в JavaScript, а также для значений, которые не определены, например, если поделите на ноль:
let num7 = 5 / 0; // will return Infinity { // вернет Infinity }
let num8 = -5 / 0; // will return –Infinity { // вернет - Infinity }
Говоря техническим языком,
Infinity
отобразится в том случае, если число превысит значение
1.797693134862315E+308
, которое считается верхним пределом JavaScript.
И аналогично,
-Infinity
отобразится в том случае, если число превысит нижний предел, а именно
1.797693134862316E+308
.
Кроме того,
Infinity
можно использовать в циклах:
while (num9 != Infinity) {
// Code here will execute through num9 = Infinity
{ // Код будет выполняться вплоть до num9 = Infinity }
}
NaN
будет отображаться для недопустимых чисел. В случае, если вы попытаетесь выполнить какую-нибудь математическую операцию над числом и нечислом, то в качестве результата вы получите
NaN
:
let x = 20 / "Shark"; // x will be NaN { // переменной x будет присвоено значение NaN }
Из-за того, что число
20
нельзя разделить на строку
“Shark”
(мы не получим в результате число), возвращаемое значение для переменной
x
будет равно
NaN
.
Однако, если строку можно определить как числовое значение, то математическое выражение вполне может быть выполнено:
let y = 20 / "5"; // y will be 4 { // переменной y будет присвоено значение 4 }
В примере выше строка
"5"
может быть определена как число, именно поэтому JavaScript может ее интерпретировать как число, и оно будет работать с математическим оператором деления.
Если переменной, которая используется в операции, присвоено значение
NaN
, то в результате вы также получите значение
NaN
, даже если другой операнд является допустимым числом:
let a = NaN;
let b = 37;
let c = a + b; // c will be NaN { // переменной c будет присвоено значение NaN }
В JavaScript есть всего один числовой тип данных. Если вы работаете с числами, то любое число, которое вы введете, будет интерпретировано как тип данных для чисел; и поскольку JavaScript имеет динамическую типизацию, вам не нужно явно объявлять тип данных.
Строки
Строка
– это последовательность, состоящая из одного или нескольких символов (букв, цифр, символов). Строки могут оказаться довольно полезными, так как могут представлять текстовые данные.
В JavaScript строки можно записывать как в одинарных кавычках, так и в двойных. Так что, для того, чтобы создать строку, вам просто нужно заключить последовательность символов в кавычки:
let singleQuotes = 'This is a string in single quotes.';
let doubleQuotes = "This is a string in double quotes.";
Вы можете использовать любые кавычки (одинарные или двойные), но они должны быть одинаковыми во всей программе.
Программа «Hello, World!» демонстрирует то, как можно использовать строки в программировании. Так, символы, которые составляют фразу
Hello, World!
в
alert()
ниже, представляют собой строку.
hello.html
Когда мы запустим код и нажмем кнопку
Click me
, мы увидим всплывающее окно со следующим текстом:
Output
Hello, World!
По аналогии с другими типами данных, строки можно хранить в переменных:
let hw = "Hello, World!";
А также выводить строки, указав в
alert()
эту самую переменную:
hello.html
...
...
Output
Hello, World!
Существует огромное количество операций, которые можно выполнять со строками, чтобы достичь того результата, который мы хотим. Строки нужны для того, чтобы программа могла передавать информацию пользователю, а пользователь мог передавать информацию обратно в программу.
Логические значения
Переменные
логического типа данных
могут принимать только два значения:
true
или
false
(истина или ложь). Логические значения используются для того, чтобы представлять значения истинности, которые относятся к логическому разделу математики, используемому в алгоритмах информатики.
Во многих математических операциях ответы можно определить, как истинные или ложные:
больше чем
500 > 100 -
true
1 > 5 -
false
меньше чем
200 < 400 -
true
4 < 2 -
false
равно
5 = 5 -
true
500 = 400 -
false
Как и другие типы данных, логические значения можно хранить в переменных:
let myBool = 5 > 8; // false
Поскольку 5 не больше, чем 8, то это значит, что значение переменной
myBool
будет равно
false
.
По мере того, как вы будете практиковаться и писать все больше и больше программ на JavaScript, вы начнете лучше понимать, как работают логические значения и различные функции и операции, вычисляющие значения
true
или
false
, которые, в свою очередь, могут в корне изменить ход программы.
Массивы
Массив
может хранить сразу несколько значений в одной переменной. Это значит, что внутри массива вы можете хранить список значений и перебирать их.
Значения внутри массива называются
элементами
. Обращаться к элементам массива можно с помощью их порядковых номеров.
Строки – это символы в кавычках, а массивы – это значения в квадратных скобках.
Массив строк, например, будет выглядеть вот так:
let fish = ["shark", "cuttlefish", "clownfish", "eel"];
Если мы вызовем переменную
fish
, то получим следующее:
["shark", "cuttlefish", "clownfish", "eel"]
Массивы – это очень гибкий тип данных. Это так, поскольку они являются изменяемы, то есть мы можем добавлять элементы в массив, удалять элементы из массива и менять элементы в массиве.
Объекты
Объекты
в JavaScript могут хранить несколько значений в виде пар
имя:значение
. Таким образом, обеспечивается удобный способ хранения данных и доступа к ним. Синтаксис объектного литерала следующий: пара имя:значение, разделенные двоеточием и заключенные в фигурные скобки.
Как правило, объекты используются для того, чтобы хранить какие-то связанные данные, например, информацию, содержащуюся в ID. Если свойств несколько, то объектный литерал записывается следующим образом:
let sammy = {firstName:"Sammy", lastName:"Shark", color:"blue", location:"ocean"};
Есть альтернативный вариант, который в особенности касается объектов с большим количеством пар имя:значение, - объекты можно записать в несколько строк с пробелом после каждого двоеточия:
let sammy = {
firstName: "Sammy",
lastName: "Shark",
color: "blue",
location: "Ocean"
};
Переменная типа объект
sammy
во всех примерах выше имеет четыре свойства:
firstName
,
lastName
,
color
и
location
, и все эти переданные значения разделены двоеточием.
Работа с несколькими типами данных
Несмотря на то, что программа, которую вы создаете, будет содержать несколько типов данных, важно не забывать о том, что операции, как правило, вы будете выполнять с одним и тем же типом данных. То есть математические операции вы будете выполнять с числами, а срезы делать у строк.
Если вы используете оператор, который может работать с разными типами данных, например, оператор + (который может складывать числа и объединять строки), то можете получить довольно неожиданные результаты.
Например, если вы будете использовать оператор + с числами и строками одновременно, числа будут интерпретироваться как строки (то есть они будут объединены со строками). Однако порядок типов данных может влиять на то, как они будут объединяться.
Таким образом, если вы создадите переменную, которая выполняет следующую операцию объединения, то JavaScript будет интерпретировать все элементы как строки:
let o = "Ocean" + 5 + 3;
И если вы вызовете переменную
o
, то получите вот такой результат:
Output
Ocean53
Однако, если первым типом данных будет число, то JavaScript сначала сложит эти два числа, а когда программа дойдет до строки
"Ocean"
, это число будет проинтерпретировано как строка. Именно поэтому в качестве результата вы получите сумму двух чисел, объединенную со строкой:
let p = 5 + 3 + "Ocean";
Output
8Ocean
Из-за того, что могут происходить вот такие непредвиденные вещи, вы, вероятнее всего, будете выполнять все операции исключительно с одним типом данных, а не с несколькими. Так или иначе, в отличие от некоторых других языков программирования JavaScript не возвращает ошибок, если вы одновременно используете разные типы данных.
Заключение
Теперь вы знаете некоторые основные типы данных, которые есть в JavaScript.
Все эти типы могут оказаться полезными при разработке программных проектов на JavaScript.
Доскональное понимание принципов работы межсетевых экранов (брандмауэров) и относящихся к ним технологий крайне необходимо для любого человека, который желает развиваться в сфере информационной безопасности. Так же это помогает настраивать и управлять системой информационной безопасности правильно и с минимальным количеством ошибок.
Слово «межсетевой экран» как правило обозначает систему или устройство, которое находится на границе между внутренней(доверенной) сетью и внешней.
Несколько различных межсетевых экранов предлагают пользователям и приложениям особые политики управления безопасностью для различных угроз. Так же они часто обладают способностью записи событий, для предоставления системному администратору возможности идентифицировать, изучить, проверить и избавиться от угрозы.
Кроме того, несколько программных продуктов могут запускаться на рабочей станции только для защиты конкретной машины.
Сетевые брандмауэры обладают несколькими ключевыми особенностями, для того что бы обеспечивать защиту сети по ее периметру. Основной задачей сетевого брандмауэры является запрет или разрешение на пропуск траффика, который попадает в сеть, основываясь на предварительно настроенных политиках. Ниже перечислены процессы, позволяющие предоставлять или блокировать доступ траффику:
Однокритериальные (простые) методики фильтрации пакетов
Многокритериальные методики фильтрации пакетов
Прокси-серверы
Проверка состояния пакетов
Трансляция сетевого адреса
Методы фильтрации пакетов
Основная цель пакетных фильтров – просто контроль доступа к отдельным сегментам сети путем определения разрешенного трафика. Фильтры, как правило, исследуют входящий трафик на 2 уровне модели OSI (транспортном). К примеру, пакетные фильтры способны анализировать пакеты TCP и UDP и оценивать их по ряду критериев, которые называются листами контроля доступа. Они проверяют следующие элементы внутри пакета:
Исходящий сетевой адрес
Адрес назначения
Исходящий порт
Порт назначения
Протокол
Различные брандмауэры основанные на технике пакетной фильтрации так же могут проверять заголовки пакетов для определения источника пакета – т.е из какой сессии он появился: новой или уже существующий.
Простые методики фильтрации пакетов, к сожалению, имеют определенные недостатки:
Листы контроля доступа могут быть крайне велики и трудны для управления
Их можно обойти путем подмены пакетов, злоумышленник может послать пакет, в заголовке которого будет разрешенный листом контроля доступа сетевой адрес.
Очень многие приложения могут постоянно строить множественные соединения со случайно используемыми портами. Из-за этого становится действительно тяжело определить какие порты будут использованы после установления соединения. К примеру, таким приложением являются различные мультимедиа программы – RealAudio, QuickTime и прочие. Пакетные фильтры не воспринимают протоколы выше транспортного и их специфику, связанную с каждым конкретным приложением и предоставление такого доступа с использованием листов контроля доступа, является очень трудоёмкой задачей.
Прокси-серверы
Прокси-серверы — это устройства, которые являются промежуточными агентами, которые действуют от имени клиентов, которые находятся в защищенной или частной сети. Клиенты на защищенной стороне посылают запросы на установление соединения к прокси-серверу для передачи информации в незащищенную сеть или в Интернет. Соответственно, прокси-сервер или приложение совершает запрос от имени внутреннего пользователя. Большинство прокси брандмауэров работает на самом верхнем, седьмом уровне модели OSI (прикладном) и могут сохранять информацию в кэш-память для увеличения их производительности. Прокси-технологии могут защитить сеть от специфических веб-атак, но в общем и целом они не являются панацеей, и, кроме того, они плохо масштабируются.
Трансляция сетевого адреса
Некоторые устройства, работающие на третьем уровне(сетевом) могут совершать трансляцию сетевых адресов, или NAT (Network Address Translation). Устройство третьего уровня транслирует внутренний сетевой адрес хоста в публичный, который может маршрутизироваться в сети Интернет. В следствие малого числа сетевых адресов в протоколе IP, данная технология используется повсеместно.
Брандмауэры с проверкой состояния пакетов
Такие межсетевые экраны имеют дополнительные преимущества по сравнению с брандмауэрами с однокритериальной пакетной фильтрацией. Они проверяют каждый пакет, проходящий через их интерфейсы на корректность. Они исследуют не только заголовок пакета, но и информацию с прикладного уровня и полезную загрузку пакета. Таким образом, возможно создание различных правил, основанных на различных типах трафика. Такие брандмауэры так же позволяют контролировать состояние соединения и имеют базу данных с данной информацию, которая так же называется «база данных состояний». В ней описываются состояния соединений, т.е такие как «установлено», «закрыто», «перезапуск», «в процессе согласования». Такие брандмауэры хорошо защищают сеть от различных сетевых атак.
Количество различных брандмауэров велико, и в настоящее время в них совмещаются различные техники предотвращения атак. Главное – сеть всегда должна находиться под защитой. Однако нельзя забывать, что не стоит увлекаться, и тратить на защиту информации больше средств, чем стоит сама информация.
Универсальный уникальный идентификатор (UUID - Universally Unique Identifier) – это форма идентификатора, которую можно с уверенностью признать уникальной для большинства практических целей. Даже если два UUID были сгенерированы в двух различных средах двумя сторонами, они имеют ничтожные шансы на то, чтобы оказаться идентичными. Именно поэтому UUID считаются универсально уникальными.
В этой статье мы с вами рассмотрим характеристики UUID, то, как работает их уникальность, и сценарии, для которых они могут упростить процесс идентификации ресурсов. Несмотря на то, что мы будем рассматривать UUID с точки зрения программного обеспечения, которое взаимодействует с записями базы данных, их также можно применять и в других ситуациях, где требуется децентрализованная генерация уникальных идентификаторов.
Что такое на самом деле универсальный уникальный идентификатор (UUID)?
UUID – это просто значение, которое с уверенностью можно рассматривать как уникальное. Вероятность обнаружения двух одинаковых UUID настолько мала, что ее можно просто игнорировать. Вы можете встретить и другие термины для UUID, например, GUID (Globally Unique Identifier, - глобальный уникальный идентификатор) (такой вариант предпочитает Microsoft), однако смысл и свойства остаются теми же.
Истинный UUID – это уникальный идентификатор, который был сгенерирован и представлен в стандартизированном формате. Допустимые UUID определены в спецификации RFC 4122. Она описывает алгоритмы, которые можно использовать для генерации UUID, которые бы сохраняли свою уникальность в различных реализациях без участия основной выдающей стороны.
В RFC есть пять различных алгоритмов. У каждого из этих алгоритмов есть свой собственный механизм генерации значений. Ниже приведено краткое описание доступных «версий»:
Версия 1 – Time-Based – объединяет метку времени, тактовую последовательность и значение, которое является характерным для генерирующего устройства (как правило, это MAC-адрес); таким образом создается выходное значение, которое является уникальным для этого хоста на определенный момент времени.
Версия 2 – DCE Security – эта версия была создана как модификация Версии 1, которую можно использовать в среде распределенных вычислений (DCE - Distributed Computing Environment). Применяется не так часто.
Версия 3 – Name-Based (MD5) – MD5 хеширует «пространство имен» и «имя» для того, чтобы создать значение, которое будет уникальным для этого имени в пределах пространства имен. Попытка создать другой UUID с тем же пространством имен и тем же именем приведет к тому, что вы получите идентичный результат. Так что, этот метод дает воспроизводимые результаты.
Версия 4 – Random – большинство современных систем выбирают именно эту версию, поскольку здесь для получения выходного значения используется источник случайных и псевдослучайных чисел. Вероятность того, что будут созданы два одинаковых UUID, ничтожна мала.
Версия 5 – Name-Based (SHA-1) – эта версия в какой-то степени похожа на Версию 3, но здесь для хеширования пространства имен и имени используется более криптостойкий алгоритм SHA-1.
Хоть в RFC алгоритмы и обозначены как «версии», это ни в коем случае не значит, что всегда нужно использовать Версию 5, потому что она вроде бы самая новая. Выбор версии зависит от вашего варианта использования; зачастую выбирается Версия 4 из-за случайного характера генерации значений. Именно это делает ее идеальным вариантом для простых сценариев из разряда «дайте мне новый идентификатор».
Алгоритмы генерации на выходе дают 128-битное целое число без знака. Но при этом UUID чаще всего рассматривают как шестнадцатеричные строки. Также их можно хранить в виде двоичной последовательности из 16 символов. Ниже приведен пример UUID:
16763be4-6022-406e-a950-fcd5018633ca
Значение записано с помощью пяти групп буквенно-числовых символов, разделенных дефисом. Последние не являются обязательными составляющими строки; их наличие связано с историческими тонкостями спецификации UUID. А еще они значительно облегчают зрительное восприятие идентификатора.
Варианты использования UUID
В основном UUID используют для децентрализованного создания уникальных идентификаторов. Вы можете создать UUID где угодно и с уверенностью сказать, то он уникальный, независимо от того, был он создан на вашем сервере, в клиентском приложении или в вашей базе данных.
UUID упрощают определение и обеспечение идентичности объекта в изолированных средах. Согласно сложившейся практике, большинство приложений в качестве первичного ключа используют целочисленное поле с автоинкрементом. В таком случае, когда вы создаете новый объект, то вы не узнаете его идентификатор до тех пор, пока не добавите его в базу данных. С помощью UUID вы можете определить идентификатор в вашем приложении намного раньше.
Ниже приведен демонстрационный пример, написанный на PHP, который покажет разницу. Для начала давайте посмотрим на целочисленную систему:
class BlogPost {
public function __construct(
public readonly ?int $Id,
public readonly string $Headline,
public readonly ?AuthorCollection $Authors=null) {}
}
#[POST("/posts")]
function createBlogPost(HttpRequest $Request) : void {
$headline = $Request -> getField("Headline");
$blogPost = new BlogPost(null, $headline);
}
Мы должны инициализировать свойство
$Id
как
null
, поскольку мы не будем знать его фактический идентификатор до тех пор, пока не добавим его в базу данных. Это не самый идеальный вариант –
$Id
не должен обнуляться, из-за этого экземпляры
BlogPost
находятся в незавершенном состоянии.
Перейдем к UUID; это решит проблему:
class BlogPost {
public function __construct(
public readonly string $Uuid,
public readonly string $Headline,
public readonly ?AuthorCollection $Authors=null) {}
}
#[POST("/posts")]
function createBlogPost(HttpRequest $Request) : void {
$headline = $Request -> getField("Headline");
$blogPost = new BlogPost("16763be4-...", $headline);
}
Идентификаторы публикаций теперь можно создавать прямо в приложении, не думая о том, что они могут повториться. Это гарантирует, что экземпляры объекта всегда находятся в действительном состоянии и что ну нужно присваивать ID нулевое значение. Также эта модель упрощает обработку транзакционной логики; дочерние записи, которым нужна ссылка на родителя (например, взаимосвязи автора (
Author
) нашей публикации), могут быть добавлены немедленно, и не нужно обращаться к базе данных для того, чтобы получить идентификатор родителя.
В перспективе большую часть логики данного приложения-блога можно будет переместить на клиентскую сторону. Возможно, внешний интерфейс сможет поддерживать полностью автономное создание черновиков, по сути создавая экземпляры
BlogPost
, которые будут временно сохраняться на устройстве пользователя. Теперь клиент может создавать UUID для публикации и, если ему нужно будет восстановить подключение к сети, передавать его на сервер. Если в обозримом будущем клиент получит копию черновика с сервера, то он сможет сравнить ее с любым сохранившимся локальным состоянием, так как он уже будет знать UUID.
С помощью UUID можно комбинировать данные из различных источников. Объединение таблиц базы данных и кэшей, которые используют целочисленные первичные ключи, может оказаться довольно трудоемким процессом, и, плюс ко всему, в процессе могут возникать ошибки. UUID обеспечивает уникальность идентификатора не только внутри таблиц, но и на уровне всего пространства. Это делает их более предпочтительным вариантом для дублируемых структур и данных, которые часто необходимо перемещать из одной системы хранения в другую.
Нюансы, возникающие при встрече UUID с базами данных
Преимущества UUID довольно привлекательны. Однако есть несколько подводных камней, о которых следует помнить при использовании UUID в реальных системах. Один из значительных факторов в пользу целочисленных идентификаторов – их легко масштабировать и оптимизировать. Механизмы управления базами данных могут с легкостью индексировать, сортировать и фильтровать список чисел, которые идут одно за другим.
А вот про UUID такого сказать нельзя. Прежде всего, UUID в четыре раза больше, чем целое число (36 против 4 байтов); для больших наборов данных этот факт уже может быть существенным моментом. Такие значения намного сложнее сортировать и индексировать, особенно если речь идет о случайных UUID, которые являются самыми популярными. Их случайный характер говорит о том, что они не имеют естественного порядка. Если вы используете UUID в качестве первичного ключа, то это может навредить производительности при индексировании.
Все эти проблемы могут усугубляться в хорошо нормализованной базе данных, которая активно использует внешние ключи. В таком случае у вас может оказаться большое количество реляционных таблиц, каждая из которых хранит ссылки на ваши 36-байтные UUID. В конечном счете, дополнительная память, которая необходима для выполнения операций объединения и сортировки, может негативно сказаться на производительность вашей системы.
У вас есть возможность немного сгладить нежелательные последствия, сохранив свои UUID в виде двоичных данных. Это значит, что вместо столбца
VARCHAR(36)
у вас будет столбец
BINARY(16)
. Некоторые базы данные, например, PostgreSQL, имеют встроенный тип данных
UUID
; другие, например, MySQL, имеют специальные функции, которые преобразовывают строку UUID в двоичную форму и наоборот. Такой подход, конечно, более эффективный, но не забывайте, что вам по-прежнему придется использовать дополнительные ресурсы для хранения и выборки данных.
Эффективной может оказаться стратегия, когда вы в качестве первичных ключей оставляете целые числа, но при этом добавляете дополнительное поле UUID для того, чтобы ваше приложение могло на него ссылаться. Реляционные таблицы ссылок могут использовать идентификаторы для повышения производительности, пока ваш код извлекает и вставляет объекты верхнего уровня с UUID. Здесь все зависит от вашей системы, ее масштаба и ваших приоритетов: если вам нужна децентрализованная генерация идентификаторов и простейшее слияние данных, то лучший вариант – это UUID, но вам следует помнить и об обратной стороне медали.
Заключение
UUID – это уникальные значения, которые можно использовать для децентрализованной генерации идентификаторов. Совпадение идентификаторов возможно, но вероятность такого события настолько мала, что ее можно не учитывать. Если бы вы генерировали один миллиард UUID в секунду в течении 100 лет, то вероятность обнаружить дубликат составила бы около 50% при условии наличия достаточной энтропии.
У вас есть возможность использовать UUID для установления идентичности независимо от вашей базы данных до того, как вы добавите объект в базу данных. Такой подход упрощает код прикладного уровня и не допускает того, что объекты в вашей системе будут идентифицированы неправильно. UUID также содействуют репликации данных, гарантируя уникальность вне зависимости от хранилища данных, устройства или среды, чего нельзя сказать о целочисленных ключах, которые действуют на уровне таблиц.
Несмотря на то, что UUID широко используются при разработке программного обеспечения, они не являются идеальным решением. Новички часто зацикливаются на возможности обнаружения совпадений, но это не должно быть вашим главным аргументом, если только ваша система не настолько чувствительна, что вам просто необходимо гарантировать уникальность идентификаторов.
Более очевидная проблема для большинства разработчиков заключается в хранении и извлечении сгенерированных UUID. Примитивное использование
VARCHAR(36)
(или
VARCHAR(32)
, если вы удалите дефисы) в долгосрочной перспективе может оказывать негативное влияние на ваше приложение, так как большая часть попыток оптимизировать индексацию базы данных будут неэффективными. Изучите встроенные средства обработки UUID в вашей системе управления базой данных для того, чтобы максимально улучшить производительность вашего программного решения.