Понятие переменной в программировании. Виды и типы переменных (Язык программирования C++)

Содержание:

ВВЕДЕНИЕ

Цель данной курсовой работы – ознакомиться с переменными в программировании, их типами и видами, научиться их применять.

Что такое переменная?

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

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

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

Слово "переменная" обозначает, что сущность может меняться, она непостоянна. Действительно, вы увидите это в дальнейшем, одна и та же переменная может быть связана сначала с одними данными, а потом – с другими. То есть ее значение может меняться, она переменчива.

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

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

Разберём переменные в популярных языках программирования.

1. Swift

За последние годы Swift стал более популярен, чем Objective-C. Это язык программирования для разработки нативных приложений для iOS или Mac OS. Также можно сказать, что это язык программирования с наибольшим потенциалом для изменения будущего. Было обнаружено, что нативные приложения превосходят кросс-платформенные гибридные приложения, а движок SpriteKit при этом упрощает создание 2D-игр. На деле Swift опирается на успехи C и Objective-C, но при этом без ограничений совместимости.

Большую роль в становлении Swift оказало влияние на него таких языков программирования, как Ruby и Python. Он считается удобным для пользователя и интересным в использовании. Swift — это высокоуровневый мультипарадигмальный язык, разработанный Apple для iOS. Если работа с продуктами Apple является вашей целью, то это язык для вас. Swift — статически типизированный язык. Это означает, что Xcode проверяет ошибки за вас, поэтому их легче отслеживать. У Swift есть преимущество перед конкурентами, так как в нем также имеется автоматический счетчик ссылок (ARC), известная функция, которая управляет использованием памяти приложения в реальном времени, etc. Использование этого языка может дать преимущество, поскольку приложения iOS зачастую более выгодны, чем приложения Android.

1.1 Переменные в Swift

В Swift для объявления переменной используется ключевое слово var. Хотя в других языках программирования переменные объявляются похожим способом, не стоит думать о других языках программирования, когда используете ключевое слова var в Swift. Есть несколько важных отличий. Ключевое слово var - это единственный способ объявления переменной в Swift.

Наиболее распространенный и краткий способ использования ключевого слова var - объявить переменную и присвоить ей значение.

var street = "5th Avenue"

Не добавляем в конце этой строки кода точку с запятой, так как точка с запятой необязательна в Swift, рекомендуется не использовать ее, если в этом нет необходимости. Мы не указали тип при объявлении переменной street. Это подводит нас к одной из ключевых особенностей Swift - выведению типа.

Выведение типа

Приведенная выше декларация объявляет переменную street и присваивает ей значение 5th Avenue. Безопасность типов - это один из краеугольных камней языка. Несмотря на то, что приведённая выше декларация не указывает явно тип, переменная street имеет тип String. Так выглядит выведение типа Swift в действии. Значение, которое мы присваиваем street, - это строка. Swift достаточно умен, чтобы это увидеть, и неявно устанавливает тип переменной street в String.

Следующее предложение дает такой же результат. Разница заключается в том, что здесь мы явно задаём тип переменной. Следующее предложение буквально говорит, что street имеет тип String

var street: String = "5th Avenue"

Swift требует явно или неявно задавать тип переменных и констант. Если вы этого не сделаете, Swift будет ругаться, выбрасывая ошибку. Добавьте следующую строку в вашу интерактивную среду, чтобы увидеть, что я имею в виду. var number

Это предложение будет допустимым в PHP или JavaScript. Однако в Swift оно является недопустимым. Причина проста. Несмотря на то, что мы объявляем переменную с помощью ключевого слова var, мы не указываем тип переменной. Swift не может вывести тип, так как мы не присваиваем значение переменной. Если щелкнуть на ошибку, Xcode покажет вам, что не так с этим предложением.

Рисунок 1 Пример ошибки Xcode

Можно легко решить эту проблему, сделав одну из двух вещей. Или присвоить значение переменной, как мы делали раньше, или явно указать тип для переменной number. После явного задания типа для number ошибка исчезает. Приведённые ниже строки кода говорят, что number имеет тип String.

var number: String

Изменение типа

Как вы можете видеть ниже, присвоение новых значений для street и number делается очень просто и происходит безо всяких сюрпризов.

var street: String = "5th Avenue"

var number: String

street = "Main Street"

number = "10"

Не было бы проще присвоить номер 10 переменной number. Нет необходимости хранения номер дома как строку. Давайте посмотрим, что произойдет, если мы это сделаем.

var street: String = "5th Avenue"

var number: String

street = "Main Street"

number = 10

Если мы присвоим number целое число, то Xcode выбросит другую ошибку. К сожалению на этот раз сообщение об ошибке не слишком полезно. Причина, по которой Xcode выдает ошибку, в том, что мы пытаемся присвоить целое число переменной типа String. Это не проблема в слабо типизированных языках, но в Swift это недопустимо. Swift является строго типизированным языком, в котором каждая переменная имеет конкретный тип, и этот тип изменить нельзя. Чтобы избавиться от ошибки, необходимо объявить переменную number как целое число Int. Взглянем на обновленный пример ниже.

var street: String = "5th Avenue"

var number: Int

street = "Main Street"

number = 10

Важно запомнить следующее. Можно объявлять переменную с использованием ключевого слова var, при этом необязательно явным образом объявлять тип переменной. Однако помните, что в Swift каждая переменная — и константа — имеет тип. Если Swift не может вывести тип, то он будет ругаться. Каждая переменная имеет тип, и этот тип изменить нельзя.

2. Go

Go – язык 2009 года – эпохи многоядерных процессоров, тогда как языки вроде Python и Java появились в годы однопоточной среды разработки. Именно поэтому язык Go учитывает многозадачность и работает в соответствии с ней. Вместо всем известных потоков (Thread), которые у большинства языков занимают уйму памяти (например, в Java это 1 Мб на каждый поток), в Go предусмотрены горутины, «съедающие» всего 2 Кб памяти. Можно создать хоть тысячу или миллион горутин, и это практически не отразится на работе приложения.

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

2.1 Переменные в Go

Для определения переменной применяется ключевое слово var, после которого идет имя переменной, а затем указывается ее тип:

var имя_переменной тип_данных

Имя переменной представляет произвольный идентификатор, который состоит из алфавитных и цифровых символов и символа подчеркивания. При этом первым символом должен быть либо алфавитный символ, либо символ подчеркивания. При этом имена не должны представлять одно из ключевых слов: break, case, chan, const, continue, default, defer, else, fallthrough, for, func, go, goto, if, import, interface, map, package, range, return, select, struct, switch, type, var.

Например, простейшее определение переменной:

var hello string

Данная переменная называется hello и она представляет тип string, то есть некоторую строку.

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

var a, b, c string

В данном случае определены переменные a, b, c, которые имеют тип string. В этом случае опять же в конце указывается тип данных, и все переменные принадлежат этому типу.

После определения переменной ей можно присвоить какое-либо значение, которое соответствует ее типу:

package main import "fmt" func main() {     var hello string     hello = "Hello world"     fmt.Println(hello) }

Поскольку переменная hello представляет тип string, ей можно присвоить строку. В данном случае переменная hello хранит строку "Hello world". С помощью функции Println значение этой переменной выводится на консоль.

Также важно учитывать, что Go - регистрозависимый язык, то есть переменные с именами "hello" и "Hello" будут представлять разные переменные:

var hello string hello = "Hello world" fmt.Println(Hello)  // ! Ошибка переменной Hello нет, есть переменная hello

Также можно сразу при объявлении переменной присвоить ей начальное значение. Такой прием называется инициализацией:

package main import "fmt" func main() {     var hello string = "Hello world"     fmt.Println(hello) }

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

package main import "fmt" func main() {     var (         name string = "Tom"         age int = 27     )           fmt.Println(name)   // Tom     fmt.Println(age)    // 27 }

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

package main import "fmt" func main() {     var hello string = "Hello world"     fmt.Println(hello)  // Hello world           hello = "Hello Go"     fmt.Println(hello)  // Hello Go           hello = "Go Go Go Ole Ole Ole"     fmt.Println(hello)  // Go Go Go Ole Ole Ole }

Краткое определение переменной

Также допустимо краткое определение переменной в формате:

имя_переменной := значение

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

package main import "fmt" func main() {     name := "Tom"  fmt.Println(name)       }

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

3. PHP

PHP используется повсеместно благодаря WordPress. 80% сайтов с посещаемостью свыше 10 млн. пользователей используют PHP. Примерами таких сайтов могут стать Facebook и Wikipedia. В PHP не существует каких-либо строгих правил в написании кода, а также он гибок в решении различных проблем.  PHP — это отличный выбор для веб-разработчиков, поскольку он является серверным скриптовым языком и для Worldpress, и для Facebook.

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

3.1 Переменные в PHP

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

Вообще, переменная - это область оперативной памяти, доступ к которой осуществляется по имени. Все данные, с которыми работает программа, хранятся в виде переменных (исключение — константа, которая, впрочем, может содержать только число или строку). Такого понятия, как указатель (как в Си), в PHP не существует — при присвоении переменная копируется один-в-один, какую бы сложную структуру она ни имела. Тем не менее, в PHP, начиная с версии 4, существует понятие ссылок — жестких и символических. Имена всех переменных в PHP должны начинаться со знака $ — так интерпретатору значительно легче "понять" и отличить их, например, в строках. Имена переменных чувствительны к регистру букв: например, $var — не то же самое, что $Var или $VAR: В официальной документации PHP указано, что имя переменной может состоять не только из букв "Латиницы" и цифр, но также и из любых символов, код ASCII которых старше 127, — в частности, и из символов кириллицы, то есть "русских" букв! Однако не рекоммендуется применять кириллицу в именах переменных — хотя бы из-за того, что в различных кодировках ее буквы имеют различные коды. Впрочем, поэксперементируйте и делайте так, как вам будет удобно. Можно сказать, что переменные в PHP — это особые объекты, которые могут содержать в буквальном смысле все, что угодно.

Приведем некоторые примеры переменных в PHP:

<?php
$var = "Bob";
$Var = "Joe";
echo "$var, $Var";      // выведет "Bob, Joe"
$4site = 'not yet';     // неверно; начинается с цифры
$_4site = 'not yet';    // верно; начинается с символа подчеркивания
$tдyte = 'mansikka';    // верно; 'д' это (Дополнительный) ASCII 228.
?>

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

Типы данных (переменных) в PHP

PHP поддерживает восемь простых типов данных (переменных):

Четыре скалярных типа:

• boolean (двоичные данные)
• integer (целые числа)
• float (числа с плавающей точкой или 'double')
• string (строки)

Два смешанных типа:

• array (массивы)
• object (объекты)

И два специальных типа:

• resource (ресурсы)
• NULL ("пустой" тип)

Существуют также несколько псевдотипов:

• mixed (смешанный)
• number (числовой)
• callback (обратного вызова)

Рассмотрим кратко перечисленные типы данных PHP.

Тип Boolean (двоичные данные)

Это простейший тип. Он выражает истинность значения - это может быть либо TRUE, либо FALSE. Булев тип был введен в PHP 4.

Чтобы определить булев тип, используйте ключевое слово TRUE или FALSE. Оба регистро-независимы.

<?php
$x = True; // присвоить $x значение TRUE
?>

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

<?php
// == это оператор, который проверяет
// эквивалентность и возвращает булево значение
if ($action == "показать_версию") {
     echo "Версия 1.23";
}

// это не обязательно…
if ($show_separators == TRUE) {
     echo "<hr>\n";
}

// ...потому что можно просто написать
if ($show_separators) {
     echo "<hr>\n";
}
?>

Тип integer (целые числа)

Целое это число из множества Z = {..., -2, -1, 0, 1, 2, ...}, обычно длиной 32 бита (от –2 147 483 648 до 2 147 483 647).

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

Если использовать восьмеричную систему счисления, то необходимо предварить число 0 (нулем), для использования шестнадцатеричной системы нужно поставить перед числом 0x.

<?php
$a = 1234; // десятичное число
$a = -123; // отрицательное число
$a = 0123; // восьмеричное число (эквивалентно 83 в десятичной системе)
$a = 0x1A; // шестнадцатеричное число (эквивалентно 26 в десятичной системе)
?>

Тип float (числа с плавающей точкой)

Double - вещественное число довольно большой точности (ее должно хватить для подавляющего большинства математических вычислений).

Числа с плавающей точкой (они же числа двойной точности или действительные числа) могут быть определены при помощи любого из следующих синтаксисов:

<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
?>

Тип string (строки)

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

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

Пример строковой переменной:

<?
$a = "Это просто текст, записанный в строковую переменную";
echo $a; //Выводит 'Это просто текст, записанный в строковую переменную'
?>

Тип array (массивы)

Массив в PHP - это упорядоченный набор данных, в котором устанавлено соответствие между значением и ключом.

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

PHP позволяет создавать массивы любой сложности. Рассмотрим некоторые примеры:

Простой массив (список)

Массивы, индексами которых являются числа, начинающиеся с нуля - это списки:

<?php
// Простой способ инициализации массива
$names[0]="Апельсин";
$names[1]="Банан";
$names[2]="Груша";
$names[3]="Помидор";
// Здесь: names - имя массива, а 0, 1, 2, 3 - индексы массива
?>

Ассоциативные массивы

В PHP индексом массива может быть не только число, но и строка. Причем на строку не накладываются ограничения: она может содержать пробелы, специальные символы и быть любой длины.

Массивы, индексами которых являются строки, называются ассоциативными массивами. Индексы ассоциативных массивов называются ключами. Пример ассоциативного массива:

<?php
// Ассоциативный массив
$names["Иванов"]="Иван";
$names["Сидоров"]="Николай";
$names["Петров"]="Петр";
// В данном примере: фамилии - ключи ассоциативного массива
// , а имена - элементы массива
?>

Многомерные массивы

Для создания массивов в PHP существует специальная инструкция array(). Ее удобно использовать для создания многомерных массивов. Приведем конкретный пример:

<?php
// Многомерный массив
$A["Ivanov"] = array("name"=>"Иванов И.И.", "age"=>"25", "email"=>"ivanov@mail.ru");
$A["Petrov"] = array("name"=>"Петров П.П.", "age"=>"34", "email"=>"petrov@mail.ru");
$A["Sidorov"] = array("name"=>"Сидоров С.С.", "age"=>"47", "email"=>"sidorov@mail.ru");
?>

Многомерные массивы похожи на записи в языке Pascal или структуры в языке C.

Тип object (объекты)

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

Для инициализации объекта используется выражение new, создающее в переменной экземпляр объекта.

<?php
class foo
{
     function do_foo()
     {
         echo "Doing foo."; 
     }
}

$bar = new foo;
$bar->do_foo();
?>

Тип resource (ресурсы)

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

Тип NULL ("пустой" тип)

Специальное значение NULL говорит о том, что эта переменная не имеет значения. NULL - это единственно возможное значение типа NULL (пустой тип).

Переменная считается NULL если:

• ей была присвоена константа NULL;
• ей еще не было присвоено какое-либо значение;
• она была удалена с помощью unset().

<?php
$var = NULL;
?>

Псевдотип mixed (смешанный)

mixed говорит о том, что параметр может принимать множество (но не обязательно все) типов.

gettype(), например, принимает все типы PHP, тогда как str_replace() принимает строки и массивы.

Псевдотип number (числовой)

number говорит о том, что параметр может быть либо integer, либо float.

Псевдотип callback (обратного вызова)

Некоторые функции, такие как call_user_func() или usort() принимают в качестве параметра определенные пользователем callback-функции. Callback-функции могут быть не только простыми функциями, но также методами объектов, включая статические методы классов.

PHP-функция передается просто как строка ее имени. Вы можете передать любую встроенную или определенную пользователем функцию за исключением array(), echo(), empty(), eval(), exit(), isset(), list(), print() и unset().

Пример callback функций:

<?php 

// простой пример callback
function my_callback_function() {
     echo 'hello world!';
}
call_user_func('my_callback_function'); 

// примеры callback-метода
class MyClass {
     function myCallbackMethod() {
         echo 'Hello World!';
     }
}

// вызов метода статического класса без создания объекта
call_user_func(array('MyClass', 'myCallbackMethod')); 

// вызов метода объекта
$obj = new MyClass();
call_user_func(array(&$obj, 'myCallbackMethod'));
?>

4. C++

С++ был создан в 1983, как альтернатива С, и сразу же приобрел заслуженную популярность. Его главной особенностью являются предопределенные классы. Microsoft Windows и Google Chrome являются самыми известными примерами проектов, созданных на С++. Этот список могут пополнить проекты Adobe и Amazon’a. Данный язык программирования остаётся востребованным и по сей день, поскольку имеет мощный инструментарий, который может быть адаптированы в различных сферах, таких как финансы, банки, игры, связь, электронные платежные системы, розничная торговля и многое другое.

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

4.1 Переменные в С++

Типы данных

В языке С++ все переменные имеют определенный тип данных. Например, переменная, имеющая целочисленный тип не может содержать ничего кроме целых чисел, а переменная с плавающей точкой — только дробные числа. Тип данных присваивается переменной при ее объявлении или инициализации. Ниже приведены основные типы данных языка C++, которые понадобятся.
Основные типы данных в C++

• int — целочисленный тип данных.
• float — тип данных с плавающей запятой.
• double — тип данных с плавающей запятой двойной точности.
• char — символьный тип данных.
• bool — логический тип данных.

Создание переменных

Чтобы объявить переменную нам необходимо воспользоваться следующей конструкцией:

<тип данных> <имя переменной № 1>, ... , <имя переменной № N>;

Полный список типов данных вы можете увидеть выше. Имена же переменных задаются следующим образом:

• Имя переменной не может начинаться с цифры.
• В имени переменной не может быть пробелов, а также специальных символов (вроде ; № # % или /).
• Имя переменной не может совпадать с другими, ранее объявленными, именами (функций, переменных, стандартных операторов и т. п.).

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

Теперь разберем пример создания различных переменных:

char c = 'p'; // переменная типа char инициализирована символом 'p' int i = 10;// здесь создали переменную целого типа со значением 10 float f = 0.3; // эта переменная с плавающей точкой, со значением 0.3 bool b = true; // передали переменной типа bool, значение true

Также мы можем не задавать значение при создании переменной. Для этого мы просто прописываем тип и имя переменной:

int a, b = 9; // создали две переменные               // для b указали значение 9

Теперь более подробно разберем значения передаваемые вышеперечисленным типам:

• Для указания переменной целого типа надо просто написать нужное число.
• Для указания дробного значения необходимо в начале написать целую часть числа, затем указать точку, а после нее дробную часть числа.
• Если хотим передать символ, необходимо обернуть требуемый символ в одинарные кавычки.
• Для записи значения «верно», в переменную типа bool, необходимо написать true, и false для значения «ложь».

5. Python

За этим языком будущее, и это не преувеличение. Во-первых, он прост в понимании и использовании: Python постепенно вводят в учебную программу, повсеместно вытесняя отживший свое Паскаль и прочие «деревянные» языки. Во-вторых, это нейронные сети: если разработчик ударяется в машинное обучение, то сразу же обращает свое внимание на Python. Почему? Да просто данный язык программирования оброс достаточным количеством библиотек, ориентированных на нейронные сети.

Качественные фреймворки, огромное количество учебных материалов, дружелюбное комьюнити, простота кодинга: все это делает Python действительно конкурентоспособным языком.

5.1 Переменные в Python

Название переменной в Python должно начинаться с алфавитного символа или со знака подчеркивания и может содержать алфавитно-цифровые символы и знак подчеркивания. И кроме того, название переменной не должно совпадать с названием ключевых слов языка Python. Ключевых слов не так много, их легко запомнить: and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, None, nonlocal, not, or, pass, raise, return, True, try, while, with, yield.

Например, создадим переменную:

name = "Tom"

Здесь определена переменная name, которая хранит строку "Tom".

В пайтоне применяется два типа наименования переменных: camel case и underscore notation.

Camel case подразумевает, что каждое новое подслово в наименовании переменной начинается с большой буквы. Например:

userName = "Tom"

Underscore notation подразумевает, что подслова в наименовании переменной разделяются знаком подчеркивания. Например:

user_name = "Tom"

И также надо учитывать регистрозависимость, поэтому переменные name и Name будут представлять разные объекты.

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

• boolean - логическое значение True или False
• int - представляет целое число, для хранения которого использует 4 байта в памяти компьютера.
• float - представляет число с плавающей точкой, для хранения которого используется 8 байт, например, 1.2 или 34.76
• complex - комплексные числа
• str - строки, например "hello". В Python 3.x строки представляют набор символов в кодировке Unicode
• bytes - последовательность чисел в диапазоне 0-255
• byte array - массив байтов, аналогичен bytes с тем отличием, что может изменяться
• list - список
• tuple - кортеж
• set - неупорядоченная коллекция уникальных объектов
• frozen set - то же самое, что и set, только не может изменяться (immutable)
• dict - словарь, где каждый элемент имеет ключ и значение

Python является языком с динамической типизацией. Он определяет тип данных переменной исходя из значения, которое ей присвоено. Так, при присвоении строки в двойных или одинарных кавычках переменная имеет тип str. При присвоении целого числа Python автоматически определяет тип переменной как int. Чтобы определить переменную как объект float, ей присваивается дробное число, в котором разделителем целой и дробной части является точка.

Число с плавающей точкой можно определять в экспоненциальной записи:

x = 3.9e3 print(x)  # 3900.0 x = 3.9e-3 print(x)  # 0.0039

Число float может иметь только 18 значимых симолов. Так, в данном случае используются только два символа - 3.9. И если число слишком велико или слишком мало, то мы можем записывать число в подобной нотации, используя экспоненту. Число после экспоненты указывает степень числа 10, на которое надо умножить основное число - 3.9.

При этом в процессе работы программы мы можем изменить тип переменной, присвоив ей значение другого типа:

user_id = "12tomsmith438"  # тип str print(user_id) user_id = 234  # тип int print(user_id)

С помощью функции type() динамически можно узнать текущий тип переменной:

user_id = "12tomsmith438" print(type(user_id))  # <class 'str'> user_id = 234 print(type(user_id))  # <class 'int'>

6. JavaScript

По статистике, собранной сайтом Stackoverflow (Stack Overflow Developer Survey), который охватил аудиторию составом больше, чем 64000 разработчиков из 173 стран, JavaScript стал самым используемым языком программирования в мире. Он предоставляет возможность создавать интерактивные сайты и является одной из основных веб-технологий наряду с HTML и CSS, поскольку большинство браузеров в том или ином виде могут использовать JS.

JavaScript отличный язык, чтобы начать свой путь в веб-разработке. Этот ЯП подойдёт для создания интерактивных сайтов в интернете. В последнее время JavaScript расширился, и теперь на нём можно писать мобильные приложения, игры, а также десктопные приложения. Это определённо повлияло на популярность языка.

6.1 Переменные в JavaScript

В JavaScript переменная содержит значение, например "hello" или 5. Используя переменную, разработчик ссылается на данные, которые она представляет, например NumberOfDaysLeft = EndDate – TodaysDate.  

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

Объявление переменных

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

JavaScript

// A single declaration.

var count;

// Multiple declarations with a single var keyword.

var count, amount, level;

// Variable declaration and initialization in one statement.

var count = 0, amount = 100;

Если не инициализировать переменную в операторе var, ей автоматически присваивается значение undefined.

Именование переменных

В языке JavaScript учитывается регистр символов.  Это значит, что имя переменной myCounter отличается от имени переменной MYCounter.  Длина имен переменных ничем не ограничена.  Ниже приведены правила создания допустимых имен переменных.  

• Первый символ должен быть буквой ASCII (в верхнем или нижнем регистре) или символом подчеркивания (_).  Обратите внимание, что в качестве первого знака нельзя использовать число.  
• Последующие знаки должны быть буквами, числами или символами подчеркивания (_).
• Имя переменной не должно совпадать с зарезервированным словом.

Ниже приведено несколько примеров допустимых имен переменных:

_pagecount

Part9

Number_Items

Ниже приведено несколько примеров недопустимых имен переменных:

JavaScript

// Cannot begin with a number.

99Balloons

// The ampersand (&) character is not a valid character for variable names.

Alpha&Beta

Если требуется объявить переменную и инициализировать ее, однако не требуется присваивать ей какое-либо определенное значение, присвойте ей значение null.  Пример приведен выше.  

JavaScript

var bestAge = null;

var muchTooOld = 3 * bestAge; // muchTooOld has the value 0.

При объявлении переменной без присвоения ей значения она имеет значение undefined.  Пример приведен выше.  

JavaScript

var currentCount;

// finalCount has the value NaN because currentCount is undefined.

var finalCount = 1 * currentCount;

Значение null ведет себя как 0, тогда как undefined ведет себя как специальное значение NaN (не число).  Если сравнить null и значение undefined, они окажутся равны.  

Можно объявить переменную без использования в объявлении ключевого слова var и присвоить ей значение.  Это называется неявным объявлением.  

JavaScript

// The variable noStringAtAll is declared implicitly.

noStringAtAll = "";

Использовать переменную, которая не была объявлена, невозможно.

JavaScript

// Error. Length and width do not yet exist.

var area = length * width;

Приведение

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

• при сложении числа и строки число приводится к строке;
• при сложении логического значения и строки логическое значение приводится к строке;
• при сложении числа и логического значения логическое значение приводится к строке.

В следующем примере результатом сложения числа и строки является строка.

JavaScript

var x = 2000;

var y = "Hello";

// The number is coerced to a string.

x = x + y;

document.write(x);

// Output:

// 2000Hel

7. Java

Java — один из самых практичных языков программирования для изучения. Его популярность нельзя переоценить, так как большинство (90%) компаний из списка Fortune используют Java для разработки бэкэнд-систем и десктопных приложений. Кроссплатформенность достигнута благодаря JVM. В Java, как и во многих современных языках, включая C++, Python, etc, используется принцип объектно-ориентированного программирования (ООП). Java в основном используется для создания серверных приложений и мобильных ПО. Также это основа нативных приложений под Android. Данный язык чрезвычайно популярен среди разработчиков, хоть и есть вероятность, что в плане мобильных приложений всю популярность вскоре может отобрать Kotlin.

7.1 Переменные в Java

В Java можно указать, какие именно значения может принимать переменная. Для этого все переменные сгруппировали в 4 группы:

1. Целочисленные (к ним относятся byte, short, int, long)
2. С плавающей точкой (к ним относятся float, double)
3. Символы (char)
4. Логические (boolean)

Рисунок 2 Типы данных сформированные в группы

Примечание:  Итого 8 типов переменных (byte, short, int, long, float, double, char, boolean). Брюс Эккель выделяет еще и 9-й тип – так называемый тип void («пустое» значение). Но рассмотрим 8 типов, как это обычно принято.

Теперь рассмотрим каждую группу переменных. И начнём с целочисленных.

Целочисленные: byte, short, int, long

Рисунок 3 Целочисленные переменные

Как видно из таблички, byte, short, int, long относятся к целочисленным, то есть к целым числам. Например, 1, 9, 1278, -5, -107 и т.д.

Очевидно:

1. byte может принимать значения от -128 до 127 и при этом занимает 1 байт памяти
2. short принимает значения от -32768 до 32767 и занимает 2 байта памяти
3. int от -2147483648 до 2147483647 и занимает 4 байта памяти
4. long от -9223372036854775808 до 9223372036854775807 и занимает 8 байтов памяти

Если byte, short, int и long отвечают все за целые числа, то как понять какой именно тип нужно выбирать. Чаще всего при написании программ на Java, используется тип int. Это самый распространенный целочисленный тип. Более того, тип int в Java является типом "по умолчанию" для целочисленных типов. Прежде, чем использовать переменную, её необходимо объявить. А объявляются переменные так:

Рисунок 4 Схема объявления переменной

Как видно, речь идёт уже не о целых.  Уже речь идёт о дробных числах. А значит уже нельзя использовать целочисленный тип: нам не подойдет ни byte, ни short, ни int, ни long. Как только речь идет о дробных числах, значит, речь идет о float или double. Примеры дробных чисел: 1.0, 1.8, 3.141562, 9.0, 12.579, 1278.0, -5.0, - 9.4, -107.0, -107.356 и т.д.

Рисунок 5 Дробные переменные

Как видно из таблички:

1. float может принимать значения от -3.4Е +38 до 3.4Е +38 и при этом занимает 4 байта памяти
2. double принимает значения от -1.7E + 308 до 1.7Е + 308 и занимает 8 байт памяти
   Важно:

• дробные числа пишутся не через запятую, как привычно, а через точку. Например, 1,5 - это неправильно. Правильно 1.5
• float определяет значение одинарной точности. Это значит, что переменные данного типа удобны, когда требуется дробная часть без особой точности. Например, для денежных сумм.
• double обеспечивает двойную точность и это видно из названия (double - двойная).

Прежде, чем использовать переменную, её необходимо объявить. А объявляются переменные float и double по такому же принципу.

А вот и примеры объявления переменных:

float money; // объявили переменную money типа float

float wage; // объявили переменную wage типа float

float c; // объявили переменную c типа float

double stat; //объявили переменную stat типа double

 Символы: char

В Java для char используется кодировка Unicode. Как видно из таблички, диапазон допустимых значений char от 0 до 65536 и при этом занимает 2 байта памяти. Отрицательных значений не существует. На самом деле переменная типа char хранит не сам символ, а его числовой код из таблички Unicode, по этому мы можем проводить целочисленные операции над символами.

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

Примеры объявления переменных:

char y; //объявили переменную y типа char

char f; //объявили переменную f типа char

Логические: boolean

Рисунок 6 Логические значения

Логические или их еще называют булевы значения могут принимать только одно из двух возможных значений: true или false.

В языке программирования Java всё очень точно:

• либо true (с английского - "истина")
• либо false (с английского - "ложь)

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

Примеры объявления переменных:

boolean check1; //объявили переменную check1 типа boolean

boolean check2; //объявили переменную check2 типа boolean

8. C#

Разработанный Microsoft, этот мультипарадигмальный язык программирования общего назначения использовался для разработки приложений на платформе Microsoft. C# — это объектно-ориентированный язык, который используется для разработки приложений, основанных на .NET frameworks. И, если это ваш рынок, то C# — лучший язык для создания нативных приложений для платформы Microsoft. Кроме того, он является рекомендуемым языком для разработки игр с использованием движка Unity Game.

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

На C# вы можете написать что угодно: веб-сервисы, мобильные ПО, серверные приложения и так далее. И в то время как эксперты утверждают, что спрос на C# падает, Xamarin опровергает эти утверждения, поскольку оказывается, что эта платформа упрощает создание приложений для Android и iOS.

8.1 Переменные в C#

Си-шарп – язык жесткой типизации. Каждая переменная должна быть определенного типа данных. Ниже, в таблице наведены встроенные типы данных языка Си-шарп:

Оперативная память - массив байтов, где каждый байт имеет уникальный адрес. Для bool достаточно одного бита: 0 - false, 1 - true, но минимальная адресуемая сущность - байт, поэтому ненулевой байт считается за истину, нулевой - ложью.

Таблица 1 – Типы данных C#

Тип	Область значений	Размер
sbyte	-128 до 127	Знаковое 8-бит целое
byte	0 до 255	Беззнаковое 8-бит целое
char	U+0000 до U+ffff	16-битовый символ Unicode
bool	true или false	1 байт*
short	-32768 до 32767	Знаковое 16-бит целое
ushort	0 до 65535	Беззнаковое 16-бит целое
int	-2147483648 до 2147483647	Знаковое 32-бит целое
uint	0 до 4294967295	Беззнаковое 32-бит целое
long	-9223372036854775808 до 9223372036854775807	Знаковое 64-бит целое
ulong	0 до 18446744073709551615	Беззнаковое 64-бит целое
float	±1,5*10-45 до ±3,4*1033	4 байта, точность — 7 разрядов
double	±5*10-324 до ±1,7*10306	8 байтов, точность — 16 разрядов
decimal	(-7,9 * 1028 до 7,9 * 1028) / (100–28)	16 байт, точность — 28 разрядов

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

static void Main(string[] args)
{
   int a; // объявляем переменную a типа int
   a = 5; // записываем в переменную a число 5
   int b, c; // объявить можно сразу несколько переменных через запятую
   bool d; // объявляем переменную d типа bool
   d = true; // записываем в переменную d значение true (истина)
   long e = 10; // при объявлении переменной можно сразу же задавать ей значение, это называется инициализацией
   float f = 5.5f; // чтобы записать число с плавающей точкой типа float, нужно после значения добавлять суффикс f.
   char g = 'g'; // объявление символьной переменой g с ее инициализацией значением символа 'g'
}

При использовании переменной, в которую не было записано значение, компилятор выдаст ошибку "Use of unassigned local variable [variableName]".

static void Main(string[] args)
{
   int a;
   Console.WriteLine(a); //ошибка
}

Язык Си-шарп чувствительный к регистру символов. Переменные max и Max это не одно и то же. Не забывайте этого, чтобы не иметь лишних проблем.
Имя переменной должно отображать суть данных, которые она отображает. Не стоит называть переменные ни о чем не говорящими именами типа a, b, c. Используйте английские слова. Высота – height, возраст – age и т. д.
Нельзя использовать кириллические символы в именах переменных.

Преобразование встроенных типов данных

Переменные одного типа можно преобразовывать в переменные другого типа. Преобразование бывает явным и неявным. Неявное преобразование выполняет компилятор.

Пример неявного преобразования:

static void Main(string[] args)
{
   int a = 35;
   short b = 10;
   a = b; // неявное преобразование. Так как int большего размера, чем short – утери данных не будет
   b = a; // ошибка компиляции, нельзя тип большего размера неявно преобразовать в тип меньшего размера
}

При явном преобразовании необходимо непосредственно перед переменной, которую вы хотите преобразовать, указать в скобках тип, к которому приводится переменная.

Пример явного преобразования:

static void Main(string[] args)
{
   int a = 35000;
   short b = 10;
   b = (short) a; // в этом случае уже ошибки не будет. Так как максимальное значение типа short 32767, здесь будет утеря данных.
}

9. Kotlin

Kotlin стремительно развивается и обладает рядом преимуществ. Среди них:

• лаконичность языка программирования;
• совместимость с Java;
• поддерживается Google;
• рост сообщества.

Вполне возможно, что скоро приложения для Android-девайсов будут писаться исключительно на Kotlin, поэтому желающим развиваться в направлении мобильной разработки настоятельно рекомендуется присмотреться к данному ЯП.

9.1 Переменные в Kotlin

Для хранения данных в программе в Kotlin, как и в других языках программирования, применяются переменные. Переменная представляет именованный участок памяти, который хранит некоторое значение.

Каждая переменная характеризуется определенным именем, типом данных и значением. Имя переменной представляет поизвольный идентификатор, который может содержать алфавитно-цифровые символы или символ подчеркивания и должен начинаться либо с алфавитного символа, либо со знака подчеркивания. Для определения переменной можно использовать либо ключевое слово val, либо ключевое слово var.

Например, определим переменную age:

val age: Int

Вначале идет слово val или var, затем имя переменной и через двоеточие тип переменной. То есть в данном случае объявлена переменная age, которая имеет тип Int. Тип Int говорит о том, что переменная будет содержать целочисленные значения.

После определения переменной ей можно присвоить значение:

fun main(args: Array<String>) {     val age: Int     age = 23     println(age) }

Для присвоения значения переменной используется знак равно. Затем мы можем производить с переменной различные операции. Например, в данном случае с помощью функции println значение переменной выводится на консоль. И при запуске этой программы на консоль будет выведено число 23. Присвоение значение переменной должно производиться только после ее объявления. И также можно сразу присвоить переменной начальное значение при ее объявлении. Такой прием называется инициализацией:

fun main(args: Array<String>) {     val age: Int = 23     println(age) }

Изменяемые и неизменяемые переменные

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

С помощью ключевого слова val определяется неизменяемая переменная (immutable variable). То есть можно присвоить значение такой переменной только один раз, но изменить его после первого присвоения уже не сможем.

Например, в следующем случае мы получим ошибку:

fun main(args: Array<String>) {     val age: Int     age = 23        // здесь норм - первое присвоение     age = 56        // здесь ошибка - переопределить значение переменной нельзя     println(age) }

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

fun main(args: Array<String>) {     var age: Int     age = 23     println(age)     age = 56     println(age) }

Поэтому если не планируется изменять значение переменной в программе, то лучше определять ее с ключевым словом val.

10. Rust

В 2016 году Rust занял первое место в опросе «что разработчики любят больше всего» на Stack Overflow. Rust оказался языком программирования, который разработчики действительно ценят (79.1% голосов). Язык разработки с открытым исходным кодом, разработанный Mozilla Foundation, работает как низкоуровневый.

Самое интересное здесь то, что Rust делает акцент на безопасном коде (т. е. объекты управляются языком программирования от начала до конца). В нем хоть и нет наследования, зато имеются способности (traits) и структуры. Данный язык программирования универсален и опирается на трех основах: эргономика, скорость и безопасность.

10.1 Переменные в Rust

Переменные в Rust объявляются ключевым словом let. Если тип переменной не указан, он определяется автоматически из контекста. По умолчанию все переменные неизменяемы (immutable), т.е. по сути константы. Ключевое слово mut позволяет создать изменяемое значение.

let hi = "hi";
let mut count = 0;
При желании можно определить тип явно «в стиле Pascal»:

let mut count: int = 0;

Указатели и их типы

По умолчанию все переменные и литералы в Rust размещаются статически в стеке. Для динамического выделения памяти используются указатели, но они отличаются от привычных в С/С++. Имеется три типа указателей: заимствованные (borrowed, задаются добавлением к переменной префикса «&»), принадлежащие (owned, префикс «~») и управляемые (managed, префикс «@»). Заимствованный указатель - это то же, что ссылка (reference) в С++; он является адресом уже соответствующей переменной:

let mut s = "Text"; // Текстовая переменная в стеке
let p = &s; // Ссылка на нее (адрес в памяти)
io::println(*p); // Разыменование ссылки и вывод на экран

Принадлежащий указатель, грубо говоря, эквивалентен классу unique_ptr<> в С++: при инициализации он выделяет память в куче и помещает туда переменную. Этот указатель уникален - никто другой не может ссылаться на ту же переменную:

let mut s1 = ~"Text"; // Переменная в куче
let mut s2 = s1; // Семантика перемещения - теперь s2 ссылается на выделенную
// память, а s1 не определен(произошло «перемещение»)
let p = &s1; // ОШИБКА! Ссылка s1 уже не определен!

Управляемый указатель похож на shared_ptr<> в С++, но он автоматически попадает в поле зрения сборщика мусора того потока, где он определен:

let mut s1 = @"Text"; // Переменная в куче потока
let mut s2 = s1; // s1 и s2 ссылаются на одну и ту же память

Массивы
В Rust имеются встроенные массивы (векторы) - как статические, так и динамические:

let a: [int,..3] = [1,5,10]; // Статический массив из 3 элементов
let mut b: @[int] = @[1,2,3]; // Динамический массив из 3 элементов
b += [4,5,6]; // добавляем еще три элемента

Функции объявляются следующим образом:

fn f1(val: int) -> int { // Функция возвращает тип int return 42+val;
}
io::println(fmt!("%i",f1(1))) // Выводим форматированное значение 43

Функции не видят окружающего их контекста и могут общаться с «внешним миром» только через переменные в стиле функциональных языков программирования. В том же стиле в Rust определены замыкания (анонимные функции с захватом контекста):

// Функция принимает как аргумент другую функцию с сигнатурой fn(int)
// и вызывает ее с параметром 10
fn call_closure_with_ten(b: &fn(int)) { b(10); }
// Переменная в локальном контексте
let captured_var = 20;
// Объявляем замыкание; между || перечисляются аргументы // все переменные локального контекста видны!
let closure = |arg| println(fmt!("captured_var=%d, arg=%d", captured_var, arg));
// Передаем замыкание в функцию
call_closure_with_ten(closure);

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

let mut max = 0;
[1, 2, 3].map(|x| if *x > max { max = *x });

Заключение

Дух функционального программирования в Rust проник даже в управляющие конструкции. Например, нормального цикла for в Rust нет, но зато есть специальный синтаксис замыканий:

// Функция принимает массив чисел и другую функцию fn для их обработки
fn each(v: &[int], op: &fn(v: &int) -> bool) {
let mut n = 0; while n < v.len() {
if !op(&v[n]) { break;
}
n += 1;
}
}
// Вызываем нашу функцию а-ля управляющую конструкцию // Все, что находится в фигурных скобках, становится телом замыкания, // которое передается как второй аргумент в функцию each for each([2, 4, 8, 5, 16]) |n| { if *n % 2 != 0 {
println("found odd number!");
break;
}
}

СПИСОК ЛИТЕРАТУРЫ

1) Блэнди Д., Орендорф Д. Программирование на языке Rust / Д. Блэнди, Д. Орендорф, Д. А. Мовчан. – М., 2018. – 550с.

2) Усов В. А. Swift. Основы разработки приложений под iOS и macOS / Усов В. Санкт-Петербург – Изд-во: Питер, 2017 – 368 с.

3) Язык программирования C++. Базовый курс / Б. Л. Стенли , Ж. Лажойе, Б. Э. Му. – М., 2017. – 1120 с.

4) Язык программирования C# / А. Хейлмберг, М. Торгерсен, С. Вилтамут, П. Голд. – М. – 2012. – 784 с.

5) Саммерфильд М. Программирование на языке Go / М. Саммерфильд,

А. Кисилев. – Москва: Изд-во ДМК Пресс, 2013. – 580 с.

6) Зандстра М. PHP. Объекты, шаблоны и методики программирования / М. Зандстра, С. Тригуб. – Москва: Изд-во Вильямс, 2016. – 1000с.

7) Минник К., Холланд Е. JavaScript для чайников / К. Минник, Е. Холланд, А. Гузикевич. – М., 2016. – 500 с.

8) Шилдт Г. Java: Руководство для начинающих / Г. Шилдт, А. Гузикевич. – Москва: Изд-во Вильямс., 2017 – 500 с.

9) Пименов С. Язык программирования Kotlin / С. Пименов, – Киев: Изд-во IPIO., 2017 – 304 с.

10) Любанович Б. Простой Python. Современный стиль программирования / Б. Любанович, – Санкт-Питербург: Изд-во Питер., 2017. – 480 с.

11) Swift 3. Разработка приложений в среде Xcode для iPhone и iPad с использованием iOS SDK / М. Маскри, К. Топли, Д. Марк, Ф. Т. Олссон, Д. Ламарш. – М., 2017 – 896 с.

12) Глушаков С. В. Программирование на Java / С. В. Глушаков, – Харьков: Изд-во Фолио., 2003. – 527 с.