Устранение ошибки ora-4031 «невозможно выделить x байтов общей памяти»

Содержание

Тестирование App Cloner Тестирование Parallel Space

2Accounts в магазине Google Play

Тестирование 2Accounts

App Cloner 2.7.1 Android 4.1 и выше

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

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

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

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

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

На телефоне создано слишком много файлов – суть проблемы

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

И если система и пользователь обычно выдерживают лимит в 4 Гб для одного файла, то с количеством файлов иногда возникают трудности. Особенно это касается различных приложений уровня «Samsung Members» или «Ping Tools», способные создавать тысячи мелких файлов внутри своих и системных директорий. Подчас общий объём созданных ими файлов составляет десятки гигабайт, и очень быстро системный лимит на количество файлов бывает исчерпан. В этом случае телефон начинает работать всё хуже, и, в конце концов, вы просто не сможете запустить большинство ваших приложений.

Попытка борьбы с ошибкой включая использование программ уровня «Clean Master», сброс телефона до заводских настроек и другие популярные решения обычно не решают возникшую проблему. Или помогают паллиативно, на пару дней, после чего уведомление о недостатке места появляются вновь. Обращения же владельцев телефонов в поддержку Самсунг не меняют ровным счётом ничего.

Эффективно устранить ошибку с большим количеством файлов на Самсунг помогут способы, которые мы последовательно опишем ниже.

Стриминг Requests¶

С вы можете легко
перебирать потоковые API, такие как API потоковой передачи Twitter.
Просто установить на
и повторите ответ с :

import json
import requests

r = requests.get('https://httpbin.org/stream/20', stream=True)

for line in r.iter_lines():

    # отфильтровать оставшиеся новые строки
    if line
        decoded_line = line.decode('utf-8')
        print(json.loads(decoded_line))

При установке decode_unicode=True с или вы захотите предоставить резервную кодировку на
случай, если сервер её не предоставляет:

r = requests.get('https://httpbin.org/stream/20', stream=True)

if r.encoding is None
    r.encoding = 'utf-8'

for line in r.iter_lines(decode_unicode=True):
    if line
        print(json.loads(line))

Так что же это?

Понятие «объектная гимнастика» ввёл Джефф Бэй (Jeff Bay) в своей книге «The ThoughtWorks Anthology» (на русском не издавалась. — Пер.). Так он назвал группу упражнений на объектно-ориентированное программирование.

Применяя объектную гимнастику, можно сделать код:

  • читабельнее;
  • удобнее:

       • для отладки,

       • тестирования,

       • повторного использования

       • и сопровождения.

Считайте это упражнением. Вам нужно научиться выполнять эти правила при кодинге. А вот в повседневном программировании какими-то из них всегда можно пожертвовать — если следовать им слишком сложно или результат того не стоит.

Заголовки ссылок¶

Многие HTTP API содержат заголовки ссылок. Они делают API-интерфейсы более
самоописываемыми и легко обнаруживаемыми.

GitHub использует их, например, для пагинации в своём API:

>>> url = 'https://api.github.com/users/kennethreitz/repos?page=1&per_page=10'
>>> r = requests.head(url=url)
>>> r.headers'link'
'<https://api.github.com/users/kennethreitz/repos?page=2&per_page=10>; rel="next", <https://api.github.com/users/kennethreitz/repos?page=6&per_page=10>; rel="last"'

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

Почему (неконстантные) глобальные переменные — это зло?

Безусловно, причина №1, почему неконстантные глобальные переменные являются опасными, — это то, что их значения могут изменять любые вызываемые функции, при этом вы можете этого и не знать. Например, рассмотрим следующую программу:

#include <iostream>

// Объявление глобальной переменной
int g_mode;

void doSomething()
{
g_mode = 2; // присваиваем глобальной переменной g_mode значение 2
}

int main()
{
g_mode = 1; // примечание: Здесь мы присваиваем глобальной переменной g_mode значение 1. Это не объявление локальной переменной g_mode!

doSomething();

// Программист по-прежнему ожидает, что g_mode будет 1.
// Но функция doSomething() изменила значение этой переменной на 2!

if (g_mode == 1)
std::cout << «No threat detected.\n»;
else
std::cout << «Launching nuclear missiles…\n»;

return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>
 
// Объявление глобальной переменной

intg_mode;

voiddoSomething()

{

g_mode=2;// присваиваем глобальной переменной g_mode значение 2

}

intmain()

{

g_mode=1;// примечание: Здесь мы присваиваем глобальной переменной g_mode значение 1. Это не объявление локальной переменной g_mode!

doSomething();

// Программист по-прежнему ожидает, что g_mode будет 1.

// Но функция doSomething() изменила значение этой переменной на 2!

if(g_mode==1)

std::cout<<«No threat detected.\n»;

else

std::cout<<«Launching nuclear missiles…\n»;

return;

}

Результат выполнения программы:

Сначала мы присваиваем переменной значение , а затем вызываем функцию doSomething(). Если бы мы не знали заранее, что doSomething() изменит значение , то, вероятно, не ожидали бы дальнейшего развития событий ( => )!

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

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

void boo()
{
// Некоторый код

if (g_mode == 4) // делаем что-нибудь полезное
}

1
2
3
4
5
6

voidboo()

{

// Некоторый код

if(g_mode==4)// делаем что-нибудь полезное

}

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

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

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

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

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

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

Подтверждение сертификата SSL¶

Requests проверяет сертификаты SSL для HTTPS запросов, как веб-браузер. По
умолчанию проверка SSL включена, и Requests выдаст ошибку SSLError, если не
сможет проверить сертификат:

>>> requests.get('https://requestb.in')
requests.exceptions.SSLError: hostname 'requestb.in' doesn't match either of '*.herokuapp.com', 'herokuapp.com'

У меня нет настройки SSL в этом домене, поэтому возникает исключение.
Превосходно. Однако у GitHub это настроено:

>>> requests.get('https://github.com')
<Response >

Вы можете передать путь к файлу или каталогу CA_BUNDLE с
сертификатами доверенных центров сертификации:

>>> requests.get('https://github.com', verify='/path/to/certfile')

или стойкий:

s = requests.Session()
s.verify = '/path/to/certfile'

Примечание

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

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

Requests также может игнорировать проверку сертификата SSL, если для
задано ложное значение:

>>> requests.get('https://kennethreitz.org', verify=False)
<Response >

Обратите внимание, что если для установлено значение ,
requests примет любой сертификат TLS, представленный сервером, и будет
игнорировать несоответствия имени хоста и/или сертификаты с истекшим сроком
действия, что сделает ваше приложение уязвимым для атак типа «человек
посередине» (MitM). Установка параметра verify на может быть полезна
во время локальной разработки или тестирования

Как защититься от «глобального разрушения»?

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

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

Например, вместо следующего:

#include <iostream>

double gravity (9.8); // по имени переменной непонятно, глобальная ли это переменная или локальная

int main()
{
return 0;
}

1
2
3
4
5
6
7
8

#include <iostream>
 

doublegravity(9.8);// по имени переменной непонятно, глобальная ли это переменная или локальная

intmain()

{

return;

}

Сделайте следующее:

#include <iostream>

double g_gravity (9.8); // теперь понятно, что это глобальная переменная

int main()
{
return 0;
}

1
2
3
4
5
6
7
8

#include <iostream>
 

doubleg_gravity(9.8);// теперь понятно, что это глобальная переменная

intmain()

{

return;

}

Во-вторых, вместо разрешения прямого доступа к глобальным переменным, лучше их «инкапсулировать». Сначала добавьте ключевое слово , чтобы доступ к ним был возможен только из файла, в котором они объявлены. Затем напишите внешние глобальные «функции доступа» для работы с переменными. Эти функции помогут обеспечить надлежащее использование переменных (например, при проверке ввода, проверке допустимого диапазона значений и т.д.). Кроме того, если вы когда-либо решите изменить первоначальную реализацию программы (например, перейти из одной базы данных в другую), то вам нужно будет обновить только функции доступа вместо каждого фрагмента кода, который напрямую использует глобальные переменные.

Например, вместо следующего:

double g_gravity (9.8); // можно экспортировать и использовать напрямую в любом файле

1 doubleg_gravity(9.8);// можно экспортировать и использовать напрямую в любом файле

Сделайте следующее:

static double g_gravity (9.8); // ограничиваем доступ к переменной только на этот файл

double getGravity() // эта функция может быть экспортирована в другие файлы для доступа к глобальной переменной
{
return g_gravity;
}

1
2
3
4
5
6

staticdoubleg_gravity(9.8);// ограничиваем доступ к переменной только на этот файл

doublegetGravity()// эта функция может быть экспортирована в другие файлы для доступа к глобальной переменной

{

returng_gravity;

}

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

Вместо следующего:

// Эта функция полезна только для расчета мгновенной скорости на основе глобальной гравитации
double instantVelocity(int time)
{
return g_gravity * time;
}

1
2
3
4
5

// Эта функция полезна только для расчета мгновенной скорости на основе глобальной гравитации

doubleinstantVelocity(inttime)

{

returng_gravity *time;

}

Сделайте следующее:

// Эта функция вычисляет мгновенную скорость для любого значения гравитации.
// Передайте возвращаемое значение из getGravity() в параметр gravity, если хотите использовать глобальную переменную gravity
double instantVelocity(int time, double gravity)
{
return gravity * time;
}

1
2
3
4
5
6

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

doubleinstantVelocity(inttime,doublegravity)

{

returngravity *time;

}

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

Файлы в Python

В целом различают два типа файлов (и работы с ними):

  • текстовые файлы со строками неопределенной длины;
  • двоичные (бинарные) файлы (хранящие коды таких данных, как, например, рисунки, звуки, видеофильмы);

Этапы работы с файлом:

  1. открытие файла;
  • режим чтения,
  • режим записи,
  • режим добавления данных.

работа с файлом;
закрытие файла.

В python открыть файл можно с помощью функции open с двумя параметрами:

  • имя файла (путь к файлу);
  • режим открытия файла:
  • «r» – открыть на чтение,
  • «w» – открыть на запись (если файл существует, его содержимое удаляется),
  • «a» – открыть на добавление.

В коде это выглядит следующим образом:

Fin = open ( "input.txt" ) 
Fout = open ( "output.txt", "w" ) 
  # работа с файлами 
Fout.close() 
Fin.close()

Работа с текстовыми файлами в Питон

Чтение из файла происходит двумя способами:

  1. построчно с помощью метода readline:

файл input.txt:
1
2
3

str1 = Fin.readline() # str1 = 1
str2 = Fin.readline() # str2 = 2

метод read читает данные до конца файла:

файл input.txt:
1
2
3

str = Fin.read() 
''' 
str = 1
2
3
'''

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

str = Fin.readline().split()
print(str)
print(str1)

Пример:
В файле записаны два числа. Необходимо суммировать их.

файл input.txt:
12 17

ответ:
27

Решение: 

  1. способ:
Fin = open ( "D:/input.txt" ) 
str = Fin.readline().split()
x, y = int(str), int(str1)
print(x+y)

способ:

...
x, y = int(i) for i in s
print(x+y)

* Функция int преобразует строковое значение в числовое.

В python метод write служит для записи строки в файл:

Fout = open ( "D:/out.txt","w" ) 
Fout.write ("hello")

Запись в файл можно осуществлять, используя определенный
шаблон вывода. Например:

Fout.write ( "{:d} + {:d} = {:d}\n".format(x, y, x+y) )

В таком случае вместо шаблонов {:d} последовательно подставляются значения параметров метода format (сначала x, затем y, затем x+y).

Аналогом «паскалевского» eof (если конец файла) является обычный способ использования цикла while или с помощью добавления строк в список:

  1. while True: 
       str = Fin.readline() 
       if not str: break
  2. Fin = open ( "input.txt" ) 
    lst = Fin.readlines() 
    for str in lst: 
        print ( str, end = "" ) 
    Fin.close()
  3. подходящий способ для Python:
for str in open ( "input.txt" ): 
   print ( str, end = "" )

Задание Python 9_1:
Считать из файла input.txt 10 чисел (числа записаны через пробел). Затем записать их произведение в файл output.txt.

Рассмотрим пример работы с массивами.

Пример:
Считать из текстового файла числа и записать их в другой текстовый файл в отсортированном виде.

Решение: 

  • Поскольку в Python работа с массивом осуществляется с помощью структуры список, то количество элементов в массиве заранее определять не нужно.
  • Считывание из файла чисел:
lst =  
while True:
   st = Fin.readline() 
   if not st: break 
   lst.append (int(st))

Сортировка.
Запись отсортированного массива (списка) в файл:

Fout = open ( "output.txt", "w" ) 
Fout.write (str(lst)) # функция str преобразует числовое значение в символьное
Fout.close()

Или другой вариант записи в файл:

for x in lst: 
    Fout.write (str(x)+"\n") # запись с каждой строки нового числа

Задание Python 9_2:
В файле записаны в целые числа. Найти максимальное и минимальное число и записать в другой файл.

Задание Python 9_3:
В файле записаны в столбик целые числа. Отсортировать их по возрастанию суммы цифр и записать в другой файл.

Рассмотрим на примере обработку строковых значений.

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

Иванов 45 бухгалтер

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

Решение: 

  • Поскольку сведения записаны в определенном формате, т.е. вторым по счету словом всегда будет возраст, то будем использовать метод split, который разделит слова по пробелам. Под номером 1 в списке будет ити возраст:
st = Fin.readline() 
data = st.split() 
stAge = data1 
intAge = int(stAge)

Более короткая запись будет выглядеть так:

st = Fin.readline() 
intAge = int(st.split()1)

Программа выглядит так:

while True: 
  st = Fin.readline() 
  if not s: break 
  intAge = int (st.split()1)

Но лучше в стиле Python:

for st in open ( "input.txt" ): 
   intAge = int (st.split()1) 
   if intAge < 40: 
      Fout.write (st)

Задание Python 9_4:
В файл записаны сведения о детях детского сада:

Иванов иван 5 лет

Необходимо записать в текстовый файл самого старшего и самого младшего.

Устранение ошибки «Лимит файловой системы» на Samsung A10

На модели телефона Самсунг А10 ошибка c лимитом файловой системы встречается чаще остальных. Перед проведением чистки памяти телефона нужно освободить оперативную память. Для этого нажмите на кнопку «Home».

В смартфоне она находится в нижней части экрана и выглядит в виде прямоугольника или вертикальных линий. Все отображаемые приложения в этом блоке нужно удалить. Смахните их с экрана при помощи свайпа вверх (или влево). Теперь нужно попасть в меню подсистемы телефона. Нажмите на кнопку питания и удерживайте её, пока не появится меню из пунктов «Выключить», «Перезагрузить» и т.д. Выберите пункт для выключения.

  1. Нажмите на клавишу для увеличения звука и удерживайте её;
  2. Не отпуская предыдущую клавишу, нажмите вместе с ней кнопку включения смартфона и также продолжайте удерживать;
  3. В открывшемся окне при помощи клавиш регулировки громкости переносим фокус на пункт «Wipe cache partition» и нажимаем клавишу питания один раз;

  4. Подтверждаем очистку памяти при помощи перевода на пункт «Yes»;
  5. Дождитесь завершения процесса очистки.

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

Либо удалить что-нибудь важное. После очистки смартфон автоматически включится

А вы сможете убедиться в том, что после этой процедуры системное сообщение «Лимит файловой системы» на смартфоне Самсунг А10 больше не появляется. Инструкция может быть полезной при других проблемах с памятью смартфона. При помощи данного меню можно полностью сбросить смартфон к заводским настройкам.

Для этого в меню нужно выбрать другой пункт на английском языке – «Wipe data/factory reset». После подтверждения сброса с телефона Samsung A10 будут удалены все настройки и файлы пользователя

Использовать его нужно осторожно

Параметризация запросов

Параметризация — одна из самых полезных особенностей Postman.

Часто необходимо выполнить один и тот же запрос на разных наборах данных. С помощью параметризации, можно использовать переменные при выполнении запросов.

В Postman, параметры создаются с помощью двойных скобок: `test`.

Например, наш base URL — https://testengineer.ru и мы сохраняем это значение в переменной с именем base_url. В этом случае, мы можем обратиться к этой переменной из запроса, написав `base_url`. Для того, чтобы отправить запрос на этот URL, мы подставим эту переменную в запрос. Выглядеть это будет так: `base_url`/get?customers=new. Запрос будет отправлен на https://testengineer.ru/get?customers=new

Шаг 1: Меняем тип HTTP-запроса на GET и вводим URL:

Шаг 2: Меняем URL на параметр `url`. После этого URL запроса должен быть таким: `url`/users

Шаг 3: Теперь нам нужно создать переменную окружения, чтобы использовать ее в качестве параметра. Для этого нажимаем на кнопку с глазом и кликаем на Edit (редактировать), чтобы создать глобальную переменную и затем использовать ее в коллекциях.

Шаг 4: В окне создания переменной задаем имя (именем будет url) и значение (значением будет https://jsonplaceholder.typicode.com). После этого нажимаем Save (Сохранить)

Шаг 5: Возвращаемся к GET-запросу и нажимаем Send (отправить)

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

Команда nslookup

Эта команда также позволяет получить информацию по домену или по IP адресу. Основной синтаксис написания nslookup:

nslookup

где — указывать необязательно.

Самый простой пример использования nslookup приведем ниже:

nslookup freehost.com.ua

Можем выполнить и обратную задачу — по IP адресу узнать доменное имя сайта.

nslookup 194.0.200.202

Ниже приведем основные опции команды nslookup:

  • type – записывается тип записи DNS (к примеру, NS, TXT, SOA и др.);
  • port – указывается номер порта;
  • recurse – в случае, когда DNS не отвечает, использовать другие DNS;
  • retry – задается количество попыток;
  • timeout – время;
  • fail – в случае, когда DNS возвращает ошибку, необходимо использовать другой сервер.

Приведем примеры команды, с использованием опции type (тип записи), например, для получения записей типа NS, MX, TXT, SOA и т.д.:

nslookup -type=ns freehost.com.ua
nslookup -type=mx freehost.com.ua
nslookup -type=txt freehost.com.ua
nslookup -type=soa freehost.com.ua

Техническую информацию о домене можно получить в ответе, запустив команду nslookup с параметром для типа записи SOA:

  • origin — источник информации;
  • mail addr — указывает email address администратора домена;
  • serial — показывает время в формате timestamp;
  • refresh — выводит время в секундах, в течении которого нужно повторить подключения, чтобы обновить информацию;
  • retry — указывает время в секундах, через которое необходимо опять повторить подключения к DNS, в случае, если он недоступен;
  • expire — показывает интервал времени в секундах, через который нужно считать информацию, полученную от первого DNS, устаревшей;
  • minimum — это время в секундах, которое проходит до следующего обновления.
Рейтинг
( Пока оценок нет )
Понравилась статья? Поделиться с друзьями:
Все про сервера
Добавить комментарий

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!:

Adblock
detector