Каталог расширений

Популярные теги

3gp       avi       fb2       jpg       mp3       pdf      

Главная » Разное » Как сохранить в файл скрипт

Как сохранить в файл скрипт


Как сохранить полностью сайт со всеми Js скриптами

сохрани через браузер со всеми файлами и все. но он у тебя может не работать, т.к. некоторые скрипты в js требуют запроса к серверу, чтобы показать какой-то динамический контент. тоесть без интернета он у тебя тупо будет показывать пустые поля вместо содержания. или вообще ничего не отображать. если интернет есть, то скорее всего он заработает, но есть вариант, когда в скриптах адреса запросов неполностью записаны, из-за этого они могут ссылаться на несуществующие ресурсы. например, обычно пишут вместо http:// blablabla. com/login.php?action=login можно записать просто /login.php?action=login. тогда страница начнет ссылаться на те файлы, которые находятся не на сервере, а на твоем жестком диске (или туда, куда сохраняешь). скорее всего, придется вручную искать их и редактировать. можно еще скрипт на питоне с парсингом и заменой ссылок написать. но я думаю, это больше времени отнимет.

Как создать Javascript (js) файл.

Многие начинающие веб-программисты, когда они начинают изучать Javascript, сталкиваются с проблемой:

Как создать файл с расширением js, в котором будет размещаться javascript код?

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

В первую очередь, нужно понимать, что javascript – это обычный текст, который написан по определенным правилам. Соответственно, храниться этот текст тоже должен в текстовом документе.

Единственное отличие этого текстового документа от простого текстового файла – это его расширение. Javascript файлы имеют расширение *.js.

Таким образом, вся задача состоит в том, чтобы создать текстовый документ и изменить его расширение.

Хочу рассказать о тех способах создания файла с расширением js, которыми я сам лично пользуюсь.

Все мои уроки по Javascript здесь.

Способ 1. Создание файла js из обычного текстового документа.

Открываем программу «Блокнот», которая входит в стандартный пакет операционной системы Windows.

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

Создаем новый документ и сохраняем его, выбрав в главном меню команду «Файл-сохранить как…»


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

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

Как включить отображение расширений файлов в Windows.

После этой операции, файл для работы с Javascript готов.

Способ 2. Создание файла js в редакторе кода Dreamweaver.

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

Имейте в виду, что Dreamweaver – это далеко не единственная программа, которая на это способна. Очень многие редакторы кода тоже позволяют также создавать файлы с расширением js.

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

Выбираем его и сохраняем документ.

Все файл готов.

Если такое окно приветствия у вас не открылось, то можно воспользоваться главным меню «Файл – Создать новый документ» и выбираем «Javascript».

Если у вас возникнут какие-то вопросы или проблемы с созданием, файлов js таким способом, прошу написать об этом в комментариях.

Все мои уроки по Javascript здесь.

начало / Блог компании RUVDS.com / Хабр

Bash-скрипты: начало
Bash-скрипты, часть 2: циклы
Bash-скрипты, часть 3: параметры и ключи командной строки
Bash-скрипты, часть 4: ввод и вывод
Bash-скрипты, часть 5: сигналы, фоновые задачи, управление сценариями
Bash-скрипты, часть 6: функции и разработка библиотек
Bash-скрипты, часть 7: sed и обработка текстов
Bash-скрипты, часть 8: язык обработки данных awk
Bash-скрипты, часть 9: регулярные выражения
Bash-скрипты, часть 10: практические примеры
Bash-скрипты, часть 11: expect и автоматизация интерактивных утилит

Сегодня поговорим о bash-скриптах. Это — сценарии командной строки, написанные для оболочки bash. Существуют и другие оболочки, например — zsh, tcsh, ksh, но мы сосредоточимся на bash. Этот материал предназначен для всех желающих, единственное условие — умение работать в командной строке Linux.



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

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

pwd ; whoami

На самом деле, если вы опробовали это в своём терминале, ваш первый bash-скрипт, в котором задействованы две команды, уже написан. Работает он так. Сначала команда pwd выводит на экран сведения о текущей рабочей директории, потом команда whoamiпоказывает данные о пользователе, под которым вы вошли в систему.

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

getconf ARG_MAX

Командная строка — отличный инструмент, но команды в неё приходится вводить каждый раз, когда в них возникает необходимость. Что если записать набор команд в файл и просто вызывать этот файл для их выполнения? Собственно говоря, тот файл, о котором мы говорим, и называется сценарием командной строки.

Как устроены bash-скрипты


Создайте пустой файл с использованием команды touch. В его первой строке нужно указать, какую именно оболочку мы собираемся использовать. Нас интересует bash, поэтому первая строка файла будет такой:
#!/bin/bash

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

Команды оболочки отделяются знаком перевода строки, комментарии выделяют знаком решётки. Вот как это выглядит:

#!/bin/bash # This is a comment pwd whoami

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

Установка разрешений для файла сценария


Сохраните файл, дав ему имя myscript, и работа по созданию bash-скрипта почти закончена. Сейчас осталось лишь сделать этот файл исполняемым, иначе, попытавшись его запустить, вы столкнётесь с ошибкой Permission denied.
Попытка запуска файла сценария с неправильно настроенными разрешениями

Сделаем файл исполняемым:

chmod +x ./myscript

Теперь попытаемся его выполнить:
./myscript

После настройки разрешений всё работает как надо.
Успешный запуск bash-скрипта

Вывод сообщений


Для вывода текста в консоль Linux применяется команда echo. Воспользуемся знанием этого факта и отредактируем наш скрипт, добавив пояснения к данным, которые выводят уже имеющиеся в нём команды:
#!/bin/bash # our comment is here echo "The current directory is:" pwd echo "The user logged in is:" whoami

Вот что получится после запуска обновлённого скрипта.
Вывод сообщений из скрипта

Теперь мы можем выводить поясняющие надписи, используя команду echo. Если вы не знаете, как отредактировать файл, пользуясь средствами Linux, или раньше не встречались с командой echo, взгляните на этот материал.

Использование переменных


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

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

Существуют два типа переменных, которые можно использовать в bash-скриптах:

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

Переменные среды


Иногда в командах оболочки нужно работать с некими системными данными. Вот, например, как вывести домашнюю директорию текущего пользователя:
#!/bin/bash # display user home echo "Home for the current user is: $HOME"

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

А что если надо вывести на экран значок доллара? Попробуем так:

echo "I have $1 in my pocket"

Система обнаружит знак доллара в строке, ограниченной кавычками, и решит, что мы сослались на переменную. Скрипт попытается вывести на экран значение неопределённой переменной $1. Это не то, что нам нужно. Что делать?

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

echo "I have \$1 in my pocket"

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

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


В дополнение к переменным среды, bash-скрипты позволяют задавать и использовать в сценарии собственные переменные. Подобные переменные хранят значение до тех пор, пока не завершится выполнение сценария.

Как и в случае с системными переменными, к пользовательским переменным можно обращаться, используя знак доллара:
TNW-CUS-FMP — промо-код на 10% скидку на наши услуги, доступен для активации в течение 7 дней

#!/bin/bash # testing variables grade=5 person="Adam" echo "$person is a good boy, he is in grade $grade"

Вот что получится после запуска такого сценария.
Пользовательские переменные в сценарии

Подстановка команд


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

Сделать это можно двумя способами.

  • С помощью значка обратного апострофа «`»
  • С помощью конструкции $()

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

При втором подходе то же самое записывают так:
mydir=$(pwd)

А скрипт, в итоге, может выглядеть так:
#!/bin/bash mydir=$(pwd) echo $mydir

В ходе его работы вывод команды pwdбудет сохранён в переменной mydir, содержимое которой, с помощью команды echo, попадёт в консоль.
Скрипт, сохраняющий результаты работы команды в переменной

Математические операции


Для выполнения математических операций в файле скрипта можно использовать конструкцию вида $((a+b)):
#!/bin/bash var1=$(( 5 + 5 )) echo $var1 var2=$(( $var1 * 2 )) echo $var2


Математические операции в сценарии

Управляющая конструкция if-then


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

А вот рабочий пример:
#!/bin/bash if pwd then echo "It works" fi

В данном случае, если выполнение команды pwdзавершится успешно, в консоль будет выведен текст «it works».

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

#!/bin/bash user=likegeeks if grep $user /etc/passwd then echo "The user $user Exists" fi

Вот что получается после запуска этого скрипта.
Поиск пользователя

Здесь мы воспользовались командой grepдля поиска пользователя в файле /etc/passwd. Если команда grepвам незнакома, её описание можно найти здесь.

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

Управляющая конструкция if-then-else


Для того, чтобы программа смогла сообщить и о результатах успешного поиска, и о неудаче, воспользуемся конструкцией if-then-else. Вот как она устроена:
if команда then команды else команды fi

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

Напишем такой скрипт:

#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "The user $user Exists" else echo "The user $user doesn’t exist" fi

Его исполнение пошло по ветке else.
Запуск скрипта с конструкцией if-then-else

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

if команда1 then команды elif команда2 then команды fi

Если первая команда вернёт ноль, что говорит о её успешном выполнении, выполнятся команды в первом блоке then, иначе, если первое условие окажется ложным, и если вторая команда вернёт ноль, выполнится второй блок кода.
#!/bin/bash user=anotherUser if grep $user /etc/passwd then echo "The user $user Exists" elif ls /home then echo "The user doesn’t exist but anyway there is a directory under /home" fi

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

Сравнение чисел


В скриптах можно сравнивать числовые значения. Ниже приведён список соответствующих команд.
n1 -eq n2Возвращает истинное значение, если n1 равно n2.
n1 -ge n2 Возвращает истинное значение, если n1больше или равно n2.
n1 -gt n2Возвращает истинное значение, если n1 больше n2.
n1 -le n2Возвращает истинное значение, если n1меньше или равно n2.
n1 -lt n2Возвращает истинное значение, если n1 меньше n2.
n1 -ne n2Возвращает истинное значение, если n1не равно n2.

В качестве примера опробуем один из операторов сравнения. Обратите внимание на то, что выражение заключено в квадратные скобки.
#!/bin/bash val1=6 if [ $val1 -gt 5 ] then echo "The test value $val1 is greater than 5" else echo "The test value $val1 is not greater than 5" fi

Вот что выведет эта команда.
Сравнение чисел в скриптах

Значение переменной val1больше чем 5, в итоге выполняется ветвь thenоператора сравнения и в консоль выводится соответствующее сообщение.

Сравнение строк


В сценариях можно сравнивать и строковые значения. Операторы сравнения выглядят довольно просто, однако у операций сравнения строк есть определённые особенности, которых мы коснёмся ниже. Вот список операторов.
str1 = str2 Проверяет строки на равенство, возвращает истину, если строки идентичны.
str1 != str2Возвращает истину, если строки не идентичны.
str1 < str2Возвращает истину, если str1меньше, чем str2.
str1 > str2 Возвращает истину, если str1больше, чем str2.
-n str1 Возвращает истину, если длина str1больше нуля.
-z str1Возвращает истину, если длина str1равна нулю.

Вот пример сравнения строк в сценарии:
#!/bin/bash user ="likegeeks" if [$user = $USER] then echo "The user $user  is the current logged in user" fi

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

Вот одна особенность сравнения строк, о которой стоит упомянуть. А именно, операторы «>» и «<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>» как команду перенаправления вывода.

Вот как работа с этими операторами выглядит в коде:

#!/bin/bash val1=text val2="another text" if [ $val1 \> $val2 ] then echo "$val1 is greater than $val2" else echo "$val1 is less than $val2" fi

Вот результаты работы скрипта.
Сравнение строк, выведенное предупреждение

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

./myscript: line 5: [: too many arguments

Для того, чтобы избавиться от этого предупреждения, заключим $val2 в двойные кавычки:
#!/bin/bash val1=text val2="another text" if [ $val1 \> "$val2" ] then echo "$val1 is greater than $val2" else echo "$val1 is less than $val2" fi

Теперь всё работает как надо.
Сравнение строк

Ещё одна особенность операторов «>» и «<» заключается в том, как они работают с символами в верхнем и нижнем регистрах. Для того, чтобы понять эту особенность, подготовим текстовый файл с таким содержимым:

Likegeeks likegeeks

Сохраним его, дав имя myfile, после чего выполним в терминале такую команду:
sort myfile

Она отсортирует строки из файла так:
likegeeks Likegeeks

Команда sort, по умолчанию, сортирует строки по возрастанию, то есть строчная буква в нашем примере меньше прописной. Теперь подготовим скрипт, который будет сравнивать те же строки:
#!/bin/bash val1=Likegeeks val2=likegeeks if [ $val1 \> $val2 ] then echo "$val1 is greater than $val2" else echo "$val1 is less than $val2" fi

Если его запустить, окажется, что всё наоборот — строчная буква теперь больше прописной.
Команда sort и сравнение строк в файле сценария

В командах сравнения прописные буквы меньше строчных. Сравнение строк здесь выполняется путём сравнения ASCII-кодов символов, порядок сортировки, таким образом, зависит от кодов символов.

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

Проверки файлов


Пожалуй, нижеприведённые команды используются в bash-скриптах чаще всего. Они позволяют проверять различные условия, касающиеся файлов. Вот список этих команд.
-d fileПроверяет, существует ли файл, и является ли он директорией.
-e fileПроверяет, существует ли файл.
-f file Проверяет, существует ли файл, и является ли он файлом.
-r fileПроверяет, существует ли файл, и доступен ли он для чтения.
-s file Проверяет, существует ли файл, и не является ли он пустым.
-w fileПроверяет, существует ли файл, и доступен ли он для записи.
-x fileПроверяет, существует ли файл, и является ли он исполняемым.
file1 -nt file2 Проверяет, новее ли file1, чем file2.
file1 -ot file2Проверяет, старше ли file1, чем file2.
-O file Проверяет, существует ли файл, и является ли его владельцем текущий пользователь.
-G fileПроверяет, существует ли файл, и соответствует ли его идентификатор группы идентификатору группы текущего пользователя.

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

Опробуем одну из команд на практике:

#!/bin/bash mydir=/home/likegeeks if [ -d $mydir ] then echo "The $mydir directory exists" cd $ mydir ls else echo "The $mydir directory does not exist" fi

Этот скрипт, для существующей директории, выведет её содержимое.
Вывод содержимого директории

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

Итоги


Сегодня мы рассказали о том, как приступить к написанию bash-скриптов и рассмотрели некоторые базовые вещи. На самом деле, тема bash-программирования огромна. Эта статья является переводом первой части большой серии из 11 материалов. Если вы хотите продолжения прямо сейчас — вот список оригиналов этих материалов. Для удобства сюда включён и тот, перевод которого вы только что прочли.
  1. Bash Script Step By Step — здесь речь идёт о том, как начать создание bash-скриптов, рассмотрено использование переменных, описаны условные конструкции, вычисления, сравнения чисел, строк, выяснение сведений о файлах.
  2. Bash Scripting Part 2, Bash the awesome — тут раскрываются особенности работы с циклами for и while.
  3. Bash Scripting Part 3, Parameters & options — этот материал посвящён параметрам командной строки и ключам, которые можно передавать скриптам, работе с данными, которые вводит пользователь, и которые можно читать из файлов.
  4. Bash Scripting Part 4, Input & Output — здесь речь идёт о дескрипторах файлов и о работе с ними, о потоках ввода, вывода, ошибок, о перенаправлении вывода.
  5. Bash Scripting Part 5, Sighals & Jobs — этот материал посвящён сигналам Linux, их обработке в скриптах, запуску сценариев по расписанию.
  6. Bash Scripting Part 6, Functions — тут можно узнать о создании и использовании функций в скриптах, о разработке библиотек.
  7. Bash Scripting Part 7, Using sed — эта статья посвящена работе с потоковым текстовым редактором sed.
  8. Bash Scripting Part 8, Using awk — данный материал посвящён программированию на языке обработки данных awk.
  9. Bash Scripting Part 9, Regular Expressions — тут можно почитать об использовании регулярных выражений в bash-скриптах.
  10. Bash Scripting Part 10, Practical Examples — здесь приведены приёмы работы с сообщениями, которые можно отправлять пользователям, а так же методика мониторинга диска.
  11. Bash Scripting Part 11, Expect Command — этот материал посвящён средству Expect, с помощью которого можно автоматизировать взаимодействие с интерактивными утилитами. В частности, здесь идёт речь об expect-скриптах и об их взаимодействии с bash-скриптами и другими программами.

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

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

Как сохранить данные и экспортировать графики в R

автор: Samoedd Май 3, 2016

В предыдущих двух статьях я написал о том, как загрузить и как отредактировать таблицу данных в Rgui. Завершающим этапом в любом статистическом анализе является сохранение результатов. Результаты можно сохранить в разном виде: начиная от электронных таблиц, и заканчивая рабочим пространством R (формат .RData). Также я расскажу о том, как сохранять алгоритм команд и экспортировать графики.

Сохранение таблиц данных

Как и в прошлых двух статьях, мы будем работать с таблицей физических данных студентов одного из вымышленных военных ВУЗов (скачать можно здесь: voenvuz_clean). В статье о редактировании данных в R мы изменили структуру и содержание таблицы, однако не сохранили результат. К счастью, я сохранил алгоритм команд, который позволит восстановить отредактированную таблицу данных. Для этого в меню откроем вкладку "Файл" и выберем опцию "Новый скрипт". В открывшееся скриптовое окно вставляем следующий текст:

### загружаем таблицу данных в R 
voenvuz <- read.table("voenvuz_clean.txt", sep = "\t", header = T) 
### меняем типы данных таблицы 
voenvuz$Name <- as.character(voenvuz$Name) 
voenvuz$Height <- as.numeric(voenvuz$Height) 
voenvuz$Weight <- as.numeric(voenvuz$Weight) 
voenvuz$Blood.group <- as.factor(voenvuz$Blood.group) 
### добавляем и удаляем элементы таблицы 
Ivan <- list("Ivan", 21, 175, 67, "2", "+") 
Oleg <- list("Oleg", 24, 189, 82, "1", "+") 
voenvuz <- rbind(voenvuz, Ivan, Oleg) 
ID <- c(1:22) 
voenvuz <- cbind(voenvuz, ID) 
voenvuz$ID <- as.character(voenvuz$ID) 
voenvuz$BMI <- voenvuz$Weight / (voenvuz$Height * 0.01)^2 
trash2 <- voenvuz[ , -7] # удалим раннее созданный столбец "ID" 
trash3 <- voenvuz[ -2, ] # удалим строку под номером 2 (данные Петра) 
trash4 <- voenvuz[ -c(1,2,3,4,5,6,7,8,9,10), ] # удалим первые десять строк 
trash5 <- voenvuz[ -c(1:10), ] # то же самое, только код короче 
rm(trash2, trash3, trash4, trash5) 
names(voenvuz)[6] <- "Rhesus" 
voenvuz[1, "Name"] <- "Vanya" 
### сортировка и фильтрация данных 
voenvuz <- voenvuz[,c("Name", "ID", "Age", "Height", "Weight", "BMI", "Blood.group", "Rhesus")] 
voenvuz <- voenvuz[order(voenvuz$Name),] # сортировка по имени 
rownames(voenvuz) = c(1:length(voenvuz$ID)) # обновление номеров строк 
voenvuz

Теперь выделяем этот текст в скриптовом окне, и при помощи комбинации клавиш "Ctrl R" запускаем алгоритм команд в консоли. В конце Вы увидите результат обработки данных - таблицу "voenvuz" в консоли.

Полученную таблицу данных можно сохранить в разных форматах: для некоторых из них необходимо подключить дополнительные пакеты, для других нет. Как и прежде, я рекомендую писать все команды сначала в скриптовое окно и лишь затем переводить в консоль. Чтобы сохранить таблицу в обычном текстовом формате .txt достаточно ввести команду:

write.table(voenvuz, file = "voenvuz_final.txt", sep = "\t") 

Некоторые мои знакомые предпочитают сохранять таблицу в .csv формате:

write.csv(voenvuz, file = "voenvuz_final.csv")

Для экспорта таблицы в файлы .xlsx следует сначала загрузить пакет "xlsx" и затем воспользоваться его функцией write.xlsx():

library(xlsx) write.xlsx(voenvuz, file = "voenvuz_final.xlsx")

Также можно сохранять данные в форматах разных статистических программ, таких как SAS, SPSS или STATA, используя r-пакет "foreign".

Экспорт векторной и растровой графики из Rgui

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

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

par(mfrow=c(1,2))
hist(voenvuz$Weight, col = "light green",
 breaks = 4, main = "Вес студентов", xlab = "Вес (кг)") boxplot(voenvuz$Weight~voenvuz$Age, col = "light blue",
 main = "Вес в разных возрастных группах", 
 ylab = "Вес (кг)", xlab = "Возраст (год)")

Таким образом, мы получили два графика в одном окне; однако заголовок второго графика не поностью умещается. Решить эту проблему легко: растяните графическое окно так, чтобы текст графика не выходил за рамки окна. После этого, кликаем на графическое окно, в меню нажимаем вкладку "Файл", затем "Сохранить как" и выбираем нужный формат. Это самый простой метод сохранения изображения из среды R.

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

# Пример 1 
svg("example_1.svg") 
hist(voenvuz$Weight, col = "light green", breaks = 4,
 main = "Вес студентов", xlab = "Вес (кг)") dev.off() 
# Пример 2 
X11 () 
hist(voenvuz$Weight, col = "light green", breaks = 4,
 main = "Вес студентов", xlab = "Вес (кг)") 
dev.copy(tiff ,filename="example_2.tif") 
dev.off()

В первом мы просто сохранили файл векторного формата (.svg) в рабочую папку, не посмотрев предварительно на график в Rgui. Во втором - сначала просмотрели, как он будет выглядеть, а потом сохранили в растровом формате (.tif). Я рекомендую сохранять при помощи кода только те графики, которые были построены вручную в R (об этом я расскажу в отдельной статье). Если же Вы использовали функции автоматического построения, такие как plot(), boxplot(), hist(), то пользуйтесь меню - проще, быстрее, удобнее.

Как сохранить результаты статистического анализа?

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

a <- lm(voenvuz$Weight ~ voenvuz$Height) 
summary(a) 
plot(voenvuz$Weight ~ voenvuz$Height, 
 main = "Зависимость веса от роста",
 xlab = "Рост (см)", ylab = "Вес (кг)")
abline(a, col = "red")

В итоге у Вас должно появиться графическое отображение линейной модели на графике и описание результатов статистической модели в консоли. Мы видим, что вес статистически зависим от роста студентов: чем больше рост, тем больше вес (r² = 0.63, p < 0.001). Из описания мы можем извлечь интересующие нас параметры, такие как r², p-value, intercept и другие. Можно сказать, что мы сохранили результаты анализа...

Сохранение рабочего пространства

Но как поступить, если анализ идет в несколько этапов, занимает длительное количество времени, и мы знаем, что нам необходимо будет его продолжить в будущем? Неужели надо будет полностью перезапускать алгоритм, реализация которого может занять сутки или даже недели (как например с Байесовскими методами). В таких случаях стоит сохранить рабочее пространство R, то есть текущую сессию со всеми переменными в ней. Для этого кликаем на консоль, в меню выбираем вкладку "Файл", затем опцию "Сохранить рабочее пространство", и в формате .RData сохраняете новый файл. Вы можете поделиться этим файлом с Вашими коллегам или руководителем, что позволяет работать над проектом в команде.

Когда вернетесь за работу, запустите Rgui, загрузите рабочее пространство и продолжайте анализ. Чтобы вспомнить, какие переменные находятся в загруженном пространстве, введите функцию ls().

Сохранение скрипта и истории команд

Почему я всегда рекомендую писать все команды в скриптовом окне и лишь потом переводить их в консоль? Потому что перед завершением работы в R, скрипт можно сохранить как текстовый файл. Другими словами, при необходимости Вам всегда будет легко повторить или изменить что-либо в анализе данных: просто отредактируйте скрипт и запустите его в R (как мы сделали в начале этой статьи). Сохранить скрипт не составляет никакого труда: кликаем на скриптовое окно, затем идем в меню, выбираем вкладку "Файл" и далее "Сохранить как...". Можно сохранить его в формате .r, но я предпочитаю обычный .txt.

Также Вы можете сохранить историю команд (я никогда ее не сохранял, но на всякий случай, расскажу как это сделать). Для этого кликаем на окно консоли, открываем в меню вкладу "Файл" и выбираем "Сохранить историю команд...".

Заключение

Эта статья была заключительной из серии "Введение в R". В первой статье я рассказал о том, что такое язык и среда R; во второй мы попробовали использовать R на практике. Последние три были посвящены загрузке, обработке и сохранению таблицы данных. Кроме того, мы научились экспортировать графики, и сохранять рабочее пространство среды, историю и алгоритм команд (скрипт). Таким образом, теперь Вы имеете достаточный багаж знаний для того, чтобы беспрепятственно начать свой собственный путь в R...

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

P.S. Если возникли вопросы, задавайте их в комментариях, обязательно отвечу. Критика также приветствуется!

ввод и вывод / Блог компании RUVDS.com / Хабр

Bash-скрипты: начало
Bash-скрипты, часть 2: циклы
Bash-скрипты, часть 3: параметры и ключи командной строки
Bash-скрипты, часть 4: ввод и вывод
Bash-скрипты, часть 5: сигналы, фоновые задачи, управление сценариями
Bash-скрипты, часть 6: функции и разработка библиотек
Bash-скрипты, часть 7: sed и обработка текстов
Bash-скрипты, часть 8: язык обработки данных awk
Bash-скрипты, часть 9: регулярные выражения
Bash-скрипты, часть 10: практические примеры
Bash-скрипты, часть 11: expect и автоматизация интерактивных утилит

В прошлый раз, в третьей части этой серии материалов по bash-скриптам, мы говорили о параметрах командной строки и ключах. Наша сегодняшняя тема — ввод, вывод, и всё, что с этим связано.


Вы уже знакомы с двумя методами работы с тем, что выводят сценарии командной строки:

  • Отображение выводимых данных на экране.
  • Перенаправление вывода в файл.

Иногда что-то надо показать на экране, а что-то — записать в файл, поэтому нужно разобраться с тем, как в Linux обрабатывается ввод и вывод, а значит — научиться отправлять результаты работы сценариев туда, куда нужно. Начнём с разговора о стандартных дескрипторах файлов.

Стандартные дескрипторы файлов


Всё в Linux — это файлы, в том числе — ввод и вывод. Операционная система идентифицирует файлы с использованием дескрипторов.

Каждому процессу позволено иметь до девяти открытых дескрипторов файлов. Оболочка bash резервирует первые три дескриптора с идентификаторами 0, 1 и 2. Вот что они означают.

  • 0, STDIN — стандартный поток ввода.
  • 1, STDOUT — стандартный поток вывода.
  • 2, STDERR — стандартный поток ошибок.

Эти три специальных дескриптора обрабатывают ввод и вывод данных в сценарии.
Вам нужно как следует разобраться в стандартных потоках. Их можно сравнить с фундаментом, на котором строится взаимодействие скриптов с внешним миром. Рассмотрим подробности о них.

STDIN


STDIN — это стандартный поток ввода оболочки. Для терминала стандартный ввод — это клавиатура. Когда в сценариях используют символ перенаправления ввода — <, Linux заменяет дескриптор файла стандартного ввода на тот, который указан в команде. Система читает файл и обрабатывает данные так, будто они введены с клавиатуры.

Многие команды bash принимают ввод из STDIN, если в командной строке не указан файл, из которого надо брать данные. Например, это справедливо для команды cat.

Когда вы вводите команду cat в командной строке, не задавая параметров, она принимает ввод из STDIN. После того, как вы вводите очередную строку, cat просто выводит её на экран.

STDOUT


STDOUT — стандартный поток вывода оболочки. По умолчанию это — экран. Большинство bash-команд выводят данные в STDOUT, что приводит к их появлению в консоли. Данные можно перенаправить в файл, присоединяя их к его содержимому, для этого служит команда >>.

Итак, у нас есть некий файл с данными, к которому мы можем добавить другие данные с помощью этой команды:

pwd >> myfile

То, что выведет pwd, будет добавлено к файлу myfile, при этом уже имеющиеся в нём данные никуда не денутся.
Перенаправление вывода команды в файл

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

ls –l xfile > myfile

После выполнения этой команды мы увидим сообщения об ошибках на экране.
Попытка обращения к несуществующему файлу

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

STDERR


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

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

▍Перенаправление потока ошибок


Как вы уже знаете, дескриптор файла STDERR — 2. Мы можем перенаправить ошибки, разместив этот дескриптор перед командой перенаправления:
ls -l xfile 2>myfile cat ./myfile

Сообщение об ошибке теперь попадёт в файл myfile.
Перенаправление сообщения об ошибке в файл

▍Перенаправление потоков ошибок и вывода


При написании сценариев командной строки может возникнуть ситуация, когда нужно организовать и перенаправление сообщений об ошибках, и перенаправление стандартного вывода. Для того, чтобы этого добиться, нужно использовать команды перенаправления для соответствующих дескрипторов с указанием файлов, куда должны попадать ошибки и стандартный вывод:
ls –l myfile xfile anotherfile 2> errorcontent 1> correctcontent


Перенаправление ошибок и стандартного вывода

Оболочка перенаправит то, что команда ls обычно отправляет в STDOUT, в файл correctcontent благодаря конструкции 1>. Сообщения об ошибках, которые попали бы в STDERR, оказываются в файле errorcontent из-за команды перенаправления 2>.

Если надо, и STDERR, и STDOUT можно перенаправить в один и тот же файл, воспользовавшись командой &>:


Перенаправление STDERR и STDOUT в один и тот же файл

После выполнения команды то, что предназначено для STDERR и STDOUT, оказывается в файле content.

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


Существует два метода перенаправления вывода в сценариях командной строки:
  • Временное перенаправление, или перенаправление вывода одной строки.
  • Постоянное перенаправление, или перенаправление всего вывода в скрипте либо в какой-то его части.

▍Временное перенаправление вывода


В скрипте можно перенаправить вывод отдельной строки в STDERR. Для того, чтобы это сделать, достаточно использовать команду перенаправления, указав дескриптор STDERR, при этом перед номером дескриптора надо поставить символ амперсанда (&):
#!/bin/bash echo "This is an error" >&2 echo "This is normal output"

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

Запустим скрипт так, чтобы вывод STDERR попадал в файл.

./myscript 2> myfile

Как видно, теперь обычный вывод делается в консоль, а сообщения об ошибках попадают в файл.
Сообщения об ошибках записываются в файл

▍Постоянное перенаправление вывода


Если в скрипте нужно перенаправлять много выводимых на экран данных, добавлять соответствующую команду к каждому вызову echo неудобно. Вместо этого можно задать перенаправление вывода в определённый дескриптор на время выполнения скрипта, воспользовавшись командой exec:
#!/bin/bash exec 1>outfile echo "This is a test of redirecting all output" echo "from a shell script to another file." echo "without having to redirect every line"

Запустим скрипт.
Перенаправление всего вывода в файл

Если просмотреть файл, указанный в команде перенаправления вывода, окажется, что всё, что выводилось командами echo, попало в этот файл.

Команду exec можно использовать не только в начале скрипта, но и в других местах:

#!/bin/bash exec 2>myerror echo "This is the start of the script" echo "now redirecting all output to another location" exec 1>myfile echo "This should go to the myfile file" echo "and this should go to the myerror file" >&2

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

Сначала команда exec задаёт перенаправление вывода из STDERR в файл myerror. Затем вывод нескольких команд echo отправляется в STDOUT и выводится на экран. После этого команда exec задаёт отправку того, что попадает в STDOUT, в файл myfile, и, наконец, мы пользуемся командой перенаправления в STDERR в команде echo, что приводит к записи соответствующей строки в файл myerror.

Освоив это, вы сможете перенаправлять вывод туда, куда нужно. Теперь поговорим о перенаправлении ввода.

Перенаправление ввода в скриптах


Для перенаправления ввода можно воспользоваться той же методикой, которую мы применяли для перенаправления вывода. Например, команда exec позволяет сделать источником данных для STDIN какой-нибудь файл:
exec 0< myfile

Эта команда указывает оболочке на то, что источником вводимых данных должен стать файл myfile, а не обычный STDIN. Посмотрим на перенаправление ввода в действии:
#!/bin/bash exec 0< testfile count=1 while read line do echo "Line #$count: $line" count=$(( $count + 1 )) done

Вот что появится на экране после запуска скрипта.
Перенаправление ввода

В одном из предыдущих материалов вы узнали о том, как использовать команду read для чтения данных, вводимых пользователем с клавиатуры. Если перенаправить ввод, сделав источником данных файл, то команда read, при попытке прочитать данные из STDIN, будет читать их из файла, а не с клавиатуры.

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

Создание собственного перенаправления вывода


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

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

#!/bin/bash exec 3>myfile echo "This should display on the screen" echo "and this should be stored in the file" >&3 echo "And this should be back on the screen"

После запуска скрипта часть вывода попадёт на экран, часть — в файл с дескриптором 3.
Перенаправление вывода, используя собственный дескриптор

Создание дескрипторов файлов для ввода данных


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

После окончания чтения файла можно восстановить STDIN и пользоваться им как обычно:

#!/bin/bash exec 6<&0 exec 0< myfile count=1 while read line do echo "Line #$count: $line" count=$(( $count + 1 )) done exec 0<&6 read -p "Are you done now? " answer case $answer in y) echo "Goodbye";; n) echo "Sorry, this is the end.";; esac

Испытаем сценарий.
Перенаправление ввода

В этом примере дескриптор файла 6 использовался для хранения ссылки на STDIN. Затем было сделано перенаправление ввода, источником данных для STDIN стал файл. После этого входные данные для команды read поступали из перенаправленного STDIN, то есть из файла.

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

Закрытие дескрипторов файлов


Оболочка автоматически закрывает дескрипторы файлов после завершения работы скрипта. Однако, в некоторых случаях нужно закрывать дескрипторы вручную, до того, как скрипт закончит работу. Для того, чтобы закрыть дескриптор, его нужно перенаправить в &-. Выглядит это так:
#!/bin/bash exec 3> myfile echo "This is a test line of data" >&3 exec 3>&- echo "This won't work" >&3

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

Всё дело в том, что мы попытались обратиться к несуществующему дескриптору.

Будьте внимательны, закрывая дескрипторы файлов в сценариях. Если вы отправляли данные в файл, потом закрыли дескриптор, потом — открыли снова, оболочка заменит существующий файл новым. То есть всё то, что было записано в этот файл ранее, будет утеряно.

Получение сведений об открытых дескрипторах


Для того, чтобы получить список всех открытых в Linux дескрипторов, можно воспользоваться командой lsof. Во многих дистрибутивах, вроде Fedora, утилита lsof находится в /usr/sbin. Эта команда весьма полезна, так как она выводит сведения о каждом дескрипторе, открытом в системе. Сюда входит и то, что открыли процессы, выполняемые в фоне, и то, что открыто пользователями, вошедшими в систему.

У этой команды есть множество ключей, рассмотрим самые важные.

  • -p Позволяет указать ID процесса.
  • -d Позволяет указать номер дескриптора, о котором надо получить сведения.

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

Ключ -a используется для выполнения операции логического И над результатами, возвращёнными благодаря использованию двух других ключей:

lsof -a -p $$ -d 0,1,2


Вывод сведений об открытых дескрипторах

Тип файлов, связанных с STDIN, STDOUT и STDERR — CHR (character mode, символьный режим). Так как все они указывают на терминал, имя файла соответствует имени устройства, назначенного терминалу. Все три стандартных файла доступны и для чтения, и для записи.

Посмотрим на вызов команды lsof из скрипта, в котором открыты, в дополнение к стандартным, другие дескрипторы:

#!/bin/bash exec 3> myfile1 exec 6> myfile2 exec 7< myfile3 lsof -a -p $$ -d 0,1,2,3,6,7

Вот что получится, если этот скрипт запустить.
Просмотр дескрипторов файлов, открытых скриптом

Скрипт открыл два дескриптора для вывода (3 и 6) и один — для ввода (7). Тут же показаны и пути к файлам, использованных для настройки дескрипторов.

Подавление вывода


Иногда надо сделать так, чтобы команды в скрипте, который, например, может исполняться как фоновый процесс, ничего не выводили на экран. Для этого можно перенаправить вывод в /dev/null. Это — что-то вроде «чёрной дыры».

Вот, например, как подавить вывод сообщений об ошибках:

ls -al badfile anotherfile 2> /dev/null

Тот же подход используется, если, например, надо очистить файл, не удаляя его:
cat /dev/null > myfile

Итоги


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

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

Уважаемые читатели! В этом материале даны основы работы с потоками ввода, вывода и ошибок. Уверены, среди вас есть профессионалы, которые могут рассказать обо всём этом то, что приходит лишь с опытом. Если так — передаём слово вам.

rstudio - Сохранение файла сценария .R с помощью сценария

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
.

linux - Как сохранить вывод скрипта в текстовый файл с повторяющимся именем файла?

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд
.

Как сохранить вывод моего скрипта Python в виде файла CSV?

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
.

Как сохранить функцию как новый сценарий R?

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанять техник
.

Как автоматически сохранять изменения перед запуском скрипта Python в VS Code

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
.Система

- Как сохранить вывод cmd в текстовый файл через другой скрипт python

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
.

Смотрите также