Null что это
Null что это
Null, ноль и Undefined: разбираемся в сортах пустоты
Скоро это будет очень полезный навык
Иногда в коде можно встретить что-то вроде такого:
Минутка информатики. Если копать совсем глубоко, то в переменной не всегда лежат именно те данные, которые мы туда отправили.
Чаще всего при объявлении переменной компьютер выделяет сколько-то байтов в памяти, в которые можно записать любое помещающееся значение. Но это работает только для простых переменных — чисел и символов (которые внутри тоже числа). Если нам нужна строка, которая состоит из множества символов, или массив, то в переменной хранится не значение, а только ссылка на область памяти, в которой лежат наши данные. В этих случаях переменная — это карта, которая объяснит компьютеру, где найти всё остальное.
Зная это, будет проще разобраться, почему компьютер иногда вместо конкретного значения переменной записывает в неё null или undefined.
Что такое undefined
Когда мы только создаём переменную без явного указания типа и ничего в неё не кладём, то компьютер многого не знает:
Код на JavaScript
В тех языках, где переменные не обязательно объявлять заранее, например в Python, интерпретатор тоже выведет подобное сообщение. Отличие будет в том, что здесь это приведёт к ошибке, так как компьютер даже не знает, что у него есть такая переменная.
Представьте, что вы занимаетесь уборкой и вам говорят: «Возьми мешок». Что это значит? Пока неясно: это мешок для мусора или вещей; какого объёма; полный или пустой. Просто «мешок». Если представить, что мешок — это переменная, то undefined мешок — это как раз «просто некий мешок, без уточнения».
Зачем нужен undefined
Чаще всего это используется для проверки состояния переменной — есть ли в ней хоть что-то. Например, если в ней что-то есть, то с этим можно работать дальше, а если нет — вывести сообщение о том, что переменная пустая. Это полезно для отладки кода или для проверки входящих в нашу программу данных и вывода информативных ошибок.
Что такое null
В отличие от undefined, когда компьютер не знает, что лежит в переменной, null — это как раз одно из значений переменной. Оно означает, что переменная — пустая, при этом компьютер точно знает, как с ней можно работать.
Допустим, мы хотим обратиться к элементу на странице по его id. Для этого мы сначала заводим переменную element, и на старте она будет определяться как undefined. После этого мы присваиваем этой переменной ссылку на нужный элемент, но если этого элемента на странице нет, то произойдёт такое:
Если вспомнить наш мешок во время уборки:
— undefined — это когда вы ничего не знаете про мешок — даже то, есть ли этот мешок в принципе или его нужно пойти и где-то купить;
— null — это когда вы знаете, что мешок есть, он определённого размера и формы, но он точно пустой и даже ещё не раскрытый;
В некоторых языках, например Python, вместо null используют None — это тоже значение переменной, которое означает, что в переменной ничего нет, но сама переменная определена верно.
Undefined и null — это одно и то же?
Нет, и в этом легко убедиться, используя строгое сравнение. Дело в том, что при обычном сравнении компьютер смотрит, есть что-то в переменной или нет, при этом ему неважно, работали мы с ней раньше или нет. А при строгом сравнении компьютер смотрит ещё и на тип данных — в этом случае сразу видно, что у undefined никакого типа данных нет:
А что такое ноль?
А ноль — это самая «жирная» пустота из всех вышеперечисленных. Ноль — это полноценное значение численной переменной (например, integer, то есть целого числа).
Представьте, что вы пишете программу, которая обрабатывает прогнозы погоды. Эти данные она получает с погодного сервера. И с этого сервера прилетала переменная temperature. Сравните:
Если temperature === undefined, то, похоже, с сервера не прилетело никакой переменной с температурой. Программа завела переменную для приёма данных, но дальше ничего не произошло. Мы даже не знаем, какого типа данные нам прилетят. А то и вовсе нет никакой переменной.
Если temperature === null, то мы знаем, в каком формате прилетит температура, но сами данные ещё не прилетели.
Если temperature === 0, то температура — ноль градусов (предположим, по Цельсию). Ноль градусов — это вполне себе значение, с которым можно работать — например нарисовать снежинку.
Возвращаясь к метафоре с мешком: ноль — это когда нам объяснили, какой именно нужен мешок, мы его взяли и запихнули в него ноль, который занял всё место. Зачем? Видимо, так надо.
NULL (SQL)
NULL в Системах управления базами данных (СУБД) — специальное значение (псевдозначение), которое может быть записано в поле таблицы базы данных (БД). NULL соответствует понятию «пустое поле», то есть «поле, не содержащее никакого значения». Введено для того, чтобы различать в полях БД пустые (визуально не отображаемые) значения (например, строку нулевой длины) и отсутствующие значения (когда в поле не записано вообще никакого значения, даже пустого).
NULL означает отсутствие, неизвестность информации. Значение NULL не является значением в полном смысле слова: по определению оно означает отсутствие значения и не принадлежит ни одному типу данных. Поэтому NULL не равно ни логическому значению FALSE, ни пустой строке, ни нулю. При сравнении NULL с любым значением будет получен результат NULL, а не FALSE и не 0. Более того, NULL не равно NULL!
Содержание
Необходимость NULL в реляционных БД
Использование NULL в БД
В БД, поддерживающих понятие NULL, для поля таблицы при описании определяется, может ли оно быть пустым. Если да, то в это поле можно не записывать никакого значения, и это поле будет иметь значение NULL. Также можно и явно записать в такое поле значение NULL.
Как правило, СУБД не разрешает значение NULL для полей, являющихся частью первичного ключа таблицы. В полях внешних ключей, напротив, NULL допускается. Наличие NULL в поле внешнего ключа может трактоваться как признак отсутствия связанной записи, и для такого внешнего ключа не требуется исполнение правил ссылочной целостности, обязательных для любого другого значения внешнего ключа.
Операции с NULL
Поскольку NULL не является, в общем смысле, значением, использование его в арифметических, строковых, логических и других операциях, строго говоря, некорректно. Тем не менее, большинство СУБД поддерживают такие операции, но вводят для них специальные правила:
Кроме того, могут существовать специальные системные функции для удобного преобразования NULL к определённым значениям, например, в Oracle имеется системная функция NVL, которая возвращает значение своего параметра, если он не NULL, или значение по умолчанию, если операнд — NULL. В стандарте SQL-92 определены две функции: NULLIF и COALESCE, поэтому их использование является более предпочтительным (если конкретная СУБД их реализует).
Заметка про NULL
Основные положения
Для удобства сделаем процедуру, печатающую состояние булевого параметра:
и включим опцию печати сообщений на консоль:
Привычные операторы сравнения пасуют перед NULLом:
Сравнение с NULLом
Соответственно, IS NOT NULL действует наоборот: вернёт истину, если значение операнда отлично от NULLа и ложь, если он является NULLом:
DECODE идёт против системы:
Пример с составными индексами находится в параграфе про индексы.
Логические операции и NULL
В большинстве случаев неизвестный результат обрабатывается как ЛОЖЬ :
Отрицание неизвестности даёт неизвестность:
Операторы IN и NOT IN
Для начала сделаем несколько предварительных действий. Для тестов создадим таблицу T с одним числовым столбцом A и четырьмя строками: 1, 2, 3 и NULL
Включим трассировку запроса (для этого надо обладать ролью PLUSTRACE ).
В листингах от трассировки оставлена только часть filter, чтобы показать, во что разворачиваются указанные в запросе условия.
Предварительные действия закончены, давайте теперь поработаем с операторами. Попробуем выбрать все записи, которые входят в набор (1, 2, NULL) :
Попробуем теперь с NOT IN :
Вообще ни одной записи! Давайте разберёмся, почему тройка не попала в результаты запроса. Посчитаем вручную фильтр, который применила СУБД, для случая A=3 :
Из-за особенностей трёхзначной логики NOT IN вообще не дружит с NULLами: как только NULL попал в условия отбора, данных не ждите.
NULL и пустая строка
Здесь Oracle отходит от стандарта ANSI SQL и провозглашает эквивалентность NULLа и пустой строки. Это, пожалуй, одна из наиболее спорных фич, которая время от времени рождает многостраничные обсуждения с переходом на личности, поливанием друг друга фекалиями и прочими непременными атрибутами жёстких споров. Судя по документации, Oracle и сам бы не прочь изменить эту ситуацию (там сказано, что хоть сейчас пустая строка и обрабатывается как NULL, в будущих релизах это может измениться), но на сегодняшний день под эту СУБД написано такое колоссальное количество кода, что взять и поменять поведение системы вряд ли реально. Тем более, говорить об этом они начали как минимум с седьмой версии СУБД (1992-1996 годы), а сейчас уже двенадцатая на подходе.
NULL и пустая строка эквивалентны:
непременный атрибут жёсткого спора:
Длина пустой строки не определена:
Сравнение с пустой строкой невозможно:
Критики подхода, предлагаемого Ораклом, говорят о том, что пустая строка не обязательно обозначает неизвестность. Например, менеджер по продажам заполняет карточку клиента. Он может указать его контактный телефон (555-123456), может указать, что он неизвестен (NULL), а может и указать, что контактный телефон отсутствует (пустая строка). С оракловым способом хранения пустых строк реализовать последний вариант будет проблемно. С точки зрения семантики довод правильный, но у меня на него всегда возникает вопрос, полного ответа на который я так и не получил: как менеджер введёт в поле «телефон» пустую строку и как он в дальнейшем отличит его от NULLа? Варианты, конечно, есть, но всё-таки…
Вообще-то, если говорить про PL/SQL, то где-то глубоко внутри его движка пустая строка и NULL различаются. Один из способов увидеть это связан с тем, что ассоциативные коллекции позволяют сохранить элемент с индексом » (пустая строка), но не позволяют сохранить элемент с индексом NULL:
Использовать такие финты ушами на практике не стоит. Во избежание проблем лучше усвоить правило из доки: пустая строка и NULL в оракле неразличимы.
Математика NULLа
Этот маленький абзац писался пятничным вечером под пиво, на фоне пятничного РЕН-ТВшного фильма. Переписывать его лень, уж извините.
Очевидно, что мы ничем не сможем помочь Коле: неизвестное количество любовников Маши до замужества сводит все расчёты к одному значению — неизвестно. Oracle, хоть и назвался оракулом, в этом вопросе уходит не дальше, чем участники битвы экстрасенсов: он даёт очевидные ответы только на очевидные вопросы. Хотя, надо признать, что Oracle гораздо честнее: в случае с Колей он не будет заниматься психоанализом и сразу скажет: «я не знаю»:
С конкатенацией дела обстоят по другому: вы можете добавить NULL к строке и это её не изменит. Такая вот политика двойных стандартов.
NULL и агрегатные функции
Таблица с данными. Используется ниже много раз:
Пустые значения игнорируются агрегатами:
Набор данных только из NULLов:
Пустой набор данных:
NULL в OLAP
Удобная фишка sqlplus: при выводе данных заменяет NULL на указанную строку:
Проверяем дуализм NULLа в многомерном кубе:
Null, великий и ужасный
Именно так и никак иначе: null в C# — однозначно ошибочное решение, бездумно скопированное из более ранних языков.
Этот ящик Пандоры был открыт еще при создании языка ALGOL W великим Хоаром, который позднее назвал собственную идею ошибкой на миллиард долларов.
Лучшая историческая альтернатива
Разумеется, она была, причем очевидная по современным меркам
Самое трагичное, что все это не было откровением и даже новинкой уже к моменту проектирования первой версии языка. Увы, тогда матерых функциональщиков в команде Хейлсберга не было.
Лекарства для текущей реальности
Хотя прогноз очень серьезный, летального исхода можно избежать за счет применения различных практик и инструментов. Способы и их особенности пронумерованы для удобства ссылок.
Явные проверки на null в операторе if. Очень прямолинейный способ с массой серьезных недостатков.
Атрибут NotNull. Немного упрощает использование явных проверок
Паттерн проектирования Null object. Очень хороший способ, но с ограниченной сферой применения.
Конвенция о возврате живых объектов по умолчанию. Очень просто и эффективно.
Любой метод или свойство, для которых явно не заявлена возможность возвращать null, должны всегда предоставлять полноценный объект. Для поддержания достаточно выработки хорошей привычки, например, посредством ревью кода.
Конвенция о стандартных способах явно указать что свойство или метод может вернуть null: например, префикс Try или суффикс OrDefault в имени метода. Органичное дополнение к возврату полноценных объектов по умолчанию. Достоинства и недостатки те же.
Атрибут CanBeNull. Добрый антипод-близнец атрибута NotNull.
Операторы C# (тернарный, Элвиса, coalesce)
Тип Optional. Позволяет явно поддержать отсутствие объекта.
Монада Maybe. LINQ для удобной обработки случаев как наличия, так и отсутствия объекта.
Пакет Fody/NullGuard. Автоматические проверки на null на стероидах.
Ссылочные типы без возможности присвоения null (если добавят в одну из будущих версий C#)
Итоги
Буду краток — все выводы в таблице:
| Настоятельная рекомендация | Антипаттерн | На ваш вкус и потребности |
|---|---|---|
| 4, 5, 7, 11, 12 (когда и если будет реализовано) | 1, 2 | 3, 6, 8, 9, 10 |
На предвосхищение ООП через 20 лет не претендую, но дополнениям и критике буду очень рад.
Обновление
добавил примеры кода к утопической альтернативе.
Значение NULL: руководство для начинающих
Если вы далеки от работы с базами данных, для вас может быть открытием, что ноль – это не значение NULL, хотя, признаем, они созвучны. Кроме того, NULL не является значением пустой строки, хотя можно найти поле, содержащее данные любого типа.
NULL можно представить как значение для представления неизвестного фрагмента данных (обратите внимание: не нулевого, хотя поле при этом выглядит пустым). А еще он не равен ничему, даже другому NULL. И сегодня мы поговорим об этом загадочном (на первый взгляд) значении NULL более подробно.
Пример значения NULL
Итак, что вы должны знать о значении NULL? Давайте разбираться.
Представьте себе письменный стол, на котором лежат канцелярские принадлежности: 6 шариковых ручек и 2 простых карандаша. Также известно, что в ящике стола должны быть фломастеры. Но вот сколько их и есть ли они вообще — данных нет. Если нам нужно составить таблицу инвентаризации с вводом значения NULL, то выглядеть она будет так:
| InventoryID | Item | Количество |
| 1 | ручки | 6 |
| 2 | карандаши | 2 |
| 3 | фломастеры | NULL |
Как вы понимаете, принимать за «0» количество фломастеров в данном случае было бы неверным, так как подобная запись показывала бы, что фломастеров нет вообще. Но точные данные об их количестве отсутствуют, поэтому может оказаться, что несколько штук все же есть.
Значение NULL и НЕ NULL
IS NULL и IS NOT NULL – специально созданные операторы, которые осуществляют сравнение имеющихся NULLов. IS NULL возвращает истину, если операнда является NULLом. Соответственно, если операнд не является NULLом, то значение будет ложным.
select case when null is null then ‘YES’ else ‘NO’ end from dual; — YES
select case when ‘a’ is null then ‘YES’ else ‘NO’ end from dual; — NO
IS NOT NULL имеет обратный принцип: значение будет истинным, если операнд не является NULLом, и ложным, если он таковым является.
select case when ‘a’ is NOT null then ‘YES’ else ‘NO’ end from dual; — YES
select case when null is NOT null then ‘YES’ else ‘NO’ end from dual; — NO
Учтите, что когда речь идет об отсутствующих значениях, есть особые случаи их сравнения:
Вот так проявляет себя DECODE:
, null, ‘EMPTY’ — это условие будет истинным
Значение NULL в MySQL
Результат при сравнении NULLов, в зависимости от операции SQL, часто будет иметь значение NULL. Предположим, что А НЕДЕЙСТВИТЕЛЕН:
Логические операции и NULL
Для логических операторов AND и OR есть свои особенности при работе со значением NULL. Краткое руководство рассмотрим на примере.
Чаще всего с неизвестным результатом работают как с ЛОЖЬЮ:
select 1 from dual where dummy = null; — запрос не вернёт записей
При отрицании неизвестности результатом будет НЕИЗВЕСТНО:
exec test_bool( not(null = null)); — UNKNOWN
exec test_bool( not(null = ‘a’) ); — UNKNOWN
exec test_bool(null or true); — TRUE с доходом
от 200 000 ₽
Скачивайте и используйте уже сегодня:
Топ-30 самых востребованных и высокооплачиваемых профессий 2022
Поможет разобраться в актуальной ситуации на рынке труда
Подборка 50+ ресурсов об IT-сфере
Только лучшие телеграм-каналы, каналы Youtube, подкасты, форумы и многое другое для того, чтобы узнавать новое про IT
ТОП 50+ сервисов и приложений от Geekbrains
Безопасные и надежные программы для работы в наши дни
Операторы IN и NOT IN для значения NULL
Чтобы понять взаимодействие этих операторов с NULLом, рассмотрим пример.
Создадим таблицу Т, состоящую из одного числового столбца А и строками: 1, 2, 3 и NULL.
create table t as select column_value a from table(sys.odcinumberlist(1,2,3,null));
Затем выполним трассировку запроса (учтите, что для этого нужно обладать ролью PLUSTRACE).
От трассировки в листингах оставлена часть filter, чтобы показать преобразование указанных в запросе условий.
Теперь, после подготовительных действий, попробуем выбрать те записи, которые будут соответствовать набору (1, 2, NULL).
select * from t where a in(1,2,null); — вернёт [1,2]
— filter(«A»=1 OR «A»=2 OR «A»=TO_NUMBER(NULL))
По какой-то причине строка с NULLом не выбрана. Возможно, это случилось потому, что вычисление предиката «А»=TO_NUMBER(NULL) вернуло состояние НЕИЗВЕСТНО. Попробуем явно указать условие включения NULLов в результаты запросов:
select * from t where a in(1,2) or a is null; — вернёт [1,2,NULL]
— filter(«A» IS NULL OR «A»=1 OR «A»=2)
Попробуем с NOT IN:
select * from t where a not in(1,2,null); — no rows selected
— filter(«A»<>1 AND «A»<>2 AND «A»<>TO_NUMBER(NULL))
Ни одной записи так и не появилось.
Это объясняется тем, что трехзначная логика NOT IN не взаимодействует с NULLами: при попадании NULL в условия отбора данных можно не ждать.
Значение NULL и пустая строка в СУБД
Oracle отличается от стандартов ANSI SQL в определении NULLов: он проводит знак равенства между NULL и пустой строкой. Эта особенность программы рождает много споров, хотя Oracle и заявляет, что, возможно, в будущих релизах будет изменен подход в обработке пустой строки, как NULL. Но в реальности проведение таких изменений сомнительно, так как под эту СУБД написано неимоверное количество кода.
Интенсив «Путь в IT» поможет:
Тест, в котором вы оцениваете свои качества и узнаете, какая профессия в IT подходит именно вам
«Критические ошибки, которые могут разрушить карьеру»
Собрали 7 типичных ошибок, четвертую должен знать каждый!
Тест «Есть ли у вас синдром самозванца?»
Мини-тест из 11 вопросов поможет вам увидеть своего внутреннего критика
Гайд по профессиям в IT
5 профессий с данными о навыках и средней заработной плате
exec test_bool( » is null ); — TRUE
Если попытаться найти причину, почему вообще пустую строку стали считать эквивалентной NULL, то ответ можно найти в формате хранения varchar`ов и NULLов внутри блоков данных. Табличные строки Oracle хранит в структуре, представляющей собой заголовок и следующими за ним столбцы с данными.
Каждый столбец, в свою очередь, состоит из 2-х полей: длина данных в столбце (1 или 3 байта) и сами данные. При нулевой длине varchar2 в поле с данными нечего вносить, так как оно не занимает ни байта. В поле же, где указывается длина, вносится специальное значение 0xFF, что и означает отсутствие данных.
NULL Oracle представляет аналогично, то есть отсутствует поле с данными, а в поле длины данных вносится 0xFF. Так как изначально разработчики Oracle не разделяли эти два состояния, то и сейчас принцип внесения данных не изменился.
Значение NULL
Понятие «пустая строка» допустимо толковать как абсолютное отсутствие значения, так как ее длина равна нулю. NULL же, в свою очередь, имеет длину неопределенного значения. Поэтому выражение length (») возвращает NULL, а не ожидаемый ноль.
Еще одна причина, по которой нельзя сравнивать NULL с пустой строкой: выражение val = » вернёт состояние НЕИЗВЕСТНО, так как, по сути, идентично val=NULL.
Неопределенная длина пустой строки:
select length(») from dual; — NULL
Сравнение с пустой строкой невозможно:
Критика такого подхода Oracle к значениям NULL и пустой строки, основывается на том, что не всегда пустая строка может означать неизвестность. Например, когда менеджер-продавец вносит данные в карточку клиента, то в поле «Контактный номер» он может указать конкретный номер; также он может указать, что номер неизвестен (NULL); но еще он может указать, что номера как такового нет (пустая строка).
Отличия между null и undefined
Можно сказать, что NULL – это такое значение, которое является определенным для отсутствующего объекта. UNDEFINED же означает именно неопределенность. Например:
// значение переменной element до её инициализации не определённо: undefined
// здесь при попытке получения несуществующего элемента, метод getElementById возвращает null
// переменная element теперь инициализирована значением null, её значение определено
Осуществляя проверку на NULL или UNDEFINED, нужно помнить о разнице в операторах равенства (==) и идентичности (===): с первым оператором производится преобразование типов.
typeof null // object (не «null» из соображений обратной совместимости)
typeof undefined // undefined
null === undefined // false
null == undefined // true
Это все то, что вы должны знать о значении NULL. Обрастая опытом и применяя некоторые уловки для избежания NullPointerException, вы научитесь делать безопасный код. Главным образом неразбериха возникает из-за того, что NULL может трактоваться как пустое значение или как неидентифицированное.
Null что это
См. также
 | Список значений слова или словосочетания со ссылками на соответствующие статьи. Если вы попали сюда из другой статьи Википедии, пожалуйста, вернитесь и уточните ссылку так, чтобы она указывала на статью. |
Полезное
Смотреть что такое «NULL» в других словарях:
Null — (de) … Kölsch Dialekt Lexikon
Null — Pour le musicien japonais, voir Kazuyuki K. Null. NULL est un mot clef présent dans de nombreux langages informatiques, et qui désigne l état d un pointeur qui n a pas de cible ou d une variable qui n a pas de valeur. La notion de valeur ou … Wikipédia en Français
Null — may refer to: Contents 1 In computing 2 In art 3 In mathematics 4 In science 5 People … Wikipedia
Null — «Null» redirige aquí. Para otras acepciones, véase Null (desambiguación). El término null o nulo es a menudo utilizado en la computación, haciendo referencia a la nada. En programación, null resulta ser un valor especial aplicado a un puntero (o… … Wikipedia Español
null — [nʌl] adjective [only before a noun] 1. STATISTICS a null effect, result etc is one that is zero or nothing 2. LAW another name for null and void: • Their suit also asks the court to declare null the buyer s shareholder rights plan. * * * … Financial and business terms
NULL (Си и Си++) — NULL в языках программирования Си и C++ макрос, объявленный в заголовочном файле stddef.h (и других заголовочных файлах). Значением этого макроса является зависящая от реализации константа нулевого указателя (англ. null pointer constant).… … Википедия
null — / nəl/ adj [Anglo French nul, literally, not any, from Latin nullus, from ne not + ullus any]: having no legal or binding force: void a null contract Merriam Webster’s Dictionary of Law. Merriam Webster. 1996 … Law dictionary
Null — Null, a. [L. nullus not any, none; ne not + ullus any, a dim. of unus one; cf. F. nul. See
Null-O — is a 1958 science fiction short story by Philip K. Dick. This rather brief story examines the concept of totally unempathic and logical humans ( Null O s) in an obvious parody of the plot and concepts of The Players of Null A by A. E. van Vogt.… … Wikipedia
Что вы должны знать о значениях NULL
Понимать использование пустых значений, чтобы избежать проблем с базой данных
Пользователи, плохо знакомые с миром баз данных, часто путаются с особым значением, относящимся к полю – значением NULL. Это значение можно найти в поле, содержащем данные любого типа, и имеет особое значение в контексте реляционной базы данных. Вероятно, лучше начать обсуждение NULL с нескольких слов о том, что такое NULL не :
Скорее, NULL – это значение, используемое для представления неизвестного фрагмента данных. Часто программисты баз данных используют фразу «значение NULL», но это неверно. Помните: NULL – это неизвестное значение, в котором поле выглядит пустым.
NULL в реальном мире
Давайте рассмотрим простой пример: стол с инвентарём для фруктовой лавки. Предположим, что наш инвентарь содержит 10 яблок и три апельсина. Мы также храним сливы, но информация о наших запасах неполная, и мы не знаем, сколько (если таковые имеются) слив есть в наличии. Используя значение NULL, мы получим таблицу инвентаризации, показанную в таблице ниже.
Инвентарь фруктовых лавок
| InventoryID | Item | Количество |
| 1 | Яблоки | 10 |
| 2 | Апельсины | 3 |
| 3 | Сливы | NULL |
Было бы неправильно указывать количество 0 для записи слив, потому что это означало бы, что в инвентаре нет слив. Напротив, у нас может быть немного слив, но мы просто не уверены.
NULL или НЕ NULL?
Таблица может быть спроектирована для разрешения значений NULL или нет. Вот пример SQL, который создает таблицу инвентаризации, которая допускает некоторые значения NULL:
Хотя допустимое значение NULL вполне приемлемо, значения NULL могут вызвать проблемы, поскольку любое сравнение значений, в которых значение равно NULL, всегда приводит к NULL.
Чтобы проверить, содержит ли ваша таблица значения NULL, используйте оператор IS NULL или IS NOT NULL. Вот пример IS NULL:
Учитывая наш пример здесь, это вернет:
| 3 | Сливы |
Работает на NULL
Работа со значениями NULL часто приводит к результатам NULL, в зависимости от операции SQL. Например, предполагая, что A НЕДЕЙСТВИТЕЛЕН:
Арифметические операторы
Операторы сравнения
Это всего лишь несколько примеров операторов, которые всегда возвращают NULL, если один из операндов равен NULL. Существуют гораздо более сложные запросы, и все они усложняются значениями NULL. Главная идея заключается в том, что, если вы разрешите значения NULL в своей базе данных, поймите последствия и спланируйте их.
Оригинал статьи этой статьи впервые был опубликован в блоге автора @KevinMarquette. Группа разработчиков PowerShell благодарит Кевина за то, что он поделился с нами этими материалами. Читайте его блог — PowerShellExplained.com.
Что означает NULL
Значение NULL можно считать неизвестным или пустым значением. Переменная имеет значение NULL, пока ей не присвоено значение или объект. Это важный момент, так как некоторые команды требуют значения и возвращают ошибку, если значением является NULL.
$null в PowerShell
$null — это автоматическая переменная в PowerShell, используемая для представления значения NULL. Ее можно назначать переменным и использовать в сравнениях, а также в качестве заполнителя для значения NULL в коллекции.
В строках
Это одна из причин, по которой я предпочитаю заключать переменные в скобки при их использовании в сообщениях журнала. Если значение находится в конце строки, это также помогает обнаружить границы значений переменных.
В числовом уравнении
Вместо коллекции
Вместо объекта
Метод в выражении со значением NULL
Взгляните на следующий пример и постарайтесь предсказать результаты:
PSScriptAnalyzer и VSCode
Поскольку VS Code также использует правила PSScriptAnalyser, в редакторе такие фрагменты кода выделяются и считаются проблемой.
Простая проверка if
Но это еще не все. На самом деле строка значит следующее:
Ниже приведен более полный пример этой инструкции.
Несколько дней назад я столкнулся с этой проблемой при рефакторинге кода. В нем присутствовала базовая проверка такого типа.
$null.Count
[PSCustomObject] Count
Выполнение этого примера в Windows PowerShell 5.1 и PowerShell 6.0 дает разные результаты.
Пустое значение NULL
Pipeline
foreach
Оператор foreach начал так работать с версии PowerShell 3.0. Если у вас предыдущая версия, такой режим работы в ней не поддерживается. Это одно из важных отличий, которое необходимо учитывать при обратном портировании кода для совместимости с версией 2.0.
Типы значений
Параметры функции
Общепринято использовать строго типизированные значения в параметрах функций. Обычно мы стараемся определять типы параметров, даже если не собираемся определять типы других переменных в скриптах. Возможно, вы сами строго типизировали переменные в функциях, даже не осознавая этого.
IsNotNullOrEmpty
Я часто так делаю, когда знаю, что тип значения должен быть строкой.
Сценарий без результатов
У меня выработалась привычка инициализировать все переменные перед их использованием. В других языках это обязательно. В начале функции или цикла foreach я определяю все используемые значения.
Вот сценарий, который я советую вам внимательно изучить. Это пример ошибки, которую я однажды выявлял.
Проблемы с областью действия
Если взять тот же пример Do-something и удалить из него цикл, то код будет таким:
Out-Null
Сводка
Что из себя представляет null?
Свободный перевод вопроса «What is null in Java?» от участника @unj2.
1 ответ 1
В Java null == null (что верно не для всех языков). Из описания java.lang.Object :
public boolean equals(Object obj)
null также является значением по умолчанию для всех ссылочных типов.
Вы можете использовать это свойства для отложенной инициализации, когда поле будет иметь начальное значение null до тех пор, пока оно фактически не будет использовано, где будет заменено «реальным» значением (вычисление которого может быть дорогостоящим).
Есть и другие применения. Если посмотреть на java.lang.System :
Returns: The system console, if any, otherwise null.
Это очень распространённая практика: null используется для обозначения несуществующего объекта.
public String readLine() throws IOException
Returns: A String containing the contents of the line, not including any line-termination characters, or null if the end of the stream has been reached.
Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
К примеру, java.util.Hashtable делает вещи проще путём запрета null в ключах и значениях; так что, если V get(Object key) вернёт null это однозначно говорит о том, что под таким ключом ничего нет.
Операции автоматического анбоксинга на null выбросят java.lang.NullPointerException :
Если резюмировать, то null используется как специальное значение для обозначения:
Как null представлен в памяти?
Небольшое дополнение
I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language (ALGOL W). My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn’t resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.
Все о null в JavaScript
Дата публикации: 2020-11-09
От автора: в JavaScript есть 2 вида типов: примитивы (строки, логические значения, числа, символы) и объекты.
Объекты — это сложные структуры данных. Самый простой объект в JavaScript — это простой объект — набор ключей и связанных значений:
Но бывают ситуации, когда объект не может быть создан. Для таких случаев JavaScript предоставляет специальное значение null, которое указывает на отсутствующий объект.
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
В этом посте вы узнаете все о null в JavaScript: его значении, как его обнаружить, разницу между null и undefined и почему широкое использование null создает трудности с обслуживанием кода.
1. Концепция null
Спецификация указывает следующее: Null — примитивное значение, которое представляет собой намеренное отсутствие какого-либо значения объекта.
Если вы видите null (присвоенное переменной или возвращенное функцией), то в этом месте должен быть объект, но по какой-то причине объект не был создан. Например, функция greetObject() создает объекты, но также может возвращать null, когда объект не может быть создан:
При вызове функции со строковым аргументом greetObject(‘Eric’), как и ожидалось, функция возвращает объект < message: ‘Hello, Eric!’ >.
Однако при вызове функции без аргументов — greetObject() — функция возвращается null. Возврат null является разумным, потому что параметр who не имеет значения и объект не может быть создан.
1.1 Аналогия null
Думая об аналогии в реальном мире, вы можете представить переменную как коробку. Так же, как переменная может содержать объект, коробка может содержать объекты, например, чайник.
2. Как проверить на null
Хороший способ проверить null, это — использовать оператор строгого равенства:
missingObject === null оценивается true, потому что переменная missingObject содержит значение null. Если переменная содержит ненулевое значение, например объект, выражение existingObject === null оценивается, как false.
2.1 null — ложно
Null, наряду с false, 0, », undefined, NaN, является ложным значением. Если в условных выражениях встречается ложное значение, то JavaScript приравнивает ложное значение к false.
2.2 typeof null
Оператор typeof value определяет тип значения. Например, typeof 15 будет ‘number’ и typeof < prop: ‘Value’ >оценивается, как ‘object’. Интересно, как оценивается type null?
Не используйте оператор typeof для определения значения null. Как упоминалось ранее, используйте оператор строгого равенства myVar === null.
Если вы хотите проверить, содержит ли переменная объект с помощью оператора typeof, вы также должны проверить снова null:
3. Ловушка для null
Null может появиться, часто неожиданно, в ситуациях, когда вы ожидаете объект. Затем, если вы попытаетесь извлечь свойство из null, JavaScript выдает ошибку.
Давайте снова воспользуемся функцией greetObject() и попробуем получить доступ к свойству message из возвращенного объекта:
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
Поскольку переменная who является пустой строкой, функция возвращает null. При доступе к свойству message из null выдается ошибка TypeError. Вы можете обработать null, используя опциональную цепочку с нулевым объединением:
или используйте 2 альтернативы, описанные в следующем разделе.
4. Альтернативы null
Заманчиво вернуть null, когда вы не можете построить объект. Но у этой практики есть и недостатки. Когда null появляется в вашем стеке выполнения, вы всегда должны его проверять. Я стараюсь не возвращать null, а вместо этого:
возвращать объект по умолчанию
выдавать ошибку вместо возврата null
Вспомним функцию greetObject(), возвращающую объекты приветствия. Вместо возврата null при отсутствии аргумента вы можете вернуть объект по умолчанию:
либо вывести ошибку:
Эти практики позволяют вам вообще избежать проблем с null.
5. null и undefined
undefined — значение неинициализированной переменной или свойства объекта. Например, если вы объявляете переменную без присвоения начального значения, доступ к такой переменной оценивается как undefined:
Основное различие между null и undefined заключается в том, что null представляет отсутствующий объект, а undefined представляет неинициализированное состояние. Оператор строгого равенства === отличает null от undefined:
В то время как оператор произвольного равенства == считает null и undefined равными:
Я использую оператор свободного равенства, чтобы проверить, является ли переменная null или undefined:
6. Заключение
null — это специальное значение в JavaScript, которое представляет отсутствующий объект. Оператор строгого равенства определяет, является ли null переменной: variable === null. Оператор typoef полезен для определения типа переменной (число, строка, логическое значение). Однако typeof вводит в заблуждение в случае null: typeof null оценивается, как ‘object’.
Null и undefined в какой-то мере эквивалентны, тем не менее, null представляют собой отсутствующий объект, а undefined неинициализированное состояние.
По возможности избегайте возврата null или установки для переменных null. Такая практика приводит к распространению значений null и проверок на null. Вместо этого попробуйте использовать объекты со свойствами по умолчанию или даже выдавать ошибки.
Какое условие вы используете для проверки null?
Автор: Dmitri Pavlutin
Редакция: Команда webformyself.
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
Настоящее и будущее безопасной работы с null и undefined в JavaScript
Основные сведения
Undefined — это примитивное значение, которое автоматически назначается объявленным, но неинициализированным переменным. Это значение можно получить, обратившись к несуществующему свойству объекта или к несуществующему аргументу функции.
Посмотрим, что произойдёт, если выполнить такой код:
Он выдаст следующую ошибку:
Проверка на null и undefined
Хотя это и работает, смотрятся такие конструкции не очень-то хорошо.
Прежде чем продолжить размышления о null и undefined в JavaScript, поговорим о том, как подобные значения обрабатываются в других языках.
Другие языки
Надо отметить, что проблема работы с неопределёнными значениями присутствует в большинстве языков программирования. Посмотрим, как проводятся проверки, подобные вышеописанным, в других языках.
В Java есть api Optional :
▍Kotlin
Как работать с undefined в JS?
После рассмотрения возможностей по работе с неопределёнными значениями в других языках, я задался вопросом о том, есть ли возможность безопасно работать с undefined в JavaScript и при этом не писать километры кода. Поэтому я приступил к экспериментам с регулярными выражениями. Мне хотелось создать функцию, которая позволила бы безопасно получать доступ к свойствам объектов.
Однако, честно говоря, я не отношусь к фанатам строковых путей, поэтому я начал искать способ, который позволил бы избежать их использования. В результате я создал решение, основанное на прокси-объектах:
Будущее безопасной работы с null и undefined в JavaScript
Сейчас в комитете TC39 имеется предложение, которое позволяет пользоваться следующими конструкциями:
По мне, так выглядит это очень аккуратно. Однако это предложение пока находится на достаточно ранней стадии согласования, то есть, его потенциальное появление в языке может занять некоторое время. Но, несмотря на это, существует плагин для babel, который позволяет уже сегодня пользоваться подобными конструкциями.
Итоги
Уважаемые читатели! Какой из упомянутых в этом материале способов безопасной работы с null и undefined в JavaScript нравится вам больше всего?
Null что это
До версии C# 8.0 всем ссылочным типам спокойно можно было присваивать значение null :
Переменную ссылочного типа следует инициализировать конкретным значением, ей не следует присваивать значение null
После этого Visual Studio откроет нам файл проекта, который будет выглядеть примерно следующим образом:
точнее элемент со значением enable указывает, что эта nullable-контекст будет распространяться на весь проект.
Кроме того, есть вероятность, что Microsoft изменит отношение в отношении null и NullReferenceException, и подобные предупреждения превратятся в будущих версиях в ошибки, поэтому лучше уже сейчас быть к этому готовым
Например, изменим предыдущий пример следующим образом:
Отключение nullable-контекста
Отключив nullable-контекст, мы больше не сможем использовать в файлах кода в проекте ссылочные nullable-типы и соответственно воспользоваться встроенным статическим анализом потенциально опасных ситуаций, где можно столкнуться с NullReferenceException.
nullable-контекст на уровне участка кода
Определим в файле Program.cs следующий код:
Первая строка позволяет включить на уровне всего файла nullable-контекст.
Исключение кода из nullable-контекста
С помощью специальной директивы #nullable disable можно исключить какой-то определенный кусок кода из nullable-контекста. Например:
Любой код между директивами #nullable disable и #nullable restore будет исключен из nullable-контекста и тем самым не будет подлежать статическому анализу.
Зона кода
А перед этим словом шло странное двойное равенство. Зачем же преподаватель дважды написал знак «равно»? Сначала я подумал, что, это, наверно, описка. Или же мел сплоховал в середине длинных чёрточек. Но в той же самой конструкции, которая содержала NULL и двойное равенство, было ещё и обычное равенство, и чёрточки в нём были совсем не длинные. И я начал смутно догадываться о том, что NULL — это какой-то необычный ноль, а два знака «равно» означают какое-то необычное равенство. Всё в этом новом и непонятном для меня языке программирования было необычно.
Значение NULL может быть присвоено указателю любого типа, в том числе, и нетипизированному. Например, все следующие присвоения корректны:
Давайте теперь рассмотрим ситуации, в которых используются макрос NULL и нулевые указатели.
2-я строка в этом примере — это как раз та, которую я упоминал в начале статьи.
В более общем случае, функции, генерирующие некоторые данные, динамически выделяющие под них память, заполняющие её этими данными и возвращающие адрес выделенного участка, могут возвращать NULL и как признак того, что данные сгенерировать не удалось, например, вследствие ошибки в переданных функции параметрах.
Этот нулевой указатель будет являться признаком того, что узел, в котором он содержится, — последний в списке. Данным признаком очень удобно пользоваться во время перебора всех узлов списка в цикле: мы переходим от узла к узлу, пока не «наткнёмся» на нулевой указатель. На этом цикл заканчивается.
Пусть, например, тип узла описывается следующим образом:
Тогда функция, печатающая на отдельной строке содержимое каждого узла, может выглядеть так:
А вот что нельзя делать — так это разыменовывать нулевые указатели! Поведение программы в результате выполнения этой операции непредсказуемо. В любом случае, ничего хорошего ожидать не приходится. Эксперименты показывают, что при использовании компилятора MinGW64 в среде Windows 7 операционная система сразу же «убивает» процесс, попытавшийся обратиться по «запрещённому» адресу.
Ну что ж, оказалось, что, по крайней мере, в случае MinGW64, NULL — это ноль!
Вы часто используете null? А он у нас в спецификации
В нынешнее время для большинства разработчиков стали очевидными минусы использования null как возвращаемых типов или передачи их как аргумента.
Младшие разработчики даже если не понимают, то обычно следуют «чистому коду» (прочитав книжку Роберта Мартина). Поэтому код с возможностью возникновения NPE стал встречаться реже, хотя, конечно, они есть.
getCookies
Returns an array containing all of the Cookie objects the client sent with this request. This method returns null if no cookies were sent.
Returns:
an array of all the Cookies included with this request, or null if the request has no cookies
Больше всего следует обратить внимание на это:
This method returns null if no cookies were sent.
То есть, если здесь нет куков, то нужно вернуть null. Посмотрим на это со стороны разработчика:
Нам нужно вернуть массив из куки, а если их нет, то что-то, что означало бы, что куков в запросе не было.
В этом плане null выполняет свою роль, ведь кто как не он говорит, что значения там нет. Но тогда что же должен был означать пустой массив? Разве не то, что куков нет?
null vs empty array
Усложнение API, которое заставляет пользователя каждый раз делать null-check
Запросы зачастую содержат хоть какой-нибудь куки, поэтому момент когда getCookies() возвратит null может произойти гораздо позже момента первого использования.
Усложнение имплементации этого метода. Если контейнер пустой, то нужно вернуть null (далее рассмотрим пример)
Но, конечно, не стоит считать что разработчики приняли такое решение напившись в баре. Использование null можно было оправдать, например, ради перформанса (избегаем аллоцирование пустого контейнера).
Тем не менее, это утверждение тоже можно поставить под сомнение.
Во-первых, обычно оптимизации такого уровня не требуются, если он действительно не сильно мешает производительности. Здесь нужно сделать маленькое отступление и сказать, что конкретно в этом случае это не совсем применимо, так как это спецификация и никогда не знаешь какой уровень оптимизации нужен будет разработчикам, которые разрабатывают продукт по этой спецификации.
Во-вторых, аллоцирования легко можно избежать просто создав пустой массив и возвращать его (например, какое-нибудь статическое неизменяемое поле)
Давайте посмотрим пару примеров, как использование null может испортить код
Как и говорилось ранее, самое обидное, что этот NPE может и не появиться сразу. И разумеется, может быть сложным случайно не забыть сделать эту проверку.
Но усложнения касаются не только API, но и его имплементации. Рассмотрим как пример Jetty
Я не зря выбрал его, так как изначально он имел по сути неправильную реализацию или же лучше будет сказать имплементацию, которая не соответствует спецификации.
При этом в реализации была не одна точка возвращения, поэтому разработчикам везде пришлось делать такую проверку.
Мы против!
Хотя люди, конечно же, возмущались новым изменениям, но не идти же против спецификации. Или же есть смельчаки, которые сделали это? Разумеется есть, хотя я и не знаю нарочно ли они это или по нутру хорошего кода изменили спецификацию?
The GNU Classpath Extensions project, aka classpathx builds free versions of Oracle’s Java extension libraries, the packages in the javax namespace. It is a companion project of the GNU Classpath project.
У них есть скажем так «своя спецификация»
Gets all the Cookies present in the request.
Returns:
an array containing all the Cookies or an empty array if there are no cookies
Since:
Статические анализаторы
Не обойдем стороной и статические анализаторы. Они также считают что возвращать null не лучшее решение. Например, тот же Sonar, SEI CERT Oracle Coding Standart for Java
Заключение
На этом примере мы можем увидеть как важно правильно составлять спецификации. Нужно думать как о разработчиках, которые будут его имплементировать, так и пользователях, которые будут их использовать.
В этом случае как разработчикам как и клиентам пришлось усложнять свой код.
Кто-то может сказать что в те времена, когда писалась спецификация не были так уж очевидны последствия использования null и это было обычной практикой. Да, так и есть, нам гораздо легче говорить об этом, так как мы имеем опыт предыдущих разработчиков, которые попались на этот капкан и которые нас и научили не попадаться на них. Это они были первопроходцами и поделились с нами знаниями и было бы не очень хорошо так уж сильно их осуждать, вместо благодарностей.
Тем не менее, на то это и спецификация, что она должна быть очень хорошо спроектирована, учитывая что она должна иметь обратную совместимость. Ведь проблемы с null существовали и до осознания того, что они есть.
Проблемы каких-то решений могут существовать и до того, как вы их осознаете
То что сейчас является обычной практикой в будущем может оказаться плохим кодом
Нужно делиться своими знаниями и опытом. Даже не ради кого-то другого, а ради себя, ведь возможно именно вашу статью прочитает будущий разработчик самого популярного фреймворка.
Язык и сообщество не стоит на месте и мы замечаем ошибки прошлого и это очень хорошо, ведь это означает, что мы стали лучше.
Speaking at a software conference in 2009, Tony Hoare apologized for inventing the null reference:[25]
I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time, I was designing the first comprehensive type system for references in an object oriented language (ALGOL W). My goal was to ensure that all use of references should be absolutely safe, with checking performed automatically by the compiler. But I couldn’t resist the temptation to put in a null reference, simply because it was so easy to implement. This has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years
9 вещей о NULL в Java
Почему Вы должны узнать о null в Java?
Что есть null в Java
Зачастую, с этим встречаются программисты, перешедшие с других языков программирования, но при использовании современных IDE проблема становится незначительной. В наши дни, IDE вроде Eclipse или NetBeans могут исправлять эту ошибку пока Вы набираете код, но в эпоху Notepad, Vim и Emacs, это была распространенная проблема, которая могла съесть кучу драгоценного времени.
Так же, как каждый примитив имеет значение по умолчанию, например, у int это 0, у boolean это false, null это значение по умолчанию любых ссылочных типов, проще говоря, для всех объектов. Так же, как при создании логической переменной ее значение по умолчанию равно false, так и любые ссылочные переменные в Java по умолчанию будут равны null. Это истинно для всех типов переменных: переменной-члена или локальной переменной, переменной экземпляра или статической переменной, кроме того, компилятор будет ругаться, если Вы используете локальную переменную не проинициализировав ее.
Несмотря на распространенное заблуждение, null это не объект ( Object ) и ни тип. Это просто специальное значение, которое может быть назначено любому ссылочному типу, и Вы можете привести null к любому типу, как показано ниже:
Как Вы можете видеть, когда мы непосредственно присваиваем null примитиву, то получаем ошибку процесса компиляции, но, если присвоить null объекту класса-обертки, а затем присвоить этот объект соответствующему примитивному типу, компилятор не отреагирует, но мы будем вознаграждены null pointer exception во время выполнения. Это происходит из-за авто упаковки ( autoboxing ) в Java, и мы еще встретимся с ним в следующем пункте.
Но, когда Вы запустите данный фрагмент кода, в консоли Вы увидите
Оператор instanceof будет возвращать false если в качестве параметра указать любую ссылочную переменную со значением null или null сам по себе. Пример:
Вы можете послать null в качестве параметра метода, принимающего любой ссылочный тип, к примеру:
может быть вызван как
Null — это зло!
Не сомневаюсь, что заголовок статьи привлек ваше внимание! А теперь позвольте мне аргументировать свою точку зрения, поскольку процентов на 50%, а то и больше, вы со мной не согласитесь. В программировании есть один момент, в отношении которого мы, несомненно, можем достичь абсолютного единодушия — нам не избежать использования null или исключений. И причин тому несметное множество: что-то пошло не так, обрушились серверы, отсутствуют нужные данные, да вы и сами можете продолжить этот список.
Я не великий Мерлин, и у меня нет заклинания, гарантирующего 100% работу сервера, или волшебной палочки, по мановению которой потерянные данные будут всегда чудесным образом находиться. Но зато в моих силах поделиться с вами подходом, который, на мой взгляд, позволит оптимизировать код, сделать его более удобным в обслуживании и готовым к обработке null или исключений. Честно вам признаюсь, что предлагаемое решение состоит в использовании разработанных мною пакетов NuGet, которые активно применяются и в личных, и рабочих проектах вашего покорного слуги. Правда, этот подход легко воспроизвести, но зачем изобретать колесо?
Null— это зло
Итак, почему же я считаю null злом? Пожалуй, будет лучше, если на этот вопрос ответит сам изобретатель нулевого указателя Энтони Хоар:
“Я называю его (нулевой указатель) ошибкой на миллиард долларов”.
Сколько раз вы писали нечто похожее на вышеуказанный пример? 10 раз? Сто? Несметное количество? И я не исключение! Каждый раз при написании кода вы тратите время, которому можно было бы найти лучшее применение. А так как время — это весьма ценный ресурс, то и тратить его нужно на что-нибудь стоящее. В этом фрагменте кода мы не только проводим проверку на null и возвращаем результат NotFound в случае его обнаружения, но и обманываем клиента. Ладно, может и не обманываем, но мы допускаем, что null означает тот факт, что Customer не найден. В данном фрагменте у нас нет никакой возможности узнать, действительно это так или нет. Все, что нам известно — customerRepository не вернул Customer, а вот определить, произошло ли это в результате ошибки или потому что Customer действительно был не найден, мы уже не сможем.
Конечно, сейчас мы имеем дело с придуманным кодом, поскольку он не выполняет проверку входящего “id”, как того требуют принципы безопасного программирования, и не предполагает обработку ошибок, но я не раз встречал подобные вариации в коде производственной среды.
Вот тут-то мы и переходим к пониманию сути утверждения “ Null — это зло”. Если взять вышеприведенный пример, то, во-первых, мы не гарантируем предоставление получателю правдивых данных— представьте, что вы запрашиваете в банке баланс счета, а он возвращает not found (не найден). Во-вторых, данный код находится в контроллере, а что если бы он состоял из двух, трех или более слоев? Сможете ли вы на основе имеющейся информации с уверенностью сказать, найден ли Customer или произошла ошибка?
Итак, что же нам делать с нулевыми указателями и нашей тягой к правде? Постараемся их не возвращать. Вместо них, по возможности, вернем значимый и ожидаемый объект Result, свидетельствующий о том, насколько успешен был вызов.
Звучит просто, не правда ли? Так и есть. В функциональном программировании эта практика существует уже долгое время, и хотя C# не принадлежит к разряду функциональных языков, LINQ не в счет, мы можем позаимствовать принципы таких языков, как F#, Haskell и Python, что выгодно отразится и на коде!
Вернемся к примеру — на этот раз скорректируем действие контроллера.
Первое, что вы должны были заметить, так это отсутствие выполняемых проверок. Кроме этого, посмотрите, каким понятным (иначе говоря, чистым) стал код. 3 метода расширения абстрагируют проверки и позволяют нам сосредоточиться на самом важном — на том что, а не как делает код.
Магия начинается с нового объекта Result — обычно я предпочитаю использовать var вместо явного объявления типа, показанного в примере (вследствие чего Visual Studio подчеркивает строку зеленой волнистой линией), но в данном случае это бы скрыло изменение в типе ответа customerRepository.Get. Объект Result выполняет 2 главные функции:
Есть еще и третья функция, о которой мы поговорим в разделе “Исключения — не меньшее зло”.
В вышеуказанном примере я решил использовать 2 метода расширения, OnSuccess и OnFailure, чтобы показать, насколько легко можно внедрить поток, аналогичный конвейеру, известному нам из LINQ (если же вы с ним до сих пор не знакомы, то нужно срочно исправить эту оплошность, так как LINQ позволит вам тратить меньше времени на ввод данных и писать более чистый код).
Метод OnSuccess проверяет результат предыдущего действия и запускает определенную функцию (также присутствует поддержка Action) только при условии успешного предшествующего вызова, поэтому проверка условий все еще осуществляется — просто она абстрагирована от класса и, следовательно, от нашего внимания. Метод OnFailure работает аналогичным образом за одним лишь исключением — он выполняется только в случае неудачного предыдущего вызова.
ToActionResult (из пакета Capgemini.SerializableResult.AspNetCore NuGet) в этом сценарии можно использовать автономно — в приведенном примере он просто вернет запрашиваемый объект Customer или NotFound, при этом предварительно внутренне проверив свойство StatusCode на наличие ошибки 404 (и многих других). Он также предусматривает возможность записать результат действия в журнал, но OnSuccess и OnFailure могут эффективно использоваться для создания цепочек операций с учетом одного нюанса — оба метода требуют, чтобы в качестве возвращаемого типа был один и тот же тип объекта или тип void.
Использование нового объекта Result (о том, где его можно найти, вы узнаете в конце статьи) в сочетании с рассмотренными методами расширения позволяет обойтись без проверки на null (технически она абстрагируется от класса и, следовательно, от нашего внимания) и в процессе создает гораздо более чистый метод. Итак, а что же насчет исключений? В нашем примере нет их обработки, можем ли мы по-прежнему их выбрасывать?
Исключения — не меньшее зло
Сколько раз вам приходилось тратить уйму времени на отладку NullReferenceException во фрагменте кода, который вы видите в первый раз или о котором уже давно забыли? Современные отладчики, бесспорно, гораздо лучше могут определить место выброса исключения, но ведь не всегда именно там оно происходит — в этом и заключается главная причина моего убеждения, что null — это зло.
Выполнение контракта, заявленного объектом Result, так же просто, как использование блока try…catch…:
Теперь перед вами на 100% правильный вариант, но подход “поймай все” может не понравиться не только некоторым аналитикам кода, но и многим разработчикам. Хотя в примере этого и нет, но в коде можно было также реализовать повторную попытку на случай тайм-аута во время вызова метода httpClient.SendAsync (или любого другого ожидаемого исключения, т. е. ошибки десериализации) перед catch-all, но для краткости этот пример был сохранен предельно простым. Данный фрагмент кода также иллюстрирует использование NotFound.Create, InternalServerError.Create и StatusMessage.Create — методов из пакета Result NuGet, предназначенных для стандартизации структуры сообщений о результатах.
Самое главное преимущество этого подхода состоит в сжатии клиентского кода:
В данном примере отсутствует необходимость проверки на null и обработки исключений, здесь — только понятный вызов метода, выполняющий сложную задачу. В случае с UI (для веб, мобильных устройств и т. д.), где многим получателям раньше приходилось выполнять проверку на null и обрабатывать исключения, теперь все это можно сократить до одной строки. 🙂
Заключение
Пакеты NuGet
В настоящее время эти пакеты доступны на NuGet. В дальнейшем планируется открыть исходный код репозиториев и перейти на полностью поддерживаемую модель, но на момент написания статьи все версии были 0.n.n и должны рассматриваться как бета, несмотря на их использование мной в личных и рабочих проектах.
NULL (SQL)
Из Википедии — свободной энциклопедии
NULL в СУБД — специальное значение (псевдозначение), которое может быть записано в поле таблицы базы данных (БД). NULL соответствует понятию «пустое поле», то есть «поле, не содержащее никакого значения». Введено для того, чтобы различать в полях БД пустые (визуально не отображаемые) значения (например, строку нулевой длины) и отсутствующие значения (когда в поле не записано вообще никакого значения, даже пустого).
NULL означает отсутствие, неизвестность информации. Значение NULL не является значением в полном смысле слова: по определению оно означает отсутствие значения и может иметь тип NULL или иметь любой другой тип (CREATE TABLE new_tab AS (SELECT NULL) — специальный тип null, CREATE TABLE new_table AS (SELECT 10+NULL) — тип integer). Поэтому NULL не равно ни логическому значению FALSE, ни пустой строке, ни нулю. При сравнении NULL с любым значением будет получен результат NULL, а не FALSE и не 0. Более того, NULL не равно NULL!
Что такое приложение Null, как его настроить и стоит ли удалять
Иногда пользователи iPhone сталкиваются с непонятным приложением «Null». Это приложение может запрашивать:
доступ к камере и микрофону;
доступ к личным файлам;
доступ к геолокации;
Пользователь может начать паниковать, ведь он не устанавливал такое приложение, а оно запрашивает конфиденциальные данные. «Взлом или вирус?» — первая мысль, которая может прийти. Ни то и ни другое. Вообще, приложение Null — это не какое-то конкретное приложение. Под этим приложением может скрываться любое приложение, даже которым вы раньше активно пользовались.
Приложение Null
Такие приложения работают, не нанося вред а телефону, а лишь озадачивают вл а дельцев устройств. Приложение Null может появит ь ся в айфоне несколькими способами.
Как появляется приложение Null на iPhone
Приложение Null п о является на устройстве по одной из трех причин:
Приложение устанавливается в обход App Store. На iPhone можно устанавливать приложения из сторонних магазинов. Делается это через «доверенные сертификаты». Случается такое, что «сертификат» перестает быть действительным, тогда установленная программа превращается в «приложение Null».
Можно ли исправить приложение Null
Есть несколько способов, как побороть приложение Null:
Заключение
Мы будем очень благодарны
если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.
Null safety в Dart
Привет, Хабр! Представляю вашему вниманию перевод статьи «Announcing sound null safety» автора Filip Hracek с моими комментариями:
Null safety — безопасная работа с пустыми ссылками. Далее по тексту для краткости и по причине устойчивости термина будет использоваться английское наименование null, null safety. Да и перевод «нулевая безопасность» наводит совсем на противоположные мысли.
sound — в данном контексте (sound null safety) можно перевести как «надежный».
Если есть предложения по улучшению перевода или нашли ошибки — пишите в личку, постараемся исправиться.
Наступил важный этап для команды Dart с их представлением технического превью наработок по null safety. Null safety позволяет избежать целого класса ошибок, которые часто трудно обнаружить, а в качестве бонуса обеспечивает ряд улучшений производительности. На данный момент мы выпустили предварительное техническое превью и ждем от вас обратной связи.
В этой статье мы раскроем планы команды Dart по развертыванию null safety, а также объясним, что скрывается за термином Sound null safety, и чем этот подход отличается от других языков программирования.
Описываемая версия была представлена 10-го июня 2020 года.
Зачем нужна null safety?
Dart — типобезопасный (type-safe) язык. Это означает, что когда вы получаете переменную некоторого типа, компилятор может гарантировать, что она принадлежит ему. Но безопасность типов сама по себе не гарантирует, что переменная не равна null.
Null-ошибки встречаются часто. Поиск на GitHub находит тысячи репортов (issue), вызванных нулевыми значениями в Dart-коде, и еще больше коммитов, пытающихся решить эти проблемы.
Попробуйте обнаружить проблему обнуления ссылки в следующем примере:
Эта функция, безусловно, завершится ошибкой, если вызывается с обнуленным параметром, но есть и второй случай, который следует рассмотреть:
Null safety устраняет эту проблему:
С null safety вы можете с большей уверенностью опираться на свой код. Не будет больше надоедливых ошибок обращения к обнуленной переменной во время выполнения. Только статические ошибки в момент компиляции кода.
Если быть совсем честными, то текущая реализация все же оставляет несколько возможностей словить null-ошибки в момент выполнения, о них чуть позже.
Sound (надежная) null safety
Немного спорное заявление, которое заставило меня копнуть в эту тему немного глубже, чтобы понять, как реализуется null safety в разных языках. В итоге я сравнил эти реализации в Swift, Kotlin и Dart. Результат этих изысканий можно посмотреть на записи нашего внутрикомандного доклада.
Подобная надежная реализация null safety в Dart имеет еще одно приятное следствие: это означает, что ваши программы могут быть меньше и быстрее. Поскольку Dart действительно уверен, что переменные никогда не могут быть обнулены, Dart может оптимизировать результат компиляции. Например, AOT-компилятор может создавать меньший и более быстрый нативный код, поскольку ему не нужно добавлять проверки на пустые ссылки.
Мы видели некоторые очень многообещающие предварительные результаты. Например, мы увидели улучшение производительности на 19% в микробенчмарке, который эмулирует типичные шаблоны рендеринга в инфраструктуре Flutter.
Основные принципы
Прежде чем приступить к детальному проектированию null safety, команда Dart определила три основных принципа:
Необнуляемость по-умолчанию. /** Часто можно увидеть в виде абревиатуры NNBD в документации **/ Если вы явно не скажете Dart’у, что переменная может быть обнулена, он сочтет ее необнуляемой. Мы выбрали это как значение по умолчанию, потому что обнаружили, что в API ненулевое значение на текущий момент является наиболее распространенным. /** Вероятно, речь идет о переработке текущего API Flutter **/.
Поэтапная применимость. Мы понимаем, что должна существовать возможность постепенного перехода к null safety шаг за шагом. На самом деле, нужно иметь обнуляемый и null safety код в одном проекте. Для этого мы планируем предоставить инструменты, помогающие с миграцией кода.
Полная надежность (sound). Как упоминалось выше, null safety в Dart надежна. Как только вы преобразуете весь свой проект и ваши зависимости на использование null safety, вы получите все преимущества надежности.
Объявление переменных с null safety
Основной синтаксис достаточно прост. Ниже приведен пример объявления различных переменных. Обратите внимание, что по умолчанию используются необнуляемые переменные, поэтому они выглядят как прежде, но их значение не может быть обнулено.
Dart позаботится о том, чтобы вы никогда не присваивали значение null ни одной из перечисленных выше переменных. Если вы попытаетесь выполнить i = null даже тысячу строк спустя, вы получите ошибку статического анализа и красные волнистые линии — ваша программа откажется компилироваться.
Если вы хотите, чтобы ваша переменная могла обнуляться, вы можете использовать ‘?’ вот так:
Перечисленные выше переменные ведут себя точно так же, как и все переменные в актуальной версии Dart.
‘?» можно также использовать в прочих местах:
Но, опять же, хотелось бы, чтобы вам почти никогда не придется использовать ‘?’. Подавляющее большинство ваших переменных будут необнуляемыми.
Упрощение использования null safety
Команда Dart изо всех сил старается сделать null safety максимально простой в использовании. Например, посмотрите на этот код, который использует if, чтобы проверить нулевое значение:
Обратите внимание, что Dart достаточно умен, чтобы понять, что к тому времени, когда мы пройдем оператор if, переменная loudness не может иметь значение null. И поэтому Dart позволяет нам вызывать метод clamp() без лишних танцев с бубном. Это удобство обеспечивается так называемым анализом потока выполнения (flow analysis): анализатор Dart просматривает ваш код, как если бы он выполнял его, автоматически выясняя дополнительную информацию о вашем коде.
Flow analysis, уже существующая фича языка Dart, используется, например, при проверке соответствия типа. В данном случае они переиспользовали ее для null safety, что позволяет смотреть на отношения типа и опционального типа как на наследование:
Вот еще один пример, когда Dart может быть уверен, что переменная не равна null, так как мы всегда присваиваем ей значение:
Анализ потока выполнения работает только внутри функций. Если у вас есть глобальная переменная или поле класса, то Dart не может гарантировать, что ему будет присвоено значение. Dart не может моделировать поток выполнения всего вашего приложения. По этой причине вы можете использовать новое ключевое слово late, если знаете, что переменная будет инициализирована на момент первого к ней обращения, но не можете инициализировать ее в момент объявления.
Обратите внимание, что v не может быть обнулена, хотя изначально не имеет значения. Dart считает, что вы не будете пытаться прочитать v, пока ему не будет присвоено ненулевое значение, и ваш код компилируется без ошибок.
А вот и он — момент для выстрела себе в ногу.
Опасный костыль, который будет главным признаком пахнущего кода. Ситуацию усугубляет еще и то, что нет возможности проверить состояние переменной. Команда Dart обсуждала такую возможность, но пришла к выводу, что на данном этапе проще не реализовывать проверки, как, например, в Kotlin через рефлексию.
Второе спорное решение — это интеграция знакомого всем Swift-программистам восклицательного знака, то есть, теперь можно будет делать force unwrap в Dart.
В обоих случаях (с late и ‘!’) мы сможем при неправильном использовании получить ошибку в момент выполнения программы.
Также стоит упомянуть в контексте late еще одно нововведение, которое почему-то скрывается в статьях и видео от команды Dart. Добавлено новое ключевое слово ‘required’ для именованных параметров конструктора. Это уже знакомый ‘@required’, только не из отдельного пакета и без собачки.
Обратная совместимость
Команда Dart работала больше года, чтобы довести null safety до уровня технического превью. Это самое большое изменение языка со времен релиза второй версии. Тем не менее, это изменение, не ломающее обратную совместимость. Существующий код может вызывать код с null safety и наоборот. Даже после полноценного релиза null safety будет дополнительной опцией, которую вы сможете использовать, когда будете готовы. Ваш существующий код продолжит работать без изменений.
Эти бы слова, да разработчикам Swift в уши, особенно 3-й версии…
Но даже тут не так все радужно, разработчики сами говорят, что при совмещении null safety кода и «старого» кода в одном проекте они не могут гарантировать надежность (soundness) системы типов.
Дальнейший план действий
Мы планируем развернуть null safety постепенно в три этапа:
Начни уже сейчас
Самый быстрый способ попробовать null safety уже сегодня — это nullsafety.dartpad.dev — версия DartPad с включенной функцией null safety. Откройте раскрывающийся список «Learn with Snippets», чтобы найти серию обучающих упражнений, описывающих новый синтаксис и основы null safety.
Также можно поэкспериментировать с null safety в небольших консольных приложениях (мы еще не обновили более крупные фреймворки, такие как Flutter). Для начала нужно загрузить Dart SDK с dev-ветки, затем можно скачать этот пример консольного приложения. В README файле есть инструкции по запуску приложения с включением экспериментальной функции null safety. Другие файлы в примере предоставляют конфигурации запуска, которые позволят выполнять отладку в VS Code и Android Studio.
Также можно ознакомиться с документацией (в дальнейшем появится еще):
Спасибо за то, что дочитали до конца. Перевод немного запоздал, но, надеюсь, комментарии привнесли пользы материалу и это не стало просто переводом один в один. От себя хочется добавить, что эта фича — действительно полезный шаг вперед для всей экосистемы Flutter. Жду с нетерпением, чтобы начать использовать уже на живых приложениях. А пока, как говорится на забугорском, stay tuned!
Нулевые указатели (null и nullptr) в C++. Учимся ходить по граблям изящно
В этом материале для новичков мы рассуждаем про обнаружение в коде C++ распространенного дефекта «разыменование нулевого указателя», попутно объясняя его скрытую коварность.
«Купи мне истребитель». Сбор средств для Воздушных Сил ВСУ
1. Разыменование нулевого указателя
Сегодня рассмотрим причину дефекта в коде С++, который получается, если программа обращается по некорректному указателю к какому-то участку памяти. Такое обращение ведет к неопределенному поведению программы, что приводит в большинстве случаев к аварийному завершению. Данный дефект получил название разыменование нулевого указателя ( CWE-476 ). Мы поговорим о том, что такое NULL и nullptr и для чего они нужны.
По сути, это почти одинаковые вещи, но есть нюансы.
Язык С++ не имеет автоматического сборщика мусора, как, например, в Java или C#. Если мы выделяем область под данные, то никто кроме нас не позаботится о том, чтобы область памяти была очищена. Если в памяти находится одно число, это не является проблемой.
Однако, если, например, программа работает в цикле, используя миллион итераций, и в каждой итерации запрашиваются в операционной системе новое место под данные, то тут возможны проблемы. На каком-то этапе место в памяти заканчивается и наша программа аварийно завершает работу. Поэтому, чтобы избежать подобной ситуации, следует использовать delete для очистки неиспользуемых данных, указав указатель на область данных.
Итак, в нашем коде (пример выше) с помощью оператора new мы выделили место для нашей оперативной памяти. После очистки места, которое мы выделяли под данные в динамической части оперативной памяти, сами данные исчезают. В следствии действия оператора delete данные уничтожаются и система может выделять память, которую мы уже не используем, для любых других своих нужд.
Однако, у нас остается проблема! В нашем указателе *pa все еще сохранен адрес на тот участок памяти, где у нас лежали данные и, в принципе, нам никто не запрещает туда обращаться.
Короче говоря, надеюсь, вы поняли эту тонкость, что после деинициализации ранее занятой памяти наш старый указатель может продолжать указывать в удаленное место памяти, что потенциально может привести к краху программы.
2. Нулевое значение и нулевые указатели
Если мы ведем какие-то расчеты и вдруг получаем некоторое случайное число (не имеющее отношение к расчетам), мы можем даже не узнать, что что-то пошло не так. Неплохо было бы определиться и отметить указатель каким-то таким образом, чтобы он никуда не указывал (чтобы однозначно исключить патовую ситуацию описанную в примере выше).
Если мы опять принудительно выведем на консоль эти данные (из освобожденного участка памяти), то в принципе, у нас может случиться чудо — мы увидим в консоли тот «мусор», который сейчас в памяти (куда указывает наш указатель, после того как мы его почистили).
3. NULL и nullptr
Таким образом мы перестраховываемся от того, чтобы получить или случайно записать некорректные данные.
4. Тип данных nullptr
К примеру, если у вас будет какая-то функция, она будет перегружена для типа Int и для указателя. И вы захотите передать в вашу функцию указатель с целочисленным нулем pa = 0 :
Представьте себе, что мы имеем дело с программой, где указатель ссылается на определенные данные в оперативной памяти.
Заключение
Надеемся, что наш материал поможет вам избежать частых проблем при работе с памятью в C++. В заключение рекомендуем посмотреть видео, в котором рассказывается про указатели в С++
а также про работу с динамической памятью при работе с массивами
Учимся избегать null-значений в современном Java. Часть 1
Null. Правила использования
В своем выступлении “Null References: The billion dollar mistake” (“Нулевые ссылки: ошибка на миллиард долларов”), Тони Хоар описывает реализацию нулевых ссылок в языках программирования ALGOL, что также по его словам стало ошибкой стоимостью в миллиард долларов. Такие авторитетные книги, как Clean Code: A Handbook of Agile Software Craftsmanship (“Чистый код: настольное руководство по гибкой разработке ПО”) рекомендуют использовать нуль как можно реже. В то же время в книге Bug Patterns in Java (“Шаблоны ошибок в Java”) проблемам, связанным с нулевыми значениями, посвящается аж целых три главы. Тема “What is a null pointer exception and how do I fix it” (“Что такое исключение нулевого значения и как его исправить”), обсуждаемая на Stack Overflow, набрала уже более 3 млн просмотров. Работа с нулевыми значениями и впрямь может вызвать немало сложностей.
Я не отношусь к тем, кто можем говорить лауреатам премии Тьюринга вроде Хоар, как проектировать языки программирования, но при этом все же не считаю null заведомо плохим. В этой и последующих статьях мы рассмотрим, что это вообще такое, когда стоит или не стоит эти значения использовать, а также, как их изящно обрабатывать.
В конкретно данной статье я поделюсь своими размышлениями об их использовании, а в следующей мы перейдем к рассмотрению практического применения некоторых методов работы с null, включая последние возможности Java 8.
Несмотря на то, что в центре нашего внимания будет именно Java, основные принципы и обсуждение должны охватывать объектно-ориентированные языки в целом. Текущая статья в первую очередь предназначена для менее опытных программистов и всех тех, кто испытывает сложности, сталкиваясь с null. Но, думаю, что даже бывалые разработчики смогут найти здесь для себя полезные приемы.
Чем опасен null?
Null — это особое значение, поскольку оно не ассоциируется ни с каким типом (можете смело проверить это инструкцией instanceof в отношении любого другого класса в JRE) и с радостью занимает место любого другого объекта в присвоениях переменных и вызовах методов. Именно в этом и кроются две основных его опасности:
В результате любое возвращаемое значение или объект параметра — это потенциальное исключение нулевого указателя (NPE), возникающее в случае неправильной обработки.
Будет ли в таком случае решением проверять каждое возвращаемое значение и параметр на null? Очевидно, что идея не очень. Во-первых, код будет загроможден проверками на null. Во-вторых, разработчики будут вынуждены тратить драгоценное время на поиск правильного способа обработки нулевых значений, которые никогда не возникнут, а проверки на null будут сбивать с толку других разработчиков.
Может тогда вообще никогда не присваивать значениям null? Тоже неудачное предположение. Если учесть тот факт, что в каждом языке программирования есть пустое значение ( nil, undefined, None, void и т.д.), то наличие общего значения, обозначающего отсутствие чего-либо, чрезвычайно полезно.
Ошибка в условии цикла while может породить бесконечный цикл в любой программе, но это не делает такие циклы плохими по природе. Аналогично будет неверным считать, что null всегда неуместен только из-за того, что его неправильное использование может привести к ошибкам. Null — это наиболее естественное значение для выражения конкретных вещей, но при этом очень неподходящее для выражения других. Компетентные разработчики должны уметь различать эти случаи. В следующем разделе я как раз перейду к объяснению этого.
Когда Null уместен, а когда нет
В этой части я рассмотрю сценарии, в которых null возвращается из методов и передается им, поясню несколько традиционных альтернатив (т.е. предшествующих Java 8) и приведу доводы в пользу уместности встроенного типа вроде null в некоторых случаях.
Возвращение null
Одной из основных идей ООП является моделирование принципов области бизнеса, в которой работает наше ПО. Для этого мы определяем классы, соответствующие данным принципам и их атрибутам. Если речь заходит об использовании нулевых значений, я считаю важным рассмотреть эти типы классов отдельно от остальных.
Сейчас я работаю над проектом электронной записи пациентов Columna, в котором у нас есть классы, представляющие элементы рабочего процесса больницы вроде пациентов, медикаментов, врачей, больничных отделений, госпитализаций и пр. При моделировании любой области возникают случаи, когда нам нужно допустить для определенного элемента отсутствие значения. Предположим, что у нас есть класс, представляющий госпитализацию с атрибутами, которые ее описывают: больничное отделение, куда помещается пациент, причина госпитализации, ее время и т.д. Аналогичным образом у нас может быть класс, который представляет пациента с набором атрибутов вроде имени и номера социального страхования. В любой момент времени пациент может быть госпитализирован или нет. Говоря более формально, у нас есть связь типа “имеет” с мощностью 0..1.
Представим метод, извлекающий из базы данных информацию о госпитализации данного пациента:
Что должен возвращать этот метод для не госпитализированного пациента, если не null? Есть ли для выражения этого более точное значение? Спорю, что нет.
Существует и много других сценариев, в которых объект области напрямую ассоциирован с необязательными значениями в качестве атрибутов. Объект, представляющий медикаменты, содержит такие значения, как название препарата, его форму, активность, действующее вещество и т.д. Однако разнообразие медикаментов чрезвычайно обширно, начиная от антибактериальных кремов и заканчивая чаями из каннабиса (оставим или на ромашку заменим?:)), следовательно не все атрибуты будут актуальны для каждого. И снова возвращение null для отсутствующего атрибута выглядит очевидным способом сообщить, что допускается отсутствие значения. Есть ли для этого лучшая альтернатива?
Некоторые выступают за использование так называемого шаблона проектирования Null Object вместо null. Главная его идея в реализации пустого класса с минимумом или вообще без функциональности, т.е. нулевого объекта, который можно использовать вместо класса, содержащего действительную функциональность. Лучше всего данный шаблон показывает себя в сценариях, где нужно рекурсивно обойти структуру бинарного дерева в поиске суммы значений всех узлов. Для этого вы выполняете поиск в глубину и рекурсивно суммируете в каждом узле значения его левого и правого поддерева.
Дерево поиска обычно реализуется так, что каждый узел в нем имеет левого и правого потомка, которые являются либо также узлами, либо концевыми вершинами. Если такое представление дерева использует для концевых узлов null, то вам придется явно выполнять проверки на нулевых потомков, чтобы останавливать рекурсию в концевом узле, предотвращая попытку получения его значения. Вместо этого вам следует определить интерфейс Node с простым методом getValue() и реализовать его в представляющем узел классе, который вычисляет значение, складывая значения getValues() потомков, как показано на рисунке ниже. Реализуйте такой же интерфейс в классе, представляющем узел, и пусть класс концевого узла возвращает при вызове 0. Теперь нам больше не нужно различать код между концевым узлом и обычным. Необходимость явно проверять наличие null отпала вместе с риском получения исключения (NPE).
Тем не менее лично мне сложно найти применение данному шаблону в типичных базах кода производственной среды, где логика зачастую превосходит сложностью простое накопление чисел. Шаблоны существуют для упрощения решений, но при несоответствующем использовании добавляют сложность, одновременно лишаясь всех преимуществ.
Во многих случаях вам придется писать код, который в определенный момент должен будет проверять что-то для обработки ложных значений. Так почему бы просто не использовать проверки на null изначально, избегая определения дополнительных усложняющих код классов? Бывают случаи, когда рассмотренный шаблон работает прекрасно, но на мой взгляд таких случаев в реальных условиях мало, поскольку его можно использовать только для объектов с методами, содержащими пустые значения, или когда вы можете вернуть что-то гармонично вписывающееся в поток окружающего кода.
Думаю, что нет. В случае класса, представляющего явления из реальной жизни, мы можем сделать обоснованное предположение. Но вышеприведенные типы классов не дают нам для этого никакой возможности, и разобраться в таких случаях можно только, читая код. По этой причине лучше избегать возвращения null вместо других типов, так как у разработчиков редко возникают причины ожидать возвращения null. Если вы этого не ждете, то зачем затрачивать усилия на защиту кода от этих значений?
Передача нулевых параметров
Из предыдущего раздела следует, что допустимо использовать нулевые аргументы при вызове методов с моделирующими область типами параметров, имеющими необязательные значения. При этом методы должны обеспечивать безопасное их использование. На практике же нулевые параметры применяются для гораздо большего спектра задач. Когда нам нужно предоставить такой параметр методу, мы должны обеспечить, чтобы все последующие обработки этого параметра были защищены от null, а это может оказаться нелегко. И даже несмотря на это, ваша программа может находиться в состоянии, скрывающем небезопасное поведение, что приведет к раскрытию проблемы только при других условиях. Предоставление нулевых параметров также добавляет риск вызвать ошибки при изменении кода в его следующих за их добавлением частях.
Как же полностью избежать нулевых параметров?
Нередко нам нужно использовать какую-либо функциональность в существующем методе, но текущий контекст вызова несколько иной, и мы либо не можем обеспечить все вызываемые методом значения, либо требуется больше информации, чем допускает его структура. Само собой мы не хотим повторять практически идентичный метод. Переиспользование является одним из столпов легко обслуживаемого кода, и одинаковая функциональность не должна реализовываться в нескольких местах, поскольку это не только усложнит поддержание синхронности кода, но и внесет риск появления ошибок. Поэтому мы изменяем существующий код под наши задачи и используем null для параметров, которые предоставляются не всегда. Некоторые методы по своей структуре могут принимать по меньшей мере несколько нулевых параметров, другие же не могут совсем. Тем не менее может оказаться затруднительным определить, какие параметры могут иметь значение null, и подходит ли оно для представления отсутствующего значения.
В таких языках, как Python, сигнатуры методов могут содержать предустановленные значения параметров, используемые при отсутствии значения аргумента в вызове метода. Тем не менее в Java такое невозможно. Ближайшим аналогом этого будет использовать перегрузку метода, когда в классе одна и та же сигнатура метода определяется несколько раз с разными параметрами. Один метод будет содержать всю функциональность и принимать весь набор параметров, а другие будут просто “декораторами” для вызова этого метода, каждый из которых будет получать свой поднабор параметров. Методы-декораторы определяют, какие значения должны использовать вместо отсутствующих параметров, чтобы вызывающему компоненту не пришлось их предоставлять. Жестко прописывая, какие значения должны предоставляться, когда у вызывающего их не хватает, мы уменьшаем риск появления ошибок и делаем принимаемые значения параметров явными.
В рассмотренном выше решении нулевые значения по-прежнему передаются в методы внутри объекта, но вызывающий и вызываемые методы спроектированы с учетом этого. Любой метод, вызываемый с одним из этих значений, по умолчанию должен корректно обрабатывать null. При этом нужно запретить сторонним вызывающим объектам передавать нулевые значения для параметров, которые не учтены в структуре, поскольку эти значения могут не поддерживаться, и правильная их обработка не гарантируется.
Воспринимайте null правильно
Все больше языков программирования начинают реализовывать определенные возможности с учетом безопасности. Например, в таких языках, как Clojure, F# и Rust переменные по умолчанию неизменяемы. Компилятор допускает изменение значений только для тех из них, которые объявлены со специальным модификатором. Такой способ использования опасных функций вынуждает программистов переопределять поведение по умолчанию, указывая тем самым, что они осознают степень риска и делают это не без весомых оснований. И к null нам стоит относиться аналогичным образом. Нужно придерживать это значение для особых случаев, где оно будет вполне уместно, ограничив при этом его использование в целом, опять же не ценой усложнения кода креативными обходными решениями. При каждом намерении использовать null вместо перемещающегося между методами значения следует учесть оправданность этого. В таком случае вы должны гарантировать, что в итоге оно не окажется в том месте, где может вызвать проблемы, и другие разработчики будут знать, что значение может быть null. Если же этого обеспечить нельзя, то лучше рассмотреть другие варианты.
Значения NULL в SQL
Дата публикации: 2017-12-08
От автора: SQL NULL — это термин, используемый для представления отсутствующего значения. Значение NULL в SQL таблице — это значение в поле, которое отображается как пустое.
Поле со значением NULL — это поле без значения. Важно понимать, что значение NULL отличается от нулевого значения или поля, содержащего пробелы.
Синтаксис
Основной синтаксис NULL при создании таблицы.
Бесплатный курс по PHP программированию
Освойте курс и узнайте, как создать веб-приложение на PHP с полного нуля
Здесь NOT NULL означает, что для столбца должны всегда явно указываться соответствующие значения соответствующего типа данных. Для двух столбцов мы не использовали NOT NULL — это означает, что они могут содержать значение NULL.
Поле со значением NULL является полем, которое не было заполнено при создании записи.
Пример
Значение NULL может привести к проблемам при выборе данных. При сравнении неизвестного значения с любым другим значением, результат всегда неизвестен и не включается в результаты. Вы должны использовать операторы IS NULL или NOT NULL для проверки значения NULL.
Рассмотрим таблицу CUSTOMERS, содержащую следующие записи.
Теперь давайте используем оператор IS NOT NULL.