Переменные и параметры

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

Подстановка переменных

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

```
var=1
```
```
var1="test"
```

различными вариантами с использованием оператора read:

```
read var
```

или в заголовке цикла:

```
for var in 1 2 3
```

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

```
#!/bin/bash
```
```
 
```
```
var="hello"
```
```
echo "$var world"
```

выведет:

freebsd /# ./test.sh
hello world

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

```
#!/bin/bash
```
```
 
```
```
var="hello"
```
```
echo '$var world'
```

выведет:

freebsd /# ./test.sh
$var world

Форма записи $var, является упрощенным вариантом ${var}. Запись с фигурными скобками ${var}, является более строгим вариантом, ее можно применять там, где обычный вариант вызывает синтаксическую ошибку.

Примеры назначения и подстановки переменных

```
#!/bin/bash
```
```
 
```
```
a=375
```
```
hello=$a
```

# Использование пробелов, перед, или после, знака =, не допустимо
# При записи VAR =value, интерпретатор попытается выполнить команду VAR с параметром =value.
# Если попробовать присвоить значение переменной таким образом VAR= value, будет произведена попытка назначить переменной окружения VAR пустое
# значение, после чего, выполнить команду value.

echo hello    # Здесь просто будет выведена строка "hello"

```
 
```
```
echo $hello 
```

echo ${hello} # Идентично предыдущей строке.

```
 
```
```
echo "$hello"
```
```
echo "${hello}"
```
```
 
```
```
echo
```

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

```
#!/bin/sh
```
```
 
```
```
hello="A B  C   D"
```
```
echo $hello   
```
```
echo "$hello" 
```
```
echo '$hello'
```

freebsd /# ./test.sh
A B C D
A B  C   D
$hello

Объявление неинициализированной переменной, фактически то-же самое что и сброс переменной

```
#!/bin/sh
```
```
 
```

# Неинициализированная переменная

```
var=
```
```
echo "var = $var"
```
```
 
```

# Присвоение значения переменной

```
var=100
```
```
echo "var = $var"
```
```
 
```

# Сброс значения переменной

```
unset var
```
```
echo "var = $var"
```

freebsd /# ./test.sh
var =
var = 100
var =

Неинициализированная переменная содержит пустое значение, в арифметических операциях пустое значение интерпретируется как 0. Использование пустых переменных потенциально может вызывать различного рода ошибки в процессе работы сценария, однако в арифметических операциях их использование вполне допустимо.

echo "$uninitialized"                                # пустое значение

let "uninitialized += 5"                             # к пустому значению прибавить 5

echo "$uninitialized"                                # результат 5

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

var1=variable1  var2=variable2  var3=variable3

echo "var1=$var1   var2=$var2  var3=$var3"

Со старыми версиями "sh" могут возникнуть проблемы .

Присваивание значений переменным

Операцией присвоения значения переменной в bash является символ равно, "=", в зависимости от контекста использования так-же является оператором сравнения "равно".

Простое присваивание

```
#!/bin/bash
```
```
 
```

# Символ  '$' не используется

```
 
```
```
a=879
```

echo "Значение переменной \"a\" = $a"

```
 
```

# Присваивание значения с помощью ключевого слова 'let'

```
let a=16+5
```

echo "Значение переменной \"a\" = $a."

```
 
```

# Неявное присваивание в заголовке цикла 'for'

echo -n "Значения переменной \"a\" в цикле: "

```
for a in 7 8 9 11
```
```
do
```
```
  echo -n "$a "
```
```
done
```
```
 
```

# Одна из разновидностей присваивания с использованием инструкции 'read'

echo -n "Введите значение переменной \"a\" "

```
read a
```

echo "Значение переменной \"a\" теперь стало равным: $a."

```
 
```
```
exit 0
```

Простое и замаскированное присваивание

```
#!/bin/bash
```
```
 
```
```
a=23
```
```
echo $a
```
```
b=$a
```
```
echo $b
```

# Подстановка команд, немного более сложный вариант.

a=`echo Hello!`   # Переменной 'a' присваивается результат выполнения команды 'echo'

```
echo $a
```

Обратите внимание на восклицательный знак (!) в подстанавливаемой команде, из командной строки такой вариант работать не будет, поскольку здесь используется механизм истории команд bash. Но в сценариях использование истории команд запрещено

a=`ls -l`         # Переменной 'a' присваивается результат выполнения команды 'ls -l'

echo $a           # Если не используются кавычки, будут удалены лишние пробелы и пустые строки

```
echo
```

echo "$a"         # При использовании кавычек, все пробелы и пустые строки будут сохранены

```
 
```
```
exit 0
```

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

```
#!/bin/sh
```
```
 
```
```
R=$(uname)
```
```
echo $R
```

f
reebsd /# ./test.sh
FreeBSD

Переменные Bash не имеют определенного типа

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

Целое число или строка

```
#!/bin/bash
```
```
 
```

# Переменной присваивается целое число

```
a=2334
```
```
let "a += 1"
```
```
echo "a = $a "
```

# Переменная все еще является целым числом 2335

```
 
```
```
# Замена "23" на "BB"
```
```
b=${a/23/BB}
```
```
 
```

# Происходит трансформация числа в строку.

```
echo "b = $b"            # b = BB35
```

declare -i b             # Явное указание типа ничего не изменит

```
echo "b = $b"            # b = BB35
```
```
 
```
```
let "b += 1"             # BB35 + 1 =
```
```
echo "b = $b"            # b = 1
```
```
 
```
```
c=BB34
```
```
echo "c = $c"            # c = BB34
```

d=${c/BB/23}             # замена "BB" на "23".

```
 
```

# Переменная $d становится целочисленной.

```
echo "d = $d"            # d = 2334
```
```
let "d += 1"             # 2334 + 1 =
```
```
echo "d = $d"            # d = 2335
```
```
 
```

# Как ведут себя  "пустые" переменные

```
e=""
```
```
echo "e = $e"            # e =
```

let "e += 1"             # В арифметических операциях возможно использование "пустых" переменных

```
echo "e = $e"            # e = 1
```

# "Пустая" переменная становится целочисленной.

```
 
```

# Поведение неинициализированных переменных

```
echo "f = $f"            # f =
```

let "f += 1"             # Арифметические операции разрешены

```
echo "f = $f"            # f = 1
```

echo                     # Неинициализированная переменная трансформируется в целочисленную.

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

Специальные типы переменных

локальные переменные

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

```
#!/usr/local/bin/bash
```
```
 
```
```
a=111
```
```
{ a=555; }
```
```
echo "a = $a"
```

freebsd /# ./test1.sh
a = 555

переменные окружения

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

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

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

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

 freebsd /# eval "`seq 10000 | sed -e 's/.*/export var&=ZZZZZZZZZZZZZZ/'`"
freebsd /# bash$ du
freebsd /# /usr/bin/du: Argument list too long

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

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

Позиционные параметры

Позиционные параметры, это аргументы, получаемые сценарием при запуске из командной строки — $0, $1, $2, $3..., где $0 — это название файла сценария, $1 — первый аргумент, $2 — второй, $3 — третий и так далее. Аргументы, следующие за $9, должны быть заключены в фигурные скобки, например: ${10}, ${11}, ${12}.

Специальные переменные $* и $@ содержат все поступившие в сценарий позиционные параметры.

```
#!/bin/bash
```
```
 
```

# Данный сценарий должен вызываться как минимум с 10 аргументами

```
# ./scriptname 1 2 3 4 5 6 7 8 9 10
```
```
MINPARAMS=10
```
```
 
```
```
echo
```
```
 
```
```
echo "Имя сценария: \"$0\"."
```

# Для текущего каталога добавит ./

echo "Имя файла сценария: \"`basename $0`\"."

# Добавит путь к имени файла (см. 'basename')

```
 
```
```
echo
```
```
 
```

if [ -n "$1" ]              # Проверяемая переменная заключена в двойные кавычки.

```
then
```

 echo "Параметр #1: $1"     # здесь кавычки для нужны для экранирования символа #

```
fi
```
```
 
```
```
if [ -n "$2" ]
```
```
then
```
```
 echo "Параметр #2: $2"
```
```
fi
```
```
 
```
```
if [ -n "$3" ]
```
```
then
```
```
 echo "Параметр #3: $3"
```
```
fi
```
```
 
```
```
# ...
```
```
 
```

if [ -n "${10}" ]  # Параметры, следующие за $9 должны заключаться в фигурные скобки

```
then
```
```
 echo "Параметр #10: ${10}"
```
```
fi
```
```
 
```

echo "-----------------------------------"

echo "Все аргументы командной строки: "$*""

```
 
```
```
if [ $# -lt "$MINPARAMS" ]
```
```
then
```
```
  echo
```

  echo "Количество аргументов командной строки должно быть не менее $MINPARAMS !"

```
fi
```
```
 
```
```
echo
```
```
 
```
```
exit 0
```

Использование скобок для позиционных параметров дает простой способ обращения к последнему аргументу, переданному в сценарий из командной строки. Такой способ подразумевает использование косвенной адресации.

args=$#           # Количество переданных аргументов.

lastarg=${!args}  # Обратите внимание: lastarg=${!$#} неприменимо.

Сценарий может вести себя по разному в зависимости от имени сценария. Для этого сценарий должен проанализировать аргумент $0 — имя файла сценария. Это могут быть и имена символических ссылок на файл сценария.

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

```
variable1_=$1_ 
```

# Это предотвратит появление ошибок, даже при отсутствии входного аргумента.

```
 
```
```
critical_argument01=$variable1_
```
```
 
```

# Дополнительные символы всегда можно "убрать" позднее.

# Это может быть сделано примерно так:

variable1=${variable1_/_/}   # Побочный эффект возникает только если имя переменной $variable1_ будет начинаться с символа "_".

# Здесь используется один из вариантов подстановки параметров. Отсутствие шаблона замены приводит к удалению.

```
 
```

# Более простой способ заключается в обычной проверке передаваемых аргументов.

```
if [ -z $1 ]
```
```
then
```
```
  exit $POS_PARAMS_MISSING
```
```
fi
```

Сценарий использующий программу whois для определения имени домена

```
#!/bin/bash
```
```
 
```

# Команда 'whois domain-name' определяет имя домена на одном из 3 серверов:

#                    ripe.net, cw.net, radb.net

```
 
```

# Разместите этот скрипт под именем 'wh' в каталоге /usr/local/bin

```
 
```

# Требуемые символические ссылки:

# ln -s /usr/local/bin/wh /usr/local/bin/wh-ripe

# ln -s /usr/local/bin/wh /usr/local/bin/wh-cw

# ln -s /usr/local/bin/wh /usr/local/bin/wh-radb

```
 
```
```
if [ -z "$1" ]
```
```
then
```

  echo "Использование: `basename $0` [domain-name]"

```
  exit 65
```
```
fi
```
```
 
```
```
case `basename $0` in
```

# Проверка имени скрипта и, соответственно, имени сервера

    "wh"     ) whois $1@whois.ripe.net;;

    "wh-ripe") whois $1@whois.ripe.net;;

    "wh-radb") whois $1@whois.radb.net;;

```
    "wh-cw"  ) whois $1@whois.cw.net;;
```

    *        ) echo "Использования: `basename $0` [domain-name]";;

```
esac
```
```
 
```
```
exit 0
```

Команда shift сдвигает позиционные параметры удаляя первый из них.

$1 <--- $2, $2 <--- $3, $3 <--- $4, и т.д.

При этом аргумент $0 (имя сценария) остается без изменений. Если вашему сценарию передается большое количество аргументов из командной строки, команда shift позволяет получить доступ к аргументам, с порядковым номером больше 9, без использования фигурных скобок.

Использование команды shift

В данном случае команда 'shift используется для перебора всех аргументов командной строки.

```
#!/bin/bash
```
```
 
```

until [ -z "$1" ]  # Пока все параметры не будут разобраны

```
do
```
```
  echo -n "$1 "
```
```
  shift
```
```
done
```
```
 
```
```
echo              
```
```
 
```
```
exit 0
```

Так-же, команда shift, может применяться и к входным аргументам функций.

freebsd /# ./test1.sh 1 2 3 a b c
1 2 3 a b c

Удаленное администрирование серверов. Настройка, оптимизация, поддержка.