Особенности хранения значений в переменных модулей объектов и форм
В платформе 1С:Предприятие 8 используется стратегия управления временем жизни объектов, основанная на подсчете ссылок на объекты — reference counting. Данная стратегия заключается в следующем. Каждый объект платформы содержит счетчик ссылок. При появлении ссылки на объект (объект присваивается какой-либо переменной) происходит увеличение счетчика на единицу, при уничтожении подобной ссылки — значение счетчика на единицу уменьшается. Объект автоматически уничтожается, и память, занимаемая им, освобождается в момент, когда счетчик ссылок объекта становится равен нулю.
Особенностью подсчета ссылок на объекты является возможность организации » циклической ссылки «. Циклическая ссылка возникает, когда объекты начинают ссылаться друг на друга. Это приводит к ситуации, при которой ни один из объектов, участвующих в циклической ссылке, не будет уничтожен. В свою очередь это является причиной возникновения утечек памяти (memory leaks).
Необходимо, по возможности, избегать появления циклических ссылок. Соблюдение достаточно простых правил при разработке конфигураций позволит избежать проблем связанных с циклическими ссылками. В случае появления подобной ссылки необходимо определить момент для ее разрыва, чтобы объекты могли быть уничтожены нормальным образом.
Полный перечень случаев возникновения циклической ссылки привести невозможно, приведем лишь некоторые примеры:
- хранение в переменной модуля объекта (набора записей, формы) ссылки на данный объект (набор записей, форму) — ситуация приводит к появлению циклической ссылки — объект (набор записей, форма) никогда не будет уничтожен;
- хранение ссылки на владеемый объект в объекте-владельце и ссылки на объект-владелец во владеемом объекте — оба объекта никогда не будут уничтожены.
Следует обратить внимание, что, помимо переменных модулей, ссылки на объекты могут образовываться при передаче их в методы встроенного языка. Например, добавление в список значений нового значения — этого же списка значений, приведет к появлению циклической ссылки.
Переменные
Очень часто в программах необходимо иметь возможность отслеживать какие-либо значения, поскольку в ходе выполнения программы, над ними совершаются различные операции и эти значения изменяются. Для отслеживания значений в программе для них выделяется определенное место в памяти, которое можно представить в виде контейнеров. Этим контейнерам присваивается идентификатор, то есть имя, по которому впоследствии можно будет найти контейнер с нужным нам значением.
Переменные в программировании — это и есть те самые контейнеры, внутри которых вы можете хранить необходимые значения. Важно понимать, что переменные не являются самими значениями, они лишь предоставляют для них место. Есть несколько ключевых слов, для объявления переменных: var , let и const .
У переменных, объявленных с var , let или const , есть своя специфика использования, о которой будет рассказываться далее в течение курса. А также у переменных, объявленных через var , есть некоторые неочевидные особенности, незнание которых, может негативно сказываться на разработке и поддержке кода. Поэтому с выходом стандарта ES6, где появились новые ключевые слова let и const , объявление через var используется всё меньше и можно сказать устаревает. Но знать об особенностях и побочных эффектах var переменных очень важно.
Для объявления переменной используется ключевое слово и следом имя, которым вы захотите ее назвать:
var myName; let age; Вы можете назвать переменную как угодно, но есть ограничения. Как правило, вы должны придерживаться только латинских символов (0-9, a-z, A-Z) и символа подчеркивания.
После объявления переменной, вы можете присвоить ей значение:
myName = "Иван"; age = 30; Или же вы можете сделать обе эти операции на одной и той же строке:
var myName = "Иван"; let age = 30; Причем, такое присваивание нужного значения, сразу при объявлении переменной, является обязательным при объявлении переменных через ключевое слово const .
const height = 180; Ключевое слово const создаёт константу — переменную, значение которой не может быть переопределено. Поэтому, попытка объявить константу, не присвоив ей при этом значение (другими словами — без её инициализации), вызовет синтаксическую ошибку:
const height; > Uncaught SyntaxError: Missing initializer in const declaration Имя переменной — это её идентификатор, по которому её можно найти. Вы можете получить значение, просто вызвав переменную по имени:
myName; age; height; Если вы запросите значение переменной, которую объявили, но не присвоили ей никакого значения, то в ответе вам придёт undefined :
var x; console.log(x); > undefined undefined — это особый тип данных в javascript, который выражает, что “значение не определено” (“не присвоено”).
После установки значения переменной, объявленной через var и let , вы можете изменить его позже:
var myName = "Иван"; myName = "Ваня"; let age = 30; age = 31; Значение переменной, которую вы объявили через const , переопределить уже нельзя.
const height = 180; height = 200; > Uncaught TypeError: Assignment to constant variable. Так как это ключевое слово подразумевает объявление константы — переменной, значение которой постоянно, такая попытка переопределить её значение вызовет ошибку TypeError в консоли. В следующих частях курса будет показано, что само значение константы, в действительности, может меняться и это зависит от типа данных, которые в ней хранятся.
JavaScript — это язык со слабой типизацией (другое название — динамическая типизация), поэтому переменные могут содержать абсолютно разные типы данных, например, строки, числа, объекты, функции и другие типы, которые будут рассматриваться в следующих частях курса. Здесь важно еще раз подчеркнуть, что переменная — это поименованная область памяти и в ней могут храниться различные типы значений.
В отличие от некоторых других языков программирования со статической типизацией, например таких, как C++, C#, Java, в JavaScript вам не требуется как-то явно указывать тип данных для переменных. Потому, что переменная связывается с типом в момент присваивания значения, а не в момент объявления переменной.
let age = 35; age = "Тридцать пять"; Переменная age начинает свой жизненный цикл с хранения числа 35 , а затем хранит строку. А потом, в какой-то момент, ей можно присвоить значение с любым другим типом.
В любом случае, переменная age хранит текущее значение, которое меняется по ходу выполнения программы. Это иллюстрирует первичную цель переменных: хранение текущего состояния программы, которое может изменяться по ходу её выполнения.
Если значения переменных var и let могут меняться в ходе выполнения программы, то переменные const — предназначены для хранения постоянных значений. Часто бывает нужно задать определенные значения в программе, которые впоследствии никак не будут меняться в течение её работы, а только использоваться для получения самих данных. То есть, другими словами, необходимо задать константы и для этой цели тоже используются переменные.
До выхода стандарта ES6 в 2015 году, для объявления констант использовалось всё то же ключевое слово var , только имя этой константы записывалось большими буквами, с подчеркиваниями _ между словами, тем самым предупреждая других разработчиков или себя в будущем, что это константа и менять её дальше в коде нельзя, например:
var PI = 3.14; var radius = 10; var circle = 2 * PI * radius; var TAX_RATE = 0.13; var salary = 1000 * TAX_RATE; Хоть это объявление заглавными буквами и давало понять, что эта переменная — константа, но никак не защищало переменную от самих изменений в дальнейшем и вся надежда была на сознательность разработчика, который увидев, что это константа, не будет её в коде изменять. Сейчас же, для объявления констант используется ключевое слово const .
const pi = 3.14; var radius = 10; var circle = 2 * pi * radius; const taxRate = 0.13; var salary = 1000 * taxRate; Объявление переменных через const предотвращает случайное изменение, где-либо после начальной установки, значения. И как было показано ранее, попытка присвоить новое значение переменным taxRate или pi после их объявления, будет отвергнуто и вызовет ошибку TypeError .
Общие принципы выбора имен переменных
В этом разделе представлены основные принципы именования переменных из книги “Совершенный код” Стива Макконнела.
Важнейший принцип именования переменных состоит в том, что имя должно полно и точно описывать сущность, представляемую переменной. Один эффективный способ выбора хорошего имени предполагает формулирование сути переменной в словах. Оптимальным именем переменной часто оказывается само это высказывание. Благодаря отсутствию загадочных сокращений оно удобочитаемо; к тому же оно однозначно. Так как оно является полным описанием сущности, его нельзя спутать с чем-либо другим. Наконец, такое имя легко запомнить потому, что оно похоже на исходную концепцию.
Переменную, представляющую число членов команды, можно было бы назвать numTeamMembers . Переменную, представляющую число мест на стадионе, — numSeatsInStadium . Для хранения максимального числа очков, набранных спортсменами какой-то страны в современной Олимпиаде, можно было бы создать переменную teamPointsMax . Переменную, определяющую текущую процентную ставку, лучше было бы назвать rate или interestRate , а не r или x .
Обратите внимание на две характеристики этих имен. Во-первых, их легко расшифровать. Фактически их не нужно расшифровывать вообще: их можно просто прочитать. Ну, а во-вторых, длина имени должна быть оптимальна для передачи сути переменной, но при этом не должна быть слишком велика, чтобы сохранять практичность её использования.
Несколько примеров удачных и неудачных имен переменных:
| суть переменной | адекватное описание | неадекватное описание |
|---|---|---|
| Сумма, на которую на данный момент выписаны чеки | runningTotal, checkTotal | written, ct, checks, CHKTTL, x, x1, x2 |
| Скорость поезда | velocity, trainVelocity, velocityInMph | velt, v, tv, x, x1, x2, train |
| Текущая дата | currentDate, todaysDat | cd, current, c, x, x1, x2, date |
Имена currentDate и todaysDate — хорошие имена, потому что полно и точно описывают идею «текущей даты». Фактически они составлены из слов с очевидным значением. Программисты иногда упускают из виду обычные слова, которые порой приводят к самому простому решению. Имена cd и c неудачны потому, что слишком коротки и «неописательны». Имя current тоже неудачно: оно не говорит, что именно является «текущим». Имя date кажется хорошим, но в итоге оно оказывается плохим, потому что мы имеем в виду не любую дату, а текущую; само по себе имя date об этом не говорит. Имена x , x1 и x2 заведомо неудачны: x традиционно представляет неизвестное количество чего-либо, и, если вы не хотите, чтобы ваши переменные были неизвестными величинами, подумайте о выборе других имен.
Имена должны быть максимально конкретны. Имена x , temp , i и другие, достаточно общие для того, чтобы их можно было использовать более чем с одной целью, не так информативны, как могли бы быть, и обычно являются плохими.
Хорошее мнемоническое имя чаще всего описывает проблему, а не ее решение. Хорошее имя в большей степени выражает что, а не как. Если же имя описывает некоторый аспект вычислений, а не проблемы, имеет место обратное. Предпочитайте таким именам переменных имена, характеризующие саму проблему.
Запись данных о сотруднике можно было бы назвать inputRec или employeeData . Имя inputRec — компьютерный термин, выражающий идеи ввода данных и записи. Имя employeeData относится к проблемной области, а не к миру компьютеров. В случае битового поля, определяющего статус принтера, имя bitFlag более компьютеризировано, чем printerReady , а в случае приложения бухгалтерского учета calcVal более компьютеризировано, чем sum .
Оптимальная длина имени, наверное, лежит где-то между длинами имен x и maximumNumberOfPointsInModernOlympics . Слишком короткие страдают от недостатка смысла. Проблема с именами вроде x1 и x2 в том, что, даже узнав, что такое x , вы ничего не сможете сказать об отношении между x1 и x2 . Слишком длинные имена надоедает печатать, к тому же они могут сделать неясной визуальную структуру программы.
Было обнаружено, что отладка программы требовала меньше всего усилий, если имена переменных состояли в среднем из 10–16 символов. Отладка программ с именами, состоящими в среднем из 8–20 символов, была почти столь же легкой. Это не значит, что следует присваивать всем переменным имена из 9–15 или 10–16 символов. Это значит, что, увидев в своем коде много более коротких имен, вы должны проверить их ясность.
Вопрос адекватности длины имен переменных поясняет следующая таблица:
| Слишком длинные имена: | Слишком короткие имена: | То, что надо: |
|---|---|---|
| numberOfPeopleOnTheUsOlympicTeam, numberOfSeatsInTheStadium, maximumNumberOfPointsInModernOlympics | n, np, ntm, n, ns, nsisd, m, mp, max, points | numTeamMembers, teamMemberCount, numSeatsInStadium, seatCount, teamPointsMax, pointsRecord |
Дата изменения: February 26, 2023
Поделиться
Обнаружили ошибку или хотите добавить что-то своё в документацию? Отредактируйте эту страницу на GitHub!
Переменные — место хранения необходимой информации
После прочтения последних двух статей вы знаете, что такое JavaScript, что он может сделать для вас, как использовать его вместе с другими веб-технологиями и какими он обладает функциями высокого уровня. В этой статье мы перейдём к реальным основам, рассмотрим, как работать с большинством базовых блоков JavaScript — Переменными.
| Необходимые навыки: | Базовая компьютерная грамотность, базовое понимание HTML и CSS, понимание того, что такое JavaScript. |
|---|---|
| Цель: | Ознакомиться с основами переменных в JavaScript. |
Инструменты, которые вам нужны
В этой статье вам будет предложено ввести строки кода, чтобы проверить ваше понимание материала. Если вы используете браузер для настольных компьютеров, лучшим примером для ввода кода примера является консоль JavaScript вашего браузера (см. What are browser developer tools для получения дополнительной информации о том, как получить доступ к этому инструменту).
Также мы предоставили простую консоль JavaScript, встроенную ниже в странице, для ввода кода, если вы не используете браузер с консолью JavaScript или консоль на странице окажется для вас более комфортной.
Что такое переменные?
Переменные — это контейнер для таких значений, как числа, используемые в сложении, или строка, которую мы могли бы использовать как часть предложения. Но одна из особенностей переменных — их значение может меняться. Давайте взглянем на простой пример:
button>Нажми на меняbutton>
const button = document.querySelector("button"); button.onclick = function () let name = prompt("Как вас зовут?"); alert("Привет " + name + ", рады видеть вас!"); >;
В примере, по нажатию кнопки выполнится несколько строк кода. Первая строка в функции покажет пользователю окно, где попросит ввести его имя и сохранит значение в переменной. Вторая строка отобразит приветствие с включённым введённым именем, взятым из значения переменной.
Чтобы лучше понять действие переменной здесь, давайте подумаем о том, как мы будем писать этот пример без использования переменной. Это будет выглядеть примерно так:
var name = prompt('Как вас зовут?'); if (name === 'Адам') < alert('Привет, Адам, рады тебя видеть!'); >else if (name === 'Алан') < alert('Привет, Алан, рады тебя видеть!'); >else if (name === 'Белла') < alert('Привет, Белла, рады тебя видеть!'); >else if (name === 'Бьянка') < alert('Привет, Бьянка, рады тебя видеть!'); >else if (name === 'Крис') < alert('Привет, Крис, рады тебя видеть!'); >// . и так далее .
Вам сейчас не обязательно понимать синтаксис, который мы используем (пока!), но вы должны понять идею: если бы у нас не было доступных переменных, нам пришлось бы реализовать гигантский блок кода, который проверял, какое имя было введено, а затем отображал соответствующее сообщение для этого имени. Очевидно, что это неэффективно (код намного больше, даже для четырёх вариантов), и он просто не сработает, так как вы не можете хранить все возможные варианты.
Переменные имеют смысл, и, когда вы узнаете больше о JavaScript, они начнут становиться второй натурой.
Ещё одна особенность переменных заключается в том, что они могут содержать практически все, а не только строки и числа. Переменные могут также содержать сложные данные и даже целые функции. Об этом вы узнаете больше при дальнейшем изучении курса..
Заметьте: мы говорим, что переменные содержат значения. Это важное различие. Переменные не являются самими значениями; они представляют собой контейнеры для значений. Представьте, что они похожи на маленькие картонные коробки, в которых вы можете хранить вещи.
Объявление переменной
Чтобы использовать переменную, вы сначала должны её создать, или, если быть точнее, объявить переменную. Чтобы сделать это, мы вводим ключевое слово var, за которым следует имя, которое вы хотите дать своей переменной:
var myName; var myAge;
Здесь мы создаём две переменные myName и myAge. Попробуйте ввести эти строки сейчас в консоли вашего веб-браузера или в консоли ниже (можно открыть эту консоль в отдельной вкладке или в новом окне). После этого попробуйте создать переменную (или две) с вашими именами.
doctype html> html> head> meta charset="utf-8" /> title>JavaScript consoletitle> style> * box-sizing: border-box; > html background-color: #0c323d; color: #809089; font-family: monospace; > body max-width: 700px; > p margin: 0; width: 1%; padding: 0 1%; font-size: 16px; line-height: 1.5; float: left; > .input p margin-right: 1%; > .output p width: 100%; > .input input width: 96%; float: left; border: none; font-size: 16px; line-height: 1.5; font-family: monospace; padding: 0; background: #0c323d; color: #809089; > div clear: both; > style> head> body>body> script> var geval = eval; function createInput() var inputDiv = document.createElement("div"); var inputPara = document.createElement("p"); var inputForm = document.createElement("input"); inputDiv.setAttribute("class", "input"); inputPara.textContent = ">"; inputDiv.appendChild(inputPara); inputDiv.appendChild(inputForm); document.body.appendChild(inputDiv); if (document.querySelectorAll("div").length > 1) inputForm.focus(); > inputForm.addEventListener("change", executeCode); > function executeCode(e) try var result = geval(e.target.value); > catch (e) var result = "error — " + e.message; > var outputDiv = document.createElement("div"); var outputPara = document.createElement("p"); outputDiv.setAttribute("class", "output"); outputPara.textContent = "Result: " + result; outputDiv.appendChild(outputPara); document.body.appendChild(outputDiv); e.target.disabled = true; e.target.parentNode.style.opacity = "0.5"; createInput(); > createInput(); script> html>
Примечание: в JavaScript все инструкции кода должны заканчиваться точкой с запятой (;) — ваш код может работать правильно для отдельных строк, но, вероятно, не будет, когда вы пишете несколько строк кода вместе. Попытайтесь превратить написание точки с запятой в привычку.
Теперь проверим, существуют ли эти значения в среде выполнения. Для этого введём только имя переменной.
; myAge;
В настоящее время они не содержат значения, это пустые контейнеры. В этом случае, когда вы вводите имена переменных, вы должны получить значение undefined . Если они не существуют, вы получите сообщение об ошибке — попробуйте сейчас ввести в консоли имя переменной ниже:
Примечание: Не путайте переменную, которая существует, но не имеет значения, с переменной, которая вообще не существует — это разные вещи.
Присвоение значения переменной
Как только переменная объявлена, ей можно присвоить значение. Для этого пишется имя переменной, затем следует знак равенства ( = ), а за ним значение, которое вы хотите присвоить. Например:
= "Chris"; myAge = 37;
Попробуйте вернуться в консоль и ввести эти строки. Вы должны увидеть значение, которое вы назначили переменной, возвращаемой в консоли. Чтобы посмотреть значения переменных, нужно набрать их имя в консоли:
; myAge;
Вы можете объявить переменную и задать ей значение одновременно:
var myName = "Chris";
Скорее всего, так вы будете писать большую часть времени, так как запись и выполнения кода с одно строки происходит быстрее, чем выполнение двух действий на двух отдельных строках.
Примечание: Если вы пишете многострочную программу JavaScript, которая объявляет и инициализирует (задаёт значение) переменную, вы можете объявить её после её инициализации, и она всё равно будет работать. Это связано с тем, что объявления переменных обычно выполняются первыми, прежде чем остальная часть кода будет выполнена. Это называется hoisting — прочитайте var hoisting для более подробной информации по этому вопросу.
Обновление переменной
Когда переменной присваивается значение, вы можете изменить (обновить) это значение, просто указав другое значение. Попробуйте ввести следующие строки в консоль:
= "Bob"; myAge = 40;
Правила именования переменных
Вы можете назвать переменную как угодно, но есть ограничения. Как правило, вы должны придерживаться только латинских символов (0-9, a-z, A-Z) и символа подчёркивания.
- Не рекомендуется использование других символов, потому что они могут вызывать ошибки или быть непонятными для международной аудитории.
- Не используйте символы подчёркивания в начале имён переменных — это используется в некоторых конструкциях JavaScript для обозначения конкретных вещей.
- Не используйте числа в начале переменных. Это недопустимо и приведёт к ошибке.
- Общепринято придерживаться так называемый «lower camel case», где вы склеиваете несколько слов, используя строчные буквы для всего первого слова, а затем заглавные буквы последующих слов. Мы использовали это для наших имён переменных в этой статье.
- Делайте имена переменных такими, чтобы было интуитивно понятно, какие данные они содержат. Не используйте только отдельные буквы / цифры или большие длинные фразы.
- Переменные чувствительны к регистру, так что myage и myAge — разные переменные.
- И последнее — вам также нужно избегать использования зарезервированных слов JavaScript в качестве имён переменных — под этим мы подразумеваем слова, которые составляют фактический синтаксис JavaScript! Таким образом, вы не можете использовать слова типа var , function , let , и for для имён переменных. Браузеры распознают их как разные элементы кода, и поэтому возникают ошибки.
Примечание: По ссылке можно найти довольно полный список зарезервированных ключевых слов: Lexical grammar — keywords.
Примеры хороших имён переменных:
age myAge init initialColor finalOutputValue audio1 audio2
Примеры плохих имён переменных:
1 a _12 myage MYAGE var Document skjfndskjfnbdskjfb thisisareallylongstupidvariablenameman
Примеры имён переменных, которые вызовут ошибки:
var Document
Попытайтесь создать ещё несколько переменных прямо сейчас, используя знания, изложенные выше.
Типы переменных
Есть несколько различных типов данных, которые мы можем хранить в переменных. В этом разделе мы кратко опишем их, а затем в будущих статьях вы узнаете о них более подробно.
Числа (Numbers)
Вы можете хранить числа в переменных (целые числа, такие как 30, или десятичные числа, такие как 2.456, также называемые числами с плавающей точкой или с плавающей запятой). Вам не нужно объявлять типы переменных в JavaScript, в отличие от некоторых других языков программирования Если давать переменной значение числа,кавычки не используются:
var myAge = 17;
Строки (‘Strings’)
Строки — это фрагменты текста. Когда вы даёте переменной значение строки, вам нужно обернуть её в одиночные или двойные кавычки, в противном случае JavaScript попытается проиндексировать её как другое имя переменной.
var dolphinGoodbye = "So long and thanks for all the fish";
Логические (Booleans)
Booleans — истинные / ложные значения — они могут иметь два значения: true или false. Они обычно используются для проверки состояния, после чего код запускается соответствующим образом. Вот простой пример:
var iAmAlive = true;
В действительности вы чаще будете использовать этот тип переменных так:
var test = 6 3;
Массивы (Arrays)
Массив — это один объект, который содержит несколько значений, заключённых в квадратные скобки и разделённых запятыми. Попробуйте ввести следующие строки в консоль:
var myNameArray = ["Chris", "Bob", "Jim"]; var myNumberArray = [10, 15, 40];
Как только эти массивы определены, можно получить доступ к каждому значению по их местоположению в массиве. Наберите следующие строки:
[0]; // should return 'Chris' myNumberArray[2]; // should return 40
Квадратные скобки указывают значение индекса, соответствующее позиции возвращаемого значения. Возможно, вы заметили, что массивы в JavaScript индексируются с нулевой отметкой: первый элемент имеет индекс 0.
В следующей статье вы узнаете больше о массивах.
Объекты (Objects)
В программировании объект представляет собой структуру кода, который моделирует объект реальной жизни. У вас может быть простой объект, представляющий автостоянку, и содержит информацию о её ширине и длине; или вы можете иметь объект, который представляет человека, и содержит данные о его имени, росте, весе, на каком языке он говорит, как сказать ему привет и многое другое.
Попробуйте ввести следующую строку в консоль:
var dog = name: "Spot", breed: "Dalmatian" >;
Чтобы получить информацию, хранящуюся в объекте, вы можете использовать следующий синтаксис:
.name;
Мы больше не будем рассматривать объекты в данном курсе — вы можете больше узнать о них в будущем модуле.
Динамическая типизация
JavaScript — это «динамически типизируемый язык», что означает, что в отличие от некоторых других языков вам не нужно указывать, какой тип данных будет содержать переменная (например, числа, строки, массивы и т. д.).
Например, если вы объявите переменную и присвоите ей значение, заключённое в кавычки, браузер будет обрабатывать переменную как строку:
var myString = "Привет";
Он всё равно будет строкой, даже если он содержит числа, поэтому будьте осторожны:
var myNumber = "500"; // упс, это все ещё строка (string) typeof myNumber; myNumber = 500; // так-то лучше, теперь это число (number) typeof myNumber;
Попробуйте ввести четыре строки выше в консоль одну за другой и посмотреть результаты. Вы заметите, что мы используем специальную функцию typeof() — она возвращает тип данных переменной, которую вы передаёте в неё. В первый раз, когда она вызывается, она должа возвращать строку, так как переменная myNumber содержит строку ‘500’ . Посмотрите, что она вернёт во второй раз, когда вы её вызовите.
Подведение итогов
К настоящему времени вы должны знать достаточно о переменных JavaScript и о том, как их создавать. В следующей статье мы остановимся на числах более подробно, рассмотрев, как сделать базовую математику в JavaScript.
Found a content problem with this page?
- Edit the page on GitHub.
- Report the content issue.
- View the source on GitHub.
This page was last modified on 3 авг. 2023 г. by MDN contributors.
Your blueprint for a better internet.
about_Variables
Описывает, как переменные хранят значения, которые можно использовать в PowerShell.
Подробное описание
Все типы значений можно хранить в переменных PowerShell. Например, сохраните результаты команд и сохраните элементы, используемые в командах и выражениях, таких как имена, пути, параметры и значения.
Переменная — это единица памяти, в которой хранятся значения. В PowerShell переменные представлены текстовыми строками, начинающимися с знака доллара ( $ ), например $a , $process или $my_var .
Имена переменных не учитывает регистр и могут включать пробелы и специальные символы. Но имена переменных, включающие специальные символы и пробелы, трудно использовать и следует избегать. Дополнительные сведения см. в разделе «Имена переменных», включающих специальные символы.
В PowerShell существует несколько различных типов переменных.
- Созданные пользователем переменные: созданные пользователем переменные создаются и поддерживаются пользователем. По умолчанию переменные, созданные в командной строке PowerShell, существуют только во время открытия окна PowerShell. При закрытии окон PowerShell переменные удаляются. Чтобы сохранить переменную, добавьте ее в профиль PowerShell. Можно также создавать переменные в скриптах с глобальными, скриптами или локальными область.
- Автоматические переменные: автоматические переменные хранят состояние PowerShell. Эти переменные создаются PowerShell, и PowerShell изменяет их значения в соответствии с требованиями, чтобы обеспечить их точность. Пользователи не могут изменить значение этих переменных. Например, $PSHOME переменная сохраняет путь к каталогу установки PowerShell. Дополнительные сведения, список и описание автоматических переменных см. в about_Automatic_Variables .
- Переменные предпочтения: переменные предпочтения хранят пользовательские настройки для PowerShell. Эти переменные создаются PowerShell и заполняются значениями по умолчанию. Пользователи могут изменять значения этих переменных. Например, $MaximumHistoryCount переменная определяет максимальное количество записей в журнале сеансов. Дополнительные сведения, список и описание переменных предпочтения см . в about_Preference_Variables.
Работа с переменными
Чтобы создать новую переменную, используйте инструкцию назначения для назначения значения переменной. Перед его использованием не нужно объявлять переменную. Значение по умолчанию для всех переменных $null .
Чтобы получить список всех переменных в сеансе PowerShell, введите Get-Variable . Имена переменных отображаются без предыдущего знака доллара ( $ ), используемого для ссылки на переменные.
$MyVariable = 1, 2, 3 $Path = "C:\Windows\System32" Переменные полезны для хранения результатов команд.
$Processes = Get-Process $Today = (Get-Date).DateTime Чтобы отобразить значение переменной, введите имя переменной, предшествующее знаку доллара ( $ ).
$MyVariable 1 2 3 $Today Tuesday, September 3, 2019 09:46:46 Чтобы изменить значение переменной, назначьте новое значение переменной.
В следующих примерах отображается значение переменной $MyVariable , изменяется значение переменной, а затем отображается новое значение.
$MyVariable = 1, 2, 3 $MyVariable 1 2 3 $MyVariable = "The green cat." $MyVariable The green cat. Чтобы удалить значение переменной, используйте Clear-Variable командлет или измените значение $null на .
Clear-Variable -Name MyVariable $MyVariable = $null Чтобы удалить переменную, используйте Remove-Variable или Remove-Item.
Remove-Variable -Name MyVariable Remove-Item -Path Variable:\MyVariable Можно также назначить значения нескольким переменным с одной инструкцией. В следующих примерах одно и то же значение назначается нескольким переменным:
$a = $b = $c = 0 Следующий пример назначает несколько значений нескольким переменным.
$i,$j,$k = 10, "red", $true # $i is 10, $j is "red", $k is True $i,$j = 10, "red", $true # $i is 10, $j is [object[]], Length 2 Дополнительные сведения см. в разделе «Назначение нескольких переменных» about_Assignment_Operators.
Типы переменных
Вы можете хранить любой тип объекта в переменной, включая целые числа, строки, массивы и хэш-таблицы. Объекты, представляющие процессы, службы, журналы событий и компьютеры.
Переменные PowerShell свободно типируются, что означает, что они не ограничиваются определенным типом объекта. Одна переменная может содержать даже коллекцию или массив различных типов объектов одновременно.
Тип данных переменной определяется типами .NET значений переменной. Чтобы просмотреть тип объекта переменной, используйте Get-Member .
$a = 12 # System.Int32 $a = "Word" # System.String $a = 12, "Word" # array of System.Int32, System.String $a = Get-ChildItem C:\Windows # FileInfo and DirectoryInfo types Вы можете использовать атрибут типа и нотацию приведения, чтобы убедиться, что переменная может содержать только определенные типы объектов или объекты, которые можно преобразовать в этот тип. Если вы пытаетесь назначить значение другого типа, PowerShell пытается преобразовать значение в его тип. Если тип не удается преобразовать, оператор присваивания завершается ошибкой.
Чтобы использовать нотацию приведения, введите имя типа, заключенное в квадратные скобки, перед именем переменной (слева от инструкции назначения). В следующем примере создается $number переменная, которая может содержать только целые числа, переменную, $words содержащую только строки, и $dates переменную, которая может содержать только объекты DateTime .
[int]$number = 8 $number = "12345" # The string is converted to an integer. $number = "Hello" Cannot convert value "Hello" to type "System.Int32". Error: "Input string was not in a correct format." At line:1 char:1 + $number = "Hello" + ~~~~~~~~~~~~~~~~~ + CategoryInfo : MetadataError: (:) [], ArgumentTransformationMetadataException + FullyQualifiedErrorId : RuntimeException [string]$words = "Hello" $words = 2 # The integer is converted to a string. $words += 10 # The plus (+) sign concatenates the strings. $words [datetime] $dates = "09/12/91" # The string is converted to a DateTime object. $dates Thursday, September 12, 1991 00:00:00 $dates = 10 # The integer is converted to a DateTime object. $dates Monday, January 1, 0001 00:00:00 Использование переменных в командах и выражениях
Чтобы использовать переменную в команде или выражении, введите имя переменной перед знаком доллара ( $ ).
Если имя переменной и знак доллара не заключены в кавычки или если они заключены в двойные кавычки ( » ) метки, значение переменной используется в команде или выражении.
Если имя переменной и знак доллара заключены в одинарные кавычки ( ‘ ) метки, имя переменной используется в выражении.
Дополнительные сведения об использовании кавычек в PowerShell см. в about_Quoting_Rules .
В этом примере возвращается значение переменной $PROFILE , представляющее собой путь к файлу профиля пользователя PowerShell в консоли PowerShell.
$PROFILE C:\Users\User01\Documents\PowerShell\Microsoft.PowerShell_profile.ps1 В этом примере показаны две команды, которые могут открыть профиль PowerShell в notepad.exe. В примере с двойными кавычками ( » ) используется значение переменной.
notepad $PROFILE notepad "$PROFILE" В следующих примерах используются одинарные кавычки ( ‘ ), которые обрабатывают переменную как литеральный текст.
'$PROFILE' $PROFILE 'Use the $PROFILE variable.' Use the $PROFILE variable. Имена переменных, включающие специальные символы
Имена переменных начинаются с знака доллара ( $ ) и могут включать буквенно-цифровые символы и специальные символы. Длина имени переменной ограничена только доступной памятью.
Рекомендуется, чтобы имена переменных включали только буквенно-цифровые символы и символ подчеркивания ( _ ). Имена переменных, включающие пробелы и другие специальные символы, трудно использовать и следует избегать.
Буквенно-цифровые имена переменных могут содержать следующие символы:
В следующем списке содержатся описания категорий Юникода. Дополнительные сведения см. в разделе ЮникодCategory.
Чтобы создать или отобразить имя переменной, включающее пробелы или специальные символы, заключите имя переменной с фигурными скобками ( <> ) символами. Фигурные скобки направляют PowerShell для интерпретации символов имени переменной как литералы.
Имена специальных переменных символов могут содержать следующие символы:
- Любой символ Юникода со следующими исключениями:
- Закрывающий фигурный скобка () символ ( > U+007D).
- Символ backtick () ( ` U+0060). Обратная черта используется для экранирования символов Юникода, поэтому они рассматриваются как литералы.
PowerShell имеет зарезервированные переменные, такие как $$ , $? $^ и $_ содержащие буквенно-цифровые и специальные символы. Дополнительные сведения см. в статье about_Automatic_Variables.
Например, следующая команда создает переменную с именем save-items . Фигурные скобки ( <> ) необходимы, так как имя переменной включает специальный символ дефиса ( — ).
$ = "a", "b", "c" $
a b cСледующая команда получает дочерние элементы в каталоге, представленном переменной ProgramFiles(x86) среды.
Get-ChildItem $
Чтобы ссылаться на имя переменной, включающую фигурные скобки, заключите имя переменной в фигурные скобки и используйте символ backtick для экранирования фигурных скобок. Например, чтобы создать переменную именованного thisis типа:
$is> = "This variable name uses braces and backticks." $is>This variable name uses braces and backticks.Переменные и область
По умолчанию переменные доступны только в область, в которой они создаются.
Например, переменная, созданная в функции, доступна только в функции. Переменная, созданная в скрипте, доступна только в скрипте. Если вы dot-source скрипт, переменная добавляется в текущую область. Дополнительные сведения см. в about_Scopes .
Для изменения область переменной можно использовать модификатор область по умолчанию. Следующее выражение создает переменную с именем Computers . Переменная имеет глобальную область, даже если она создана в скрипте или функции.
$Global:Computers = "Server01"Для любого скрипта или команды, выполняющегося вне сеанса, требуется Using модификатор область для внедрения значений переменных из вызывающего сеанса область, чтобы получить к ним доступ из кода сеанса.
Дополнительные сведения см. в about_Remote_Variables .
Сохранение переменных
Создаваемые переменные доступны только в сеансе, в котором они создаются. Они потеряны при закрытии сеанса.
Чтобы создать переменную в каждом начальном сеансе PowerShell, добавьте переменную в профиль PowerShell.
Например, чтобы изменить значение переменной $VerbosePreference в каждом сеансе PowerShell, добавьте следующую команду в профиль PowerShell.
$VerbosePreference = "Continue"Эту команду можно добавить в профиль PowerShell, открыв $PROFILE файл в текстовом редакторе, например notepad.exe. Дополнительные сведения о профилях PowerShell см. в about_Profiles .
Переменная: диск
Поставщик переменных PowerShell создает Variable: диск, который выглядит и действует как диск файловой системы, но содержит переменные в сеансе и их значения.
Чтобы изменить Variable: диск, используйте следующую команду:
Set-Location Variable:Чтобы перечислить элементы и переменные на Variable: диске, используйте Get-Item командлеты или Get-ChildItem элементы.
Get-ChildItem Variable:Чтобы получить значение определенной переменной, используйте нотацию файловой системы, чтобы указать имя диска и имя переменной. Например, чтобы получить автоматическую $PSCulture переменную, используйте следующую команду.
Get-Item Variable:\PSCultureName Value ---- ----- PSCulture en-USЧтобы отобразить дополнительные сведения о Variable: диске и поставщике переменных PowerShell, введите следующее:
Get-Help VariableСинтаксис переменной с путями поставщика
Вы можете префиксить путь поставщика с помощью знака доллара ( $ ) и получить доступ к содержимому любого поставщика, реализующего интерфейс IContentCmdletProvider .
Следующие встроенные поставщики PowerShell поддерживают эту нотацию:
- about_Environment_Provider
- about_Variable_Provider
- about_Function_Provider
- about_Alias_Provider
Командлеты переменной
PowerShell включает набор командлетов, предназначенных для управления переменными.
Чтобы вывести список командлетов, введите следующее:
Get-Command -Noun VariableЧтобы получить справку для определенного командлета, введите следующее:
Get-Help
Имя командлета Description Clear-Variable Удаляет значение переменной. Get-Variable Получает переменные в текущей консоли. New-Variable Создает новую переменную. Remove-Variable Удаляет переменную и ее значение. Set-Variable Изменяет значение переменной. См. также
- about_Automatic_Variables
- about_Environment_Variables
- about_Preference_Variables
- about_Profiles
- about_Quoting_Rules
- about_Remote_Variables
- about_Scopes
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.