|
|
| Строка 1: |
Строка 1: |
| <div style="background-color: #fff0f3; border-left: 5px solid #dc3545; padding: 15px; margin: 10px 0; color: #a71d2a;">
| |
| <b>Внимание!</b><br/>
| |
| Это описание - для старой версии дизайнера документов (<b><i>AR</i></b>).<br/>
| |
| В ближайшее время страница будет обновлена на описание настройки в <b><i>FastReports</i></b>.
| |
| </div>
| |
|
| |
|
| ==Общие сведения==
| |
|
| |
| Функции, вынесенные в глобальную видимость через объект <code>Code</code>, позволяют централизованно управлять логикой форматирования данных.
| |
|
| |
| Это избавляет от необходимости дублировать код в каждом отдельном макете и обеспечивает единообразие расчетов во всех отчетах.
| |
|
| |
| ==Rounding.RoundBase()==
| |
|
| |
| Предназначена для гибкого округления числовых значений.
| |
|
| |
| В отличие от стандартных функций, она поддерживает работу с отрицательными разрядами и округление до значащих цифр.
| |
|
| |
| ===Входные параметры===
| |
| *<code>value</code> (''Double'') - исходное число для обработки;
| |
| *<code>digits</code> (''Object'')
| |
| **при <code>Mode = 1</code> - количество знаков после запятой (положительное) или до запятой (отрицательное);
| |
| **при <code>Mode = 0</code> - количество значащих цифр;
| |
| *<code>mode</code> (''Object'') - режим работы:
| |
| **<code>1</code> (''ToDecimalPlace'') - десятичное округление;
| |
| **<code>0</code> (''ToSignificantPlace'') - значащие цифры.
| |
|
| |
| ===Выходные параметры===
| |
| *<code>String</code> - возвращает строковое представление числа.
| |
|
| |
| ===Алгоритм===
| |
| Функция работает по методу <code>Away From Zero</code> (округление от нуля).
| |
|
| |
| '''Режим 1''' (''десятичное округление''):
| |
| *вычисляется множитель;
| |
| *число умножается на множитель, округляется до целого и делится обратно;
| |
| *при положительном n результат форматируется с фиксированным количеством нулей после запятой.
| |
|
| |
| '''Режим 0''' (''значащие цифры''):
| |
| *определяется порядок числа через десятичный логарифм;
| |
| *вычисляется масштабный коэффициент, чтобы оставить ровно <code>n</code> цифр;
| |
| *число масштабируется, округляется и возвращается в исходный порядок;
| |
| *результат преобразуется в компактную строку (удаляются лишние нули в конце).
| |
|
| |
| ===Примеры использования внутри ячейки===
| |
|
| |
| {|class="wikitable" style="margin:auto; background-color: #fff; width:100%"
| |
| |-
| |
| !Исходное значение
| |
| !Синтаксис в соответствии с формулой <code>=Code.Rounding.RoundBase(x, n, m)</code>
| |
| !Результат
| |
| |-
| |
| |style="text-align:right"|12345
| |
| |<syntaxhighlight lang="vb">=Code.Rounding.RoundBase(ReportItems!variable.Value, 2, 1)</syntaxhighlight>
| |
| |style="text-align:right"|12345,00
| |
| |-
| |
| |style="text-align:right"|12345.00
| |
| |<syntaxhighlight lang="vb">=Code.Rounding.RoundBase(ReportItems!variable.Value, 0, 1)</syntaxhighlight>
| |
| |style="text-align:right"|12345
| |
| |-
| |
| |style="text-align:right"|12345.01
| |
| |<syntaxhighlight lang="vb">=Code.Rounding.RoundBase(ReportItems!variable.Value, -2, 1)</syntaxhighlight>
| |
| |style="text-align:right"|12300
| |
| |-
| |
| |style="text-align:right"|555.55
| |
| |<syntaxhighlight lang="vb">=Code.Rounding.RoundBase(ReportItems!variable.Value, 1, 0)</syntaxhighlight>
| |
| |style="text-align:right"|600
| |
| |-
| |
| |}
| |
|
| |
| ===Примеры использования во вкладке <code>Scripts</code>===
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Return New Triteia.Rounding().RoundBase(variable, 2, 1)
| |
| </syntaxhighlight>
| |
|
| |
| или
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Dim rounder As New Triteia.Rounding()
| |
|
| |
| Return rounder.RoundBase(variable, 2, 1)
| |
| </syntaxhighlight>
| |
|
| |
| ===Предварительный вариант на VB.NET===
| |
| <syntaxhighlight lang="vb">
| |
| Public Function RoundBase(ByVal xValue As Double, ByVal nDigits As Integer, ByVal mMode As Integer) As String
| |
|
| |
| If xValue = 0 Then Return "0"
| |
|
| |
| 'Проверка аргумента nDigits, является ли пустым, остутствующим в БД или пустой строкой
| |
| Dim nDigitsFlag As Boolean = True
| |
| If nDigits Is Nothing OrElse IsDBNull(nDigits) OrElse String.IsNullOrEmpty(nDigits.ToString().Trim()) Then
| |
| nDigitsFlag = False
| |
| End If
| |
|
| |
| 'Проверка аргумента mMode, является ли пустым, остутствующим в БД или пустой строкой
| |
| Dim mModeFlag As Boolean = True
| |
| If mMode Is Nothing OrElse IsDBNull(mMode) OrElse String.IsNullOrEmpty(mMode.ToString().Trim()) Then
| |
| mModeFlag = False
| |
| End If
| |
|
| |
| 'Если хотя бы один из параметров (nDigits или mMode) отсутствует, возвращается исходное число xValue
| |
| If (nDigitsFlag = False) Or (mModeFlag = False)
| |
| Return xValue
| |
| End If
| |
|
| |
| If mMode = 1 Then
| |
| ' Округление до n знаков после запятой
| |
| ' В отличие от стандартной функции Math.Round(value, digits, MidpointRounding.AwayFromZero)
| |
| ' может работать с отрицательными digits за счет сдвига
| |
|
| |
| ' Вычисление множителя
| |
| Dim factor As Double = Math.Pow(10, nDigits)
| |
|
| |
| ' Свдиг запятой на расстояние множителя, округление до целого, обратный сдвиг
| |
| ' Направление сдвига зависит от знака (+-) в nDigits
| |
| Dim result As Double = Math.Round(xValue * factor, 0, MidpointRounding.AwayFromZero) / factor
| |
|
| |
| ' Форматирование результата (либо до целого(0), либо по положительному nDigits)
| |
| Return result.ToString("F" & Math.Max(0, nDigits))
| |
| End If
| |
|
| |
| If mMode = 0 Then
| |
| ' Округление до n значащих цифр
| |
|
| |
| ' Определение порядка числа (до запятой)
| |
| Dim scale As Double = Math.Pow(10, Math.Floor(Math.Log10(Math.Abs(xValue))) + 1 - nDigits)
| |
|
| |
| ' Свдиг запятой влево (уменьшение порядка числа), округление, сдвиг вправо (увеличение порядка числа)
| |
| Dim result As Double = Math.Round(xValue / scale, 0, MidpointRounding.AwayFromZero) * scale
| |
|
| |
| ' Форматирование результата в компактную строку (удаление лишних нулей, научная нотация)
| |
| Return result.ToString("G")
| |
| End If
| |
|
| |
| ' При некорректном значении режима mMode
| |
| Return ""
| |
|
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Итоговый вариант на С#===
| |
| <syntaxhighlight lang="csharp">
| |
| public class Rounding
| |
| {
| |
| public string RoundBase(double value, int digits, RoundMode mode)
| |
| {
| |
| if (value == 0)
| |
| return "0";
| |
|
| |
| double result;
| |
| switch (mode)
| |
| {
| |
| case RoundMode.ToDecimalPlace:
| |
| double factor = Math.Pow(10, digits);
| |
| result = Math.Round(value * factor, 0, MidpointRounding.AwayFromZero) / factor;
| |
| return result.ToString("F" + Math.Max(0, digits));
| |
| case RoundMode.ToSignificantPlace:
| |
| double scale = Math.Pow(10, Math.Floor(Math.Log10(Math.Abs(value))) + 1 - digits);
| |
| result = Math.Round(value / scale, 0, MidpointRounding.AwayFromZero) * scale;
| |
| return result.ToString("G");
| |
| default:
| |
| throw new ArgumentOutOfRangeException(nameof(mode), "Некорректный режим округления");
| |
| }
| |
| }
| |
|
| |
| public string RoundBase(double value, int digits, int mode) => RoundBase(value, digits, (RoundMode)mode);
| |
| }
| |
| </syntaxhighlight>
| |
|
| |
| ==GetOrDash()==
| |
| Функция <code>GetOrDash()</code> - предназначена для обработки пустых значений (<code>NULL</code>, пустые строки, пробелы) в ячейках отчета.
| |
|
| |
| Она гарантирует, что вместо пустого места в таблице всегда будет отображаться визуальный маркер <code>-</code> (''дефис''), что улучшает читаемость документа.
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Public Function GetOrDash(field As Object) As String
| |
| If field Is Nothing OrElse IsDBNull(field) OrElse String.IsNullOrEmpty(field.ToString().Trim()) Then
| |
| Return "-"
| |
| End If
| |
|
| |
| Return field.ToString()
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>field</code> (''Object'') - данные из поля набора данных (принимает любой тип данных, так как параметр объявлен как <code>Object</code>).
| |
|
| |
| ===Выходные данные===
| |
| * <code>String</code> - строковое представление данных, если поле содержит значимую информацию;
| |
| * <code>-</code> (''дефис'') - если входной параметр:
| |
| **равен <code>Nothing</code> (не инициализирован);
| |
| **равен <code>DBNull.Value</code> (пустое значение из базы данных);
| |
| **является пустой строкой <code>""</code>;
| |
| **содержит только пробелы (метод <code>.Trim()</code>).
| |
|
| |
| ==GetOr()==
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Public Function GetOr(field As Object,
| |
| Optional swap As String = "",
| |
| Optional pref As String = "",
| |
| Optional suf As String = "") As String
| |
|
| |
| If field Is Nothing OrElse IsDBNull(field) OrElse String.IsNullOrWhiteSpace(field.ToString()) Then
| |
| Return swap
| |
| End If
| |
|
| |
| Return pref & field.ToString().Trim() & suf
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>field</code> (''Object'') - проверяемое поле (может быть числом, строкой или объектом базы данных);
| |
| *<code>swap</code> (''String'', необязательно) - значение «подмены», которое вернется, если поле пустое; по умолчанию — пустая строка;
| |
| *<code>pref</code> (''String'', необязательно) - префикс, который добавится перед значением;
| |
| *<code>suf</code> (''String'', необязательно) - суффикс, который добавится после значения.
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code> - отформатированная строка с префиксом и суффиксом, либо значение <code>swap</code>;
| |
|
| |
| ===Алгоритм===
| |
| *проверка на пустоту - функция проверяет объект <code>field</code> на три условия: равен ли он <code>Nothing</code>, является ли он <code>DBNull</code> (пустота из базы данных) или состоит ли он только из пробелов;
| |
| *обработка пустого значения - если хотя бы одно условие истинно, возвращается значение параметра <code>swap</code>;
| |
| *форматирование - если поле содержит данные, функция обрезает лишние пробелы по краям (<code>Trim</code>), добавляет к нему заданные префикс (<code>pref</code>) и суффикс (<code>suf</code>) и возвращает результат.
| |
|
| |
| ==ConcatFields()==
| |
|
| |
| Функция <code>ConcatFields()</code> - предназначена для объединения нескольких текстовых значений в одну строку с использованием заданного разделителя.
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Public Function ConcatFields(separator As String, ParamArray fields() As Object) As String
| |
| If fields Is Nothing Then Return "-"
| |
|
| |
| Dim list As New System.Collections.Generic.List(Of String)
| |
|
| |
| For Each f As Object In fields
| |
| If f Is Nothing Then Continue For
| |
| Dim elem As String = f.ToString().Trim()
| |
| If String.IsNullOrEmpty(elem) Then Continue For
| |
| list.Add(elem)
| |
| Next
| |
|
| |
| If list.Count = 0 Then
| |
| Return "-"
| |
| Else
| |
| Return String.Join(separator, list.ToArray())
| |
| End If
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>separator</code> (''String'') - символ или текст, который будет стоять между элементами (например - запятая, или пробел, или перенос на следующую строку);
| |
| *<code>ParamArray fields()</code> (''Object'') - список аргументов любого количества, перечисляется через запятую (также можно передать массив).
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code> - одна строка из объединенных элементов.
| |
| *<code>-</code> (''дефис'') - если данных нет.
| |
|
| |
| ===Алгоритм===
| |
| *<code>If fields Is Nothing Then Return "-"</code> - если массив аргументов вообще не передан, функция сразу возвращает дефис;
| |
| *<code>Dim list As New System.Collections.Generic.List(Of String)</code> - создается временный список для хранения "чистых" строковых элементов;
| |
| *<code>For Each f As Object In fields</code> - цикл по каждому полученному на входе значению;
| |
| *<code>If f Is Nothing Then Continue For</code> - если текущий элемент пуст (null), он пропускается;
| |
| *<code>Dim elem As String = f.ToString().Trim()</code> - значение переводится в строковый элемент и очищается от лишних пробелов по краям;
| |
| *<code>If String.IsNullOrEmpty(elem) Then Continue For</code> - если после удаления пробелов строковый элемент оказался пустым, он пропускается;
| |
| *<code>list.Add(elem)</code> - корректный строковый элемент добавляется в итоговый список;
| |
| *<code>If list.Count = 0 Then Return "-"</code> - если после проверки всех элементов список пуст (все было null или пробелы), возвращается дефис;
| |
| *<code>Return String.Join(separator, list.ToArray())</code> - все накопленные в списке элементы склеиваются в одну строку через указанный разделитель.
| |
|
| |
| ==GetExperience()==
| |
|
| |
| Функция <code>GetExperience()</code> рассчитывает и форматирует строку о стаже работы сотрудника на основе даты получения диплома.
| |
|
| |
| Она выводит количество лет с правильным суффиксом (через вспомогательную функцию <code>YearsWithSuffix</code>) и указывает временной интервал от даты диплома до сегодняшнего дня.
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Public Function GetExperience(diplomDate As Object) As String
| |
| If IsDBNull(diplomDate) OrElse diplomDate Is Nothing Then
| |
| Return "-"
| |
| End If
| |
|
| |
| Return YearsWithSuffix(diplomDate) & vbLF & Format(diplomDate, "dd.MM.yyyy") & " - по текущую дату"
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>diplomDate</code> (''Object'') - дата выдачи диплома.
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code>
| |
| **<code>-</code> - если дата не указана;
| |
| **многострочный текст, если дата есть; например:
| |
| ::{| style="border-collapse: collapse;"
| |
| |
| |
| <syntaxhighlight>
| |
| 5 лет
| |
| 15.05.2018 - по текущую дату
| |
| </syntaxhighlight>
| |
| |}
| |
|
| |
| ===Алгоритм===
| |
| *проверка на пустоту - является ли входное значение пустым (<code>IsDBNull</code>) или отсутствующим (<code>Nothing</code>); если данных нет, возвращается прочерк;
| |
| *расчет лет - вызывается внешняя функция <code>YearsWithSuffix(diplomDate)</code>, которая вычисляет разницу между текущей датой и датой диплома, добавив правильное окончание (<code>год</code> / <code>года</code> / <code>лет</code>);
| |
| *форматирование даты - исходная дата преобразуется в стандартный формат <code>дд.мм.гггг.</code>;
| |
| *сборка результата - все части склеиваются в одну строку, символ <code>vbLF</code> переносит информацию о датах на новую строку.
| |
|
| |
| ==YearsWithSuffix()==
| |
|
| |
| Функция <code>YearsWithSuffix()</code> - предназначена для формирования строки, содержащей количество лет и правильное грамматическое окончание существительного «год» (год, года, лет) на основе разницы между переданной датой и текущим моментом.
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Public Function YearsWithSuffix(inputDate As Date) As String
| |
| Dim yearsDiff As Long = DateDiff(DateInterval.Year, inputDate, Now())
| |
| Dim resultDate As Long = yearsDiff
| |
| Dim resultString As String = yearsDiff.ToString()
| |
|
| |
| If (resultDate > 20) Then
| |
| resultDate = resultDate Mod 10
| |
| End If
| |
|
| |
| Select Case resultDate
| |
| Case 1
| |
| resultString &= $" год"
| |
| Case 2 To 4
| |
| resultString &= $" года"
| |
| Case Else
| |
| resultString &= $" лет"
| |
| End Select
| |
|
| |
| Return resultString
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>inputDate</code> (''Date'') - дата, от которой ведется отсчет.
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code> - разница лет до текущего момента с текстом-суффиксом "21 год", "25 лет", "34 года".
| |
|
| |
| ===Алгоритм===
| |
| *вычисляется полное количество лет между <code>inputDate</code> и текущей датой <code>Now()</code> с помощью функции <code>DateDiff</code>;
| |
| *<code>resultDate</code> - техническая переменная для определения логики окончания;
| |
| *<code>resultString</code> - строковое представление числа лет;
| |
| *обработка исключений (20+ лет) - если число больше 20, применяется операция <code>Mod 10</code> (остаток от деления на 10), чтобы привести числа вроде 21, 22, 25 к виду 1, 2, 5 для подбора окончания;
| |
| *<code>Select Case</code> - блок выбора окончания;
| |
| *<code>Case 1</code> - если число (или его остаток) равно 1, добавляется слово <code> год</code>;
| |
| *<code>Case 2 To 4</code> - если число (или его остаток) в диапазоне от 2 до 4 включительно, добавляется слово <code> года</code>;
| |
| *<code>Case Else</code> - в остальных случаях (для 0, 5–19 и специфических остатков) добавляется слово <code> лет</code>;
| |
| *возврат итоговой склеенной строки.
| |
|
| |
| ==GetNorms()==
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Public Function GetNorms(lowLimit As Double, upLimit As Double) As String
| |
| If upLimit <> 0 Then
| |
| Return "не менее " & lowLimit & vbLF & "не более " & upLimit
| |
| End If
| |
|
| |
| If lowLimit <> 0 Then
| |
| Return "не менее " & lowLimit
| |
| End If
| |
|
| |
| Return ""
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>lowLimit</code> (''Double'') - нижняя граница нормы;
| |
| *<code>upLimit</code> (''Double'') - верхняя граница нормы.
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code> текстовое описание диапазона; возвращает пустую строку, если оба параметра равны нулю.
| |
|
| |
| ===Алгоритм===
| |
| *проверка верхней границы - если <code>upLimit</code> не равен <code>0</code>, функция возвращает строку с обоими пределами (<code>не менее X, не более Y</code>), разделяя их переносом строки (<code>vbLF</code>);
| |
| *проверка нижней границы - если верхний предел равен <code>0</code>, но <code>lowLimit</code> не равен <code>0</code>, возвращается только нижний порог (<code>не менее X</code>);
| |
| *значение по умолчанию - если оба параметра равны <code>0</code>, функция возвращает пустую строку.
| |
|
| |
| ==NormProcessing()==
| |
| <syntaxhighlight lang="vb">
| |
| Function NormProcessing(ByVal min As String, ByVal max As String) As String
| |
| Dim result As String = ""
| |
|
| |
| Dim hasMin As Boolean = Not String.IsNullOrEmpty(min) AndAlso min <> "0"
| |
| Dim hasMax As Boolean = Not String.IsNullOrEmpty(max) AndAlso max <> "0"
| |
|
| |
| If hasMin And hasMax Then
| |
| result = min & "-" + max
| |
| Else If hasMin Then
| |
| result = "≥" & min
| |
| Else If hasMax Then
| |
| result = "≤" & max
| |
| Else
| |
| result = "-"
| |
| End If
| |
|
| |
| Return result
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>min</code> (''String'') - строковое значение нижней границы;
| |
| *<code>max</code> (''String'') - строковое значение верхней границы.
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code> - форматированная строка диапазона, либо символ прочерка (<code>-</code>).
| |
|
| |
| ===Алгоритм===
| |
| *проверка наличия данных - определяются два флага (<code>hasMin</code> и <code>hasMax</code>); значение считается валидным, если оно не пустое и не равно строке <code>0</code>;
| |
| *выбор формата:
| |
| **если есть оба значения - возвращается диапазон через дефис (<code>min-max</code>);
| |
| **если есть только <code>min</code> - возвращается значение с символом «больше или равно» (<code>≥min</code>);
| |
| **если есть только max - возвращается значение с символом «меньше или равно» (<code>≤max</code>);
| |
| *значение по умолчанию - если оба входа пустые или равны <code>0</code>, возвращается дефис (<code>-</code>).
| |
|
| |
| ==RemoveTagsSimple()==
| |
| <syntaxhighlight lang="vb">
| |
| Function RemoveTagsSimple(ByVal input As String) As String
| |
| Dim tags() As String = {"<span>", "</span>", "<sub>", "</sub>", "<sup>", "</sup>"}
| |
| Dim txt As String = input
| |
|
| |
| For Each tag As String In tags
| |
| txt = Replace(txt, tag, "", , , CompareMethod.Text)
| |
| Next
| |
|
| |
| Return txt
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>input</code> (''String'') - исходная строка, содержащая HTML-подобные теги.
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code> - очищенный текст без специфических тегов.
| |
|
| |
| ===Алгоритм===
| |
| *определение списка - создается массив <code>tags</code>, содержащий конкретные строковые теги - <code><nowiki><span></nowiki></code>, <code><nowiki><sub></nowiki></code>, <code><nowiki><sup></nowiki></code> (открывающие и закрывающие);
| |
| *циклическая замена - функция перебирает каждый тег из списка и удаляет его из строки, заменяя на пустую строку;
| |
| *игнорирование регистра - используется метод <code>CompareMethod.Text</code>, что позволяет удалять теги независимо от того, написаны они заглавными или строчными буквами (например, удалит и <code><nowiki><span></nowiki></code>, и <code><nowiki><SPAN></nowiki></code>).
| |
|
| |
| ==FormatFio()==
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Function FormatFio(surname As String, name As String, patronymic As String, mode As Integer) As String
| |
| Dim f = Trim(surname)
| |
| Dim i = Trim(name)
| |
| Dim o = Trim(patronymic)
| |
|
| |
| Dim i_init = ""
| |
| Dim o_init = ""
| |
|
| |
| If Len(i) > 0 Then i_init = Left(i, 1) & "."
| |
| If Len(o) > 0 Then o_init = Left(o, 1) & "."
| |
|
| |
| Dim result = ""
| |
|
| |
| Select Case mode
| |
| Case 0 ' Фамилия Имя Отчество
| |
| result = Trim(f & " " & i & " " & o)
| |
| Case 1 ' Фамилия И.О.
| |
| result = Trim(f & " " & i_init & o_init)
| |
| Case 2 ' И.О. Фамилия
| |
| result = Trim(i_init & o_init & " " & f)
| |
| End Select
| |
|
| |
| Return GetOrDash(result)
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>surname</code> (''String'') - фамилия,
| |
| *<code>name</code> (''String'') - имя,
| |
| *<code>patronymic</code> (''String'') - отчество;
| |
| *<code>mode</code> (''Integer'') - режим форматирования (0, 1 или 2).
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code> - ФИО в выбранном формате; если результат пуст, вызывается внешняя функция <code>GetOrDash</code> (возвращает прочерк).
| |
|
| |
| ===Алгоритм===
| |
| *очистка - удаляются лишние пробелы из всех входящих строк (<code>Trim</code>);
| |
| *подготовка инициалов - для имени и отчества берутся первые буквы с точкой (i., o.), если соответствующие строки не пустые;
| |
| *Выбор формата (по mode):
| |
| **<code>0</code> - полное ФИО через пробел (Фамилия Имя Отчество);
| |
| **<code>1</code> - фамилия и инициалы слитно (Фамилия И.О.);
| |
| **<code>2</code> - инициалы и фамилия через пробел (И.О. Фамилия);
| |
| *финальная обработка - результат обрезается от лишних крайних пробелов и передается в <code>GetOrDash</code>.
| |
|
| |
| ==CollapseNumbers()==
| |
| Функция <code>CollapseNumbers()</code> свертывает массив чисел в компактную строку, заменяя последовательные числовые ряды диапазонами.
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Public Function CollapseNumbers(inputNums As Object()) As String
| |
| If inputNums Is Nothing OrElse inputNums.Length = 0 Then Return ""
| |
|
| |
| Dim nums(inputNums.Length - 1) As Integer
| |
| For i As Integer = 0 To inputNums.Length - 1
| |
| nums(i) = CInt(inputNums(i))
| |
| Next
| |
| Array.Sort(nums)
| |
|
| |
| Dim result As String = ""
| |
| Dim index As Integer = 0
| |
|
| |
| While index < nums.Length
| |
| Dim startNum As Integer = nums(index)
| |
| Dim endNum As Integer = startNum
| |
|
| |
| While index + 1 < nums.Length AndAlso nums(index + 1) = nums(index) + 1
| |
| index += 1
| |
| endNum = nums(index)
| |
| End While
| |
|
| |
| Dim currentStr As String = ""
| |
|
| |
| If endNum - startNum = 0 Then
| |
| currentStr = startNum.ToString()
| |
| ElseIf endNum - startNum = 1 Then
| |
| currentStr = startNum.ToString() & ", " & endNum.ToString()
| |
| Else
| |
| currentStr = startNum.ToString() & "-" & endNum.ToString()
| |
| End If
| |
|
| |
| If result = "" Then
| |
| result = currentStr
| |
| Else
| |
| result &= ", " & currentStr
| |
| End If
| |
|
| |
| index += 1
| |
| End While
| |
|
| |
| Return result
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>inputNums</code> (''Object()'') - массив объектов (чисел), которые нужно сгруппировать.
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code> - строка с перечисленными числами, где последовательные ряды заменены на диапазоны (например, <code>1, 2, 3, 5</code> превратится в <code>1-3, 5</code>).
| |
|
| |
| ===Алгоритм===
| |
| *подготовка - входные объекты преобразуются в массив целых чисел (Integer) и сортируются по возрастанию;
| |
| *поиск последовательностей - цикл проходит по массиву, определяя блоки идущих подряд чисел (где каждое следующее больше предыдущего на 1);
| |
| *форматирование группы:
| |
| **если число одиночное - записывается просто число;
| |
| **если в ряду два числа - записываются через запятую (<code>1, 2</code>);
| |
| **если в ряду три и более чисел - записываются через дефис как диапазон (<code>1-3</code>);
| |
| *сборка - все обработанные группы объединяются в одну строку через запятую с пробелом.
| |
|
| |
| ==AddIndents()==
| |
| Добавление абзацев (на перспективу).
| |
|
| |
| <syntaxhighlight lang="vb">
| |
| Public Function AddIndents(ByVal text As String) As String
| |
|
| |
| If String.IsNullOrEmpty(text) Then Return ""
| |
|
| |
| Dim indentedText As String = text.Replace(vbCrLf, vbLf & " ")
| |
|
| |
| Return " " & indentedText
| |
|
| |
| End Function
| |
| </syntaxhighlight>
| |
|
| |
| ===Входные параметры===
| |
| *<code>text</code> (''String'') - исходный многострочный текст.
| |
|
| |
| ===Выходные данные===
| |
| *<code>String</code> - текст, в котором каждая строка начинается с отступа (4 пробела).
| |
|
| |
| ===Алгоритм===
| |
| *проверка на пустоту - если входящая строка пустая или <code>Nothing</code>, возвращается пустая строка;
| |
| *обработка переносов - функция находит все стандартные символы переноса строки (<code>vbLf</code>) и заменяет их на перенос, за которым сразу следуют 4 пробела; это создает отступы для всех строк, кроме первой;
| |
| *обработка первой строки - в начало всей полученной строки принудительно добавляются 4 пробела, чтобы первая строка также имела отступ.
| |
