Печать многоуровневого и псевдоассоциативного массива

DyadyaGenya · Суббота в 17:47

Доброго времени суток. Возможно где-то и есть такая тема, но не нашел. По сути изначально нужно было печатать/выводить трёхмерный массив. И такие темы есть. И Не то, чтобы оно мне было очень нужно. Свою задачу по печати 3-4 уровневого массива я сделал. Но не получается сделать это универсальным. Пока имею например для 4-х мерного массива такое для вывода в консоль:

Код:

Func printArray4dToConsole($aArray)
    ; Проверяем, является ли массив 4-мерным
    If Not IsArray($aArray) Or UBound($aArray, 0) <> 4 Then
        ConsoleWrite("Ошибка: Переданный массив не является 4-мерным." & @CRLF)
        Return
    EndIf

    ; Начинаем вывод массива
    ConsoleWrite("Array" & @CRLF)
    ConsoleWrite("(" & @CRLF)
    For $i = 0 To UBound($aArray, 1) - 1
        ConsoleWrite("    [" & $i & "] => Array" & @CRLF)
        ConsoleWrite("    (" & @CRLF)
        For $j = 0 To UBound($aArray, 2) - 1
            ConsoleWrite("        [" & $j & "] => Array" & @CRLF)
            ConsoleWrite("        (" & @CRLF)
            For $k = 0 To UBound($aArray, 3) - 1
                ConsoleWrite("            [" & $k & "] => Array" & @CRLF)
                ConsoleWrite("            (" & @CRLF)
                For $l = 0 To UBound($aArray, 4) - 1
                    ConsoleWrite("                [" & $l & "] => " & $aArray[$i][$j][$k][$l] & @CRLF)
                Next
                ConsoleWrite("            )" & @CRLF)
            Next
            ConsoleWrite("        )" & @CRLF)
        Next
        ConsoleWrite("    )" & @CRLF)
    Next
    ConsoleWrite(")" & @CRLF)
EndFunc

Или для печати в файл:

Код:

Func printArray4d($aArray, $sFilePath)
    ; Открываем файл для записи
    Local $hFile = FileOpen($sFilePath, 2) ; 2 = Режим перезаписи файла
    If $hFile = -1 Then
        MsgBox(16, "Ошибка", "Не удалось открыть файл для записи: " & $sFilePath)
        Return
    EndIf

    ; Начинаем запись массива
    FileWriteLine($hFile, "Array")
    FileWriteLine($hFile, "(")
    For $i = 0 To UBound($aArray, 1) - 1
        FileWriteLine($hFile, "    [" & $i & "] => Array")
        FileWriteLine($hFile, "    (")
        For $j = 0 To UBound($aArray, 2) - 1
            FileWriteLine($hFile, "        [" & $j & "] => Array")
            FileWriteLine($hFile, "        (")
            For $k = 0 To UBound($aArray, 3) - 1
                FileWriteLine($hFile, "            [" & $k & "] => Array")
                FileWriteLine($hFile, "            (")
                For $l = 0 To UBound($aArray, 4) - 1
                    FileWriteLine($hFile, "                [" & $l & "] => " & $aArray[$i][$j][$k][$l])
                Next
                FileWriteLine($hFile, "            )")
            Next
            FileWriteLine($hFile, "        )")
        Next
        FileWriteLine($hFile, "    )")
    Next
    FileWriteLine($hFile, ")")

    ; Закрываем файл
    FileClose($hFile)
EndFunc

Ну или так:

Код:

Func Write4DArrayToFile($aArray, $sFilePath, $sDelimiter)
    ; Проверяем, является ли массив четырёхмерным
    If Not IsArray($aArray) Or UBound($aArray, 0) <> 4 Then
        MsgBox(16, "Ошибка", "Переданный массив не является четырёхмерным.")
        Return False
    EndIf

    ; Открываем файл на запись
    Local $hFile = FileOpen($sFilePath, 2)
    If $hFile = -1 Then
        MsgBox(16, "Ошибка", "Не удалось открыть файл для записи.")
        Return False
    EndIf

    ; Проходим по всем уровням массива и записываем в файл
    For $i = 0 To UBound($aArray, 1) - 1
        FileWriteLine($hFile, "Срез уровня 1 [" & $i & "]:")
        For $j = 0 To UBound($aArray, 2) - 1
            FileWriteLine($hFile, "  Срез уровня 2 [" & $j & "]:")
            For $k = 0 To UBound($aArray, 3) - 1
                ; Формируем строку для текущей строки с разделителем
                Local $sLine = ""
                For $l = 0 To UBound($aArray, 4) - 1
                    $sLine &= $aArray[$i][$j][$k][$l] & $sDelimiter
                Next
                ; Убираем последний разделитель и записываем строку
                $sLine = StringTrimRight($sLine, StringLen($sDelimiter))
                FileWriteLine($hFile, "    " & $sLine)
            Next
            FileWriteLine($hFile, "") ; Добавляем пустую строку между подуровнями
        Next
        FileWriteLine($hFile, "") ; Добавляем пустую строку между срезами
    Next

    ; Закрываем файл
    FileClose($hFile)
    Return True
EndFunc

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

Я пробовал рекурсию, как я её понимаю, но получается, что нужно обращаться что-то типа $aArray[$i]. А к многомерному массиву так не обратишься.. Будет ошибка.
Пробовал использовать для цикла UBound($aArray, 0), но без особых успехов. Пока вот так:

Код:

Func MultiArray2($Array)

       ; Определяем количество измерений массива
    Local $iDimensions = UBound($aArray, 0)

    ; Создаём массив-каунтер с количеством элементов, равным числу измерений
    Local $aCounter[$iDimensions]

    ; Заполняем массив-каунтер
    For $i = 0 To $iDimensions - 1
        $aCounter[$i] = $i + 1 ; Индексы начинаются с 1 для измерений
    Next

_ArrayDisplay($aCounter)

Local $sSpaces = _StringRepeat(" ", 4)

       ConsoleWrite("Array"  & @CRLF)
    ConsoleWrite("("  & @CRLF)
    ; Начинаем запись массива
     For $i = 0 To UBound($Array, 0)-1
       If UBound($Array, $i) <> 0 Then
         ConsoleWrite("    [" & $i & "] => Array" & @CRLF)
             ConsoleWrite("("  & @CRLF)
         For $j =0 To UBound($aCounter)-1
       ;ConsoleWrite("Количество элементов в измерении " & $i & ": " & UBound($Array, $i) & @CRLF)
            ConsoleWrite($aCounter[$j]  & @CRLF)

         Next
            ConsoleWrite(")"  & @CRLF)
       EndIf

   Next
    ConsoleWrite(")"  & @CRLF)
EndFunc

Alecsis · Воскресенье в 21:11

Привет + с наступившим НГ! Вот результат эксперимента «на табуретке» :acute:

PS1 Конечно в исходнике бардак, но для 1-D, 2-D и 3-D проверено и работает.
PS2 Постарался хоть как-то откомментить, но сильно не пинайте — чукча не литератор…

DyadyaGenya · Вчера в 19:18

Alecsis сказал(а):
Привет + с наступившим НГ!

И вас аналогично с наступившим НГ )))

Alecsis сказал(а):
Вот результат эксперимента «на табуретке»

Самое время для экспериментов ))) Весной/летом/осенью огороды, а сейчас делать нечего )))

Alecsis сказал(а):
Конечно в исходнике бардак

В моих исходниках ещё хуже. Правда сюда стараюсь подчищенные вылаживать.

Alecsis сказал(а):
но для 1-D, 2-D и 3-D проверено и работает.

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

Код:

; Объявляем массив с 7 уровнями
Local $aArray[2][2][2][2][2][2][2]

; Генерация данных с помощью циклов
For $i1 = 0 To 1
    For $i2 = 0 To 1
        For $i3 = 0 To 1
            For $i4 = 0 To 1
                For $i5 = 0 To 1
                    For $i6 = 0 To 1
                        For $i7 = 0 To 1
                            $aArray[$i1][$i2][$i3][$i4][$i5][$i6][$i7] = "Value-" & $i1 & $i2 & $i3 & $i4 & $i5 & $i6 & $i7
                        Next
                    Next
                Next
            Next
        Next
    Next
 Next

Глубоко ваш код не смотрел. Возможно что-то подсмотрю и себе. По полученному результату можно взять и ваш, но так не видна структура.
Я как раз пришел к вот такому варианту:

Код:

Func _printArray(Const ByRef $avArray)
    If Not IsArray($avArray) Then Return SetError(1, 0, '')

    Local $iDimensions = UBound($avArray, 0) ; Определяем количество измерений
    Local $aCounters[$iDimensions] ; Массив-счётчик для индексов
    Local $aBounds[$iDimensions] ; Массив границ для каждого уровня
    Local $aStartedLevels[$iDimensions] = [False] ; Отслеживаем, начат ли уровень

    ; Заполняем границы
    For $i = 0 To $iDimensions - 1
        $aBounds[$i] = UBound($avArray, $i + 1)
        $aCounters[$i] = 0
    Next

    Local $sResult = "Начало массива" & @CRLF
    Local $bRunning = True

    While $bRunning
        ; Добавляем начало уровней
        For $i = 0 To $iDimensions - 1
            If Not $aStartedLevels[$i] Then
                $sResult &= _StringRepeat("  ", $i) & "Уровень " & ($i + 1) & " - Начало" & @CRLF
                $aStartedLevels[$i] = True
            EndIf
        Next

        ; Добавляем текущий элемент массива
        If $iDimensions = 1 Then
            $sResult &= _StringRepeat("  ", $iDimensions) & $avArray[$aCounters[0]] & @CRLF
        ElseIf $iDimensions = 2 Then
            $sResult &= _StringRepeat("  ", $iDimensions) & $avArray[$aCounters[0]][$aCounters[1]] & @CRLF
        ElseIf $iDimensions = 3 Then
            $sResult &= _StringRepeat("  ", $iDimensions) & $avArray[$aCounters[0]][$aCounters[1]][$aCounters[2]] & @CRLF
        Else
            Local $sAccess = "$avArray"
            For $i = 0 To $iDimensions - 1
                $sAccess &= "[" & $aCounters[$i] & "]"
            Next
            $sResult &= _StringRepeat("  ", $iDimensions) & Execute($sAccess) & @CRLF
        EndIf

        ; Обновляем счётчики и обрабатываем завершение уровней
        For $i = $iDimensions - 1 To 0 Step -1
            If $aCounters[$i] < $aBounds[$i] - 1 Then
                $aCounters[$i] += 1
                ; Сбрасываем состояния начатых уровней для уровней ниже
                For $j = $i + 1 To $iDimensions - 1
                    $aStartedLevels[$j] = False
                Next
                ExitLoop
            Else
                ; Завершаем уровень
                $aCounters[$i] = 0
                $sResult &= _StringRepeat("  ", $i) & "Уровень " & ($i + 1) & " - Конец" & @CRLF
                $aStartedLevels[$i] = False
                If $i = 0 Then
                    $bRunning = False ; Завершаем весь цикл, если завершился первый уровень
                EndIf
            EndIf
        Next
    WEnd

    ; Завершаем массив
    $sResult &= "Конец массива"
    Return $sResult
EndFunc

Но хочется, чтобы было похоже на вывод в PHP функции print_r. Пока у меня не получается отформатировать, да и подсчет индексов потерялся.

Код:

Func _ArrayToStringPHPStyle(Const ByRef $avArray)
    If Not IsArray($avArray) Then Return SetError(1, 0, '')

    Local $iDimensions = UBound($avArray, 0) ; Определяем количество измерений
    Local $aCounters[$iDimensions] ; Массив-счётчик для индексов
    Local $aBounds[$iDimensions] ; Массив границ для каждого уровня
    Local $aStartedLevels[$iDimensions] = [False] ; Отслеживаем, начат ли уровень

    ; Заполняем границы
    For $i = 0 To $iDimensions - 1
        $aBounds[$i] = UBound($avArray, $i + 1)
        $aCounters[$i] = 0
    Next

    Local $sResult = "Array (" & @CRLF
    Local $bRunning = True

    While $bRunning
        ; Добавляем начало уровней
        For $i = 0 To $iDimensions - 1
            If Not $aStartedLevels[$i] Then
                $sResult &= _StringRepeat("    ", $i) & "[" & $aCounters[$i] & "] => Array (" & @CRLF
                $aStartedLevels[$i] = True
            EndIf
        Next

        ; Добавляем текущий элемент массива
        Local $sAccess = "$avArray"
        For $i = 0 To $iDimensions - 1
            $sAccess &= "[" & $aCounters[$i] & "]"
        Next
        $sResult &= _StringRepeat("    ", $iDimensions) & "[" & $aCounters[$iDimensions - 1] & "] => " & Execute($sAccess) & @CRLF

        ; Обновляем счётчики и обрабатываем завершение уровней
        For $i = $iDimensions - 1 To 0 Step -1
            If $aCounters[$i] < $aBounds[$i] - 1 Then
                $aCounters[$i] += 1
                ; Сбрасываем состояния начатых уровней для уровней ниже
                For $j = $i + 1 To $iDimensions - 1
                    $aStartedLevels[$j] = False
                Next
                ExitLoop
            Else
                ; Завершаем уровень
                $aCounters[$i] = 0
                $sResult &= _StringRepeat("    ", $i) & ")" & @CRLF
                $aStartedLevels[$i] = False
                If $i = 0 Then
                    $bRunning = False ; Завершаем весь цикл, если завершился первый уровень
                EndIf
            EndIf
        Next
    WEnd

    ; Завершаем массив
    $sResult &= ")" & @CRLF
    Return $sResult
EndFunc

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

Код:

Local $aArray[2][2][3] = [ _
    [["A1-1", "A1-2", "A1-3"], _
     ["A2-1", "A2-2", "A2-3"]], _
    [["B1-1", "B1-2", "B1-3"], _
     ["B2-1", "B2-2", "B2-3"]] _
]

Пока что получаю вот такой вывод в печать:

Код:

Array (
[0] => Array (
    [0] => Array (
        [0] => Array (
            [0] => A1-1
            [1] => A1-2
            [2] => A1-3
        )
        [0] => Array (
            [0] => A2-1
            [1] => A2-2
            [2] => A2-3
        )
    )
    [0] => Array (
        [0] => Array (
            [0] => B1-1
            [1] => B1-2
            [2] => B1-3
        )
        [0] => Array (
            [0] => B2-1
            [1] => B2-2
            [2] => B2-3
        )
    )
)
)

а хочется такой:

Код:

Array
(
    [0] => Array
        (
            [0] => Array
                (
                    [0] => A1-1
                    [1] => A1-2
                    [2] => A1-3
                )

            [1] => Array
                (
                    [0] => A2-1
                    [1] => A2-2
                    [2] => A2-3
                )

        )

    [1] => Array
        (
            [0] => Array
                (
                    [0] => B1-1
                    [1] => B1-2
                    [2] => B1-3
                )

            [1] => Array
                (
                    [0] => B2-1
                    [1] => B2-2
                    [2] => B2-3
                )

        )

)

Сообщение автоматически объединено: Понедельник в 21:16

Alecsis сказал(а):
Вот результат эксперимента «на табуретке»

Пока для начала переделал ваш набор в одну функцию:

Код:

#include <Array.au3>
#include <String.au3>

; Объявляем массив
Local $aArray[2][2][3] = [ _
    [["A1-1", "A1-2", "A1-3"], _
     ["A2-1", "A2-2", "A2-3"]], _
    [["B1-1", "B1-2", "B1-3"], _
     ["B2-1", "B2-2", "B2-3"]] _
]

Func PrintArrayInfo($aArray)
    ; Проверка на массив
    If Not IsArray($aArray) Then
        ConsoleWrite("Ошибка: Переданная переменная не является массивом." & @CRLF)
        Return
    EndIf

    ; Определяем размерности и индексы
    Local $iDimensions = UBound($aArray, 0)
    Local $aDims[1 + $iDimensions]
    Local $aIndx[1 + $iDimensions]
    Local $sResult = ""
    Local $k = 0

    ; Заполнение таблицы размерностей
    $aDims[0] = $iDimensions
    For $i = 1 To $iDimensions
        $aDims[$i] = UBound($aArray, $i)
    Next

    ; Инициализация индексов
    For $i = 1 To $iDimensions
        $aIndx[$i] = 0
    Next
    $aIndx[$iDimensions] = -1 ; Фиктивный индекс для первого вызова

    ; Формирование общей информации
    Local $iTotal = 1
    Local $sDims = ""
    For $i = 1 To $iDimensions
        $iTotal *= $aDims[$i]
        $sDims &= "[" & $aDims[$i] & "]"
    Next
    $sResult &= StringFormat("Размерность  : %s\n", $sDims)
    $sResult &= StringFormat("Число эл-тов : %u\n", $iTotal)

    ; Основной цикл обхода элементов массива
    While True
        ; Пропускаем фиктивный индекс
        If $aIndx[$iDimensions] = -1 Then
            $aIndx[$iDimensions] = 0
            ContinueLoop
        EndIf

        ; Генерация индексов
        Local $sArr_Item = ""
        For $i = 1 To $aDims[0]
            $sArr_Item &= "[" & $aIndx[$i] & "]"
        Next

        ; Получение значения текущего элемента
        $k += 1
        Local $sValue = Execute('$aArray' & $sArr_Item)
        $sResult &= StringFormat("%3u. Arr%s = %s\n", $k, $sArr_Item, $sValue)

        ; Обновление индексов
        For $i = $iDimensions To 1 Step -1
            $aIndx[$i] += 1
            If $aIndx[$i] < $aDims[$i] Then ExitLoop
            $aIndx[$i] = 0
            If $i = 1 Then
                ; Завершение обхода
                ConsoleWrite($sResult)
                Return
            EndIf
        Next
    WEnd
EndFunc

; Выводим содержимое массива
PrintArrayInfo($aArray)

Буду пробовать переделать дальше под свои нужды.

Сообщение автоматически объединено: Вторник в 17:39

Alecsis сказал(а):
Вот результат эксперимента «на табуретке»

Я тут на основе вашего результата ещё переделал и упростил ))) Пока столбиком так:

Код:

Func PrintArrayRaw($aArray)

   ; Узнаем количество измерений (глубину массива)
   Local $iDimensions = UBound($aArray, 0) ; Количество измерений

   ; Перебираем каждое измерение и узнаем размерность
   ConsoleWrite("Массив имеет " & $iDimensions & " измерения." & @CRLF)
   For $i = 1 To $iDimensions
      Local $iSize = UBound($aArray, $i) ; Размерность текущего уровня
      ConsoleWrite("Размерность " & $i & "-го уровня: " & $iSize & @CRLF)
   Next

   Local $aSizes[$iDimensions]
   For $i = 1 To $iDimensions
      $aSizes[$i - 1] = UBound($aArray, $i)
   Next
_ArrayDisplay($aSizes)

; Вычисляем общее количество элементов в многомерном массиве
Local $iTotalElements = 1
For $i = 1 To $iDimensions
    $iTotalElements *= UBound($aArray, $i)
Next
ConsoleWrite("$iTotalElements = " & $iTotalElements & @CRLF)

; Создаем двухмерный массив индексов
Local $aIndices[$iTotalElements][$iDimensions]

; Перебираем индексы и заполняем массив $aIndices
For $i = 0 To $iTotalElements - 1
    Local $carry = $i ; Используем переменную-носитель для вычисления индексов
    For $j = $iDimensions - 1 To 0 Step -1
        $aIndices[$i][$j] = Mod($carry, $aSizes[$j]) ; Получаем индекс текущего уровня
        $carry = Int($carry / $aSizes[$j]) ; Обновляем "носитель" для старших уровней
    Next
Next

; Отображаем массив индексов
_ArrayDisplay($aIndices)

; Результирующая строка для вывода
Local $sResult = ""
Local $k = 1 ; Счетчик для нумерации строк

; Перебираем массив индексов
For $i = 0 To UBound($aIndices) - 1
    ; Формируем строку индексов в формате [0][0][0]
    Local $sArr_Item = ""
    For $j = 0 To UBound($aIndices, 2) - 1
        $sArr_Item &= "[" & $aIndices[$i][$j] & "]"
    Next

    ; Получаем значение текущего элемента массива
    Local $sValue = Execute('$aArray' & $sArr_Item)

    ; Формируем строку и добавляем в результат
    $sResult &= StringFormat("%3u. Arr%s = %s\n", $k, $sArr_Item, $sValue)
    $k += 1
Next

; Выводим результат в консоль
ConsoleWrite($sResult)

EndFunc

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

Сообщение автоматически объединено: Вчера в 17:14

Сообщение автоматически объединено: Вторник в 17:39

Alecsis сказал(а):
Вот результат эксперимента «на табуретке»

Если интересно
Кое-что домучал. Прикрепляю вроде как рабочий вариант функции для распечатки в консоль массива любого уровня в стиле print_r из PHP, с разбивкой по уровням. Вроде бы работает как для обычных многоуровневых массивов типа $aArray[2][2][2][2], так и для массивов в массиве. По идее даже в том случае, если в обычный массив $aArray[2][2][2][2] вдруг имеет вложенный массив
На этих тестах работает:

Код:

; ==========================================================
;       Т Е С Т Ы
; ==========================================================

; -----------------------------------
; A) Настоящий 3D массив: [2][5][3]
; -----------------------------------
; Определяем массив 4-мерного размера
Local $aArray[3][4][4][4]

; Заполняем массив значениями вида "A1-1", "B2-2", "C3-3", и т.д.
For $i1 = 0 To 2 ; Первый уровень (A, B, C)
    For $i2 = 0 To 3 ; Второй уровень
        For $i3 = 0 To 3 ; Третий уровень
            For $i4 = 0 To 3 ; Четвёртый уровень
                ; Формируем строку и записываем в массив
                $aArray[$i1][$i2][$i3][$i4] = Chr(65 + $i1) & ($i2 + 1) & "-" & ($i3 + 1) & "-" & ($i4 + 1)
            Next
        Next
    Next
 Next

ConsoleWrite("=== 3D AutoIt-массив [2][5][3] ===" & @CRLF)
PrintArrayPHPStyle($aArray)

ConsoleWrite(@CRLF & @CRLF)

; -----------------------------------
; B) "Массив массивов" (PHP-стиль)
; -----------------------------------
Local $aSubArray1[2]
$aSubArray1[0] = "ПрЮвет"
$aSubArray1[1] = "Волк!"

Local $aSubArray2[3]
$aSubArray2[0] = 100
$aSubArray2[1] = 200
$aSubArray2[2] = $aSubArray1

Local $aMainArray[3]
$aMainArray[0] = "AutoIt"
$aMainArray[1] = $aSubArray1
$aMainArray[2] = $aSubArray2

ConsoleWrite("=== Массив массивов (как в PHP) ===" & @CRLF)
PrintArrayPHPStyle($aMainArray)

Local $slovo = "asklhgdfsig"
PrintArrayPHPStyle($slovo)

Local $arr[5] = [10, 20, 30, 40, 50]
PrintArrayPHPStyle($arr)

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

Сообщение автоматически объединено: Вчера в 19:18

Когда уже понял принцип, то всё получается быстрее. Переделал под работу ещё и с псевдоассоциативными массивами, например такими:

Код:

; ==========================================================
;       Т Е С Т Ы
; ==========================================================

; -----------------------------------
; A) Настоящий 3D массив: [2][5][3]
; -----------------------------------
; Определяем массив 4-мерного размера
Local $aArray[3][4][4][4]

; Заполняем массив значениями вида "A1-1", "B2-2", "C3-3", и т.д.
For $i1 = 0 To 2 ; Первый уровень (A, B, C)
    For $i2 = 0 To 3 ; Второй уровень
        For $i3 = 0 To 3 ; Третий уровень
            For $i4 = 0 To 3 ; Четвёртый уровень
                ; Формируем строку и записываем в массив
                $aArray[$i1][$i2][$i3][$i4] = Chr(65 + $i1) & ($i2 + 1) & "-" & ($i3 + 1) & "-" & ($i4 + 1)
            Next
        Next
    Next
 Next

ConsoleWrite("=== 3D AutoIt-массив [2][5][3] ===" & @CRLF)
Local $Test = PrintArrayPHPStyle($aArray)
ConsoleWrite($Test & @CRLF)

ConsoleWrite(@CRLF & @CRLF)

; -----------------------------------
; B) "Массив массивов" (PHP-стиль)
; -----------------------------------
Local $aSubArray1[2]
$aSubArray1[0] = "ПрЮвет"
$aSubArray1[1] = "Волк"

Local $aSubArray2[3]
$aSubArray2[0] = 100
$aSubArray2[1] = 200
$aSubArray2[2] = $aSubArray1

Local $aMainArray[3]
$aMainArray[0] = "AutoIt"
$aMainArray[1] = $aSubArray1
$aMainArray[2] = $aSubArray2

ConsoleWrite("=== Массив массивов (как в PHP) ===" & @CRLF)
Local $Test = PrintArrayPHPStyle($aMainArray)
ConsoleWrite($Test & @CRLF)

Local $slovo = "asklhgdfsig"
Local $Test = PrintArrayPHPStyle($slovo)
ConsoleWrite($Test & @CRLF)

Local $arr[5] = [10, 20, 30, 40, 50]
Local $Test = PrintArrayPHPStyle($arr)
ConsoleWrite($Test & @CRLF)

; -- Уровень 1 --
; Создадим верхний 2D-массив: 5 строк (ключей), 2 столбца (ключ/значение)
Local $aTop[5][2]

For $i1 = 0 To 4
    ; Ключ верхнего уровня
    $aTop[$i1][0] = "TopKey_" & $i1

    ; Теперь создаём 2D-массив для подуровня, скажем, [3][2]
    Local $aSub[3][2]

    For $i2 = 0 To 2
        ; Ключ второго уровня
        $aSub[$i2][0] = "SubKey_" & $i2

        ; Создаём ещё один 2D-массив для третьего уровня, [2][2]
        Local $aSubSub[2][2]

        For $i3 = 0 To 1
            ; Ключ на третьем уровне
            $aSubSub[$i3][0] = "LeafKey_" & $i3

            ; Значение на третьем уровне
            $aSubSub[$i3][1] = "LeafValue_" & $i1 & "_" & $i2 & "_" & $i3
        Next

        ; Присваиваем подмассив третьего уровня ячейке "значение" второго уровня
        $aSub[$i2][1] = $aSubSub
    Next

    ; Присваиваем подмассив второго уровня ячейке "значение" первого уровня
    $aTop[$i1][1] = $aSub
 Next

Local $Test = PrintArrayPHPStyle($aTop)
ConsoleWrite($Test & @CRLF)

; 1) Псевдоассоциативный массив (2D: [N][2])
Local $aSubPref[2][2]
$aSubPref[0][0] = "Игры"
$aSubPref[0][1] = "футбол"
$aSubPref[1][0] = "Еда"
$aSubPref[1][1] = "пицца"

Local $aUser1[4][2]
$aUser1[0][0] = "Name"
$aUser1[0][1] = "Alice"
$aUser1[1][0] = "Age"
$aUser1[1][1] = 25
$aUser1[2][0] = "Email"
$aUser1[2][1] = "[email protected]"
$aUser1[3][0] = "Preferences"
$aUser1[3][1] = $aSubPref

Local $aMain[1][2]
$aMain[0][0] = "User1"
$aMain[0][1] = $aUser1

Local $Test = PrintArrayPHPStyle($aMain)
ConsoleWrite($Test & @CRLF)

; 2) Многомерный массив [2][3][2] ...
Local $aMulti[2][3][2]
For $i=0 To 1
    For $j=0 To 2
        For $k=0 To 1
            $aMulti[$i][$j][$k] = "MValue_" & $i & "_" & $j & "_" & $k
        Next
    Next
Next
Local $Test = PrintArrayPHPStyle($aMulti)
ConsoleWrite($Test & @CRLF)

Автор темы	Похожие темы	Форум	Ответы	Дата
H	Автоматическая печать документа на два принтера.	Общие вопросы по AutoIt	3	15 Дек 2021
	Файловая система To Print - печать файлов pdf	Примеры и рабочие проекты	0	24 Янв 2021
S	Как скриптом снять пароль на печать документа - с файла pdf	Стол заказов	0	8 Фев 2019
S	Получить список файлов, отправленных на печать	Общие вопросы по AutoIt	4	5 Май 2018
T	[Автоматизация] Поиск на странице PDF и печать совпадения	Стол заказов	0	16 Янв 2018

Поиск

Поиск

Печать многоуровневого и псевдоассоциативного массива

DyadyaGenya

Знающий

Alecsis

Осваивающий

Вложения

DyadyaGenya

Знающий

Вложения