Python - как проверить, существует ли переменная?

если (а === б)

3 FYI, (a == b) размещение в сетке Game of Life было не так уж и интересно.

Я предпочитаю .

Как бы вы ни выбрали, рассмотрите возможность размещения чека в такой функции

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

Если вы знаете, что переменная объявлена, но может не существовать, вы можете использовать

Проверяемая переменная иногда может быть вложенным свойством. Вы можете использовать prop || {}, чтобы перейти к проверке существования рассматриваемого свойства:

После каждого свойства используйте (… ‘|| {}’). NextProp, чтобы отсутствующее свойство не приводило к ошибке.

Или вы можете использовать existy, например

Если вы поместите его в функцию, это будет лишним. эквивалентно , если заявлено .

Это зависит от ситуации. Если вы проверяете что-то, что могло или не могло быть определено глобально вне вашего кода (например, jQuery), вам нужно:

(Здесь нет необходимости в строгом равенстве, typeof всегда возвращает строку.) Но если у вас есть аргументы функции, которые могут или не могли быть переданы, они всегда будут определены, но если они будут опущены, null.

Я удивлен, что об этом еще не упомянули …

вот несколько дополнительных вариантов с использованием

Преимущество использования этого метода в том, что его можно использовать до определения переменной.

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

работает нормально и проверяет только undefined.

В ReactJS, все немного сложнее! Это связано с тем, что это скомпилированная среда, которая следует правилу ESLint с момента (выпущено 1 октября 2018 г.). Представленная здесь документация полезна всем, кто интересуется этой проблемой …

Таким образом, хотя можно иметь переменную (или «неинициализированную»), это невозможно иметь необъявленную переменную в ReactJS без отключения правил eslint.

Это может быть очень неприятно — на GitHub так много проектов, которые просто используют преимущества стандартов до ES6; и напрямую скомпилировать их без каких-либо корректировок в принципе невозможно.

Но для ReactJS вы можете использовать . Если у вас есть необъявленная переменная, например …

Вы можете просто переписать эту часть как …

Например…

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

Вы можете использовать блок try … catch, как показано ниже:

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

Редактировать:

Если вы работали с интерфейсным Javascript и вам нужно было проверить, не инициализирована ли переменная ( будет считаться не инициализированной), вы можете использовать:

A real-life analogy

We can easily grasp the concept of a “variable” if we imagine it as a “box” for data, with a uniquely-named sticker on it.

For instance, the variable can be imagined as a box labeled with the value in it:

We can put any value in the box.

We can also change it as many times as we want:

When the value is changed, the old data is removed from the variable:

We can also declare two variables and copy data from one into the other.

Declaring twice triggers an error

A variable should be declared only once.

A repeated declaration of the same variable is an error:

So, we should declare a variable once and then refer to it without .

Functional languages

It’s interesting to note that there exist functional programming languages, like Scala or Erlang that forbid changing variable values.

In such languages, once the value is stored “in the box”, it’s there forever. If we need to store something else, the language forces us to create a new box (declare a new variable). We can’t reuse the old one.

Though it may seem a little odd at first sight, these languages are quite capable of serious development. More than that, there are areas like parallel computations where this limitation confers certain benefits. Studying such a language (even if you’re not planning to use it soon) is recommended to broaden the mind.

A variable

A variable is a “named storage” for data. We can use variables to store goodies, visitors, and other data.

To create a variable in JavaScript, use the keyword.

The statement below creates (in other words: declares) a variable with the name “message”:

Now, we can put some data into it by using the assignment operator :

The string is now saved into the memory area associated with the variable. We can access it using the variable name:

To be concise, we can combine the variable declaration and assignment into a single line:

We can also declare multiple variables in one line:

That might seem shorter, but we don’t recommend it. For the sake of better readability, please use a single line per variable.

The multiline variant is a bit longer, but easier to read:

Some people also define multiple variables in this multiline style:

…Or even in the “comma-first” style:

Technically, all these variants do the same thing. So, it’s a matter of personal taste and aesthetics.

instead of

In older scripts, you may also find another keyword: instead of :

The keyword is almost the same as . It also declares a variable, but in a slightly different, “old-school” way.

There are subtle differences between and , but they do not matter for us yet. We’ll cover them in detail in the chapter The old «var».

var VS let VS const

Сперва сравним и . Главное отличие в том, что область видимости переменной ограничивается блоком, а не функцией. Другими словами, переменная, созданная с помощью оператора , доступна внутри блока, в котором она была создана и в любом вложенном блоке. Говоря «блок», я имею ввиду всё что вложено между фигурными скобками , как например в цикле или условии .

Давайте в последний раз вернёмся к нашей функции .

function discountPrices (prices, discount) {  var discounted = []for (var i = 0; i < prices.length; i++) {    var discountedPrice = prices * (1 - discount)    var finalPrice = Math.round(discountedPrice * 100) / 100    discounted.push(finalPrice)  }console.log(i) // 3  console.log(discountedPrice) // 150  console.log(finalPrice) // 150return discounted}

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

function discountPrices (prices, discount) {  let discounted = []for (let i = 0; i < prices.length; i++) {    let discountedPrice = prices * (1 - discount)    let finalPrice = Math.round(discountedPrice * 100) / 100    discounted.push(finalPrice)  }console.log(i) // 3  console.log(discountedPrice) // 150  console.log(finalPrice) // 150return discounted}discountPrices(, .5) //  ReferenceError: i is not defined

Вот что мы получим: . Это подтверждает, что переменные ограничены блоком, а не функцией. Поэтому попытка получить к ним доступ приводит к ошибке.

var VS letvar: function scopedlet: block scoped

Следующее отличие связано с поднятием переменной. Ранее мы определили, что интерпретатор в JavaScript присваивает переменным значение по умолчанию во время фазы «Создания». Вы даже видели это в действии, логируя переменную до её объявления (и получили ).

function discountPrices (prices, discount) {  console.log(discounted) // undefinedvar discounted = []for (var i = 0; i < prices.length; i++) {    var discountedPrice = prices * (1 - discount)    var finalPrice = Math.round(discountedPrice * 100) / 100    discounted.push(finalPrice)  }console.log(i) // 3  console.log(discountedPrice) // 150  console.log(finalPrice) // 150return discounted}

Я даже не могу придумать причину, по которой стоит запрашивать переменную до её объявления. Мне кажется, что получать по умолчанию ReferenceError лучше, чем возврат .

Кстати, именно это и делает , т.е. вы получите ошибку ReferenceError вместо значения , если запросите переменную, созданную оператором , до её объявления.

Variable naming

There are two limitations on variable names in JavaScript:

The name must contain only letters, digits, or the symbols and .
The first character must not be a digit.

Examples of valid names:

When the name contains multiple words, camelCase is commonly used. That is: words go one after another, each word except first starting with a capital letter: .

What’s interesting – the dollar sign and the underscore can also be used in names. They are regular symbols, just like letters, without any special meaning.

These names are valid:

Examples of incorrect variable names:

Case matters

Variables named and are two different variables.

Non-Latin letters are allowed, but not recommended

It is possible to use any language, including cyrillic letters or even hieroglyphs, like this:

Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we’re writing a small script, it may have a long life ahead. People from other countries may need to read it some time.

Reserved names

There is a , which cannot be used as variable names because they are used by the language itself.

For example: , , , and are reserved.

The code below gives a syntax error:

An assignment without

Normally, we need to define a variable before using it. But in the old times, it was technically possible to create a variable by a mere assignment of the value without using . This still works now if we don’t put in our scripts to maintain compatibility with old scripts.

This is a bad practice and would cause an error in strict mode:

7 ответов

Лучший ответ

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

Установите вторую переменную равной первой
Сравнивайте второе с первым через равные промежутки времени (или по какому-либо событию)
Ответьте соответственно

isherwood
14 Янв 2014 в 22:19

Я бы использовал MV * framework , как это было предложено (нокаут — это легкий вариант) или никогда не меняйте переменную напрямую. Используйте функцию установки, которая меняет свое значение и каждый раз запускает пользовательское событие. Пример JQuery :

CodeToad
15 Янв 2014 в 08:36

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

maxedison
14 Янв 2014 в 22:29

Очень похоже на предыдущие ответы.

Но организуйте это по-другому. И убедитесь, что вы оставили последнюю переменную вне функции . Более того, в конце ваших условных операторов if обновите значение того, которое проверяется на наличие изменений.

Надеюсь, это поможет!

ElGavilan
4 Сен 2015 в 12:24

1 Используйте Object.observe:

Дополнительные замечания о

Если вы хотите включить его в Chrome 33,

Посетите chrome: // flags /

И включите Включить экспериментальный JavaScript

2 . Используйте setInterval: .

Должен войти «увеличение» в одну секунду.

3 Используйте Object.watch:

Дополнительные замечания о

Чтобы поддерживать больше браузеров, добавьте этот скрипт:

Полученный от https://gist.github.com/eligrey/384583

4. Используйте функцию набора пользовательских значений:

Следует регистрировать «увеличение».

Большинство из них требуют, чтобы переменная была Object, , поэтому я бы лучше обнаружил ее с течением времени, как показано в методе 2.

Cilan
14 Янв 2014 в 23:10

Object.observe должен хорошо поддерживаться. Вы можете отслеживать свое состояние по своему усмотрению (возможно, в каком-то закрытии).

D. Patrick
14 Янв 2014 в 22:31

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

Peter Bankuti
14 Янв 2014 в 22:35

13 ответов

Лучший ответ

Используя предоставленные ответы, я получил следующее:

Это можно назвать так:

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

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

pimvdb
19 Авг 2011 в 14:10

Это легко расширяется и читается:

Но не обязательно проще

orlp
18 Янв 2011 в 19:30

Кроме того, поскольку значения, по которым вы проверяете результат, являются уникальными, вы можете использовать Set.prototype.has ().

Ivan Sivak
18 Сен 2017 в 14:01

Я просто использовал функцию inArray jQuery и массив значений для этого:

ScottyG
3 Ноя 2017 в 01:51

Обратите внимание, что indexOf отсутствует в основном ECMAScript. Вам понадобится фрагмент кода для IE и, возможно, других браузеров, которые не поддерживают Array.prototype.indexOf

meder omuraliev
18 Янв 2011 в 19:30

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

Я предпочел вышеупомянутое решение над проверкой indexOf, где нужно также проверять index.

Javed Shaikh
26 Сен 2019 в 11:57

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

Вы можете удалить приведение типа, изменив на .

Greg Perham
28 Фев 2013 в 01:31

Для потомков вы можете использовать регулярные выражения в качестве альтернативы. Довольно хорошая поддержка браузера (см. )

Попробуй это

-4

martisj
2 Май 2018 в 11:27

В ECMA2016 вы можете использовать метод include. Это самый чистый способ, который я видел. (Поддерживается всеми основными браузерами, кроме IE (Polyfill находится в ссылке)

107

Alister
1 Мар 2017 в 10:36

Вы можете написать , если определите как

Elian Ebbing
18 Янв 2011 в 20:17

Вы можете использовать массив и :

168

Gumbo
18 Янв 2011 в 19:29

Это маленькая вспомогательная стрелка:

Victor
9 Июл 2019 в 16:40

Если у вас есть доступ к Underscore, вы можете использовать следующее:

раньше также работал в Lodash (до V4), теперь вы должны использовать

David Salamon
19 Сен 2016 в 14:51

8 ответов

Лучший ответ

Я думаю, что вы используете последнюю версию TypeScript. См. Раздел «Строгая инициализация класса» в { { X0 }} сильный > .

Есть два способа исправить это:

О. Если вы используете VSCode, вам нужно изменить версию TS, которую использует редактор.

Б. Просто инициализируйте массив, когда вы объявите его внутри конструктора,

Matteo Guarnerio
23 Июл 2018 в 09:20

При обновлении с использованием [email protected] строгие правила его компилятора следуют правилам объявления типа массива внутри конструктора класса компонента.

Для решения этой проблемы либо измените код, объявленный в коде, либо не добавляйте компилятору свойство «strictPropertyInitialization»: false в файл «tsconfig.json» и выполните опять нпм старт.

Угловая разработка веб-приложений и мобильных приложений вы можете перейти на www.jtechweb.in

Jai Govind Gupta
17 Окт 2019 в 05:15

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

anothernode
23 Июл 2018 в 08:57

Просто перейдите на tsconfig.json и установите

Избавиться от ошибки компиляции.

В противном случае вам нужно инициализировать все ваши переменные, что немного раздражает

Martin Čuka
8 Май 2018 в 20:37

Мы можем получить сообщение при добавлении некоторой конфигурации в файл , чтобы проект Angular компилировался в строгом режиме:

Затем компилятор жалуется, что переменная-член, имеющая директиву , не определена перед использованием:

Мы можем заставить компилятор замолчать, указав, что переменная может быть необязательной:

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

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

Способ сообщить об этом компилятору — добавить оператор , например:

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

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

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

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

Зная переменную, переменная теперь может использоваться:

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

Принимая во внимание, что метод вызывается после попытки привязки ввода, и только в том случае, если для привязок был предоставлен фактический ввод. 1

Stephane
7 Фев 2020 в 11:55

Вам либо нужно отключить , который Sajeetharan упомянул или сделал что-то подобное, чтобы удовлетворить требование инициализации:

kshetline
6 Апр 2018 в 18:42

Вы также можете сделать следующее, если вы действительно не хотите его инициализировать.

SpeedOfSpin
3 Июн 2019 в 14:06

Разве вы не можете просто использовать Утверждение Определенного Назначения? (См. )

То есть объявление свойства как ! заверяет машинопись, что определенно будет значение во время выполнения.

Извините, я не пробовал это по-угловому, но это отлично сработало, когда у меня возникла точно такая же проблема в React.

Andy
17 Мар 2020 в 18:06

9 ответов

Лучший ответ

Чтобы проверить существование локальной переменной:

Чтобы проверить существование глобальной переменной:

Чтобы проверить, есть ли у объекта атрибут:

1531

Ayman Hourieh
9 Май 2009 в 13:16

использование переменных, которые еще не были определены или установлены (неявно или явно), — это почти всегда плохо на любом языке, так как это часто указывает на то, что логика Программа не была продумана должным образом и может привести к непредсказуемому поведению.

Если вам нужно сделать это в Python, следующий трюк, аналогичный вашему, гарантирует, что переменная имеет значение some перед использованием:

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

117

paxdiablo
18 Сен 2019 в 05:57

Я создал пользовательскую функцию.

Затем следует вызов функции, заменив на переменную, которую вы хотите проверить:

Вернет или

Abhishek R
31 Янв 2020 в 11:41

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

SilentGhost
9 Май 2009 в 13:28

Для объектов / модулей вы также можете

Например,

Wyrmwood
28 Окт 2014 в 18:39

Простой способ — сначала инициализировать его, сказав

Потом позже:

Roger Dahl
10 Янв 2018 в 19:42

Использование try / исключением — лучший способ проверить существование переменной. Но почти наверняка есть лучший способ сделать то, что вы делаете, чем устанавливать / тестировать глобальные переменные.

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

user97370user97370
9 Май 2009 в 13:27

Способ, который часто работает хорошо для обработки подобного рода ситуаций, заключается в том, чтобы не явно проверять, существует ли переменная, а просто пойти дальше и обернуть первое использование, возможно, несуществующей переменной, в try / кроме NameError:

Roger Dahl
8 Сен 2010 в 03:05

Я предполагаю, что тест будет использоваться в функции, аналогичной ответу user97370. Мне не нравится этот ответ, потому что он загрязняет глобальное пространство имен. Один из способов исправить это — использовать класс:

Мне это не нравится, потому что это усложняет код и открывает такие вопросы, как, должно ли это подтвердить шаблон программирования Singleton? К счастью, Python позволил функциям некоторое время иметь атрибуты, что дает нам простое решение:

Community
23 Май 2017 в 12:26

Типы данных в JavaScript

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

До ES6 в JavaScript присутствовало 6 типов данных. Но с появлением ES6-спецификации был добавлен тип данных . Ниже приведен список всех существующих типов данных:

String
Number
Boolean (значения true and false)
null (значение null)
undefined (значение undefined)
Symbol
Object

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

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

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

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

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

— для создания объектов даты
— для создания регулярных выражений
— для создания JavaScript ошибок

Constants

To declare a constant (unchanging) variable, use instead of :

Variables declared using are called “constants”. They cannot be reassigned. An attempt to do so would cause an error:

When a programmer is sure that a variable will never change, they can declare it with to guarantee and clearly communicate that fact to everyone.

There is a widespread practice to use constants as aliases for difficult-to-remember values that are known prior to execution.

Such constants are named using capital letters and underscores.

For instance, let’s make constants for colors in so-called “web” (hexadecimal) format:

Benefits:

is much easier to remember than .
It is much easier to mistype than .
When reading the code, is much more meaningful than .

When should we use capitals for a constant and when should we name it normally? Let’s make that clear.

Being a “constant” just means that a variable’s value never changes. But there are constants that are known prior to execution (like a hexadecimal value for red) and there are constants that are calculated in run-time, during the execution, but do not change after their initial assignment.

For instance:

The value of is not known prior to the page load, so it’s named normally. But it’s still a constant because it doesn’t change after assignment.

In other words, capital-named constants are only used as aliases for “hard-coded” values.

Проверка на NaN

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

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

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

Вы можете проверить на значение следующим образом

Функция выше очень похожа на реализацию функции , добавленную в ES6, и следовательно, ее можно использовать в качестве полифила для сред выполнения, отличных от ES6, следующим образом:

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

Name things right

Talking about variables, there’s one more extremely important thing.

A variable name should have a clean, obvious meaning, describing the data that it stores.

Variable naming is one of the most important and complex skills in programming. A quick glance at variable names can reveal which code was written by a beginner versus an experienced developer.

In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it’s much easier to find information that is well-labeled. Or, in other words, when the variables have good names.

Please spend time thinking about the right name for a variable before declaring it. Doing so will repay you handsomely.

Some good-to-follow rules are:

Use human-readable names like or .
Stay away from abbreviations or short names like , , , unless you really know what you’re doing.
Make names maximally descriptive and concise. Examples of bad names are and . Such names say nothing. It’s only okay to use them if the context of the code makes it exceptionally obvious which data or value the variable is referencing.
Agree on terms within your team and in your own mind. If a site visitor is called a “user” then we should name related variables or instead of or .

Sounds simple? Indeed it is, but creating descriptive and concise variable names in practice is not. Go for it.

Reuse or create?

And the last note. There are some lazy programmers who, instead of declaring new variables, tend to reuse existing ones.

As a result, their variables are like boxes into which people throw different things without changing their stickers. What’s inside the box now? Who knows? We need to come closer and check.

Such programmers save a little bit on variable declaration but lose ten times more on debugging.

An extra variable is good, not evil.

Modern JavaScript minifiers and browsers optimize code well enough, so it won’t create performance issues. Using different variables for different values can even help the engine optimize your code.