В JavaScript мы часто видим код таким: сравнение переменных с нулевым (это использование очень проблематично), используемое для определения того, дается ли переменная разумное значение. например:
var controller = {process: function (items) {if (items! == null) {// плохое написание method.sort (); item.foreach (function (item) {// Выполнить некоторую логику});}}}В этом коде метод Process (), очевидно, ожидает, что элементы будут массивом, потому что мы видим, что элементы имеют sort () и foreach (). Намерение этого кода очень очевидно: если элементы параметров не являются номером группы, то следующая операция будет остановлена. Проблема с этим методом написания заключается в том, что сравнение с NULL не может действительно предотвратить ошибки. Значение элементов может быть 1, строка или даже любого объекта. Эти значения не равны нулю, что, в свою очередь, приведет к ошибке, когда метод Process () будет выполнен для сортировки ().
По сравнению с только NULL не предоставляет достаточно информации, чтобы определить, действительно ли последующее выполнение кода безопасным. К счастью, JavaScript предоставляет нам множество способов обнаружить истинное значение переменной.
Обнаружение исходного значения
В JavaScript есть 5 примитивных типов (также известных как простые типы данных): строка, число, логическое, неопределенное и нулевое. Если вы хотите, чтобы значение было строкой, номером, логическим или неопределенным, лучшим вариантом является использование оператора TypeOF, который возвращает строку, представляющую тип.
Для строк тип возвращает «строка».
Для номеров TypeOF возвращает "номер".
Для логического, типоф возвращает «логический».
Для неопределенного типа возвращает «не определен».
Основной синтаксис TypeOF: TypeOF переменная, вы также можете использовать TypeOF (переменная), хотя это легальный синтаксис JavaScript, который делает TypeOF выглядеть как функция, а не оператор. В связи с этим мы рекомендуем писать без скобков.
Использование TypeOF для обнаружения этих 4 примитивных типов очень безопасно. Давайте посмотрим на следующие примеры.
// Обнаружение «string» if (typeof name === "string") {inothername = name.substring (3);} // обнаружение "номер" if (typeof count === "number") {updateCount (count);} // обнаруживает "boolean" if (typeof sound === "boolean" && indect) {ondect/ "stepect/"/ ""/ ""/ "/" "/"/ ""/ "/" "/"/ ""/ ""/ "/" "/"/ "? (typeof myApp === "undefined") {myApp = {// Другой код};}Оператор TypeOF уникален тем, что он не будет сообщать об ошибке при использовании с не выявленной переменной. Неопределенные переменные и переменные с неопределенным значением будут возвращать «неопределенные» через тип.
Последний примитивный тип NULL через TypeOF будет возвращать «объект», который выглядит странно и считается серьезной ошибкой в стандартной спецификации, поэтому при программировании вы должны предотвратить использование типа для обнаружения нулевых типов.
console.log (typeof null); // "объект"
Простое сравнение с NULL обычно не содержит достаточного количества информации, чтобы определить, является ли тип стоимости законным, поэтому NULL обычно не используется в операторах обнаружения.
Но есть исключение, если ожидаемое значение действительно нулевое, вы можете напрямую сравниваться с NULL. Например:
// Если вам нужно обнаружить NULL, используйте этот метод var element = document.getElementById ("my-div"); if (element! == null) {element.classname = "sud";}Если элемент DOM не существует, значение, полученное Document.getElementByID (), является нулевым. Этот метод либо возвращает узел, либо возвращает NULL. Поскольку NULL является предсказуемым выходом в настоящее время, результат возврата может быть обнаружен с использованием оператора идентификации === или оператора, не являющейся идентичностью! ==.
В дополнение к строке, номеру, логическому, неопределенному и объекту, упомянутому выше, возвращаемое значение оператора TypeOF также имеет функцию. С технической точки зрения функции также являются объектами в JavaScript, а не в типах данных. Тем не менее, функции обладают некоторыми специальными свойствами, поэтому необходимо отличить функции от других объектов оператором TypeOF. Эта функция будет использоваться в функции обнаружения позже.
Обнаружение эталонных значений
В JavaScript, за исключением исходных значений, все эталонные значения (также называемые объектами). Обычно используемые эталонные типы: объект, массив, дата и регуляция. Эти ссылочные типы являются встроенными объектами в JavaScript. Оператор TypeOF возвращает «объект» при оценке этих ссылок.
console.log (typeof {}); // "Object" console.log (typeof []); // "Object" console.log (typeof new Date ()); // "Object" console.log (typeof new Regexp ()); // "Object" console.log (typeof new Regexp ()); // "объект"Лучший способ обнаружить указанный тип значения - это использовать экземпляр оператора. Основной синтаксис экземпляра:
Value InstanceOf Constructor // DETECT DATE IF (Value EncanceOF DATE) {console.log (value.getfyear);} // обнаружил ошибку (exanceOf exanceOf exanceof exanceOf) {} // Обнаружение регулярного выражения if (exanceOf exanteof regexp) {if (value.test (sothervalue)) {console.log ("Соответствует");Интересной особенностью экземпляра является то, что он не только обнаруживает конструктор, который строит этот объект, но и обнаруживает цепочку прототипа. Цепочка прототипа содержит много информации, включая шаблон наследования, используемый для определения объекта. Например, по умолчанию каждый объект наследует от объекта, поэтому экземпляр значения объекта каждого объекта возвращает туру. например:
var now = new Date (); console.log (теперь экземпляр объекта); // natureConsole.log (теперь экземпляр даты); // Оператор NatureInStance также может обнаружить пользовательские типы, такие как: function Person (name) {this.name = name;} var me = new Person ("nicholas"); console.log (me ancementof object); // natureConsole.log (me exaction of person); // природаТип человека создается в этом примере кода. Переменная меня - это экземпляр человека, поэтому я экземпляр человека правдив. Как упомянуто выше, все объекты считаются экземплярами объекта, поэтому ME ExanceOf Object также является Ture.
При обнаружении встроенных и пользовательских типов в JavaScript лучший способ сделать это-использовать экземпляр оператора, который является единственным способом сделать это.
Но есть серьезное ограничение. Предполагая, что оба рамки браузера (кадры) имеют конструктора, а экземпляр человека FrameapersonInstance в кадре A передается в кадр B, следующие результаты будут:
Console.log (экземпляр FrameapersonInstance frameaperson) // ture
Console.log (экземпляр FrameapersonInstance framebperson) // false
Хотя определения двух человек точно одинаковы, они считаются разными типами в разных кадрах. Есть два очень важных встроенных типа, которые также имеют эту проблему: массив и функция, поэтому обнаружение их обычно не использует экземпляр.
Функция обнаружения
Технически говоря, функции в JavaScript являются эталонными типами, а также существует конструктор функций. Каждая функция является примером, например:
function myfunc () {} // bad writing method console.log (myfunc ancessionof function); // истинныйОднако этот метод не может быть использован в рамках, потому что каждый кадр имеет свой собственный конструктор функции. К счастью, оператор TypeOF также можно использовать для функций, возвращая «функцию».
function myfunc () {} // Хороший метод написания консоли.log (typeof myfunc === "function"); // истинныйЛучший способ обнаружить функцию - использовать TypeOF, потому что ее можно использовать в рамках.
Существует ограничение на использование TypeOF для обнаружения функций. В IE 8 и раньше браузеры IE TypeOF используется для обнаружения этих функций в узлах DOM, все возвращают «объект» вместо «функции». например:
// ieconsole.log (typeof document.createElement); // "Object" console.log (typeof Document.getElementByID); // "Object" console.log (typeof Document.getElementBytagName); // "Object" console.log (typeof Document.getElementBytagName); // "объект"
Это странное явление происходит потому, что браузеры имеют различия в реализации DOM. Короче говоря, эти более ранние версии IE не реализовали DOM в качестве встроенного метода JavaScript, в результате чего встроенный оператор типа определял эти функции как объекты. Поскольку DOM четко определен, знание того, что существует объект, означает, что это метод, разработчики часто используют оператор для обнаружения методов DOM, таких как:
// Обнаружение метода DOM if ("queryselectorall" в документе) {var Images = document.queryselectorall ("img");}Этот код проверяет, определяется ли QuerySelectorall в документе, и если да, используйте этот метод. Хотя это и не идеальный метод, это самый безопасный способ определить, существует ли метод DOM в IE 8 и более ранних браузерах. Во всех других случаях оператор TypeOF является лучшим выбором для обнаружения функций JavaScript.
Обнаружение массива
Одной из старейших проблем междомена в JavaScript является прохождение массивов взад и вперед между кадрами. Разработчик вскоре обнаружил, что экземпляр массива не может вернуть правильный результат в этом сценарии. Как упоминалось выше, каждый кадр имеет свой собственный конструктор массива, поэтому экземпляры в одном кадре не будут распознаваться в другом кадре.
Было проведено много исследований о том, как обнаружить типы массивов в JavaScript, и, наконец, Kangax дал элегантное решение:
Функция isArray (value) {return object.prototype.tostring.call (value) === "[object array]";}Кангакс обнаружил, что вызов встроенного метода значения ToString () возвращает стандартную строку, результаты во всех браузерах. Для массивов возвращаемой строкой - «[массив объектов]», и нет необходимости учитывать, какой кадр построен экземпляр массива. Этот метод часто очень полезен при определении встроенных объектов, но, пожалуйста, не используйте этот метод для пользовательских объектов.
Ecmascript5 официально вводит Array.isarray () в JavaScript. Единственная цель - точно определить, является ли значение массивом. Как и функции Kangax, Array.isarray () также может обнаружить значения, передаваемые через кадры, так много библиотек классов JavaScript в настоящее время реализуют этот метод аналогичным образом.
Функция isarray (value) {if (typeof array.isarray === "function") {return array.isarray (value);} else {return object.prototype.toString.call (value) === "IE 9+, Firefox 4+, Safari 5+, Opera 10.5+ и Chrome реализуют метод массива.
Обнаружить свойства
Другой сценарий, в котором нуль (и неопределенная) заключается в обнаружении, существует ли атрибут в объекте, например:
// Плохое написание: обнаружение ложных значений if (Object [PropertyName]) {// какой -то код} // Плохое письмо: сравните с null if (object [propertyname]! = Null) {// какой -то код} // Плохое письмо: сравните с неопределенным if (ObjectName]!Каждое суждение в приведенном выше коде фактически проверяет значение атрибута по данным имени, а не оценивает, существует ли атрибут, упомянутый данным именем. В первом решении результат будет ошибочным, когда значение свойства является ложным значением, таким как: 0, "" (пустая строка), ложная, нулевая и неопределенная, в конце концов, это юридические значения имущества.
Лучший способ определить, существует ли атрибут, - это использовать оператор. Оператор In просто судит, существует ли имущество без чтения стоимости имущества. Если свойство объекта экземпляра существует или наследует от прототипа объекта, оператор в IN вернет true. например:
var object = {count: 0, связано: null}; // хорошее написание if («count» in object) {// код здесь будет выполнен} // Плохое письмо: обнаружение ложных значений, если (объект [«count»]) {// Код здесь не будет выполнен} // Плохое написание, если («связанный с объектом») {// код здесь не будет выполнен} //. {// Код здесь не будет выполнен}Если вы просто хотите проверить, существует ли определенное свойство объекта экземпляра, используйте метод hasownproperty (). Все объекты JavaScript, унаследованные от объекта, имеют этот метод. Если это свойство существует в экземпляре, оно возвращает true (если это свойство существует только в прототипе, оно возвращает false). Следует отметить, что в IE 8 и более ранних версиях IE объекты DOM не наследуют от объекта, поэтому этот метод не включает. То есть вы должны проверить, существует ли метод объекта DOM HasownProperty (), прежде чем вызовать его.
// Это хороший способ написать if (object.hasownproperty ("insulity")) {// выполнить код здесь} // Если вы не уверены, является ли это объектом DOM, то запишите if ("hasownproperty" в Object && objПоскольку есть IE 8 и более ранние версии IE, при оценке того, существуют ли атрибуты объекта экземпляра, я предпочитаю использовать оператор IN. HasownProperty () будет использоваться только при оценке свойств экземпляра.
Независимо от того, когда вам нужно обнаружить существование свойства, используйте оператор или hasownproperty (). Это может избежать многих ошибок.
Выше приведено обнаружение JavaScript исходных значений, эталонных значений и атрибутов, введенных редактором. Я надеюсь, что это будет полезно для всех. Если у вас есть какие -либо вопросы, пожалуйста, оставьте мне сообщение, и редактор ответит всем вовремя. Большое спасибо за вашу поддержку сайту wulin.com!