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

Какая функция предназначена для вывода в консоль

  • автор:

Какая функция предназначена для вывода в консоль

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

print("Hello METANIT.COM")

Данный код выведет нам на консоль строку «Hello METANIT.COM».

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

print("Hello World") print("Hello METANIT.COM") print("Hello Python")

Здесь три вызова функции print() выводят некоторое сообщение. Причем при выводе на консоль каждое сообщение будет размещаться на отдельной строке:

Hello World Hello METANIT.COM Hello Python

Такое поведение не всегда удобно. Например, мы хотим, чтобы все значения выводились на одной строке. Для этого нам надо настроить поведение функции с помощью параметра end . Этот параметр задает символы, которые добавляются в конце к выводимой строке и . При применении параметра end вызов функции print() выглядит следующим образом:

print(значение, end = конечные_символы)

По умолчанию end равен символу «\n» , который задает перевод на следующую строку. Собственно поэтому функция print по умолчанию выводит передаваемое ей значение на отдельной строке.

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

print("Hello World", end=" ") print("Hello METANIT.COM", end=" ") print("Hello Python")

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

Hello World Hello METANIT.COM Hello Python

Причем это может быть не один символ, а набор символов:

print("Hello World", end=" and ") print("Hello METANIT.COM", end=" and ") print("Hello Python")

В данном случае выводимые сообщения будут отделяться символами » and » :

Hello World and Hello METANIT.COM and Hello Python

Консольный ввод

Наряду с выводом на консоль мы можем получать ввод пользователя с консоли, получать вводимые данные. Для этого в Python определена функция input() . В эту функцию передается приглашение к вводу. А результат ввода мы можем сохранить в переменную. Например, определим код для ввода пользователем имени:

name = input("Введите свое имя: ") print(f"Ваше имя: ")

В данном случае в функцию input() передается приглашение к вводу в виде строки «Введите свое имя: «. Результат функции — результат ввода пользователя передается в переменную name . Затем мы можем вывести значение этой переменной на консоль с помощью функции print() . Пример работы кода:

Введите свое имя: Eugene Ваше имя: Eugene

Еще пример с вводом нескольких значений:

name = input("Your name: ") age = input("Your age: ") print(f"Name: Age: ")

Пример работы программы:

Your name: Tom Your age: 37 Name: Tom Age: 37

Стоит учитывать, что все введенные значения рассматриваются как значения типа str , то есть строки. И даже если мы вводим число, как в втором случае в коде выше, то Python все равно будет рассматривать введенное значение как строку, а не как число.

Ввод и вывод данных

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

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

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

Можно сказать, что программа – это открытая система, которая обменивается чем-либо с внешней для нее средой. Если живой организм в основном обменивается веществом и энергией, то программа – данными, информацией.

Вывод данных. Функция print()

Что такое функция в программировании, узнаем позже. Пока будем считать, что print() – это такая команда языка Python, которая выводит то, что в ее скобках на экран.

>>> print(1032) 1032 >>> print(2.34) 2.34 >>> print("Hello") Hello

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

>>> print("a:", 1) a: 1 >>> one = 1 >>> two = 2 >>> three = 3 >>> print(one, two, three) 1 2 3

Можно передавать в функцию print() как непосредственно литералы (в данном случае «a:» и 1), так и переменные, вместо которых будут выведены их значения. Аргументы функции (то, что в скобках), разделяются между собой запятыми. В выводе вместо запятых значения разделены пробелом.

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

>>> print("hello" + " " + "world") hello world >>> print(10 - 2.5/2) 8.75

В print() предусмотрены дополнительные параметры. Например, через параметр sep можно указать отличный от пробела разделитель строк:

>>> print("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun", sep="-") Mon-Tue-Wed-Thu-Fri-Sat-Sun >>> print(1, 2, 3, sep="//") 1//2//3

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

>>> print(10, end="") 10>>>

Обычно end используется не в интерактивном режиме, а в скриптах, когда несколько выводов подряд надо разделить не переходом на новую строку, а, скажем, запятыми. Сам переход на новую строку обозначается символом ‘\n’. Если присвоить это значение параметру end , то никаких изменений в работе функции print вы не увидите, так как это значение и так присвоено по-умолчанию:

>>> print(10, end='\n') 10 >>>

Однако, если надо отступить на одну дополнительную строку после вывода, то можно сделать так:

>>> print(10, end='\n\n') 10 >>>

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

Форматирование может выполняться в так называемом старом стиле или с помощью строкового метода format . Старый стиль также называют Си-стилем, так как он схож с тем, как происходит вывод на экран в языке C. Рассмотрим пример:

>>> pupil = "Ben" >>> old = 16 >>> grade = 9.2 >>> print("It's %s, %d. Level: %f" % (pupil, old, grade)) It's Ben, 16. Level: 9.200000

Здесь вместо трех комбинаций символов %s , %d , %f подставляются значения переменных pupil , old , grade . Буквы s , d , f обозначают типы данных – строку, целое число, вещественное число. Если бы требовалось подставить три строки, то во всех случаях использовалось бы сочетание %s .

Хотя в качестве значения переменной grade было указано число 9.2, на экран оно вывелось с дополнительными нулями. Чтобы указать, сколько требуется знаков после запятой, надо перед f поставить точку, после нее указать желаемое количество знаков в дробной части:

>>> print("It's %s, %d. Level: %.1f" % (pupil, old, grade)) It's Ben, 16. Level: 9.2

Теперь посмотрим на метод format() :

>>> print("This is a . It's .".format("ball", "red")) This is a ball. It's red. >>> >>> print("This is a . It's .".format("white", "cat")) This is a cat. It's white. >>> >>> print("This is a . It's .".format("a", "number", 1)) This is a 1. It's a number.

В строке в фигурных скобках указаны номера данных, которые будут сюда подставлены. Далее к строке применяется метод format() . В его скобках указываются сами данные (можно использовать переменные). На нулевое место подставится первый аргумент метода format() , на место с номером 1 – второй и т. д.

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

В новых релизах Питона появился третий способ создания форматированных строк – f-строки. Перед их открывающей кавычкой прописывается буква f . В самой строке внутри фигурных скобок записываются выражения на Python, которые исполняются, когда интерпретатор преобразует строку-шаблон в обычную.

>>> a = 10 >>> b = 1.33 >>> c = 'Box' >>> print(f'qty - , goods - ') qty - 10, goods - Box >>> print(f'price - ') price - 1.5

В примере число 5 после переменной a обозначает количество знакомест, отводимых под вывод значения переменной. В выражении b + 0.2:.1f сначала выполняется сложение, после этого значение округляется до одного знака после запятой.

Ввод данных. Функция input()

За ввод в программу данных с клавиатуры в Python отвечает функция input . Когда вызывается эта функция, программа останавливает свое выполнение и ждет, когда пользователь введет текст. После этого, когда он нажмет Enter , функция input() заберет введенный текст и передаст его программе, которая уже будет обрабатывать его согласно своим алгоритмам.

Если в интерактивном режиме ввести команду input() , то ничего интересного вы не увидите. Компьютер будет ждать, когда вы что-нибудь введете и нажмете Enter или просто нажмете Enter . Если вы что-то ввели, это сразу же отобразиться на экране:

>>> input() Yes! 'Yes!'

Функция input() передает введенные данные в программу. Их можно присвоить переменной. В этом случае интерпретатор не выводит строку сразу же:

>>> answer = input() No, it is not.

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

>>> answer 'No, it is not.'

При использовании функции print() кавычки в выводе опускаются:

>>> print(answer) No, it is not.

Куда интересней использовать функцию input() в скриптах – файлах с кодом. Рассмотрим такую программу:

name_user = input() city_user = input() print(f'Вас зовут . Ваш город ')

Использование функции input()

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

Вышеприведенный скрипт далек от совершенства. Откуда пользователю знать, что хочет от него программа? Чтобы не вводить человека в замешательство, для функции input предусмотрен специальный параметр-приглашение. Это приглашение выводится на экран при вызове input() . Усовершенствованная программа может выглядеть так:

name_user = input('Ваше имя: ') city_user = input('Ваш город: ') print(f'Вас зовут . Ваш город ')

Функция input() с аргументом-приглашением

Обратите внимание, что в программу поступает строка. Даже если ввести число, функция input() все равно вернет его строковое представление. Но что делать, если надо получить число? Ответ: использовать функции преобразования типов.

Преобразование ввода к числу

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

Программный код можно сократить, если преобразование типов выполнить в тех же строках кода, где вызывается функция input() :

qty = int(input("Сколько апельсинов? ")) price = float(input("Цена одного? ")) summa = qty * price print("Заплатите", summa, "руб.")

Сначала выполняется функция input() . Она возвращает строку, которую функция int() или float() сразу преобразует в число. Только после этого происходит присваивание переменной, то есть она сразу получает численное значение.

Практическая работа

  1. Напишите программу (файл user.py ), которая запрашивала бы у пользователя:
    — его имя (например, «What is your name?»)
    — возраст («How old are you?»)
    — место жительства («Where are you live?»)
    После этого выводила бы три строки:
    «This is имя »
    «It is возраст »
    «(S)he live in место_жительства »
    Вместо имя , возраст , место_жительства должны быть данные, введенные пользователем. Примечание: можно писать фразы на русском языке, но если вы планируете стать профессиональным программистом, привыкайте к английскому.
  2. Напишите программу (файл arithmetic.py ), которая предлагала бы пользователю решить пример 4 * 100 — 54. Потом выводила бы на экран правильный ответ и ответ пользователя. Подумайте, нужно ли здесь преобразовывать строку в число.
  3. Запросите у пользователя четыре числа. Отдельно сложите первые два и отдельно вторые два. Разделите первую сумму на вторую. Выведите результат на экран так, чтобы ответ содержал две цифры после запятой.

Примеры решения и дополнительные уроки в pdf-версии курса

X Скрыть Наверх

Python. Введение в программирование

Какая функция предназначена для вывода в консоль

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

  • Стандартный поток ввода stdin
  • Стандартный поток вывода stdout
  • Стандартный поток вывода сообщений об ошибках stderr

Стандартный поток ввода stdin по умолчанию соответствует клавиатуре, а потоки stdout и stderr — экрану монитора.

Для управления вводом-выводом с помощью этих потоков используются ряд функций:

  • getchar() : ввод с клавиатуры одного символа
  • putchar() : вывод на консоль одного символа
  • fgets() : ввод одной строки
  • puts() / fputs() : вывод одной строки на консоль
  • scanf() : ввод с консоли с форматированием данных
  • sscanf() : ввод с из строки с форматированием данных
  • printf() : вывод с форматированием данных

Функции printf и scanf уже рассматривались ранее, поэтому посмотрим, как применять остальные функции.

Ввод и вывод символов

Для ввода и вывода символа применяются функции getchar() и putchar() . Но следует сказать, что на самом деле они полноценными функциями не являются, а определены как макросы в заголовочном файле stdio.h :

#define getchar() getc(stdin) #define putchar(c) putc((c), stdout)
Вывод символа

Для вывода отдельного символа на консоль предназначена функция putchar() со следующим прототипом:

int putchar(int c);

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

#include int main(void) < char c = 'A'; putchar(c); // Выводим символ A >
Ввод символа

Для ввода одного символа с клавиатуры применяется функция getchar() , которая имеет следующий прототип:

int getchar(void);

В качестве результата функция возвращает числовой код введенного символа.

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

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

При этом при нажатии клавиши Enter, в буфер также помещается код этой клавиши. То есть если мы введем один символ и нажмем на Enter, в буфере окажутся два числовых кода — введенного символа и клавиши Enter. И это надо учитывать при работе с функцией getchar. В частости, рассмотрим простой, но показательный пример:

#include int main(void) < printf("1"); getchar(); // ожидание ввода символа printf("2"); getchar(); // ожидание ввода символа printf("3"); return 0; >

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

Например, введем при первом вызове функции getchar символ «a», а затем Enter:

1a 23

Но если при каждом вызове getchar мы будем только нажимать клавишу Enter, тогда в буфер будет заноситься только код этой клавиши, и соответственно программа будет работать, как и ожидалось:

1 2 3

Применим функции getchar и putchar для ввода и вывода символов с клавиатуры:

#include int main(void) < int c; while((c=getchar())!=EOF) < putchar(c); >return 0; >

Функция getchar() считывает числовой код символа, который потом выводится в функции putchar() . Для вывода из программы необходимо ввести комбинацию клавиш Ctrl+C.

Ввод и вывод строк

Вывод строк и puts

Для вывода одной строки на консоль предназначена функция puts() со следующим прототипом:

int putchar(char *s);

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

При этом функция puts() будет выводить символы переданной строки, пока не дойдет до нулевого символа ‘\0’. Если же выводимый массив символов не содержит этого символа, то результат программы неопределен. Например:

#include int main(void) < puts("Hello World"); // выводим строковый литерал char* name = "Hello Metanit.com"; puts(name); // выводим значение переменной return 0; >
Hello World Hello Metanit.com
Вывод строк и fputs

Функция fputs() также записывает в поток вывода строку, то есть набор символов, который завершается символом ‘\0’. При записи строки нулевой символ ‘\0’ не записывается. Она имеет следующий прототип:

int fputs(const char *s, FILE *stream);

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

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

#include int main(void)

Ввод строк и fgets

Для ввода строки с клавиатуры применяется функция fgets() , которая имеет следующий прототип:

char *fgets(char *str, int count, FILE *stream);
  • char *str : строка, в которую производится считывание.
  • int count : сколько символов необходимо считывать.
  • FILE *stream : файловый поток, из которого производится считывание. В качестве потока ввода может выступать и консольный ввод.

Функция fgets() прекращает считывание, когда пользователь нажимает клавишу ENTER, то есть когда в поток добавляется символ перевода строки.

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

#include #define MAX 15 int main(void)

Здесь функция fgets считывает не более 15 символов в строку name, а В реальности функция предложит ввести 14 символов, так как последний символ зарезервирован для нулевого символа ‘\0’. Если будет введено больше символов, то fgets все равно считает не более 15 символов. Таким образом функция позволяет проверить количество считываемых символов и поэтому считается безопасной.

Пример работы программы:

Enter name: Tom Smith Your name: Tom Smith

Стоит отметить, что функция fgets() возвращает указатель char * — указатель на буфер, в который считаны данные. В реальности это тот же самый буфер, который передавался в качестве первого параметра, то есть в примере выше — это массив name. Однако этот результат может нам пригодится для проверки успешности выполнения функции — если считывание прошло неудачно, то функция возвращает NULL :

#include #define MAX 15 int main(void) < char name[MAX]; printf("Enter name: "); if(fgets(name, MAX, stdin) != NULL) // if(fgets(name, MAX, stdin)) - можно сократить < printf("Your name: %s\n", name); >else < printf("Critical Error. "); >return 0; >

Для эмуляции ошибки можно передать в функцию вторым параметром число 0.

fgets и scanf

При использовании функции fgets() после функции scanf() мы можем столкнуться с некорректным вводом:

#include #define N 32 int main(void) < int age; char name[N]; // считываем возраст в переменную age printf("Input age: "); scanf("%d", &age); // считываем строку в переменну. name printf("Input name: "); fgets(name, N, stdin); // проверяем ввод printf("Age: %d\n", age); printf("Name: %s\n", name); >

В данном случае сначала с помощью функции scanf() считываем число в переменную age. После этого считываем имя — строку с помощью функции fgets() в переменную name. Но посмотрим, какой будет результат работы программы:

Input age: 39 Input name: Age: 39Name:

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

Все дело в том, что функция scanf() считывает именно то, что ей предписано — число в виде переменной типа int. Все остальные символы остаются в буфере, в который предварительно попадают введенные с клавиатуры символы. Так, после ввода возраста мы нажимаем на клавишу Enter, и в буфер попадает символ «\n», то есть перевод строки. И fgets считывает этот символ из буфера, после чего ввод имени завершается. Очевидно, это не то поведение, на которое мы рассчитывали.

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

Первый способ — считывание символа с помощью вызова scanf(«%*c») :

#include #define N 32 int main(void) < int age; char name[N]; // считываем возраст в переменную age printf("Input age: "); scanf("%d", &age); scanf("%*c"); // вытаскиваем символ из буфера // считываем строку в переменну. name printf("Input name: "); fgets(name, N, stdin); // проверяем ввод printf("Age: %d\n", age); printf("Name: %s\n", name); >

Второй способ — мы можем считать символ с помощью getchar() :

#include #define N 32 int main(void) < int age; char name[N]; // считываем возраст в переменную age printf("Input age: "); scanf("%d", &age); getchar(); // вытаскиваем символ из буфера // считываем строку в переменну. name printf("Input name: "); fgets(name, N, stdin); // проверяем ввод printf("Age: %d\n", age); printf("Name: %s\n", name); >

Результат работы программы:

Input age: 39 Input name: Tom Age: 39 Name: Tom

Использование JavaScript-консоли в браузерах

Сегодня мы публикуем заметку, посвящённую особенностям использования JavaScript-консоли в браузерах, лежащим за пределами широко известной команды console.log() . Собственно говоря, эта команда представляет собой простейший инструмент для отладки программ, который позволяет выводить что-либо в консоль. Однако знание некоторых особенностей этого инструмента позволит тем, кто им пользуется, повысить эффективность работы.

Команда console.log() и имена переменных

Простейший вариант использования console.log() заключается, например, в выводе некоей строки или объекта. Например, выведем в консоль строку:

console.log('Is this working?');

Теперь представим себе, что в консоль нужно вывести несколько объектов. Например — таких:

const foo = < id: 1, verified: true, color: 'green' >; const bar = < id: 2, verified: false, color: 'red' >;

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

Взглянем на то, что выводится в консоль.

В консоли нет имён переменных

Как можно видеть, имён переменных, foo и bar , здесь нет. Объекты, пользуясь значком в виде стрелки в левых частях строк, можно разворачивать, но даже так, глядя на внутреннюю структуру объектов, понять, какой именно объект выведен в консоль, может быть весьма непросто. В решении этой проблемы нам помогут вычисляемые имена свойств объектов. А именно, эта особенность объектных литералов, появившаяся в ES6, позволяет пользоваться удобной конструкцией следующего вида:

console.log(< foo, bar >);

При таком подходе в консоль попадёт объект, имена свойств которого будут представлять собой имена переменных-объектов, которые нужно вывести. Кроме того, это позволяет избавиться от некоторых вызовов console.log() , используемых ранее для вывода объектов по отдельности.

Команда console.table()

Улучшать внешний вид того, что программа выводит в консоль, можно и дальше, оформив содержимое объектов в виде таблицы. Это хорошо скажется на читаемости информации. А именно, речь идёт о том, что если вы выводите в консоль объекты с одинаковыми именами свойств, или массивы похожих объектов, вы можете воспользоваться командой console.table() . Вот как выглядит результат выполнения команды вида console.table(< foo, bar >) .

Команда console.table() в действии

Команда console.group()

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

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

console.group('User Details'); console.log('name: John Doe'); console.log('job: Software Developer'); // Вложенная группа console.group('Address'); console.log('Street: 123 Townsend Street'); console.log('City: San Francisco'); console.log('State: CA'); console.groupEnd(); console.groupEnd();

Вот как выглядят результаты работы этого кода.

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

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

Команды console.warn() и console.error()

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

Предупреждения и ошибки

Возможно, вам пригодится и команда console.info() , которая предназначена для вывода информационных сообщений.

В настройке внешнего вида сообщений, выводимых в консоль, можно пойти и ещё дальше, самостоятельно их стилизовав. Для стилизации текстов, выводимых в консоль, можно воспользоваться директивой %c . Это может оказаться полезным, например, для организации визуального разделения сведений, поступающих от подсистем выполнения обращений к неким API, от подсистем, ответственных за обработку событий, генерируемых пользователем, и так далее. Главное тут — выработать некие правила стилизации и их придерживаться. Вот пример настройки внешнего вида данных, выводимых в консоль:

console.log('%c Auth ', 'color: white; background-color: #2274A5', 'Login page rendered'); console.log('%c GraphQL ', 'color: white; background-color: #95B46A', 'Get user details'); console.log('%c Error ', 'color: white; background-color: #D33F49', 'Error getting user details');

Тут же можно настраивать и другие CSS-свойства текста, наподобие font-size и font-style .

Стилизация данных, выводимых в консоль

Команда console.trace()

Команда console.trace() выводит в консоль результаты трассировки стека и позволяет судить о том, что произошло в определённом месте программы во время её выполнения. Например, существуют некоторые методы, которые, в определённых ситуациях, нужно вызывать лишь один раз, скажем — методы для удаления информации из базы данных. Проверить, действительно ли выполняется лишь однократный вызов подобного метода, можно с помощью console.trace() . Эта команда позволяет вывести в консоль сведения, которые помогают проконтролировать правильность работы внутренних механизмов программ.

Команда console.time()

Одна из важных задач, встающая перед фронтенд-разработчиком, заключается в том, чтобы обеспечить высокую скорость работы кода. Команда console.time() позволяет замерять время выполнения операций и выводить то, что удалось выяснить, в консоль. Например, исследуем с помощью этой команды пару циклов:

let i = 0; console.time("While loop"); while (i < 1000000) < i++; >console.timeEnd("While loop"); console.time("For loop"); for (i = 0; i < 1000000; i++) < // Тело цикла >console.timeEnd("For loop");

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

Результаты использования console.time()

Итоги

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

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *