В руках опытных Python-разработчиков декораторы могут стать элегантным и мощным инструментом. Они позволяют изменять поведение функций без внесения изменений в их исходный код. Это лаконичный и гибкий способ улучшения функций и расширения их возможностей.
В этой статье я расскажу о тонкостях использования декораторов в Python и покажу примеры, где они могут быть полезны.
Функции в Python
Если говорить по-простому, функция — это способ многократного выполнения блока кода с различными аргументами.
Функция может принимать входные данные, использовать их для выполнения некоторого заранее определенного набора кода, а затем возвращать выходной результат.
В языке Python функция записывается следующим образом:
def add_one(num): return num + 1
Когда мы хотим вызвать функцию, мы можем написать ее имя, а в круглых скобках передать необходимые входные данные (аргументы):
final_value = add_one(1) print(final_value) # 2
Обратите внимание, что в большинстве случаев аргументы и параметры означают одно и то же. Это переменные, используемые в функции.
Анализ простой программы. Значение переменной после выполнения цикла while-do (информатика, ЕГЭ)
Разница заключается в том, где мы их обозначаем. Аргументы — это то, что мы передаем в функцию при ее вызове, а параметры — то, что объявлено в функции при ее создании.
Как передавать аргументы в функцию
Обычно при вызове функций в качестве аргументов передаются числовые значения типа int или float, строки, списки, словари и другие типы данных.
Но можно также передавать в качестве аргумента и функцию:
def inner_function(): print(«inner_function is called») def outer_function(func): print(«outer_function is called») func() outer_function(inner_function) # Результат: # outer_function is called # inner_function is called
В этом примере мы создаем две функции: inner_function и outer_function (внутренняя и внешняя функция соответственно).
Функция outer_function имеет параметр func . Это функция, которую outer_function вызывает после того, как сама была вызвана.
Считайте, что к функциям можно относиться так же, как и к любым другим значениям или переменным.
Выражаясь более правильно, можно сказать, что функции — это объекты первого класса. Это означает, что они являются такими же объектами, как и любые другие. Их можно передавать в качестве аргументов в другие функции или присваивать в качестве значений переменным. Также они могут возвращаться другими функциями.
Таким образом, outer_function может принимать в качестве параметра функцию и вызывать ее при выполнении.
Как возвращать функции
Еще одно преимущество обращения с функциями как с объектами заключается в том, что мы можем определять их внутри других функций и возвращать:
def outer_function(): print(«outer_function is called») def inner_function(): print(«inner_function is called») return inner_function
Обратите внимание: возвращая функцию inner_function , мы не вызывали ее. Мы вернули только ссылку на нее, чтобы затем сохранить и вызывать при необходимости:
Информатика Босова 8 кл. №137 Решение задания
returned_function = outer_function() # outer_funciton is called returned_function() # inner_function is called
Вероятно, вам любопытно, причем тут декораторы. Сейчас мы это разберем!
Как создавать декораторы в Python
Принятие функций в качестве аргументов, определение функций внутри других функций и их возврат — это именно то, что нам нужно знать для создания декораторов в Python.
Декораторы используются для добавления дополнительной функциональности к существующим функциям.
Например, если мы хотим создать декоратор, который будет добавлять единицу к возвращаемому значению любой функции, мы можем сделать это следующим образом:
def add_one_decorator(func): def add_one(): value = func() return value + 1 return add_one
Допустим, у нас есть функция, возвращающая число. Мы можем использовать этот декоратор для добавления единицы к любому значению, которое она выводит.
def example_function(): return 1 final_value = add_one_decorator(example_function) print(final_value()) # 2
В данном примере мы вызываем функцию add_one_decorator и передаем ссылку на example_function .
При вызове функции-декоратора add_one_decorator она создает новую функцию add_one , определенную внутри нее, и возвращает ссылку на эту новую функцию. Эту функцию мы храним в переменной final_value .
Таким образом, при выполнении функции final_value вызывается функция add_one .
Функция add_one , определенная внутри add_one_decorator , вызовет функцию example_function , сохранит ее значение и прибавит к нему единицу.
В итоге возвращается и выводится на консоль число 2.
Обратите внимание, что нам не пришлось изменять исходную функцию example_function , чтобы модифицировать возвращаемое ею значение. Именно это и делает декораторы такими полезными!
Как вы видели на примере, чтобы декорировать функцию, необходимо передать ее в функцию-декоратор.
example_function = add_one_decorator(example_function)
Это означает, что всякий раз, когда мы вызываем функцию example_function , мы будем вызывать функцию add_one , определенную в декораторе.
Как передавать аргументы с помощью декораторов
При использовании декораторов мы также можем захотеть, чтобы декорированная функция могла получать аргументы при вызове из функции-обертки.
Допустим, у нас есть функция, которая требует два параметра и возвращает их сумму:
def add(a,b): return a + b print(add(1,2)) # 3
Алгоритмы и программы. Язык С++ : учебное пособие для СПО [Елена Александровна Конова] (pdf) читать онлайн
Книга в формате pdf! Изображения и текст могут не отображаться!
Е. А. КОНОВА,
Г. А. ПОЛЛАК
АЛГОРИТМЫ
И ПРОГРАММЫ.
ЯЗЫК С++
УЧЕБНОЕ ПОСОБИЕ
ИЗДАНИЕ ТРЕТЬЕ, СТЕРЕОТИПНОЕ
САНКТПЕТЕРБУРГ
МОСКВА•КРАСНОДАР
2022
УДК 004.42
ББК 32.973.26018.1я723
К 64
Конова Е. А. Алгоритмы и программы. Язык С++ : учеб
ное пособие для СПО / Е. А. Конова, Г. А. Поллак. — 3е
изд., стер. — СанктПетербург : Лань, 2022. — 384 с. : ил. —
Текст : непосредственный.
ISBN 9785507449255
При изложении материала авторы используют методику обучения
от алгоритмов к программам, поэтому вначале излагаются сведения об
алгоритмах с примерами реализации типовых алгоритмов. Изучение
основ языка программирования С++ опирается на полученные знания,
приведены примеры кода на данном языке. Примеры можно решать в
любой среде разработчика, поддерживающей язык С++, но авторами
примеры отлажены в Visual Studio 2013. Коды программ соответствуют
стандарту С++ 11 (ISO/IEC 14882:2011), разработаны в консольных
приложениях на основе шаблона «Пустой проект». В практикуме пред
лагаются как задачи, использующие типовые алгоритмы, так и содержа
тельные, для которых приведено только вербальное описание. В типо
вых задачах оттачиваются навыки кодирования, в содержательных
требуются построение инфологической модели и выбор алгоритмов
решения.
Соответствует современным требованиям Федерального государст
венного образовательного стандарта среднего профессионального обра
зования и профессиональным квалификационным требованиям.
Пособие предназначено для студентов среднего профессионального
образования, обучающихся по направлению подготовки «Прикладная
информатика», может быть рекомендовано для самостоятельного изуче
ния, так как не требует предварительных знаний о языках программи
рования.
УДК 004.42
ББК 32.973.26018.1я723
Обложка
П. И. ПОЛЯКОВА
вторы прекрасно понимают трудности, которые возникают у начинающего программиста, поэтому учебное пособие предназначено, в первую очередь, для тех,
кто только начинает изучать программирование.
В разработке методики изложения авторы придерживались определения, данного Н. Виртом [1]: Программа = Алгоритмы + Данные.
Согласно этому определению программы представляют собой конкретные формулировки абстрактных алгоритмов, основанные на конкретных представлениях
данных. Именно поэтому авторами уделяется большое
внимание как разработке алгоритмов, так и концепции
данных языка программирования.
Учебное пособие состоит из трех глав.
В первой главе приводятся сведения о типовых алгоритмах обработки данных безотносительно к языку программирования. Приведены примеры решения некоторых классов задач, где для каждой задачи разработан алгоритм в виде блок-схемы с пояснениями, набор тестовых
данных и таблица исполнения алгоритма. Приводимые
способы решения задач по возможности являются рациональными, но не претендуют на то, чтобы быть наилучшими.
В качестве языка программирования выбран классический С++. Краткое описание синтаксических правил
С++ и механизмов реализации приведено во второй главе. Материал разбит на темы, позволяющие изучать язык
по принципу «от простого к сложному». В изложении авторы опираются на материал первой главы, приводя программную реализацию всех алгоритмов. Добавлено мно-
го примеров, иллюстрирующих как особенности языка
С++, так и некоторые алгоритмические приемы решения
задач. В качестве методологии выбрано структурное программирование на основе функций.
Все приведенные программы проверены на работоспособность авторами в среде проектирования
Visual Studio 2013. Коды программ соответствуют стандарту C++11 (ISO/IEC 14882:2011) и разработаны в консольных приложениях на основе шаблона «Пустой проект».
Третья глава — это практикум, который содержит
задания для самостоятельного выполнения. В практикуме авторы опираются на материал второй главы. Третья
глава состоит из десяти основных тем. В каждой теме есть
краткое теоретическое введение, а также примеры программ решения некоторых задач. В каждом примере назван типовой алгоритм и приведен код программы с подробными комментариями.
Примеры и типовые решения помогут начинающим
в освоении практических приемов программирования
и выработке собственного стиля.
В каждой теме для самостоятельного решения предлагаются по 30 вариантов задач примерно одинакового уровня сложности. Особый интерес, по нашему мнению, представляют содержательные задачи, в которых постановка
задачи выполнена на вербальном уровне, т. е. не формализована. Здесь студент должен самостоятельно осмыслить
задачу, формализовать ее, предложить структуру данных
и выбрать или разработать алгоритм решения. Опыт показывает, что часто именно этот этап в практическом программировании является наиболее трудным.
Материал пособия консолидирует многолетний опыт
работы авторов в преподавании различных курсов программирования.
Соответствует ФГОС ВПО третьего поколения для направления «Прикладная информатика».
Не требуется каких-либо предварительных знаний
о языках программирования, поэтому пособие может
быть рекомендовано для самостоятельного изучения.
1.1. Определение алгоритма
и его свойства
од алгоритмом понимается точное предписание, задающее последовательность действий, которая ведет
от произвольного исходного данного (или от некоторой совокупности возможных для данного алгоритма исходных
данных) к достижению полностью определяемого этим
исходным данным результата.
Алгоритм должен обладать определенными свойствами, наличие которых гарантирует получение решения задачи исполнителем.
Дискретность. Решение задачи должно быть разбито
на элементарные действия. Запись отдельных действий
реализуется в виде упорядоченной последовательности
отдельных команд, образующих дискретную структуру алгоритма. Это свойство непосредственно отражено
в определении алгоритма.
Понятность. На практике любой алгоритм предназначен для определенного исполнителя, и любую команду
алгоритма исполнитель должен уметь выполнить.
Определенность (детерминированность). Каждая команда алгоритма должна определять однозначные действия исполнителя. Результат их исполнения не должен
зависеть от факторов, не учтенных в алгоритме явно. При
одних и тех же исходных данных алгоритм должен давать
стабильный результат.
Массовость. Разработанный алгоритм должен давать
возможность получения результата при различных исходных данных для однотипных задач.
Например, пользуясь алгоритмом решения квадратного уравнения, можно находить его корни при любых
значениях коэффициентов.
Свойство массовости полезное, но не обязательное
свойство алгоритма, так как интерес представляют и алгоритмы, пригодные для решения единственной задачи.
Результативность (конечность). Это свойство предполагает обязательное получение результата решения задачи за конечное число шагов. Под решением задачи понимается и сообщение о том, что при заданных значениях
исходных данных задача решения не имеет.
Если решить задачу при заданных исходных данных
за конечное число шагов не удается, то говорят, что алгоритм «зацикливается».
Смысл условий дискретности, понятности и определенности ясен: их нарушение ведет к невозможности
выполнения алгоритма. Остальные условия не столь
очевидны. Для сложных алгоритмов выполнить исчерпывающую проверку результативности и корректности
невозможно. Это равносильно полному решению задачи,
для которой создан алгоритм, вручную.
Можно сформулировать общие правила, руководствуясь
которыми следует записывать алгоритм решения задачи.
1. Выделить величины, являющиеся исходными данными для задачи.
2. Разбить решение задачи на такие команды, каждую
из которых исполнитель может выполнить однозначно.
3. Указать порядок выполнения команд.
4. Задать условие окончания процесса решения задачи.
5. Определить, что является результатом решения задачи в каждом из возможных случаев.
Хотя алгоритмы обычно предназначены для автоматического выполнения, они создаются и разрабатываются людьми. Поэтому первоначальная запись алгоритма обычно производится в форме, доступной для восприятия человеком.
Самой простой является словесная форма записи алгоритмов на естественном языке. В этом виде алгоритм
представляет собой описание последовательности этапов
обработки данных, изложенное в произвольной форме.
Ос н о в ы а л г о р и т м и з а ц и и
Словесная форма удобна для человеческого восприятия,
но страдает многословностью и неоднозначностью.
Когда запись алгоритма формализована частично, то
используется псевдокод. Он содержит как элементы естественного языка, так и формальные конструкции, описывающие базовые алгоритмические структуры. Эти конструкции называются служебными словами. Формального определения псевдокода или строгих правил записи
алгоритмов в таком формате не существует.
Графическая форма представления алгоритма является более компактной. Алгоритм изображается в виде
последовательности связанных между собой блоков, каждый из которых соответствует выполнению одного или
нескольких действий. Графическое представление алгоритма называется блок-схемой. Блок-схема определяет
структуру алгоритма.
Графические обозначения блоков стандартизованы.
Некоторые из часто используемых блоков представлены
в таблице 1.1.
Та блица 1.1
Изображение основных блоков на блок-схеме
Обозначение блока
Процесс (вычислительное действие, реализованное операцией присваивания)
Решение (проверка условия, реализующая условный переход)
Начало, конец алгоритма
Ввод-вывод в общем виде
Модификация (начало цикла с параметром)
Отдельные блоки соединяются линиями переходов,
которые определяют очередность выполнения действий.
Направление линий сверху вниз или слева направо принимается за основное.
Алгоритм, записанный на языке программирования,
называется программой. При использовании этих языков
запись алгоритма абсолютно формальна и пригодна для
выполнения на ЭВМ. Отдельная конструкция языка программирования называется оператором. Программа —
это упорядоченная последовательность операторов.
1.2. Базовые алгоритмические
конструкции
Число реализованных конструкций конечно в любом
языке программирования. Структурной элементарной
единицей алгоритма является команда, обозначающая
один элементарный шаг обработки или отображения информации. Простая команда на языке блок-схем изображается в виде функционального блока «процесс», который имеет один вход и один выход. Из команд проверки
условий и простых команд образуются составные команды, имеющие более сложную структуру, но тоже один
вход и один выход.
Алгоритм любой сложности может быть представлен
комбинацией трех базовых структур:
• следование;
• ветвление (в полной и сокращенной форме);
• цикл (с предусловием или постусловием).
Характерной особенностью этих структур является
наличие у них одного входа и одного выхода.
1.2.1. Линейные алгоритмы
Базовая структура «следование» означает, что несколько операторов выполняются последовательно друг
за другом, и только один раз за время выполнения программы. Структура «следование» используется для реализации задач, имеющих линейный алгоритм решения.
Это означает, что такой алгоритм не содержит проверок
Ос н о в ы а л г о р и т м и з а ц и и
условий и повторений, действия в нем выполняются последовательно, одно за другим.
Пример 1.1. Построить блок-схему алгоритма вычисления высот треугольника со сторонами a, b, c по формулам:
2
ha = ⋅ p ( p − a) ( p − b) ( p − c);
a
2
ha = ⋅ p ( p − a) ( p − b) ( p − c);
b
2
ha = ⋅ p ( p − a) ( p − b) ( p − c),
c
где p =
риметр.
(a + b + c)
— полупе2
Для того чтобы не вычислять три раза одно и то же
значение, введем вспомогательную величину:
t = 2 p ( p − a) ( p − b) ( p − c).
Блок 1. Ввод значений
сторон треугольника.
Блок 2. Вычисление полупериметра.
Блок 3. Вычисление вспомогательной величины t.
Блок 4. Вычисление высот, опущенных на стороны
а, b, c.
Блок 5. Вывод результатов.
1.2.2. Разветвляющиеся алгоритмы
Второй базовой структурой является «ветвление». Эта
структура обеспечивает, в зависимости от результата проверки условия, выбор одного из альтернативных путей
работы алгоритма, причем каждый из путей ведет к обще-
му выходу, так что работа алгоритма будет продолжаться
независимо от того, какой путь будет выбран.
Существует структура с полным и неполным ветвлением.
Структура с полным ветвлением (если — то — иначе)
записывается так:
Если < условие >
то
иначе
Все если
Команда выполняется так: если является истинным, то выполняются , записанные после
ключевого слова то, если является ложным, то
выполняются , записанные после слова иначе.
Структура с неполным ветвлением (если — то) не содержит части, начинающейся со слова иначе:
Если
то
Все если
Команда выполняется так: если является
истинным, то выполняются , записанные после ключевого слова то.
Блок-схема алгоритма с ветвлением выглядит так:
Полное ветвление. Структура
Если — То — Иначе
Неполное ветвление.
Структура Если — То
Пример 1.2. Вычислить значение функции
x + a, при x < 10;
y = x + b, при 10 ≤ x ≤ 20;
x + c, при x > 20.
Ос н о в ы а л г о р и т м и з а ц и и
Дано: x, a, b, c — произвольные числа.
Найти: y.
Представим задачу графически на числовой оси
10 ≤ x ≤ 20
Так как значение переменной x вводится произвольно, то оно может оказаться в любом из трех интервалов.
Приведем блок-схему.
Блок 1. Ввод исходных данных.
Блок 2. Проверка введенного значения. Если х < 10
(выход «Да»), то точка находится в первом интервале.
В противном случае х ≥ 10 (выход «Нет»), и точка может
оказаться во втором или третьем интервале.
Блок 4. Проверка ограничения значения х справа
(х < 20). Если условие выполняется (выход «Да»), то х находится во втором интервале, иначе х ≥ 20, и точка находится в третьем интервале.
Блоки 3, 5 и 6. Вычисление значения y.
1.2.3. Циклические алгоритмы
При составлении алгоритмов решения большинства
задач возникает необходимость в неоднократном повторении одних и тех же команд. Алгоритм, составленный
с использованием многократных повторений одних и тех
же действий (циклов), называется циклическим. Однако
слово «неоднократно» не означает «до бесконечности».
Организация циклов, никогда не приводящая к остановке в выполнении алгоритма («зацикливание» алгоритма),
нарушает требование его результативности — получения
результата за конечное число шагов.
Блок, для выполнения которого организуется цикл,
называется телом цикла. Остальные операторы служат
для управления процессом повторения вычислений: это
начальные установки, проверка условия продолжения
цикла и модификация параметра цикла. Один проход
цикла называется итерацией.
Цикл с предусловием
Цикл с постусловием
Начальные установки служат для того, чтобы до входа в цикл задать значения переменных, которые в нем используются.
Проверка условия продолжения цикла выполняется
на каждой итерации либо до тела цикла (цикл с предусло-
Ос н о в ы а л г о р и т м и з а ц и и
вием), либо после тела цикла (цикл с постусловием). Тело
цикла с постусловием всегда выполняется хотя бы один
раз. Проверка необходимости выполнения цикла с предусловием делается до начала цикла, поэтому возможно,
что он не выполнится ни разу.
При конструировании циклов следует соблюдать обязательное условие результативности алгоритма (т. е. его
окончания за конечное число шагов). Практически это
означает, что в условии должна быть переменная, значение которой изменяется в теле цикла. Причем, изменяется таким образом, чтобы условие в конечном итоге перестало выполняться. Такая переменная называется управляющей переменной цикла или параметром цикла.
Еще один вид циклов — цикл с параметром, или
арифметический цикл. Тело цикла выполняется, пока
параметр цикла i пробегает множество значений от начального (In) до конечного (Ik).
Переменная i определяет количество повторений тела
цикла S. Если шаг изменения значения параметра цикла
обозначить через ∆I, то количество повторений тела цикла n можно вычислить по формуле
−
n = I k I n + 1.
∆I
Если параметр цикла i изменяется с шагом 1, то шаг
может не указываться.
Цикл выполняется так: начальное значение параметра
цикла i равно In. Если i ≤ Ik, выполняется тело цикла S, после
чего параметр цикла увеличивается на 1 с помощью оператора присваивания i = i + 1, и снова проверяется условие i ≤ Ik.
Пример 1.3. Дано целое положительное число n. Вычислить
факториал этого числа. Известно, что факториал любого целого
положительного числа n определяется как произведение чисел от 1 до заданного числа n:
n! = 1 ⋅ 2 ⋅ 3 ⋅ . ⋅ n.
По определению 0! = 1 и 1! = 1.
Задача решается с помощью циклического алгоритма. Введем следующие обозначения: N — заданное число,
F — факториал числа, R — параметр цикла. Составим два
варианта алгоритма: с использованием цикла с предусловием и цикла с параметром.
Правильность алгоритма можно проверить, если выполнить его формально «вручную». Выполним алгоритм
при n = 4.
Цикл с предусловием
Цикл с параметром
Цикл с предусловием
Цикл с параметром
R 0 выполняется (выход
«Да»), то вычисляется группа операторов в блоке 4:
k = k + 1; Y[k] = X[i].
Тест
Данные
n=5
X = (–1, 2, 0, 4, –3)
Выполнение алгоритма.
k
Источник: coollib.net
Блог
Что такое подъем в JavaScript | Подъемные функции, переменные и классы
- Запись опубликована: 12 июля, 2023
- Рубрика записи: JavaScript
- Комментарии к записи: 0 комментариев
Подъем — это концепция или поведение в JavaScript, при котором объявление функции, переменной или класса переходит в верхнюю часть области, в которой они были определены. Что это значит?
Подъем — это концепция, которую вы можете найти в некоторых языках программирования (таких как JavaScript) и не найти в других. Это особое поведение интерпретатора JavaScript. Мы узнаем о том, как это работает, в этой статье.
Давайте начнем с функций.
У меня есть видеоверсия этой темы, которую вы можете посмотреть.
Функция Подъема
Взгляните на этот пример кода:
function printHello() < console.log(«hello») >printHello() // hello
Здесь мы объявляем printHello и выполняем функцию сразу после строки, в которой она была объявлена. Ошибок нет, все работает!
Теперь посмотрите на этот пример:
printHello() // hello function printHello()
Здесь мы выполняем printHello перед строкой, в которой была объявлена функция. И все по-прежнему работает без ошибок. Что здесь произошло? Подъем.
Прежде чем интерпретатор выполнит весь код целиком, он сначала поднимает объявленную функцию на вершину области видимости, в которой она определена. В этом случае printHello определяется в глобальной области видимости, поэтому функция поднимается на вершину глобальной области видимости. При подъеме функция (включая логику) становится доступной даже до строки, в которой она была объявлена в коде.
Давайте посмотрим на другой пример:
printHello() // hello printDillion() // ReferenceError: printDillion is not defined function printHello() < console.log(‘hello’) function printDillion() < console.log(«dillion») >>
Как вы видите здесь, мы заявляем printHello . В этой функции мы сначала выполняем, console.log(‘hello’) затем мы объявляем другую вызываемую функцию, printDillion которая выполняется console.log(‘dillion’) при вызове.
Перед printHello объявлением в коде мы пытаемся получить к нему доступ, выполнив printHello() . Он доступен (поскольку поднят на вершину глобальной области видимости), поэтому у нас на консоли напечатано «hello».
Но затем мы пытаемся получить доступ printDillion и получаем ошибку ссылки: printDillion не определен. Подъем не происходит на printDillion ?
printDillion поднят, но он поднимается только до верхней части области, в которой он был заявлен. В этом случае он объявлен в локальной области видимости — в printHello . Следовательно, он был бы доступен только в функции. Давайте обновим наш код:
printHello() // hello function printHello() < printDillion() // dillion console.log(‘hello’) function printDillion() < console.log(«dillion») >>
Теперь мы выполняем printDillion in printHello перед строкой, в которой printDillion было фактически объявлено. Поскольку функция поднята на вершину локальной области видимости, мы можем получить к ней доступ до строки, где она была фактически объявлена.
Подъем делает все это возможным для объявлений функций. Но также стоит отметить, что подъем не происходит в выражениях функций. Я объяснил причину этого здесь: Объявления функций против выражений функций
Теперь давайте рассмотрим подъем для переменных.
Переменный Подъем
Вы можете объявлять переменные в JavaScript с помощью переменных var , let и const . И эти объявления переменных были бы подняты, но вели бы себя по-другому. Давайте начнем с var .
Переменные для подъема var
Взгляните на этот пример:
console.log(name) // undefined var name = «Dillion»
Здесь мы объявляем переменную с именем name со строковым значением «Dillion». Но мы пытаемся получить доступ к переменной до строки, в которой она была объявлена. Но мы не получаем никаких ошибок. Произошел подъем. name Объявление поднимается на самый верх, поэтому интерпретатор «знает», что существует вызываемая переменная name . Если бы интерпретатор не знал, вы бы получили name is not defined. Давайте попробуем это сделать:
console.log(name) // ReferenceError: name is not defined var myName = «Dillion»
У нас есть переменная с именем myName , но нет name . Мы получаем ошибку name is not defined при попытке доступа name . Интерпретатор «не знает» об этой переменной.
Возвращаясь к нашему примеру выше:
console.log(name) // undefined var name = «Dillion»
Хотя здесь произошло поднятие, значение name не определено, когда мы обращаемся к нему перед строкой объявления. При объявлении переменных var объявление переменной повышается, но со значением по умолчанию undefined . Фактическое значение инициализируется при выполнении строки объявления.
Обращаясь к переменной после этой строки, мы получаем фактическое значение:
console.log(name) // undefined var name = «Dillion» console.log(name) // Dillion
Допустим, мы объявили name в функции:
print() console.log(name) // ReferenceError: name is not defined function print()
Здесь мы получаем ошибку ссылки: имя не определено. Помните, что переменные переносятся, но только в верхнюю часть области видимости, в которой они были объявлены. В этом случае name объявлено в print , поэтому оно будет поднято на вершину этой локальной области. Давайте попробуем получить к нему доступ с помощью функции:
print() function print() < console.log(name) // undefined var name = «Dillion» >
Пытаясь получить доступ name к функции, даже если она находится выше строки объявления, мы не получаем ошибку. Это потому, что name установлен, но не забывайте, со значением по умолчанию undefined .
Переменные для подъема let
Хотя переменные, объявленные с помощью let , также активируются, они ведут себя по-другому. Давайте посмотрим на пример:
console.log(name) // ReferenceError: Cannot access ‘name’ before initialization let name = «Dillion»
Здесь мы получаем ошибку ссылки: не удается получить доступ к ‘name’ перед инициализацией. Вы заметили, что в ошибке не указано имя не определено? Это потому, что интерпретатор «осведомлен» о name переменной, потому что переменная поднята.
«Невозможно получить доступ к ‘name’ перед инициализацией» происходит потому, что переменные, объявленные с помощью let , не имеют значения по умолчанию при поднятии. Как мы видели в var , переменные имеют значение по умолчанию undefined до тех пор, пока не появится строка, в которой выполняется объявление / инициализация. Но с let переменные неинициализированы.
Переменные поднимаются в верхнюю часть области видимости, в которой они объявлены (локальная, глобальная или блочная), но недоступны, поскольку они не были инициализированы. Эта концепция также называется Временной мертвой зоной.
Они могут быть доступны только после выполнения строки инициализации:
let name = «Dillion» console.log(name) // Dillion
Получая доступ name после строки, в которой она была объявлена и инициализирована, мы не получаем ошибок.
Переменные для подъема const
Точно так же, как let переменные, объявленные с помощью const , отображаются, но недоступны. Например:
console.log(name) // ReferenceError: Cannot access ‘name’ before initialization const name = «Dillion»
Та же концепция временной мертвой зоны применима к const переменным. Такие переменные поднимаются в верхнюю часть области, в которой они определены (локальная, глобальная или блочная), но они остаются недоступными до тех пор, пока переменные не будут инициализированы значением.
const name = «Dillion» console.log(name) // Dillion
При обращении к переменной после того, как она была инициализирована значением (как вы видите выше), все работает нормально.
Переходим к подъему для занятий.
Класс Подъема
Классы на JavaScript также подняты. Давайте посмотрим на пример:
const Dog = new Animal(«Bingo») // ReferenceError: Cannot access ‘Animal’ before initialization class Animal < constructor(name) < this.name = name >>
Здесь мы объявляем класс с именем Animal . Мы пытаемся получить доступ к этому классу (создать экземпляр Dog объекта) до того, как он был объявлен. Мы получаем ошибку ссылки: Не удается получить доступ к ‘Animal’ перед инициализацией. О чем вам напоминает эта ошибка?
Точно так же, как переменные let и const , классы поднимаются на вершину области видимости, в которой они определены, но недоступны до тех пор, пока они не будут инициализированы. Мы не получаем «Animal не определено», что показывает, что интерпретатор «знает», что существует Animal класс (из-за подъема). Но мы не можем получить доступ к этому классу до тех пор, пока не будет выполнена строка инициализации.
Давайте обновим код:
class Animal < constructor(name) < this.name = name >> const Dog = new Animal(«Bingo») console.log(Dog) //
После Animal инициализации он становится доступным, поэтому мы можем создать экземпляр Dog объекта из класса без ошибок.
Заканчивайте
В некоторых кодовых базах вы можете найти код, подобный этому:
function1() function2() function3() // lines of code // lines of code function function1() function function2() function function3()
Три функции здесь вызываются вверху, но на самом деле объявлены в коде внизу. Это возможно благодаря подъему. Функции поднимаются на вершину глобальной области видимости (именно там они были определены) вместе со своей логикой, поэтому они становятся доступными / исполняемыми еще до того, как была определена строка, в которой они были определены.
У других все по-другому. var переменные поднимаются, но со значением по умолчанию undefined . let и const переменные и классы подняты, но недоступны, поскольку у них нет инициализации по умолчанию.
Если вам понравилась эта статья, пожалуйста, поделитесь ею с другими
Вам также может понравиться
JavaScript программа для подсчета количества гласных в строке
28 мая, 2023
JavaScript-программа для реализации стека
29 мая, 2023
Программа JavaScript для замены двух переменных
28 мая, 2023