Неизменяемый объект

В объектно-ориентированном (ОО) и функциональном программировании неизменяемый объект (неизменяемый) ^[1] object) — объект которого , состояние нельзя изменить после его создания. ^[2] В этом отличие от изменяемого объекта (изменяемого объекта), который можно изменить после его создания. ^[3]В некоторых случаях объект считается неизменным, даже если изменяются некоторые внутренние атрибуты, но состояние объекта кажется неизменным с внешней точки зрения. Например, объект, который использует мемоизацию для кэширования результатов дорогостоящих вычислений, по-прежнему может считаться неизменяемым объектом.

Строки и другие конкретные объекты обычно выражаются как неизменяемые объекты, чтобы улучшить читаемость и эффективность выполнения объектно-ориентированного программирования. Неизменяемые объекты также полезны, поскольку они по своей сути потокобезопасны . ^[2] Другие преимущества заключаются в том, что их проще понять и обосновать, а также они обеспечивают более высокий уровень безопасности, чем изменяемые объекты. ^[2]

Концепции [ править ]

Неизменяемые переменные [ править ]

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

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

Слабая и сильная неизменность [ править ]

Иногда говорят о неизменяемости определенных полей объекта. Это означает, что невозможно изменить эти части состояния объекта, даже если другие части объекта могут быть изменяемыми ( слабо неизменяемыми ). Если все поля неизменяемы, то объект является неизменяемым. Если весь объект не может быть расширен другим классом, объект называется строго неизменяемым . ^[4]Это может, например, помочь явно обеспечить соблюдение определенных инвариантов в отношении определенных данных в объекте, которые останутся неизменными на протяжении всего времени существования объекта. В некоторых языках это делается с помощью ключевого слова (например, const в С++ , finalв Java ), который обозначает поле как неизменяемое. В некоторых языках все наоборот: в OCaml поля объекта или записи по умолчанию являются неизменяемыми и должны быть явно помечены значком mutable быть таким.

Ссылки на объекты [ править ]

В большинстве объектно-ориентированных языков на объекты можно ссылаться с помощью ссылок . Некоторыми примерами таких языков являются Java , C++ , C# , VB.NET и многие языки сценариев , такие как Perl , Python и Ruby . В этом случае имеет значение, может ли состояние объекта меняться при совместном использовании объектов через ссылки.

Ссылки и копирование объектов [ править ]

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

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

Копирование при записи [ править ]

сочетает в себе преимущества изменяемых и неизменяемых объектов и напрямую поддерживается практически всем современным оборудованием Метод копирования при записи (COW) . При использовании этого метода, когда пользователь просит систему скопировать объект, она вместо этого просто создает новую ссылку, которая по-прежнему указывает на тот же объект. Как только пользователь пытается изменить объект с помощью определенной ссылки, система создает реальную копию, применяет к ней изменения и устанавливает ссылку для ссылки на новую копию. На других пользователей это не влияет, поскольку они по-прежнему ссылаются на исходный объект. Таким образом, в COW все пользователи имеют изменяемую версию своих объектов, хотя в случае, если пользователи не изменяют свои объекты, преимущества неизменяемых объектов в экономии места и скорости сохраняются. Копирование при записи популярно в системах виртуальной памяти, поскольку позволяет им экономить пространство памяти, сохраняя при этом правильную обработку всего, что может делать прикладная программа.

Стажировка [ править ]

Практика постоянного использования ссылок вместо копий одинаковых объектов называется интернированием . Если используется интернирование, два объекта считаются равными тогда и только тогда, когда их ссылки, обычно представленные в виде указателей или целых чисел, равны. Некоторые языки делают это автоматически: например, Python автоматически интернирует короткие строки . Если алгоритм, реализующий интернирование, гарантированно делает это во всех возможных случаях, то сравнение объектов на равенство сводится к сравнению их указателей — существенный выигрыш в скорости в большинстве приложений. (Даже если алгоритм не является всеобъемлющим, все равно существует возможность улучшения случая быстрого пути , когда объекты равны и используют одну и ту же ссылку.) Интернирование обычно полезно только для неизменяемых объектов.

Потокобезопасность [ править ]

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

Нарушение неизменности [ править ]

компьютера, Неизменяемость не означает, что объект, хранящийся в памяти не подлежит записи. Скорее, неизменяемость — это конструкция времени компиляции , которая указывает, что программист может сделать через обычный интерфейс объекта, а не обязательно то, что он может сделать абсолютно (например, обходя систему типов или нарушая корректность const в C или C++ ).

Подробности, специфичные для языка [ править ]

На Python , Java ^[5]^: 80и .NET Framework строки являются неизменяемыми объектами. И в Java, и в .NET Framework есть изменяемые версии строк. На Яве ^[5]^: 84 это StringBuffer и StringBuilder (изменяемые версии Java String), а в .NET это StringBuilder (изменяемая версия .Net String). Python 3 имеет вариант изменяемой строки (байтов) с именем bytearray. ^[6]

Кроме того, все примитивные классы-оболочки в Java являются неизменяемыми.

Похожие шаблоны — Immutable Interface и Immutable Wrapper .

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

Есть [ править ]

В Ada любой объект объявляется либо переменной (т. е. изменяемой; обычно это неявное значение по умолчанию), либо constant (т.е. неизменяемый) через constant ключевое слово.

  введите   Some_type   —   новое   целое число  ;    -- может быть что-нибудь более сложное 
   x  :   constant   Some_type  :=   1  ;    -- неизменяемый 
   y  :   Some_type  ;    -- изменчивый

Параметры подпрограммы неизменяемы в режиме in и изменяемы в режимах in out и out .

  процедура   Do_it  (  a  :  in   Integer  ;   b  :  in   out   Integer  ;   c  :  out   Integer  )   is 
   Begin 
     -- a неизменяема 
     b  :=   b   +   a  ; 
      с  :=   а  ; 
    закончить   Do_it  ;

С# [ править ]

В C# вы можете обеспечить неизменность полей класса с помощью readonly заявление. ^[7]^: 239 Сделав все поля неизменяемыми, вы получите неизменяемый тип.

класс   AnImmutableType 
 { 
     public   readonly   double   _value  ; 
      общественный   AnImmutableType  (  двойной   х  )  
     {  
         _value   =   х  ;  
      } 
     Общественный   AnImmutableType   Square  ()  
     {  
         вернуть   новый   AnImmutableType  (  _value   *   _value  );  
      } 
 }

В C# есть неизменяемые записи. ^[8]^[9]

запись   Person  (  строка   FirstName  ,   строка   LastName  );

С++ [ править ]

В C++ константно-корректная реализация Cart позволит пользователю создавать экземпляры класса, а затем использовать их как const (неизменяемый) или изменяемый, по желанию, предоставляя две разные версии items()метод. (Обратите внимание, что в C++ нет необходимости — и даже невозможно — предоставлять специализированный конструктор для const случаи.)

class   Cart   { 
  public  : 
   Cart  (  std  ::  vector  <Item>  items  <Item>   items  )  :   items_  (  )  )   } 

   std  ::  vector  items  return  &    (   {   ;   items_  {    } 
   const   std  ::  vector  <  Item  >&   items  ()   const   {   return   items_  ;    } 

   int   ComputeTotalCost  ()   const   {   /* возвращаем сумму цен */   } 

  Private  : 
   std  ::  vector  <  Item  >   items_  ; 
  };

Обратите внимание: если существует элемент данных, который является указателем или ссылкой на другой объект, то изменить объект, на который указывает или на который ссылается ссылка, можно только в рамках неконстантного метода.

C++ также обеспечивает абстрактную (в отличие от побитовой) неизменяемость посредством mutable ключевое слово, которое позволяет изменять переменную-член изнутри const метод.

class   Cart   { 
  public  : 
   Cart  (  std  ::  vector  <Item>  items  )   items  ::  :   items_  (  )  {   } 

   const   std  vector  Item  <  items  >&   (  )   const   {   return   items_  ;    } 

   int   ComputeTotalCost  ()   const   { 
     if   (  tal_cost_  )   { 
       return   *  total_cost_  ; 
      } 

     Int   total_cost   =   0  ; 
      for   (  const   auto  &   item   :   items_  )   { 
       tal_cost   +=   item  .   Расходы  (); 
      } 
     total_cost_   =   total_cost  ; 
      вернуть   общую_стоимость  ; 
    } 

  Private  : 
   std  ::  vector  <Item>  items_    ;  
    изменяемый   std  ::  необязательный  <int>   total_cost_    ; 
  };

Д [ править ]

В D существуют два квалификатора типа : const и immutable, для переменных, которые нельзя изменить. ^[10] В отличие от C++ const, Ява finalи C# readonly, они транзитивны и рекурсивно применяются ко всему, что достижимо через ссылки на такую переменную. Разница между const и immutable это то, к чему они применяются: constявляется свойством переменной: на указанное значение могут существовать изменяемые ссылки, т. е. значение может фактически измениться. В отличие, immutableявляется свойством указанного значения: значение и все, что транзитивно достижимо из него, не может измениться (без нарушения системы типов, что приводит к неопределенному поведению ). Любая ссылка на это значение должна быть отмечена const или immutable. В основном для любого неквалифицированного типа T, const(T) представляет собой непересекающееся объединение T (изменяемый) и immutable(T).

класс   C   { 
   /*mutable*/   Object   mField  ; 
      константный       объект   cField  ; 
      неизменяемый   объект   iField  ; 
  }

Для изменяемого C объект, его mFieldможно написать. Для const(C) объект, mField не может быть изменен, он наследует const; iFieldпо-прежнему неизменен, поскольку это более сильная гарантия. Для immutable(C), все поля неизменяемы.

В такой функции:

void   func  (  C   m  ,   const   C   c  ,   неизменяемый   C   i  ) 
 {   /* внутри фигурных скобок */   }

Внутри брекетов, c может относиться к тому же объекту, что и m, поэтому мутации в m может косвенно изменить cтакже. Также, c может относиться к тому же объекту, что и i, но поскольку значение тогда является неизменным, изменений не происходит. Однако, m и i не могут по закону относиться к одному и тому же объекту.

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

Ценности, которые const или immutable должен быть инициализирован прямым присвоением в точке объявления или конструктором .

Потому что const параметры забывают, было ли значение изменяемым или нет, аналогичная конструкция, inout, действует, в некотором смысле, как переменная для информации об изменчивости. Функция типа const(S) function(const(T)) возвращает const(S)типизированные значения для изменяемых, константных и неизменяемых аргументов. Напротив, функция типа inout(S) function(inout(T)) возвращает S для изменяемого T аргументы, const(S) для const(T) ценности и immutable(S) для immutable(T) ценности.

Приведение неизменяемых значений к изменяемым приводит к неопределенному поведению при изменении, даже если исходное значение происходит из изменяемого источника. Приведение изменяемых значений к неизменяемым может быть законным, если после этого не останется изменяемых ссылок. «Выражение может быть преобразовано из изменяемого (...) в неизменяемое, если выражение уникально и все выражения, на которые оно транзитивно ссылается, либо уникальны, либо неизменяемы». ^[10] Если компилятор не может доказать уникальность, приведение можно выполнить явно, и программист должен гарантировать отсутствие изменяемых ссылок.

Тип string это псевдоним для immutable(char)[], т.е. типизированный фрагмент памяти неизменяемых символов. ^[11]Создание подстрок обходится дешево, поскольку просто копирует и изменяет указатель и поле длины, и безопасно, поскольку базовые данные не могут быть изменены. Объекты типа const(char)[] может относиться к строкам, а также к изменяемым буферам.

Создание поверхностной копии константного или неизменяемого значения удаляет внешний слой неизменяемости: копирование неизменяемой строки ( immutable(char[])) возвращает строку ( immutable(char)[]). Неизменяемый указатель и длина копируются, а копии являются изменяемыми. Указанные данные не были скопированы и сохраняют свой квалификатор, в примере immutable. Его можно удалить, создав глубокую копию, например, с помощью dup функция.

Ява [ править ]

Классическим примером неизменяемого объекта является экземпляр класса Java. String сорт

Строка   s   =   "ABC"  ; 
  с  .   в нижний регистр  ();    // Это ничего не дает!

Метод toLowerCase() не меняет данные «ABC», которые sсодержит. Вместо этого создается экземпляр нового объекта String, которому во время создания присваиваются данные «abc». Ссылка на этот объект String возвращается методом toLowerCase()метод. Чтобы сделать строку s содержат данные «abc», необходим другой подход:

с   =   с  .   в нижний регистр  ();

Теперь строка sссылается на новый объект String, содержащий «abc». нет ничего, В синтаксисе объявления класса String что делало бы его неизменяемым; скорее, ни один из методов класса String никогда не влияет на данные, содержащиеся в объекте String, что делает его неизменяемым.

Ключевое слово final ( подробная статья ) используется при реализации неизменяемых примитивных типов и ссылок на объекты, ^[12]но он не может сам по себе сделать сами объекты неизменными. См. примеры ниже:

Переменные примитивного типа ( int, long, shortи т. д.) можно переназначить после определения. Этого можно избежать, используя final.

интервал   я   =   42  ;    //int — примитивный тип 
 i   =   43  ;    // ОК, 

 финал   int   j   =   42  ; 
  j   =   43  ;    // не компилируется.   j является окончательным, поэтому его нельзя переназначить

Ссылочные типы нельзя сделать неизменяемыми, просто используя final ключевое слово. final только предотвращает переназначение.

окончательный   MyObject   м   =   новый   MyObject  ();    //m имеет ссылочный тип 
 m  .   данные   =   100  ;    // ХОРОШО.   Мы можем изменить состояние объекта m (m изменчив, и Final не меняет этого факта) 
 m   =   new   MyObject  ();    // не компилируется.   m является окончательным, поэтому его нельзя переназначить

Примитивные обертки ( Integer, Long, Short, Double, Float, Character, Byte, Boolean) также все неизменяемы. Неизменяемые классы можно реализовать, следуя нескольким простым рекомендациям. ^[13]

JavaScript [ править ]

В JavaScript все примитивные типы (Undefine, Null, Boolean, Number, BigInt, String, Symbol) являются неизменяемыми, но пользовательские объекты обычно изменяемы.

function   doSomething  (  x  )   {   /* изменение x здесь меняет оригинал?   */   }; 
  вар   стр   =   'строка'  ; 
  вар   объект   =   {   ан  :   'объект'   }; 
  сделать что-нибудь  (  ул  );            // строки, числа и типы bool неизменяемы, функция получает копию 
 doSomething  (  obj  );            // объекты передаются по ссылке и изменяются внутри функции 
 doAnotherThing  (  str  ,   obj  );    // `str` не изменился, но `obj` может измениться.

Чтобы имитировать неизменность объекта, можно определить свойства как доступные только для чтения (доступные для записи: false).

вар   объект   =   {}; 
  Объект  .   defineProperty  (  obj  ,   'foo'  ,   {   значение  :   'bar'  ,   доступно для записи  :   false   }); 
  объект  .   Фу   =   'бар2'  ;    // молча игнорируется

Однако описанный выше подход по-прежнему позволяет добавлять новые свойства. В качестве альтернативы можно использовать Object.freeze , чтобы сделать существующие объекты неизменяемыми.

вар   obj   =   {   foo  :   'bar'   }; 
  Объект  .   заморозить  (  объект  ); 
  объект  .   Фу   =   'бары'  ;    // не могу редактировать свойство, молча игнорирую 
 obj  .   foo2   =   'бар2'  ;    // невозможно добавить свойство, молча игнорируется

Благодаря реализации ECMA262 JavaScript получил возможность создавать неизменяемые ссылки, которые нельзя переназначить. Однако, используя const Объявление не означает, что значение ссылки только для чтения является неизменяемым, просто имя не может быть присвоено новому значению.

const   ALWAYS_IMMUTABLE   =   правда  ; 

  попробуйте   { 
   ALWAYS_IMMUTABLE   =   ложь  ; 
  }   поймать   (  ошибка  )   { 
   console  .   log  (  "Невозможно переназначить неизменяемую ссылку."  ); 
  } 

 const   arr   =   [  1  ,   2  ,   3  ]; 
  обр  .   нажать  (  4  ); 
  консоль  .   журнал  (  обр  );    // [1, 2, 3, 4]

Использование неизменяемого состояния стало растущей тенденцией в JavaScript с момента появления React , который отдает предпочтение шаблонам управления состоянием, подобным Flux, таким как Redux . ^[14]

Перл [ править ]

В Perl можно создать неизменяемый класс с помощью библиотеки Moo, просто объявив все атрибуты только для чтения:

пакет   Неизменяемый  ; 
  используйте   Му  ; 

  имеет   значение   =>   ( 
     is        =>   'ro'  ,     # только для чтения 
     по умолчанию   =>   'data'  ,   # можно переопределить, предоставив конструктору 
                        # значение: Immutable->new(value => 'something else'); 
 ) ; 

  1  ;

Раньше для создания неизменяемого класса требовалось два шага: во-первых, создание средств доступа (автоматически или вручную), которые предотвращают изменение атрибутов объекта, и, во-вторых, предотвращение прямого изменения данных экземпляра экземпляров этого класса (обычно это хранилось в хэше). ссылку и может быть заблокирован с помощью функции lock_hash Hash::Util):

пакет   Неизменяемый  ; 
  используйте   строгий  ; 
  использовать   предупреждения  ; 
  используйте   базу   qw(Class::Accessor)  ; 
  # создаем средства доступа только для чтения 
 __PACKAGE__  ->  mk_ro_accessors  (  qw(value)  ); 
  используйте   Hash::Util   'lock_hash'  ; 

  суб   новый   { 
     мой   $класс   =   сдвиг  ; 
      вернуть   $class   , если   ref  (  $class  ); 
      die   "Аргументами new должны быть пары ключ => значение\n" 
         if   (  @_   %   2   ==   0  ); 
      мои   %defaults   =   ( 
         значение   =>   'данные'  , 
     ); 
      мой   $obj   =   { 
         %defaults  , 
         @_  , 
     }; 
      благослови   $obj  ,   $class  ; 
      # предотвращаем изменение данных объекта 
     lock_hash   %$obj  ; 
  } 
 1  ;

Или с помощью написанного вручную аксессора:

пакет   Неизменяемый  ; 
  используйте   строгий  ; 
  использовать   предупреждения  ; 
  используйте   Hash::Util   'lock_hash'  ; 

  суб   новый   { 
     мой   $класс   =   сдвиг  ; 
      вернуть   $class   , если   ref  (  $class  ); 
      die   "Аргументами new должны быть пары ключ => значение\n" 
         if   (  @_   %   2   ==   0  ); 
      мои   %defaults   =   ( 
         значение   =>   'данные'  , 
     ); 
      мой   $obj   =   { 
         %defaults  , 
         @_  , 
     }; 
      благослови   $obj  ,   $class  ; 
      # предотвращаем изменение данных объекта 
     lock_hash   %$obj  ; 
  } 

 доступа только для чтения 
 # подзначение   средства   { 
     my   $self   =   сдвиг  ; 
      if   (  my   $new_value   =   shift  )   { 
         # попытка установить новое значение 
         die   "Этот объект не может быть изменен\n"  ; 
      }   else   { 
         return   $self  ->  {  значение  } 
     } 
 } 
 1  ;

Питон [ править ]

В Python некоторые встроенные типы (числа, логические значения, строки, кортежи, замороженные наборы) являются неизменяемыми, но пользовательские классы, как правило, изменяемы. Чтобы имитировать неизменяемость в классе, можно переопределить установку и удаление атрибута, чтобы вызвать исключения:

class   ImmutablePoint  : 
     """Неизменяемый класс с двумя атрибутами 'x' и 'y'.""" 

     __slots__   =   [  'x'  ,   'y'  ] 

     def   __setattr__  (  self  ,   *  args  ): 
         поднять   TypeError  (  "Невозможно изменить неизменяемый экземпляр."  ) 

     __delattr__   =   __setattr__ 

     def   __init__  (  self  ,   x  ,   y  ): 
         # Мы больше не можем использовать self.value = value для хранения данных экземпляра 
         # поэтому мы должны явно вызвать суперкласс 
         super  ()  .   __setattr__  (  'x'  ,   x  ) 
         супер  ()  .   __setattr__  (  'y'  ,   y  )

Помощники стандартной библиотеки collections.namedtuple и typing.NamedTuple, доступный начиная с Python 3.6, позволяет создавать простые неизменяемые классы. Следующий пример примерно эквивалентен приведенному выше, плюс некоторые функции, подобные кортежу:

от   ввода   import   NamedTuple 
 import   Collections 

 Point   =   Collections  .   именованный кортеж  (  'Point'  ,   [  'x'  ,   'y'  ]) 

 # следующий пример создает аналогичный именованный кортеж для приведенного выше 
 класса   Point  (  NamedTuple  ): 
     x  :   int 
     y  :   int

Представлено в Python 3.7, dataclassesпозволяют разработчикам эмулировать неизменяемость с помощью замороженных экземпляров . Если создается замороженный класс данных, dataclasses переопределит __setattr__() и __delattr__() поднимать FrozenInstanceError если его вызвать.

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

 @dataclass  (  замороженный  =  True  ) 
 класс   Точка  : 
     x  :   int 
     y  :   int

Ракетка [ править ]

Racket существенно отличается от других реализаций Scheme , делая тип своей базовой пары («минус-ячейки») неизменяемым. Вместо этого он предоставляет тип параллельной изменяемой пары через mcons, mcar, set-mcar!и т. д. Кроме того, поддерживаются многие неизменяемые типы, например неизменяемые строки и векторы, и они широко используются. Новые структуры по умолчанию являются неизменяемыми, если только поле специально не объявлено изменяемым или вся структура:

(  структура   foo1   (  x   y  ))               ;   все поля неизменяемы 
 (  struct   foo2   (  x   [  y   #:mutable  ]))   ;   одно изменяемое поле 
 (  struct   foo3   (  x   y  )   #:mutable  )     ;   все поля изменяемы

Язык также поддерживает функционально реализованные неизменяемые хеш-таблицы и неизменяемые словари.

Ржавчина [ править ]

Rust Система владения позволяет разработчикам объявлять неизменяемые переменные и передавать неизменяемые ссылки. По умолчанию все переменные и ссылки являются неизменяемыми. Изменяемые переменные и ссылки создаются явно с помощью mut ключевое слово.

Постоянные элементы в Rust всегда неизменяемы.

// константные элементы всегда неизменяемы 
 const   ALWAYS_IMMUTABLE  :  bool   =   true  ; 

  struct   Object   { 
     x  :  usize  , 
     y  :  usize  , 
 } 

 fn   main  ()   { 
     // явно объявляем изменяемую переменную 
     let   mut   mutable_obj   =   Object   {   x  :  1  ,   y  :  2   }; 
      mutable_obj  .   х   =   3  ;    // окей, 

     let   mutable_ref   =   &  mut   mutable_obj  ; 
      mutable_ref  .   х   =   1  ;    // окей, 

     пусть   immutable_ref   =   &  mutable_obj  ; 
      immutable_ref  .   х   =   3  ;    // ошибка E0594 

     // по умолчанию переменные неизменяемы 
     let   immutable_obj   =   Object   {   x  :  4  ,   y  :  5   }; 
      immutable_obj  .   х   =   6  ;    // ошибка E0596 

     let   mutable_ref2   =  
         &  mut   immutable_obj  ;    // ошибка E0596 

     let   immutable_ref2   =   &  immutable_obj  ; 
      immutable_ref2  .   х   =   6  ;    // ошибка E0594 
    
 }

Скала [ править ]

В Scala любую сущность (в узком смысле, привязку) можно определить как изменяемую или неизменяемую: в объявлении можно использовать val (значение) для неизменяемых сущностей и var(переменная) для изменяемых. Обратите внимание: даже если неизменяемую привязку нельзя переназначить, она все равно может ссылаться на изменяемый объект, и для этого объекта по-прежнему можно вызывать изменяющие методы: привязка является неизменяемой, но базовый объект может быть изменяемым.

Например, следующий фрагмент кода:

val   maxValue   =   100 
 вар   currentValue   =   1

определяет неизменяемую сущность maxValue (целочисленный тип определяется во время компиляции) и изменяемый объект с именем currentValue.

По умолчанию классы коллекций, такие как List и Mapявляются неизменяемыми, поэтому методы обновления возвращают новый экземпляр, а не изменяют существующий. Хотя это может показаться неэффективным, реализация этих классов и их гарантии неизменяемости означают, что новый экземпляр может повторно использовать существующие узлы, что, особенно в случае создания копий, очень эффективно. ^[15]^{[ нужен лучший источник ]}

См. также [ править ]

Ссылки [ править ]

Эта статья содержит некоторые материалы из Книги шаблонов проектирования Perl.

^ «неизменяемое прилагательное — определение, изображения, произношение и примечания по использованию — Оксфордский словарь для продвинутых учащихся на сайте OxfordLearnersDictionaries.com» . www.oxfordlearnersdictionaries.com .
^ Перейти обратно: ^а ^б ^с Гетц и др. Параллелизм Java на практике . Addison Wesley Professional, 2006, раздел 3.4. Неизменяемость
^ «6.005 — Создание программного обеспечения» .
^ Дэвид О'Мира (апрель 2003 г.). «Изменяемые и неизменяемые объекты: убедитесь, что методы не могут быть переопределены» . Яванское ранчо . Проверено 14 мая 2012 г. Предпочтительный способ — сделать класс финальным. Иногда это называют «сильной неизменностью». Это не позволяет кому-либо расширить ваш класс и случайно или намеренно сделать его изменяемым.
^ Перейти обратно: ^а ^б Блох, Джошуа (2018). «Эффективная Java: Руководство по языку программирования» (третье изд.). Аддисон-Уэсли. ISBN 978-0134685991 .
^ «Встроенные функции — документация Python v3.0» . docs.python.org .
^ Скит, Джон (23 марта 2019 г.). C# в глубине . Мэннинг. ISBN 978-1617294532 .
^ «Использование типов записей — учебник C# — C#» . Learn.microsoft.com . 14 ноября 2023 г. Проверено 23 февраля 2024 г.
^ «Записи — Справочник по C# — C#» . Learn.microsoft.com . 25 мая 2023 г. Проверено 23 февраля 2024 г.
^ Перейти обратно: ^а ^б D Спецификация языка § 18
^ D Спецификация языка § 12.16 (Термины массив и срез используются как взаимозаменяемые.)
^ «Как создать неизменяемый класс и объект в Java – пример учебника» . Javarevisited.blogspot.co.uk. 04.03.2013 . Проверено 14 апреля 2014 г.
^ «Неизменяемые объекты» . javapractices.com . Проверено 15 ноября 2012 г.
^ «Неизменяемость в JavaScript: противоположный взгляд» . Десалас работает .
^ «API коллекций Scala 2.8 — конкретные неизменяемые классы коллекций» . Scala-lang.org . Проверено 14 апреля 2014 г.

Внешние ссылки [ править ]

Неизменяемые объекты в C# за 3 простых шага.
Статья Теория и практика Java: Мутировать или не мутировать? Брайан Гетц из IBM DeveloperWorks – копия сохранена в Интернет-архиве Брайан Гетц из IBM DeveloperWorks – сохраненная копия в Интернет-архиве
Неизменяемые объекты с JavaPractices.com
Неизменяемые объекты из репозитория шаблонов Портленда
Immutable.js от Facebook
Неизменяемые структуры в C#. Архивировано 21 декабря 2017 г. в проекте с открытым исходным кодом Wayback Machine в Codeplex.
Неизменяемые коллекции в официальной библиотеке .NET от Microsoft
Неизменяемые объекты в C# от Tutlane.com

[1] «неизменяемое прилагательное — определение, изображения, произношение и примечания по использованию — Оксфордский словарь для продвинутых учащихся на сайте OxfordLearnersDictionaries.com» . www.oxfordlearnersdictionaries.com .

[Goetz-2] Перейти обратно: ^а ^б ^с Гетц и др. Параллелизм Java на практике . Addison Wesley Professional, 2006, раздел 3.4. Неизменяемость

[3] «6.005 — Создание программного обеспечения» .

[4] Дэвид О'Мира (апрель 2003 г.). «Изменяемые и неизменяемые объекты: убедитесь, что методы не могут быть переопределены» . Яванское ранчо . Проверено 14 мая 2012 г. Предпочтительный способ — сделать класс финальным. Иногда это называют «сильной неизменностью». Это не позволяет кому-либо расширить ваш класс и случайно или намеренно сделать его изменяемым.

[Bloch-5] Перейти обратно: ^а ^б Блох, Джошуа (2018). «Эффективная Java: Руководство по языку программирования» (третье изд.). Аддисон-Уэсли. ISBN 978-0134685991 .

[6] «Встроенные функции — документация Python v3.0» . docs.python.org .

[Skeet-7] Скит, Джон (23 марта 2019 г.). C# в глубине . Мэннинг. ISBN 978-1617294532 .

[8] «Использование типов записей — учебник C# — C#» . Learn.microsoft.com . 14 ноября 2023 г. Проверено 23 февраля 2024 г.

[9] «Записи — Справочник по C# — C#» . Learn.microsoft.com . 25 мая 2023 г. Проверено 23 февраля 2024 г.

[d_spec_const-10] Перейти обратно: ^а ^б D Спецификация языка § 18

[11] D Спецификация языка § 12.16 (Термины массив и срез используются как взаимозаменяемые.)

[12] «Как создать неизменяемый класс и объект в Java – пример учебника» . Javarevisited.blogspot.co.uk. 04.03.2013 . Проверено 14 апреля 2014 г.

[13] «Неизменяемые объекты» . javapractices.com . Проверено 15 ноября 2012 г.

[14] «Неизменяемость в JavaScript: противоположный взгляд» . Десалас работает .

[15] «API коллекций Scala 2.8 — конкретные неизменяемые классы коллекций» . Scala-lang.org . Проверено 14 апреля 2014 г.

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]