Задание (информатика)

О назначении букв дисковым файловым системам см. в разделе Назначение букв диска .

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

Сегодня наиболее часто используемое обозначение для этой операции: x = expr(первоначально Superplan 1949–51, популяризированный Fortran 1957 и C ). Вторым наиболее часто используемым обозначением является x := expr (первоначально АЛГОЛ 1958 года, популяризированный Паскалем ) . Также используются многие другие обозначения. В некоторых языках используемый символ рассматривается как оператор (это означает, что оператор присваивания в целом возвращает значение). Другие языки определяют присваивание как оператор (это означает, что его нельзя использовать в выражении).

Присвоения обычно позволяют переменной хранить разные значения в разное время в течение ее жизненного цикла и области действия . Однако некоторые языки (в первую очередь строго функциональные ) не допускают такого рода «деструктивного» переназначения, поскольку оно может подразумевать изменения нелокального состояния. Цель состоит в том, чтобы обеспечить ссылочную прозрачность , то есть функции, которые не зависят от состояния некоторых переменных, но дают одинаковые результаты для заданного набора параметрических входных данных в любой момент времени. Современные программы на других языках также часто используют аналогичные стратегии, хотя и менее строгие, и только в определенных частях, чтобы уменьшить сложность, обычно в сочетании с дополняющими методологиями, такими как структурирование данных , структурированное программирование и объектная ориентация .

Семантика

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

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

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

Пример: Предполагая, что a — числовая переменная, присвоение a := 2*a означает, что содержимое переменной a удваивается после выполнения оператора.

Пример сегмента кода C :

интервал   х   =   10  ;  
  плавать   y  ; 
  х   =   23  ; 
  у   =   32,4f  ; 

В этом примере переменная xсначала объявляется как целое число, а затем ему присваивается значение 10. Обратите внимание, что объявление и присвоение происходят в одном операторе. Во второй строке yобъявляется без присвоения. В третьей строке x ему присваивается значение 23. Наконец, y присвоено значение 32,4.

Для операции присваивания необходимо, чтобы значение expression четко определен (это допустимое значение rvalue ) и что variableпредставляет изменяемый объект (это допустимое изменяемое (неконстантное ) значение lvalue ). В некоторых языках, обычно динамических , нет необходимости объявлять переменную перед присвоением ей значения. В таких языках переменная автоматически объявляется при первом присвоении, а область ее объявления варьируется в зависимости от языка.

Одно задание

См. также: Статическая форма с одним назначением.

Любое присвоение, которое изменяет существующее значение (например, x := x + 1) запрещено в чисто функциональных языках. В функциональном программировании присваивание не рекомендуется в пользу одиночного присваивания, более известного как инициализация . Одиночное присвоение является примером привязки имени и отличается от присвоения, описанного в этой статье, тем, что его можно выполнить только один раз, обычно при создании переменной; последующее переназначение не допускается.

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

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

Нечистые функциональные языки обеспечивают как одиночное, так и истинное присваивание (хотя истинное присваивание обычно используется реже, чем в императивных языках программирования). Например, в Scheme оба одиночных присваивания (с let) и истинное присваивание (с set!) можно использовать для всех переменных, а для деструктивного обновления внутри списков, векторов, строк и т. д. предусмотрены специализированные примитивы. В OCaml для переменных разрешено только однократное присвоение через метод let name = valueсинтаксис; однако деструктивное обновление может использоваться для элементов массивов и строк с отдельными <- оператор, а также поля записей и объектов, которые были явно объявлены изменяемыми (то есть способными быть изменены после их первоначального объявления) программистом.

Языки функционального программирования, использующие одно присваивание, включают Clojure (для структур данных, а не переменных), Erlang (он допускает множественное присваивание, если значения равны, в отличие от Haskell), F# , Haskell , JavaScript (для констант), Lava , OCaml , Oz (для переменных потока данных, а не ячеек), Racket (для некоторых структур данных, таких как списки, а не символы), SASL , Scala (для значений), SISAL , Standard ML . без возврата Код Пролога можно рассматривать как явное однократное присвоение, явное в том смысле, что его (именованные) переменные могут находиться в явно неназначенном состоянии или быть установлены ровно один раз. В Haskell, напротив, не может быть неназначенных переменных, и каждую переменную можно рассматривать как неявно установленную при ее создании в свое значение (или, скорее, в вычислительный объект, который будет выдавать свое значение по требованию ).

Ценность задания

В некоторых языках программирования оператор присваивания возвращает значение, а в других — нет.

В большинстве языков программирования, ориентированных на выражения (например, C ), оператор присваивания возвращает присвоенное значение, что позволяет использовать такие идиомы, как x = y = a, в котором оператор присваивания y = a возвращает значение a, который затем присваивается x. В таком заявлении, как while ((ch = getchar()) != EOF) {…}, возвращаемое значение функции используется для управления циклом при присвоении того же значения переменной.

В других языках программирования, например в Scheme , возвращаемое значение присваивания не определено, и такие идиомы недопустимы.

В Хаскеле ​ нет присваивания переменных; но операции, подобные присваиванию (например, присвоение полю массива или полю изменяемой структуры данных), обычно оцениваются по типу единицы , который представлен как (). Этот тип имеет только одно возможное значение и поэтому не содержит никакой информации. Обычно это тип выражения, который оценивается исключительно из-за его побочных эффектов.

Варианты форм задания

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

Дополненное задание

Основная статья: Дополненное задание

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

Связанное задание

Заявление вроде w = x = y = z называется цепным присваиванием , в котором значение z присваивается нескольким переменным w, x, и y. Связанные присваивания часто используются для инициализации нескольких переменных, как в

a = b = c = d = f = 0

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

В некоторых языках программирования ( например, C ) поддерживаются цепочки присваиваний, поскольку присваивания являются выражениями и имеют значения. В этом случае цепное присвоение может быть реализовано с помощью право-ассоциативного присваивания , а присвоения выполняются справа налево. Например, i = arr[i] = f() эквивалентно arr[i] = f(); i = arr[i]. В C++ они также доступны для значений типов классов путем объявления соответствующего возвращаемого типа для оператора присваивания.

В Python операторы присваивания не являются выражениями и, следовательно, не имеют значения. Вместо этого цепные присваивания представляют собой серию операторов с несколькими целями для одного выражения. Задания выполняются слева направо, так что i = arr[i] = f() оценивает выражение f(), затем присваивает результат самой левой цели, i, а затем присваивает тот же результат следующей цели, arr[i], используя новое значение i. По сути это эквивалентно tmp = f(); i = tmp; arr[i] = tmp хотя для временного значения не создается фактическая переменная.

Параллельное назначение

Некоторые языки программирования, такие как APL , Common Lisp , Идти , JavaScript (начиная с версии 1.7), PHP , Maple , Lua , occam 2 , Перл , Питон , РЕБОЛ , Руби , и PowerShell позволяют назначать несколько переменных параллельно, используя такой синтаксис:

а, б := 0, 1
 

который одновременно присваивает 0 a и от 1 до b. Чаще всего это называют параллельным присваиванием ; оно было введено в CPL в 1963 году под названием « Совместное назначение» . и иногда его называют множественным присвоением , хотя это сбивает с толку при использовании с «одиночным присвоением», поскольку это не противоположности. Если правая часть присваивания представляет собой одну переменную (например, массив или структуру), эта функция называется распаковкой. или деструктурирующее задание :

список переменных  := {0, 1} 
  а, б := список 
 

Список будет распакован, и ему будет присвоено значение 0. a и от 1 до b. Более того,

а, б := б, а
 

меняет значения a и b. В языках без параллельного присваивания это пришлось бы писать с использованием временной переменной.

вар  т := а 
  а := б 
  б := т 
 

с a := b; b := a оставляет обоих a и b с исходной стоимостью b.

Некоторые языки, такие как Go , F# и Python , сочетают в себе параллельное присваивание, кортежи и автоматическую распаковку кортежей, чтобы обеспечить возможность возврата нескольких значений из одной функции, как в этом примере Python:

def   f  (): 
     вернуть   1  ,   2 
 a  ,   b   =   f  () 

в то время как другие языки, такие как C# и Rust , показанные здесь, требуют явного построения и деконструкции кортежей с помощью круглых скобок:

// Допустимый синтаксис C# или Rust 
 (  a  ,   b  )   =   (  b  ,   a  ); 

// Возврат кортежа C# 
 (  string  ,   int  )   f  ()   =>   (  "foo"  ,   1  ); 
  вар   (  а  ,   б  )   =   ж  (); 

// Возвращаем кортеж Rust 
 let   f   =   ||    (  «фу»  ,   1  ); 
  пусть   (  a  ,   b  )   =   f  (); 

Это обеспечивает альтернативу использованию выходных параметров для возврата нескольких значений из функции. Это относится к CLU (1974), и CLU помог популяризировать параллельное задание в целом.

C# дополнительно допускает обобщенное назначение деконструкции с реализацией, определяемой выражением в правой части, когда компилятор ищет подходящий экземпляр или расширение . Deconstruct метод для выражения, которое должно иметь выходные параметры для присваиваемых переменных. Например, один из таких методов, который бы придавал классу то же поведение, что и возвращаемое значение f() выше было бы

void   Deconstruct  (  out   string   a  ,   out   int   b  )   {   a   =   "foo"  ;    б   =   1  ;    } 

В C и C++ оператор запятая аналогичен параллельному присваиванию, позволяя выполнять несколько присваиваний в одном операторе. a = 1, b = 2 вместо a, b = 1, 2. В основном это используется в циклах for и заменяется параллельным присваиванием в других языках, таких как Go. Однако приведенный выше код C++ не обеспечивает идеальную одновременность, поскольку правая часть следующего кода a = b, b = a+1оценивается после левой стороны. В таких языках, как Python, a, b = b, a+1 одновременно назначит две переменные, используя начальное значение a для вычисления нового b.

Присваивание

См. Также: Оператор отношения § Путаница с операторами присваивания.

Использование знака равенства =как оператор присваивания часто подвергался критике из-за конфликта с равенством при сравнении на равенство. Это приводит как к путанице у новичков при написании кода, так и к путанице даже у опытных программистов при чтении кода. Использование равенства для присваивания восходит к Хайнца Рутисхаузера языку Superplan , разработанному с 1949 по 1951 год, и было особенно популяризировано Фортраном:

Ярким примером плохой идеи был выбор знака равенства для обозначения присваивания. Это восходит к Фортрану в 1957 году. и был слепо скопирован армиями языковых дизайнеров. Почему это плохая идея? Потому что это опровергает вековую традицию, позволяющую «=» обозначать сравнение на равенство, предикат, который может быть либо истинным, либо ложным. Но в Фортране это означало присвоение, обеспечение равенства. В этом случае операнды находятся в неравных отношениях: левый операнд (переменная) должен быть равен правому операнду (выражению). x = y не означает то же самое, что y = x.

— Никлаус Вирт , «Хорошие идеи в Зазеркалье»

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

В некоторых языках, таких как BASIC , один знак равенства ( "=") используется как для оператора присваивания, так и для оператора отношения равенства, при этом контекст определяет, какой из них имеется в виду. В других языках для этих двух операторов используются разные символы. Например:

• В Алголе и Паскале оператором присваивания является двоеточие и знак равенства ( ":="), в то время как оператор равенства представляет собой одиночное равенство ( "=").
• В C оператор присваивания представляет собой один знак равенства ( "="), а оператор равенства представляет собой пару знаков равенства ( "==").
• В R оператор присваивания в основном <-, как в x <- value, но в определенных контекстах можно использовать один знак равенства.

Сходство двух символов может привести к ошибкам, если программист забудет, в какой форме (" =", " ==", " :=") подходит, или опечатка " =" когда " ==". Это распространенная проблема программирования на таких языках, как C (включая одну известную попытку взлома ядра Linux), где оператор присваивания также возвращает присвоенное значение (так же, как функция возвращает значение) и может быть правильно вложен внутри выражений. Если намерением было сравнить два значения в if например, присваивание вполне вероятно вернет значение, интерпретируемое как логическое значение true, и в этом случае thenбудет выполнено, что приведет к неожиданному поведению программы. Некоторые языковые процессоры (например, gcc ) могут обнаруживать такие ситуации и предупреждать программиста о потенциальной ошибке.

Обозначения

См. также: Сравнение языков программирования (объявления переменных и констант).

Двумя наиболее распространенными представлениями присваивания копирования являются знак равенства ( =) и двоеточие равно ( :=). присваивания Обе формы могут семантически обозначать либо оператор присваивания , либо оператор (который также имеет значение), в зависимости от языка и/или использования.

variable = expression	Fortran , PL/I , C (и его потомки , такие как C++ , Java и т. д.), оболочка Bourne , Python , Go (присвоение предварительно объявленным переменным), R , PowerShell , Nim и т. д.
variable := expression	АЛГОЛ (и производные), Simulate , CPL , BCPL , Pascal (и потомки, такие как Modula ), Mary , PL/M , Ada , Smalltalk , Eiffel , Оберон , Дилан , Seed7 , Python (выражение присваивания), Go (сокращение от объявления и определения переменной), Io , AMPL , ML (присваивание эталонному значению), Автохоткей и т. д.

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

variable << expression	Магия
variable <- expression	Ф# , ОКамл , Р , С
variable <<- expression	р
assign("variable", expression)	р
variable ← expression	АПЛ , Smalltalk , Программирование на языке BASIC
variable =: expression	Дж
LET variable = expression	БАЗОВЫЙ
let variable := expression	XQuery
set variable to expression	AppleScript
set variable = expression	оболочка C
Set-Variable variable (expression)	PowerShell
variable : expression	Максима, Максима , К
variable: expression	Ребол
var variable expression	язык сценариев mIRC
reference-variable :- reference-expression	начало

Математические назначения псевдокодов обычно обозначаются стрелкой влево.

Некоторые платформы помещают выражение слева, а переменную справа:

MOVE expression TO variable	КОБОЛ
expression → variable	ТИ-БЕЙСИК , Касио БЕЙСИК
expression -> variable	ПОП-2 , БЕТА , Р
put expression into variable	LiveCode
PUT expression IN variable	АВС

Некоторые языки, ориентированные на выражения, такие как Lisp. и Tcl единообразно используют префиксный (или постфиксный) синтаксис для всех операторов, включая присваивание.

(setf variable expression)	Общий Лисп
(set! variable expression)	Схема
set variable expression	Ткл
expression variable !	Форт

См. также

• Оператор присваивания (C++)
• Унификация (информатика)
• Неизменяемый объект
• Проблема с назначением