Зиг (язык программирования)

Зиг

Парадигмы	Мультипарадигма : императивная , параллельная , процедурная , функциональная.
Разработано	Эндрю Келли
Впервые появился	8 февраля 2016 г ( 08.02.2016 )
Предварительный выпуск	0.13.0  / 6 июня 2024 г ( 6 июня 2024 г. )
Дисциплина набора текста	Статический , сильный , предполагаемый , структурный , общий.
Управление памятью	Руководство
Платформа	x86-64 , ARM64 , Веб-сборка Уровень 2: ARM , IA-32 , RISC-V , MIPS64 , POWERPC64 , SPARC64 , некоторые платформы уровня 2 имеют поддержку уровня 1 для автономных программ.
ТЫ	Кроссплатформенность : Linux , FreeBSD , Windows.
Лицензия	С
Расширения имен файлов	.зиг, .зир
Веб-сайт	зигланг .org
Под влиянием
C , C++ , LLVM IR , Go , Rust , JavaScript

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

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

Еще один набор дополнений к Zig призван повысить безопасность кода. Как и C, Zig не включает сборку мусора , а обработка памяти осуществляется вручную. Чтобы устранить потенциальные ошибки, возникающие в таких системах, он включает типы опций и простой синтаксис для их использования. среда тестирования В язык также встроена .

Описание

Цели

Основная цель Zig — стать лучшим решением тех задач, которые в настоящее время решаются с помощью C. Основная проблема в этом отношении — читаемость; Зиг пытается использовать существующие концепции и синтаксис везде, где это возможно, избегая добавления другого синтаксиса для аналогичных концепций. Кроме того, он спроектирован с учетом «надежности, оптимальности и ремонтопригодности», включая множество функций для повышения безопасности, оптимизации и тестирования. Небольшой и простой синтаксис — важная часть сопровождения, поскольку цель языка — дать возможность сопровождающим отлаживать код без необходимости изучать тонкости языка, с которым они, возможно, не знакомы. Даже с этими изменениями Zig может компилироваться в существующий код C и против него; Заголовки C могут быть включены в проект Zig и вызывать их функции, а код Zig можно связать с проектами C, включая заголовки, созданные компилятором.

В соответствии с общей философией проектирования, направленной на то, чтобы сделать код простым и легким для чтения, система Zig в целом также включает в себя ряд стилистических изменений по сравнению с C и другими C-подобными языками. Например, в языке Rust есть перегрузка операторов , что означает оператор типа a = b + cна самом деле может быть вызовом функции перегруженной версии оператора плюс. Кроме того, эта функция может вызвать панику, что может привести к вытеснению любого последующего кода. В Zig, если что-то вызывает функцию, это выглядит как вызов функции, если нет, то это не похоже на функцию. Если возникает ошибка, это явно указано в синтаксисе: обработка ошибок осуществляется через типы ошибок и может обрабатываться с помощью catch или try.

Цели Zig отличаются от целей многих других языков, разработанных в тот же период времени, таких как Go , Rust , Carbon и Nim . Как правило, эти языки более сложны и содержат дополнительные функции, такие как перегрузка операторов , функции, маскирующиеся под значения (свойства), и многие другие функции, предназначенные для помощи в создании больших программ. Подобные возможности имеют больше общего с подходом C++, и эти языки больше соответствуют этому языку. Zig имеет более консервативное расширение системы типов, поддерживающее дженерики во время компиляции и допускающее форму утиной типизации с помощью comptime директива.

Работа с памятью

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

Распространенным решением этих проблем является сборщик мусора (GC), который проверяет программу на наличие указателей на ранее выделенную память и удаляет все блоки, на которые больше ничего не указывает. Хотя это значительно уменьшает или даже устраняет ошибки памяти, системы GC относительно медленны по сравнению с ручным управлением памятью и имеют непредсказуемую производительность, что делает их непригодными для системного программирования . Другим решением является автоматический подсчет ссылок (ARC), который реализует ту же базовую концепцию поиска указателей на удаленную память, но делает это во время malloc, записывая количество указателей на этот блок, что означает, что нет необходимости выполнять исчерпывающий поиск. , но вместо этого добавляет время к каждой операции malloc и Release.

Zig стремится обеспечить производительность, аналогичную или лучшую, чем C, поэтому GC и ARC не являются подходящими решениями. Вместо этого он использует современную версию по состоянию на 2022 год. , концепция, известная как типы опционов . Вместо того, чтобы указатель мог указывать на ничего или на ноль, используется отдельный тип для обозначения данных, которые могут быть пустыми. Это похоже на использование структуры с указателем и логическим значением, которое указывает, действителен ли указатель, но состояние логического значения невидимо управляется языком и не требует явного управления программистом. Так, например, когда указатель объявлен, ему присваивается значение «нераспределенный», а когда этот указатель получает значение от malloc, ему присваивается значение «выделенный», если malloc завершился успешно.

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

Еще одно изменение в управлении памятью в Zig заключается в том, что фактическое выделение осуществляется через structописывает действие, а не вызов функций управления памятью в libc . Например, если вы хотите написать в C функцию, которая создает строку, содержащую несколько копий другой строки, эта функция может выглядеть так:

const   char  *   повтор  (  const   char  *   original  ,   size_t   times  ); 

В коде функция будет проверять размер original а затем маллок timesэту длину, чтобы выделить память для строки, которую она создаст. Этот malloc невидим для вызывающих его функций; если им позже не удастся освободить память, произойдет утечка. В Zig это можно сделать с помощью такой функции:

fn   повтор  (  распределитель  :   *  std  .  mem  .  Распределитель  ,   оригинал  :   []  const   u8  ,   times  :   useize  )   std  .   мем  .   Распределитель  .   Ошибка  !   []  константа   u8  ; 

В этом коде allocator переменной передается структура, описывающая, какой код должен выполнить выделение, а repeat функция возвращает либо результирующую строку, либо, используя необязательный тип, указанный в !, Распределитель.Ошибка. Непосредственно выражая распределитель как входные данные, выделение памяти никогда не «скрывается» внутри другой функции, оно всегда предоставляется API функцией, которая в конечном итоге вызывает выделение памяти. Zig никакие выделения не выполняются Внутри стандартной библиотеки . Далее, поскольку структура может указывать на что угодно, можно использовать альтернативные распределители, даже написанные в программе. Это может позволить, например, использовать распределители небольших объектов, которые не используют функции операционной системы , которые обычно выделяют целую страницу памяти .

Необязательные типы — это пример языковой функции, которая предлагает общую функциональность, оставаясь при этом простой и универсальной. Их не обязательно использовать для решения проблем с нулевым указателем, они также полезны для любого типа значения, где подходящим ответом является «нет значения». Рассмотрим функцию countTheNumberOfUsers который возвращает целое число и целочисленную переменную, theCountedUsersкоторый сохраняет результат. Во многих языках магическое число помещается в theCountedUsers чтобы указать, что countTheNumberOfUsersеще не вызывался, хотя во многих реализациях ему просто присваивалось нулевое значение. В Zig это можно реализовать как var theCountedUsers: ?i32 = null который устанавливает для переменной четкое значение «не вызывалось».

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

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

Прямое взаимодействие с C

Zig продвигает эволюционный подход к использованию языка, который объединяет новый код Zig с существующим кодом C. Для этого он стремится сделать взаимодействие с существующими библиотеками C максимально простым. Zig импортирует свои собственные библиотеки с помощью @import директива, обычно следующим образом:

const   std   =   @import  (  "std"  ); 

Зиг-код в этом файле теперь может вызывать функции внутри std, например:

стандарт  .   отладка  .   print  (  "Привет, мир!  \n  "  ,   .{}); 

Для работы с кодом C достаточно просто заменить @import с @cImport:

const   c   =   @cImport  (  @cInclude  (  "soundio/soundio.h"  )); 

Код Zig теперь может вызывать функции в библиотеке soundio, как если бы они были собственным кодом Zig. Поскольку Zig использует новые типы данных, которые явно определены, в отличие от более общих типов C. int и floatдля перемещения данных между типами C и Zig используется небольшое количество директив, в том числе @intCast и @ptrCast.

Кросс-компиляция

Зиг рассматривает кросс-компиляцию как первоклассный вариант использования языка. Это означает, что любой Zig-компилятор может компилировать работоспособные двоичные файлы для любой из своих целевых платформ, а их десятки. К ним относятся не только широко используемые современные системы, такие как ARM и x86-64 , но также PowerPC , SPARC , MIPS , RISC-V и даже IBM z/Architectures (S390). Инструментарий может скомпилироваться для любой из этих целей без установки дополнительного программного обеспечения. Вся необходимая поддержка находится в базовой системе.

Комптайм

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

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

Например, в Zig общий тип связанного списка может быть реализован с помощью такой функции:

fn   LinkedList  (  comptime   T  :   type  )   type  ; 

Эта функция принимает некоторый тип Tи возвращает пользовательский struct определение связанного списка с этим типом данных.

Происхождение названия

Сообщается, что имя «Зиг» было выбрано в результате процесса, включающего сценарий Python , который случайным образом комбинировал буквы, начиная с буквы «Z» и сопровождаемой гласной или «Y», для создания четырехбуквенных слов. Несмотря на запланированную длину, трехбуквенное слово «Зиг» в конечном итоге было выбрано из различных комбинаций, созданных сценарием.

Другие особенности

Zig поддерживает времени компиляции дженерики , отражение и оценку, кросс-компиляцию и ручное управление памятью . Основная цель языка — улучшить C. язык а также черпая вдохновение из Rust , среди других. Zig имеет множество функций для низкоуровневого программирования , в частности упакованные структуры (структуры без заполнения между полями), целые числа произвольной ширины. и несколько типов указателей.

Zig — это не просто новый язык: он также включает в себя компилятор C/C++ и может использоваться с одним или обоими языками.

Версии

Начиная с версии 0.10 компилятор Zig (новый по умолчанию) написан на языке программирования Zig, т. е. это самостоятельный компилятор , и это основная новая функция этой версии. Старый устаревший компилятор начальной загрузки , написанный на C++, по-прежнему доступен, но его не будет в версии 0.11. При компиляции с помощью нового компилятора Zig используется гораздо меньше памяти и компиляция происходит немного быстрее. Более старый, теперь уже устаревший компилятор на основе C++ использует в 3,5 раза больше памяти.

Серверной частью Zig по умолчанию для оптимизации по-прежнему является LLVM . а LLVM написан на C++. Компилятор Zig с LLVM занимает 169 МБ, а без LLVM — 4,4 МБ. Более быстрый исполняемый код обычно компилируется с помощью нового компилятора на основе Zig-lang, его генерация кода LLVM лучше и исправлено множество ошибок, но в версии 0.10 также есть улучшения для старого устаревшего компилятора. Автономный компоновщик тесно связан с автономным компилятором. В новой версии также добавлена ​​некоторая экспериментальная (уровень 3) поддержка графических процессоров AMD (есть также незначительная поддержка графических процессоров Nvidia и PlayStation 4 и 5).

Старый компилятор начальной загрузки («stage1») написан на Zig и C++ с использованием LLVM 13 в качестве серверной части. поддерживая многие из своих местных целей. Компилятор является бесплатным программным обеспечением с открытым исходным кодом, выпущенным под лицензией MIT . Компилятор Zig предоставляет возможность компилировать C и C++ аналогично Clang с помощью команд zig cc и zig c++, предоставление множества заголовков, включая стандартную библиотеку C (libc) и стандартную библиотеку C++ (libcxx) для множества различных платформ, что позволяет Zig cc и c++ подкоманды, которые действуют как кросс-компилятор . по умолчанию

Плюс официально поддерживаемые (и документированные) операционные системы (в основном настольные), (минимальные) приложения могут и были созданы для Android (с помощью Android NDK ), а также возможно программирование для iOS .

До версии 0.11.0 у Zig не было менеджера пакетов , но в 0.11.0 была выпущена экспериментальная версия, которая была расширена в версии 0.12.0. нет Официального репозитория пакетов ; вместо этого пакет — это просто URL-адрес, указывающий на сжатый файл , который в несжатом виде включает стандартный файл build.zig (который компилятор Zig по соглашению использует для компиляции исходного кода) и, в идеале, файл build.zig.zon, который используется для определения имени и версии пакета.

Разработка Zig финансируется Zig Software Foundation (ZSF), некоммерческой корпорацией под руководством Эндрю Келли, которая принимает пожертвования и нанимает несколько штатных сотрудников.

Примеры

Привет, мир

const   std   =   @import  (  "std"  ); 

  паб   fn   main  ()   !   пустота   { 
     const   stdout   =   std  .   ио  .   getStdOut  ().   писатель  (); 
      попробуйте   стандартный вывод  .   print  (  "Привет, {s}!  \n  "  ,   .{  "мир"  }); 
  } 

Общий связанный список

const   std   =   @import  (  "std"  ); 
  константный   стандартный вывод   =   стандартный  .   ио  .   getStdOut  ().   писатель  (); 

  fn   LinkedList  (  comptime   T  :   type  )   type   { 
     return   struct   { 
         const   Self   =   @This  (); 
          pub   const   Node   =   struct   { 
             next  :   ?*  Node   =   null  , 
             data  :   T  , 
         }; 

          первый  :   ?*  Node   =   null  , 

         pub   fn   prepend  ( 
             list  :   *  Self  , 
             new_node  :   *  Node  , 
         )   void   { 
             new_node  .   следующий   =   список  .   первый  ; 
              список  .   первый   =   новый_узел  ; 
          } 
         pub   fn   Формат  ( 
             список  :   Self  , 
             comptime   fmt  :   []  const   u8  , 
             параметры  :   std  .  fmt  .  FormatOptions  , 
             out_stream  :   Anytype  , 
         )   !   void   { 
             попробуйте   out_stream  .   writeAll  (  (  ) 
             var   it   =   list.first  ,  fmt  ; 
             while   (  it  )   |  node  |   :   (  it   =   node.next  )  ,  )   { 
                 try   std.fmt.formatType  (  1  ,  ;  " 
                     node.data  , ​ ​ 
                    ​  , 
                     options  out_stream 
                    ​ ​ 
                    ​ ​ 
                 " ; 
                 попробуйте   out_stream.writeAll  out_stream.writeAll  "  (  "  } 
             попробуйте 
            ​   )  (  "  ;  "  ) 
          } 
     }; 
  } 

 паб   fn   main  ()   !   void   { 
     const   ListU32   =   LinkedList  (  u32  ); 
     вар    список   =   ListU32  {}; 
      вар   узел1   =   ListU32  .   Узел  {   .   данные   =   1   }; 
      вар   узел2   =   ListU32  .   Узел  {   .   данные   =   2   }; 
      вар   node3   =   ListU32  .   Узел  {   .   данные   =   3   }; 
      список  .   добавить  (  &  node1  ); 
      список  .   добавить  (  &  node2  ); 
      список  .   добавить  (  &  node3  ); 
      попробуйте   стандартный вывод  .   print  (  "{}  \n  "  ,   .{  list  }); 
      попробуйте   стандартный вывод  .   print  (  "{b}  \n  "  ,   .{  list  }); 
  } 

выход

( 3 2 1 ) 
( 11 10 1 )
 

Повторение строки с помощью распределителя

const   std   =   @import  (  "std"  ); 

  fn   повтор  ( 
     распределитель  :   *  std  .  mem  .  Распределитель  , 
     оригинал  :   []  const   u8  , 
     times  :   useize  , 
 )   std  .   мем  .   Распределитель  .   Ошибка  !   []  const   u8   { 
     var   buffer   =   попробовать   распределитель  .   alloc  ( 
         u8  , 
         original.len ​  *   раз   ,  ) 
     ; 

      для   (  0  ..  раз  )   |   я  |    { 
         станд  .   мем  .   copyForwards  ( 
             u8  , 
             буфер  [(  оригинал  .  len   *   i  )..], 
             оригинал  , 
         ); 
      } 

     вернуть   буфер  ; 
  } 

 паб   fn   main  ()   !   пустота   { 
     const   stdout   =   std  .   ио  .   getStdOut  ().   писатель  (); 

      вар   арена   =   станд  .   куча  .   Аренааллокатор  .   init  ( 
         std  .  heap  .  page_allocator  , 
     ); 
      отложить   арену  .   деинит  (); 

      вар   распределитель   =   арена  .   распределитель  (); 

      const   original   =   "Привет"  ; 
      const   повторено   =   попробуйте   повторить  ( 
         &  распределитель  , 
         оригинал  , 
         3  , 
     ); 

      // Печатает «Привет, привет, привет» 
     try   stdout  .   print  (  "{s}  \n  "  ,   .{  повторено  }); 
  } 

выход

Здравствуйте Здравствуйте Здравствуйте
 

Проекты

• Bun — это среда выполнения JavaScript и TypeScript , написанная на Zig с использованием Safari JavaScriptCore виртуальной машины .

См. также

• С
• С++
• Д
• Nim
• Идти
• Ржавчина
• Углерод
• V

Ссылки

Библиография

• Элизабет, Джейн (19 октября 2017 г.). «Устали от C? Новый язык программирования Zig стремится стать более прагматичным и читабельным» . Джексентер . Архивировано из оригинала 01 октября 2020 г. Проверено 22 апреля 2020 г.
• Егулалп, Сердар (29 августа 2016 г.). «Новый претендент присоединяется к Rust, чтобы свергнуть язык C» . Инфомир . Проверено 11 февраля 2020 г.
• Оуэнс, Джеффри (2 декабря 2023 г.). Освоение зиг-программирования . Независимо опубликовано. ASIN   B0CPCMJ4QX . ISBN  979-8870587332 .

Внешние ссылки

• Официальный веб-сайт
• Зиг на GitHub
• Фильм: Знакомство с Зигом
• Фильм: Дорога к 1.0
• Зиг Еженедельник