Ошибка при получении undefined

Почему выводит undefined?

Потому что функция rush — ничего не возвращает.

Если убрать все лишнее функцию можно записать так:

function rush (filename){
    (function(){...})();
}

Отсюда хорошо видно отсутствие return. Поэтому результат этой функции всегда — undefined.

Решение «в лоб» — добавление return

function rush(filename) {
  return (function() {
    var res = filename.split(".");
    var b = res[res.lenght - 1];
    return b;
  })();
}
console.log(rush("work.tt"));

При добавлении можно заметить, что все равно не работает. Так как допущена опечатка

lenght -> length

function rush(filename) {
  return (function() {
    var res = filename.split(".");
    var b = res[res.length - 1];
    return b;
  })();
}
console.log(rush("work.tt"));

Теперь видно, что самовызывающаяся функция не нужна

function rush(filename) {
  var res = filename.split(".");
  var b = res[res.length - 1];
  return b;
}
console.log(rush("work.tt"));

Также, для получения последнего элемента массива можно использовать функцию pop

function rush(filename) {
  return filename.split(".").pop();
}
console.log(rush("work.tt"));

Когда новички начинают изучать JavaScript, то иногда сталкиваются с одной интересной проблемой. Они зачастую не могут понять разницу между undefined и null. Ведь null и undefined представляют собой пустые значения. Даже операция сравнения null == undefined выводит true. Давайте попробуем разобраться в том, что из себя всё-таки представляет undefined.

Содержание статьи:

1. Введение.
2. Что такое undefined.
3. Что влияет на появление undefined.
4. Undefined в массивах.
5. Разница между null и undefined.
6. Заключение.

Введение

Большинство современных языков вроде Ruby, Python и Java имеют только одно значение null (null или nill), что совершенно логично.

В случае с JavaScript интерпретатор возвращает undefined при попытке доступа к переменной или свойству объекта, которые ещё не былы заданы. Пример:

Что же касается null, это значение представляет собой ссылку на отсутствующий объект. В JavaScript не устанавливается значение null для переменных или свойств объекта.

Некоторые встроенные методы, такие как String.prototype.match(), могут возвращать значение null для обозначения отсутствующего объекта:

Поскольку в JavaScript  у разработчиков есть возможность получить доступ к неинициализированным значениям, это может вызвать некоторые ошибки.

Часто такие действия приводят к ошибке undefined, что ломает весь скрипт. Наиболее часто при этом возникают следующие ошибки:

• typeError: undefined не является функцией;
• typeError: невозможно прочитать '<prop-name>' свойство undefined;
• другие подобные ошибки.

А иронию этой шутки может понять только разработчик JavaScript:

Чтобы избежать ошибок, связанных с undefined, нужно понимать, когда эта ошибка может возникать, и снизить риски ее появления в вашем приложении.

В JavaScript есть 6 примитивных типов:

• Boolean. У этого типа есть два значения: true (истина) и false (ложь). Как правило,  логический тип boolean используется для хранения значения типа да/нет.
• Number. Тип число используется как для целых, так и для дробных чисел (1, 6.7, 0xFF);
• String. В JavaScript любые текстовые данные являются строками. В JavaScript нет разницы между двойными и одинарными кавычками: var text = "строка" / var texts = 'строки';
• Symbol. Новый примитивный тип данных Symbol служит для создания уникальных идентификаторов: Symbol("name") (начиная с ES2015);
• Null. Значение null не относится ни к одному из типов выше, а образует свой отдельный тип, состоящий из единственного значения null;
• Undefined. Значение undefined, как и null, образует свой собственный тип, состоящий из одного этого значения. Если переменная объявлена, но в неё ничего не записано, то её значение как раз и есть undefined (значение не присвоено).

Отдельно от всех стоит тип Object (объект), который используется для организации данных и объявления более сложных сущностей. Пример:

Объект может иметь любые свойства до тех пор, пока они находятся внутри {фигурных скобок}.

Среди этих 6 примитивных типов undefined является специальным значением. Согласно спецификации ECMAScript, undefined используется тогда, когда переменной не присвоено значение.

Этот стандарт четко определяет, что значение undefined можно получить при доступе к неинициализированным переменным, несуществующим свойствам объекта, несуществующим элементам массива и тому подобному. Например:

Пример выше показывает, что undefined выводится при попытке доступа к:

• неинициализированной переменной number;
• несуществующему свойству объекта movie.year;
• несуществующему элементу массива movies[3].

Оператор typeof возвращает строку undefined для неопределенного значения:

Оператор typeof отлично подходит для проверки значения undefined у переменной:

Что влияет на появление undefined

Неинициализированная переменная

Объявленная переменная, которая еще не имеет значения (неинициализированна), по умолчанию undefined.
Пример:

Переменная myVariable уже объявлена, но еще не имеет присвоенного значения. Попытка обратиться к переменной закончится выводом undefined.

Эффективный подход к решению проблем неинициализированных переменных — это по возможности присвойте им начальное значение. Чем меньше переменная существует в неинициализированном состоянии, тем лучше. В идеале вы сразу же присваиваете значение myVariable = 'Стартовое значение’, хотя это не всегда возможно.

Отдавайте предпочтение const и let, а от var нужно постепенно отказываться

Некоторые разработчики считают, что одной из лучших особенностей ECMAScript 2015 является новый способ объявления переменных путём использования const и let. Это большой шаг вперед, так как объявленные таким способом объекты/переменные находятся в области видимости, ограниченной текущим блоком кода (в отличие от старой функции var), и находятся во временной мертвой зоне до момента присвоения им конкретного значения.

При использовании неизменяемых данных (констант) рекомендуется инициализировать их как const. Это создаст неизменную связку.

Одна из приятных особенностей const заключается в том, что существует возможность назначить начальное значение константы. Пример:

Таким образом, константа не подвергается неинициализированному состоянию, и получить значение undefined просто невозможно.

Давайте протестируем функцию, которая проверяет, является ли слово палиндромом:

Переменным length и half  значение присваивается один раз. В этом случае объявить их как const будет логично, так как их значение не будет меняться.

Если вам нужно будет менять значение переменной несколько раз, то обозначьте ее как let. По возможности сразу присваивайте ей начальное значение. Пример:

А когда использовать var? Некоторые разработчики, ссылаясь на стандарт ES2015, предлагают перестать использовать var.

Проблема использования var заключается в так называемом поднятии переменных (англ. variable hoisting). Где бы ни находилось объявление, это равнозначно тому, что переменную объявили в самом начале кода.

В этом случае переменная myVariable содержит undefined до получения значения:

Если же переменную объявить как let, то она останется недоступной до момента присвоения ей значения. Это происходит из-за того, что переменная находится во временной мертвой зоне. В этом случае вероятность получения значения undefined близится к нулю.

Вышеприведенный пример с let (вместо var) выведет ReferenceError, потому что переменная во временной мертвой зоне недоступна.

Использование const или let для неизменяемых привязок позволит снизить риски получения значения undefined при написании кода.

Усильте связность

Связность характеризует степень взаимосвязанности элементов модуля (пространства имен, класса, метода, блока кода). Есть два вида связанности — сильная и слабая.

Сильная связность предпочтительнее, поскольку она предполагает, что элементы модуля должны фокусироваться исключительно на одной задаче. Это поможет модулю быть:

• сфокусированным и понятным — становится легче понять, какую задачу выполняет модуль;
• легко поддерживаемым и поддающимся рефакторингу — изменение модуля влияет на меньшее количество элементов;
• многоразовым — если модуль ориентирован на выполнение одной задачи, то его легче использовать повторно;
• простым для тестирования — вам будет проще протестировать модуль, ориентированный на одну задачу.

Сильная связность, сопровождающаяся слабым зацеплением, является характеристикой хорошо спроектированной системы.

Блок кода сам по себе может считаться небольшим модулем. Чтобы извлечь выгоду из преимуществ сильной связности, нужно держать переменные как можно ближе к блоку кода, который их использует.

Например, если переменная нужна только для использования в определенном блоке кода, тогда можно объявить её и разрешить существовать только внутри нужного блока (используя const или let для объявления).

Одним из классических примеров излишнего срока жизни переменных является использование цикла for внутри функции:

index, item и length — эти переменные объявляются в начале тела функции. Однако они используются только ближе к концу функции. Так в чем проблема с таким подходом?

Всё время между объявлением переменной в начале и до использования её в цикле for переменные index и item не инициализируются и выводят undefined. По этому примеру видно, что срок жизни переменной является необоснованно длинным.

Разумнее будет переместить переменные ближе к месту их применения:

Переменные index и item существуют только в области действия блока  for. У них нет никакого значения за его пределами.

Переменная (const) length объявляется в месте ее использования.

Почему модифицированная версия лучше первоначальной? Посмотрим:

• значения не подвергаются неинициализированному состоянию, поэтому нет риска получения undefined;
• перемещение переменных ближе к месту их использования увеличивает читаемость кода;
• элементы с высокой связанностью кода легче рефакторить и извлекать при необходимости в отделенные функции.

Доступ к несуществующему свойству

При доступе к несуществующему свойству объекта JavaScript возвращает undefined.

Обратите внимание на пример:

favoriteMovie — это объект с одним значением title. Доступ к несуществующему свойству actors путём использования favoriteMovie.actors приведет к выводу undefined.

Сам по себе доступ к несуществующему свойству не вызывает ошибки. Реальная проблема возникает при попытке получить значение из несуществующего свойства. Это сообщение об ошибке отражает наиболее распространенную ловушку, связанную с undefined:

Немного изменим предыдущий фрагмент кода, чтобы пояснить поведение TypeError:

В favoriteMovie нет свойства actors, поэтому использование favoriteMovie.actors приведет к undefined.

В результате доступ к элементу со значением undefined с помощью выражения favoriteMovie.actors [0] вызывает TypeError.

Возможности JavaScript, которые позволяют получить доступ к несуществующим свойствам, являются источником путаницы. Свойство может быть установлено или может отсутствовать. Идеальным решением этой проблемы будет установка правил для объекта, которые позволят ему содержать только свойства с явно заданными значениями.

К сожалению, не всегда возможно контролировать объекты, с которыми приходится работать. Такие объекты могут иметь разный набор свойств в различных сценариях. Таким образом, нужно обрабатывать все эти сценарии вручную.

Попробуем реализовать функцию append(array, toAppend), которая добавляет в начале и/или в конце массива новые элементы. Параметр toAppend принимает объект со свойствами:

• first: элемент, вставленный в начале массива;
• last: элемент, вставленный в конец массива.

Функция возвращает новый экземпляр массива, не изменяя исходный (т.е. это чистая функция).

Функция append() может выглядеть так:

Поскольку объект toAppend может удалять первые или последние свойства, необходимо проверить, существуют ли эти свойства в toAppend.

Доступ к свойству приведет к получению undefined, если его не существует. Можно проверить существует ли первое или последнее свойство, чтобы избежать undefined. Как вариант, это можно сделать с помощью условий if(toAppend.first){} и if(toAppend.last){}.

Но не будем торопиться. В этом подходе есть серьезный недостаток. undefined, также как false, null, 0, NaN и ' ' являются ложными значениями (falsy values).

В текущей реализации append() функция не позволяет вставлять ложные элементы:

0 и false — ложные значения, потому что if (toAppend.first) {} и if (toAppend.last) {} фактически сравниваются с ложными значениями и эти элементы не вставляются в массив. Функция возвращает исходный массив [10] без изменений.

Последующие подсказки объясняют, как правильно проверить существование свойства.

Проверьте, существует ли свойство

К счастью, JavaScript предлагает множество способов определить, имеет ли объект определенное свойство:

• obj.prop !== undefined позволяет сравнивать объект напрямую с undefined;
• typeof obj.prop !== 'undefined' проверяет тип значения свойства;
• obj.hasOwnProperty('prop') проверяет объект на наличие собственного свойства;
• 'prop' in obj проверяет объект на наличие собственного или унаследованного свойства.

Рекомендацией в этом случае будет использование in оператора. У него простой и понятный синтаксис. Присутствие оператора in указывает на четкое намерение проверить, имеет ли объект определенное свойство, не обращаясь к фактическому значению этого свойства.

Использование obj.hasOwnProperty('prop') — это также неплохое решение. Оно немного длиннее, чем  оператор in , и проверяет только собственные свойства объекта.

Эти два способа сравнения с undefined могут сработать… Но кажется, что использование obj.prop !== undefined и typeof obj.prop !== 'undefined' является не очень хорошим решением и может привести к непонятным последствиям при прямом сравнении с undefined.

Давайте попробуем улучшить функцию append(array, toAppend), используя in оператора:

'first' in toAppend ( как и 'last' in toAppend) выводит true, независимо от существующего свойства. В других случаях выводится — false.

Использование оператора in устраняет проблему со вставкой ложных элементов 0 и false. Теперь добавление элементов в начале и в конце массива [10] приводит к ожидаемому результату [0, 10, false].

Выполните деструктурирование доступа к свойствам объекта

При доступе к свойству объекта иногда необходимо указать значение по умолчанию, если свойство не существует.

Можно использовать in с тернарным оператором, чтобы получить следующий результат:

Использование синтаксиса тернарного оператора становится сложным, когда число проверяемых свойств увеличивается. Для каждого свойства нужно создать новую строку кода, чтобы обработать значение, увеличивая опасную кучу похожих тернарных операторов.

Чтобы использовать более простой подход, давайте познакомимся с функцией ES2015, называемой деструктурирование объекта.

Деструктурирование объекта позволяет напрямую извлекать значения свойств объекта непосредственно в переменные и устанавливать значение по умолчанию, если свойство не существует. Это удобно использовать для исключения прямого контакта с undefined.

Действительно, извлечение свойств теперь выглядит совершенно по-другому:

Чтобы увидеть это в действии, определяем полезную функцию, обертывающую строку в кавычки. quote(subject, config) принимает первый аргумент как строку, которую нужно обернуть. Второй аргумент config — это объект со следующими свойствами:

• char — символ цитаты, например, '(одинарная кавычка) или "(двойная кавычка). По умолчанию — ";
• skipIfQuoted — логическое значение, чтобы пропустить цитирование, если строка уже цитируется. По умолчанию —  true.

Применяя преимущества деструктурирования объекта, давайте реализуем quote():

const { char = '"', skipIfQuoted = true } = config в одной строкe извлекает свойства char и skipIfQuoted из объекта config.

Если некоторые свойства недоступны в объекте config,  деструктурирование задает значения по умолчанию: '"' для char и false для skipIfQuoted.

К счастью, функцию можно даже улучшить.

Давайте переместим деструктурирование прямо в раздел параметров. И установим значение по умолчанию (пустой объект { }) для параметра config, чтобы пропустить второй аргумент, когда будет достаточно значений по умолчанию.

Обратите внимание, что деструктурирующее присваивание заменяет параметр config в сигнатуре функции. Это позволяет сделать параметр quote() на одну строку короче. Параметр = {} в правой части деструктурирующее присваивание гарантирует, что используется пустой объект, если второй аргумент не указан вообще quote('Sunny day').

Деструктурирование объектов — это мощная функция, которая эффективно обрабатывает извлечение свойств из объектов. Это хорошо, когда есть возможность указать значение по умолчанию, которое будет возвращено при попытке доступа к несуществующему свойству. В результате вы избегаете возникновения значения undefined и всех проблем, которые могут быть связаны с ним.

Установите объекту свойства по умолчанию.

Если нет необходимости создавать переменные для каждого свойства, такого как назначение деструктурирования, объект, который пропускает некоторые свойства, может быть заполнен значениями по умолчанию.

Функция ES2015 Object.assign (target, source1, source2, ...) копирует значения всех перечисленных собственных свойств из одного или нескольких исходных объектов в целевой объект. После чего возвращает целевой объект.

Например, вам нужно получить доступ к данным объекта unsafeOptions, который не всегда содержит полный набор свойств.

Чтобы избежать появления значения undefined при доступе к несуществующему свойству из unsafeOptions, можно сделать следующие настройки:

• определить объект defaults, который содержит значения свойств по умолчанию;
• вызвать функцию Object.assign({ }, defaults, unsafeOptions), чтобы создать новый объект options. Новый объект получает все свойства из unsafeOptions, недостающие берутся из defaults.

unsafeOptions содержит только свойство fontSize. Объект defaults указывает значения по умолчанию для fontSize и color.

Object.assign() принимает первый аргумент как целевой объект {}. Целевой объект получает значение свойства fontSize из объекта-источника unsafeOptions. А значение свойства color — из объекта-источника defaults, поскольку unsafeOptions не содержит color. Важен порядок, в котором перечислены исходные объекты: первый пришёл — первый ушёл.

Теперь возможно получить доступ к любому свойству объекта options, включая options.color, который изначально был недоступен в unsafeOptions.

К счастью, существует более простой и легкий способ установить значения по умолчанию для свойств объекта. Рекомендуется использовать новую функцию JavaScript, которая позволяет расширять свойства при инициализации объектов.

Вместо вызова Object.assign() используйте синтаксис распространения объекта, чтобы скопировать в целевой объект все собственные и перечисляемые свойства из исходных объектов:

Инициализатор объекта распространяет свойства из исходных объектов defaults и unsafeOptions. Важен порядок, в котором указаны исходные объекты: свойства более позднего исходного объекта перезаписывают более ранние.

Заполнение неполного объекта значением по умолчанию является эффективной стратегией, обеспечивающей безопасность и стабильность вашего кода. Независимо от ситуации, объект всегда содержит полный набор свойств, и появление undefined невозможно.

Параметры функции

Параметры функции по умолчанию установлены на undefined.

Обычно функция, имеющая определенные параметры, должна вызываться с одинаковым количеством аргументов. В таком случае параметры получают ожидаемые значения:

При вызове функции multiply(5, 3) параметры a и b получают соответствующие значения 5 и 3. Умножение рассчитывается как ожидаемое: 5 * 3 = 15.

Что происходит, когда пропускается аргумент при вызове? Параметр внутри функции получает значение undefined.

Давайте немного изменим предыдущий пример, вызвав функцию только с одним аргументом:

Функция multiply(a, b) { } определяется двумя параметрами: a и b. Вызов multiply(5) выполняется с помощью одного аргумента, в результате параметр равен 5, а параметр b получает значение undefined.

Используйте значение параметра по умолчанию

Иногда функция имеет не полный набор аргументов при ее вызове. В таком случае нужно установить значения по умолчанию для параметров, у которых нет значений.

Учитывая предыдущий пример, давайте сделаем некоторые улучшения. Если параметр b — undefined, то по умолчанию ему присваивается значение 2:

Функция вызывается одним аргументом multiply(5). Первоначально параметр a равен 2, а b соответствует undefined. Выражение проверяет, не равно ли b параметру undefined. Если это так, b получает значение по умолчанию 2.

Хотя представленный способ назначения значений по умолчанию работает, не рекомендуется сравнивать значения напрямую сundefined. Это уже будет выглядеть как хак.

Лучшим подходом является использование параметров по умолчанию из ES2015. Он краткий и не содержит в себе прямого сравнения значений с undefined.

Установка параметров по умолчанию для b не выводит значения undefined:

Значение b = 2 в сигнатуре функции гарантирует, что если b получит значение undefined, то по умолчанию параметр изменится на 2.

Функция параметров по умолчанию из ES2015 интуитивно понятна и выразительна. Всегда используйте ее для установки значений по умолчанию для необязательных параметров.

Возвращаемое значение функции

В JavaScript функция, которая не имеет оператора return, возвращает значение undefined:

Функция square() не возвращает результаты вычислений. Результат — undefined.

Такая же ситуация возникает, когда оператор return присутствует, но без какого-либо выражения рядом:

return; выполняется, но он не возвращает ничего. Результат вызова — undefined.

Указывая значение для return, можно получить желаемый результат:

Теперь вызов функции выведет нужное значение.

Не доверяйте автоматической расстановке точки с запятой

Следующий список операторов в JavaScript должен заканчиваться точкой с запятой (;):

• пустой оператор;
• операторы: let, const, var, import, export;
• утверждение значения;
• утверждение отладчика;
• утверждения: continue, break, throw, return.

Если вы используете одно из вышеуказанных утверждений, обязательно нужно ставить точку с запятой в конце:

Как можно видеть, в конце объявленияlet и  оператором return обязательно ставится точка с запятой.

Что происходит, когда вы не хотите указывать точки с запятой? Например, чтобы уменьшить размер исходного файла.

В такой ситуации ECMAScript предоставляет механизм автоматической установки точки с запятой (ASI),  который сделает всю работу за вас.

Используя ASI, вы можете удалить точки с запятой из предыдущего примера:

Вышеприведенный текст является допустимым кодом JavaScript. Отсутствующие точки с запятой автоматически вставлены за вас.

На первый взгляд, это выглядит довольно многообещающе. Механизм ASI позволяет пропустить ненужные точки с запятой. Вы можете сделать код JavaScript меньше и более простым для чтения.

Но тут существует один небольшой, но раздражающий момент, который может создать ASI. Если между return и возвращаемым выражением стоит новая строка return n expression, ASI автоматически вставляет точку с запятой return; n expression.

К чему приведет пустой оператор return ? Функция вернет значение undefined. Если вы не знаете, как работает механизм ASI, то неожиданное появление значения undefined может ввести в заблуждение.

Например, давайте изучим возвращаемое значение вызываемой функции getPrimeNumbers():

Между return и значением массива есть новая строка. JavaScript автоматически вставляет точку с запятой после оператора return, интерпретируя код следующим образом:

В таком случае мы получим значение undefined.

Проблема решена путем удаления новой строки между return и массивом:

Оператор void

Оператор void выполняет выражение и возвращает undefined вне зависимости от результата:

Одним из вариантов использования оператора void является переопределение результата выполнения выражения и возврат undefined, в случае возникновения побочных эффектов выполнения функции.

Undefined в массивах

Вы получаете undefined при попытке доступа к элементу массива с индексом вне пределов массива.

Массив colors имеет 3 элемента, поэтому корректные индексы равны 0, 1 и 2.

Поскольку в индексах массива 5 и -1 нет элементов, значения colors[5] and colors[-1] получают значение undefined.

В JavaScript вы можете столкнуться с так называемыми разреженными массивами. Эти массивы имеют пробелы, то есть на некоторых индексах не определены никакие элементы.

Когда делаем попытку получить доступ к пустому значению в разреженном массиве, на выходе получаем  undefined.

Следующий пример генерирует разреженные массивы и пытается получить доступ к их пустым элементам:

sparse1 создается путем вызова конструктора Array с числовым первым аргументом. Он имеет 3 пустых элемента.

sparse2 создается с литералом массива, второй элемент которого отсутствует. В любом из этих разреженных массивов доступ к пустому элементу оценивается как undefined.

При работе с массивами, чтобы избежать появления значения undefined, обязательно используйте допустимые индексы массивов или вообще не создавайте разреженные массивы. А вообще не забывайте, что массивы начинаются с нуля.

Разница между undefined и null

Часто у людей возникает разумный вопрос: в чем основное отличие между undefined и null? Оба специальных значения означают пустое состояние.

Основное различие заключается в том, что undefined представляет значение переменной, которая еще не была инициализирована, а null представляет собой намеренное отсутствие объекта.

Рассмотрим разницу на примерах.

Переменная number определена, но ей не назначено начальное значение:

Числовая переменная не определена, что явно указывает на неинициализированную переменную.

То же самое произойдёт при попытке доступа к несуществующему свойству объекта:

Поскольку свойство lastName не существует в obj, JavaScript корректно оценивает obj.lastName как undefined.

Нужно понимать, что переменная должна ожидать возвращение объекта функции. Но по какой-то причине создание объекта невозможно. В этом случае null является значимым индикатором недостающего объекта.

Например, clone() — это функция, которая клонирует простой объект JavaScript. Ожидается, что функция вернет объект:

Однако clone() может быть вызван с пустым аргументом: 15 или null (или вообще со значением null или undefined). В этом случае функция не может создать клон, поэтому возвращает null — индикатор отсутствующего объекта.

Оператор typeof делает различие между двумя значениями:

Строгий оператор равенства === правильно отличает undefined от null:

Заключение

Существование undefined является следствием разрешительной природы JavaScript, которая позволяет использовать:

• неинициализированные переменные;
• несуществующие свойства или методы объекта;
• несуществующие индексы для доступа к элементам массива;
• вызов функции, которая ничего не возвращает.

В основном сравнение напрямую с undefined является плохой практикой, потому что вы, вероятно, полагаетесь на разрешенную, но плохую практику, упомянутую выше.

Стратегия борьбы с undefined заключается в уменьшении появления этого значения в вашем коде. И выработайте в себе привычку делать следующее:

• уменьшать использование неинициализированных переменных;
• делать жизненный цикл переменных коротким и близким к источнику их использования;
• по возможности назначать начальное значение переменным;
• стараться использовать const или let;
• использовать значения по умолчанию для некритичных параметров функции;
• проверять наличие свойств или заполнить небезопасные объекты по умолчанию;
• избегать использования разреженных массивов.

При отладке своего кода (обычно на JavaScript) программист может столкнуться с системным сообщением об ошибке «TypeError: Cannot read property ‘xxx’ of undefined». Вместо значения ХХХ указана какая-либо объявленная переменная или свойство объекта, значение которых по различным причинам не задано разработчиком. Ниже разберём, каков перевод данного сообщения, и каково может быть решение возникшей проблемы.

Почему возникает ошибка

В переводе данное сообщение выглядит как «Ошибка типа: Не удаётся прочитать неопределённое свойство ХХХ». Поскольку в некоторых языках программирования (в частности, «JavaScript») есть возможность получения доступа к неинициализированным значениям, то это может вызывать появление рассматриваемой мной ошибки.

Что до причин ошибки undefined, то она обычно возникает при отладке какого-либо программного кода, и может быть вызвана следующими факторами:

• Использующиеся в программном коде переменная не была инициализирована (переменной не присвоено значение);
• Была осуществлена попытка доступа к отсутствующему свойству объекта;
• Была попытка получить доступ к отсутствующему элементу массива.

Давайте разберёмся, как исправить данную ошибку при написании вашего кода.

Читайте также: Failed to execute ‘replaceChild’ on ‘Node’  на JavaScript – как исправить.

Присвойте начальное значение переменной

Наиболее очевидным способом исправить ошибку «TypeError: Cannot read property ‘xxx’ of undefined» является присвоение переменной начального значения. Чем меньше такая переменная пребывает в неинициализированном состоянии – тем будет лучше. В идеале лучше сразу же присвоить значение «Variable» = «начальное значение» (‘initial’), хотя далеко не всегда специфика вашего кода может предполагать указанный вариант.

Улучшите связность вашего кода

Термин «связность» в нашем контексте характеризует уровень взаимосвязанности элементов разрабатываемого вами модуля (пространства имён, метода, класса, блока кода). Как известно, существуют два типа связности, а именно сильная и слабая связность. Использование сильной связности предполагает фокусировку элементов модуля лишь на одной задаче. Потому для извлечения выгоды из сильной связности, необходимо держать используемые переменные поближе к блоку кода, в работе которого они используются.

К примеру, вместо блока кода:

будет оптимальнее переместить переменные поближе к месту их применения:

Улучшение связности позволит избежать появление ошибки «Cannot read property ‘xxx’ of undefined» при отладке вашего кода.

Проверьте наличие свойства

В языке Javascript имеются ряд инструментов, позволяющих определить, имеет ли необходимый нам объект какое-либо свойство:

В частности, это:

• typeof obj.prop !== ‘undefined’ — данный инструмент позволяет проверить тип значения свойства;
• obj.prop !== undefined — этот инструмент позволяет сравнить объект непосредственно с undefined;
• ‘prop’ in obj позволяет проверить объект на наличие его собственного или полученного свойства;
• И obj.hasOwnProperty(‘prop’) позволяет проверить объект на наличие его собственного свойства.

В этом и схожих случаях рекомендуется использовать оператор in, который обладает простым и удобным синтаксисом. Наличие оператора in демонстрирует желание проверить, имеет ли объект нужное свойство без обращения к фактическому значению данного свойства.

Деструктурируйте доступ к свойствам нужного объекта

Деструктурирование нужного объекта позволяет непосредственно извлекать значения свойства объекта в переменные или, если такое свойство не существует, устанавливать значение по дефаулту. Такой вариант позволяет исключить прямой контакт с undefined.

Извлечение свойств теперь выглядит примерно так:

Деструктурирование хорошо, когда можно указать значение по умолчанию, и это значение будет возвращено при попытке доступа к отсутствующему свойству. В конечном счёте, благодаря деструктурированию вы сможете избежать появления undefined и всех сопутствующих проблем.

Это интересно: что означает «JavaScript error: Mutations are not initialized.

Заключение

В нашей статье мы разобрали, почему появляется ошибка «TypeError: Cannot read property ‘xxx’ of undefined», как она переводится и как от неё можно избавиться. Во избежание возникновения данной ошибки присвойте начальное значение соответствующей переменной. Это позволит избежать появления рассмотренной выше дисфункции при отладке вашего кода.

От автора: чтобы вернуть сообщество разработчиков, мы рассмотрели нашу базу данных по тысячам проектов и нашли 10 самых распространённых ошибок в JavaScript. Мы собираемся показать вам, что к ним приводит и как это предотвратить. Если ни одна ошибка JavaScript не встречается в вашем коде, это делает вас лучшим разработчиком.

Поскольку всем управляют данные, мы собрали, проанализировали и оценили первые 10 ошибок JavaScript. Rollbar собирает все ошибки из каждого проекта и суммирует, сколько раз каждая из них возникала. Мы делаем это, группируя ошибки в соответствии с их отпечатками пальцев . В принципе, группируется по две ошибки, если вторая — это просто повторение первой. Это дает пользователям хороший обзор вместо огромной свалки, какую вы видели в файле журнала.

Мы сосредоточились на ошибках, которые скорее всего повлияют на вас и ваших пользователей. Чтобы сделать это, мы оценили ошибки по количеству проектов, испытывающихся в разных компаниях. Если бы мы посмотрели только на общее количество раз, когда произошла каждая ошибка, то клиенты большого объема могли бы подавить набор данных с ошибками, которые не имеют отношения к большинству читателей.

Вот первые 10 ошибок JavaScript:

Ошибки были сокращены для удобства чтения. Давайте погрузимся глубже в каждую, чтобы определить, что может вызвать её, и как избежать их появления.

1. Uncaught TypeError: Cannot read property

Если вы разработчик JavaScript, то, вероятно, видели эту ошибку очень много раз. Это происходит в Chrome, когда вы читаете свойство или вызываете метод на неопределенный объект. Это можно очень легко проверить в консоли разработчика Chrome.

Это может произойти по многим причинам, но чаще всего это неправильная инициализация состояния при рендеринге компонентов пользовательского интерфейса. Давайте рассмотрим пример того, как это может произойти в реальном приложении. Мы выберем React, но те же принципы неправильной инициализации применимы и к Angular, Vue или любой другой структуре.

Здесь понимаются две важные вещи:

Это легко исправить. Самый простой способ: инициализировать состояние с разумными значениями по умолчанию в конструкторе.

Код в вашем приложении может отличаться, но мы надеемся, что дали вам достаточно информации, чтобы исправить или избежать этой проблемы. Если нет, продолжайте читать, потому что далее мы рассмотрим больше примеров связанных с ошибками.

2. TypeError: ‘undefined’ is not an object (evaluating

Эта ошибка возникает в Safari при чтении свойства или вызове метода для неопределенного объекта. Вы можете проверить это в консоли разработчика Safari. Это по сути то же самое, что и вышеприведенная ошибка для Chrome, только Safari использует другое сообщение об ошибке.

3. TypeError: null is not an object (evaluating

Это ошибка, которая возникает в Safari при чтении свойства или вызове метода для пустого объекта. Проверить это можно в консоли разработчика Safari.

Интересно, что в JavaScript значения null и undefined не совпадают, поэтому мы видим два разных сообщения об ошибках. Undefined обычно является переменной, которая не была назначена, а null означает, что значение пустое. Чтобы убедиться, что они не одно и то же, попробуйте использовать строгий оператор равенства:

Один из способов, которым эта ошибка может возникнуть в реальном мире — это попытка использовать элемент DOM в JavaScript перед загрузкой элемента. Это потому, что DOM API возвращает null для ссылок на пустые объекты.

Любой JS-код, который выполняет и обрабатывает элементы DOM, должен выполняться после создания элементов DOM. JS-код интерпретируется сверху вниз, как изложено в HTML. Итак, если перед элементами DOM есть тег, код JS в теге скрипта будет выполняться, когда браузер анализирует HTML-страницу. Вы получите эту ошибку, если элементы DOM не были созданы до загрузки сценария.

В этом примере мы можем решить проблему, добавив прослушиватель событий, который уведомит нас, когда страница будет готова. После addEventListener метод init() может использовать элементы DOM.

4. (unknown): Script error

Ошибка скрипта возникает, когда ошибка неперехваченного JavaScript пересекает границы домена и нарушает политику перекрестного происхождения. Например, если вы размещаете свой код JavaScript на CDN, любые неперехваченные ошибки (ошибки, которые появляются в обработчике window.onerror, вместо того, чтобы быть пойманным в try-catch) будут переданы как просто «Script error» вместо того, чтобы содержать полезную информацию. Эта мера безопасности браузера предназначена для предотвращения передачи данных по доменам, которые в противном случае не были бы допущены к коммуникации.

Чтобы получить реальные сообщения об ошибках, выполните следующие действия:

1. Отправьте заголовок Access-Control-Allow-Origin

Установка заголовка Access-Control-Allow-Origin в * означает, что к ресурсу можно получить доступ из любого домена. Вы можете заменить * своим доменом, если необходимо: например, Access-Control-Allow-Origin: www.example.com . Если вы используете CDN из-за проблем с кэшированием, которые могут возникнуть, обработка нескольких доменов становится сложной и нельзя не приложить усилий. Подробнее см. здесь.

Вот несколько примеров того, как установить этот заголовок в различных средах:

Apache

В папках, где будут храниться ваши файлы JavaScript, создайте файл .htaccess со следующим содержимым:

Nginx

Добавьте директиву add_header в блок местоположения, который служит файлам JavaScript:

HAProxy

Добавьте в ресурс, где будут загружены файлы JavaScript:

2. Установите crossorigin = «anonymous» в теге скрипта

В HTML-источнике для каждого из сценариев, где вы установите заголовок Access-Control-Allow-Origin, в теге SCRIPT установите crossorigin=»anonymous». Убедитесь, что заголовок отправляется для файла сценария, перед добавлением свойства crossorigin в тег скрипта. В Firefox, если атрибут crossorigin присутствует, но заголовок Access-Control-Allow-Origin отсутствует, сценарий не будет выполнен.

5. TypeError: Object doesn’t support property

Это ошибка, которая возникает в IE при вызове неопределенного метода. Вы можете проверить это в IE Developer Console.

Это эквивалентно ошибке «TypeError: ‘undefined’ is not a function» в Chrome. Да, разные браузеры могут иметь разные сообщения для одной и той же ошибки.

Это обычная проблема для IE в веб-приложениях, использующих пространство имен JavaScript. Когда это так, проблема в 99,9% случаев— это неспособность IE связать методы в текущем пространстве имен с ключевым словом this. Например, если у вас есть пространство имен имен Rollbar с помощью метода isAwesome. Обычно, если вы находитесь в пространстве имен Rollbar вы можете вызвать метод isAwesome со следующим синтаксисом:

Chrome, Firefox и Opera с радостью согласятся с этим синтаксисом. С другой стороны, IE не станет. Таким образом, самая безопасная ставка при использовании JS namespacing — это префикс с фактическим пространством имен.

6. TypeError: ‘undefined’ is not a function

Это ошибка, возникающая в Chrome при вызове неопределенной функции. Вы можете протестировать это в консоли разработчика Chrome и в Mozilla Firefox.

Поскольку на протяжении многих лет методы кодирования JavaScript и шаблоны проектирования становятся все более изощренными, наблюдается соответствующее увеличение распространения областей самореференции в обратных вызовах и закрытиях, которые являются довольно распространенным источником этой путаницы.

Рассмотрим фрагмент кода:

Выполнение вышеуказанного кода приводит к следующей ошибке: «Uncaught TypeError: undefined is not function». Причина, по которой вы получаете эту ошибку, заключается в том, что при вызове setTimeout() вы вызываете window.setTimeout(). В результате анонимная функция, передаваемая setTimeout(), определяется в контексте объекта окна, у которого нет clearBoard().

Традиционное решение, совместимое со старым браузером — просто сохранить ссылку на this в переменной, которая затем может быть унаследована закрытием. Например:

Кроме того, в новых браузерах для передачи правильной ссылки вы можете использовать метод bind():

7. Uncaught RangeError: Maximum call stack

Это ошибка, которая возникает в Chrome при нескольких обстоятельствах. Одно из них — когда вы вызываете рекурсивную функцию, которая не завершается. Вы можете протестировать это в консоли разработчика Chrome.

Это также может произойти, если вы передадите значение функции, находящейся за пределами допустимого диапазона. Многие функции принимают только определенный диапазон чисел для своих входных значений. Например, Number.toExponential(digits) и N umber.toFixed(digits) принимают цифры от 0 до 20, а Number.toPrecision(digits) принимают цифры от 1 до 21.

8. TypeError: Cannot read property ‘length’

Это ошибка, которая возникает в Chrome из-за свойства длины чтения для неопределенной переменной. Вы можете протестировать это в консоли разработчика Chrome.

Обычно вы определяете длину, определенную в массиве, но вы можете столкнуться с этой ошибкой, если массив не инициализирован или если имя переменной скрыто в другом контексте. Давайте рассмотрим эту ошибку на следующем примере.

Когда вы объявляете функцию с параметрами, эти параметры становятся локальными. Это означает, что даже если у вас есть переменные с именами testArray , параметры с одинаковыми именами внутри функции будут по-прежнему рассматриваться как локальные.

У вас есть два способа решить эту проблему:

1. Удалите параметры в объявлении функции (оказывается, вы хотите получить доступ к тем переменным, которые объявлены вне функции, поэтому вам не нужны параметры для вашей функции):

2. Вызовите функцию, передав ей массив, который мы объявили:

9. Uncaught TypeError: Cannot set property

Когда мы пытаемся получить доступ к неопределенной переменной, она всегда возвращает undefined, а мы не можем получить или установить любое свойство undefined. В этом случае приложение будет выбрасывать “Uncaught TypeError cannot set property of undefined.”

Например, в браузере Chrome:

Если объект test не существует, будет выдаваться ошибка: “Uncaught TypeError cannot set property of undefined.”

10. ReferenceError: event is not defined

Эта ошибка возникает при попытке получить доступ к переменной, которая не определена или находится за пределами текущей области. Вы можете легко протестировать её в браузере Chrome.

Если вы получаете эту ошибку при использовании системы обработки событий, убедитесь, что вы используете объект события, переданный в качестве параметра. Старые браузеры, такие как IE, предлагают событие глобальной переменной, но не поддерживаются во всех браузерах. Библиотеки, подобные jQuery, пытаются нормализовать это поведение. Тем не менее, лучше использовать тот объект, который передается в функцию обработчика событий.

Вывод

Мы надеемся, что вы узнали что-то новое и сможете избежать ошибок в будущем или, что это руководство помогло вам решить возникшую проблему. Тем не менее, даже при использовании лучших практик в производстве появляются неожиданные ошибки. Важно иметь видимость ошибок, которые влияют на пользователей, и хорошие инструменты для их быстрого решения.

Rollbar предлагает уникальные возможности для приложений JavaScript, таких как телеметрия, которые сообщают вам, что произошло в браузере пользователя, что приводит к ошибке. Это прозрение, которого у вас нет за пределами локальной консоли разработчика.

Автор: Jason Skowronski

Источник: //rollbar.com/

Редакция: Команда webformyself.