Файлы chunk что это
Еще один способ использования Webpack 4 и разделение кода
Ни для кого не секрет, что с выходом Webpack 4 стратегия разделения кода сильно поменялась. Тут даже лучше сказать, что она была заново придумана, т.к. старый подход просто перестал работать, а новый не понятно как использовать.
Для тех, кто все еще не в курсе, плагина webpack.optimize.CommonsChunkPlugin больше нет. Совсем. Вместо этого предлагается в конфиге писать следующее:
Это должно работать как магия. Т.е. теперь не мы говорим webpack’у что сделать общим чанком, а он сам все сделает, да еще может даже и лучше нас.
И наступит счастье. Шутка. На самом деле нет.
Базовые приготовления
Вот пример из документации:
Результатом сборки будут 3 файла: another.bundle.js, index.bundle.js, vendors
Теперь, для того, чтобы запустить наши веб приложения, мы, в одном случае, должны подключить vendors
index.bundle.js и index.bundle.js, а во втором vendors
index.bundle.js и another.bundle.js.
В чем проблема?
Проблема в имени vendors
index.bundle.js. Пока у нас меньше трех точек входа, ничего страшного не происходит. Здесь все кажется логичным — бандл содержит npm модули (они же vendors) и общие модули для index и another. На каждую из страниц мы подключаем 2 файла и не имеем проблем.
Однако если у нас три и более точки входа, то новых бандлов (они же чанки) может быть куда больше и мы уже не знаем ни их количества, ни имен. Все становится еще веселее, если мы еще и css извлекаем в отдельные файлы. И это проблема.
Как решить эту проблему?
После завершения работы webpack у нас нет никаких файлов, которые содержали бы в себе информацию о том, какие именно бандлы на той или иной странице надо подключать. И в какой последовательности.
Однако в output’е мы можем найти вот такие строки:
На самом деле это почти то, что нам надо. Т.е. webpack прекрасно знает какие бандлы нужны для каждой точки входа, но почему-то сам не хочет этой информацией с нами делиться.
Манифест нам здесь не помогает. Да, мы знаем что такой (vendors
index.bundle.js) бандл есть. Мы знаем где он лежит. Но кому он нужен не знаем. Т.е. манифест бесполезен.
Тогда я решил что раз webpack знает нужную информацию, то ее возможно получится достать с помощью плагинов. Готовых я не нашел и решил написать свой. И, только ради демонстрации этого плагина, я и пишу эту статью.
В файле webpack.config.(ts|js) добавим новый плагин:
и дождемся результата. Результатом будет файл entrypoints.json с вот таким содержанием:
Если используется extract-css, то кроме секции js будет еще и css.
Поиск правильного способа разделения материалов сайтов с помощью Webpack
Поиск наилучшего способа организации материалов веб-проектов может оказаться непростой задачей. Существует множество различных сценариев работы пользователей с проектами, множество технологий и других факторов, которые нужно принимать во внимание.
Автор материала, перевод которого мы сегодня публикуем, говорит, что хочет рассказать здесь обо всём, что нужно знать для грамотной подготовки материалов веб-проектов к работе. Во-первых, речь пойдёт о том, как подобрать такую стратегию разделения файлов сайта, которая наилучшим образом подойдёт для конкретного проекта и для его пользователей. Во-вторых — будут рассмотрены средства реализации выбранной стратегии.
Общие сведения
В соответствии с глоссарием Webpack, существуют две стратегии разделения файлов. Это — разделение бандла (bundle splitting) и разделение кода (code splitting). Эти термины могут показаться взаимозаменяемыми, но таковыми они не являются.
Однако мне хотелось бы сказать, что для многих сайтов гораздо более ценным оказывается именно первая стратегия — разделение бандлов. И, пожалуй, от её внедрения способны выиграть буквально все веб-проекты.
Поговорим об этом подробнее.
Разделение бандлов
В основе методики разделения бандлов лежит весьма простая идея. Если у вас имеется один огромный файл и вы меняете в нём одну единственную строчку кода, постоянному пользователю придётся, при очередном посещении сайта, загрузить весь этот файл. Однако если разделить этот файл на два файла, тогда такому же пользователю нужно будет загрузить лишь тот из них, в который внесены изменения, а второй файл будет взят из браузерного кэша.
Стоит отметить, что так как оптимизация материалов сайта путём разделения бандлов завязана на кэшировании, пользователям, посещающим сайт впервые, в любом случае, придётся загружать все материалы, поэтому для них нет разницы — будут ли эти материалы представлены в виде одного файла или в виде нескольких.
Мне кажется, что слишком много разговоров о производительности веб-проектов посвящено пользователям, которые посещают сайт впервые. Возможно, это так, отчасти, из-за важности первого впечатления, которое проект произведёт на пользователя, а также от того, что объёмы данных, передаваемые пользователям при первом посещении сайта, просто и удобно измерять.
Когда же дело доходит до регулярных посетителей, может оказаться сложным измерить воздействие на них применяемых техник оптимизации материалов. Но мы просто обязаны знать о том, к каким последствиям приводят подобные оптимизации.
Для анализа таких вещей потребуется нечто вроде электронной таблицы. Также нужно будет сформировать строгий перечень условий, в которых мы можем протестировать каждую из исследуемых стратегий кэширования.
Вот сценарий, подходящий под общее описание, данное в предыдущем абзаце:
▍Исходные условия
В соответствии с вышеописанным сценарием, когда мы, каждую неделю, вносим в код сайта какие-то изменения, строка contenthash пакета меняется. В результате, посещая еженедельно наш сайт, Алиса вынуждена загружать новый файл размером 400 Кб.
Если сделать симпатичную табличку (с бесполезной пока строкой итогов), содержащую данные о еженедельном объёме загрузки данных, приходящихся на этот файл, то у нас получится следующее.
Объём данных, загруженных пользователем
В результате оказывается, что пользователь, за 10 недель, загрузил 4.12 Мб кода. Этот показатель можно улучшить.
▍Отделение пакетов сторонних разработчиков от основного кода
Webpack 4 старается максимально облегчить жизнь разработчику, поэтому он делает всё, что может, и при этом не требует, чтобы ему сообщали о том, как именно нужно разбивать бандлы на части.
Такое вот автоматическое поведение программы приводит к немногочисленным восторгам, вроде: «Ну что за прелесть этот Webpack», и к множеству вопросов в духе: «А что это тут делается с моими бандлами?».
В любом случае, добавление в конфигурацию конструкции optimization.splitChunks.chunks = ‘all’ сообщает Webpack о том, что нам надо, чтобы он взял всё из node_modules и поместил бы это в файл vendors
После того, как мы провели такое вот базовое разделение бандла, Алиса, регулярно посещающая наш сайт еженедельно, будет загружать при каждом визите файл main.js размером 200 Кб. А вот файл vendor.js она загрузит лишь три раза. Произойдёт это во время визитов в первую, пятую и восьмую недели. Вот соответствующая таблица, в которой, волею судьбы, размеры файлов main.js и vendor.js в первые четыре недели совпадают и равняются 200 Кб.
Объём данных, загруженных пользователем
В результате получается, что объём загруженных пользователем за 10 недель данных составил 2.64 Мб. То есть, в сравнении с тем, что было до разделения бандла, объём уменьшился на 36%. Не такой уж и плохой результат, достигнутый добавлением нескольких строк в конфигурационный файл. Кстати, прежде чем читать дальше — сделайте то же самое в своём проекте. А если вам надо обновиться с Webpack 3 на 4 — делайте это и не беспокойтесь, так как процесс это довольно простой и всё ещё бесплатный.
Мне кажется, что рассматриваемое тут улучшение выглядит несколько абстрактно, так как оно растянуто на 10 недель. Однако если считать объём данных, отправленных лояльному пользователю, то это честное сокращение этого объёма на 36%. Это очень хороший результат, но его можно улучшить.
▍Выделение пакетов в отдельные файлы
В документации можно найти отличное разъяснение использованных здесь конструкций, но я, всё же, посвящу немного времени рассказу о некоторых вещах, так как для того, чтобы правильно ими воспользоваться, у меня ушло немало времени.
Ниже показана новая версия таблицы со сведениями об объёмах еженедельных загрузок данных. По странному стечению обстоятельств размер каждого файла с npm-пакетами составляет 20 Кб.
Объём данных, загруженных пользователем
Теперь объём загруженных за 10 недель данных составляет 2.24 Мб. Это значит, что мы улучшили базовый показатель на 44%. Результат это уже весьма приличный, но тут возникает вопрос о том, можно ли сделать так, чтобы добиться результата, превышающего 50%. Если подобное получится — это будет просто здорово.
▍Разбиение кода приложения на фрагменты
Выше я говорил о том, что на нашем сайте имеется два самостоятельных раздела. Первый — это список товаров, второй — страница с подробными сведениями о товаре. Размер кода, уникального для каждого из них, составляет 25 Кб (а 150 Кб кода применяется и там и там).
Страница со сведениями о товаре не подвергается изменениям, так как мы уже довели её до совершенства. Поэтому, если мы выделим её код в отдельный файл, этот файл, большую часть времени работы с сайтом, будет загружаться в браузер из кэша.
Кроме того, как оказалось, у нас имеется огромный встроенный SVG-файл, используемый для рендеринга значков, который весит целых 25 Кб и изменяется редко.
С этим надо что-то делать.
Мы вручную создали несколько входных точек, сообщая Webpack о том, что ему нужно создать отдельный файл для каждой из этих сущностей.
То, что мы только что сделали, позволит Алисе экономить почти каждую неделю по 50 Кб трафика. Обратите внимание на то, что файл с описанием значков мы отредактировали на шестой неделе. Вот наша традиционная таблица.
Объём данных, загруженных пользователем
Теперь за десять недель загружено всего 1.815 Мб данных. Это означает, что экономия трафика составила впечатляющие 56%. В соответствии с нашим теоретическим сценарием постоянный пользователь всегда будет работать с таким уровнем экономии.
Всё это сделано за счёт изменений, внесённых в конфигурацию Webpack. Код приложений мы для достижения таких результатов не меняли.
Выше я говорил о том, что конкретный сценарий, по которому проводится подобный тест, на самом деле, особой роли не играет. Сказано это из-за того, что, вне зависимости от используемого сценария, вывод из всего, о чём мы говорили, будет одним и тем же: разбиение приложения на небольшие файлы, имеющие смысл в применении к его архитектуре, позволяет снизить объёмы данных сайта, загружаемых его постоянными пользователями.
Совсем скоро мы перейдём к разговору о разделении кода, но сначала мне бы хотелось ответить на три вопроса, над которыми вы, наверняка, сейчас размышляете.
▍Вопрос №1. Разве необходимость выполнения множества запросов не вредит скорости загрузки сайта?
На этот вопрос можно дать простой короткий ответ: «Нет, не вредит». Подобная ситуация выливалась в проблему в былые времена, когда в ходу был протокол HTTP/1.1, а при использовании HTTP/2 это уже неактуально.
Хотя, надо отметить, что в этом материале, опубликованном в 2016 году, и в этой статье Khan Academy 2015 года делаются выводы о том, что даже при использовании HTTP/2, использование слишком большого количества файлов замедляет загрузку. Но в обоих этих материалах «слишком большое количество» означает «несколько сотен». Поэтому стоит помнить о том, что если вам приходится работать с сотнями файлов, на скорость их загрузки могут повлиять ограничения на параллельную обработку данных.
Если интересно, поддержка HTTP/2 имеется в IE 11 в Windows 10. Кроме того, я проводил всестороннее исследование среди тех, кто пользуется более старыми системами. Они единодушно заявили, что их скорость загрузки веб-сайтов особенно не заботит.
▍Вопрос №2. В Webpack-бандлах есть вспомогательный код. Создаёт ли он дополнительную нагрузку на систему?
▍Вопрос №3. При работе с множеством маленьких файлов ухудшается уровень их сжатия, не так ли?
Да, это тоже так. На самом деле, мне хотелось бы сказать вот что:
Только что я провёл испытание, в ходе которого код из файла размером 190 Кб был разбит на 19 частей. Это добавило примерно 2% к объёму данных, отправляемых в браузер.
В итоге получается, что при первом посещении сайта пользователь загрузит на 2% больше данных, а при последующих — на 60% меньше, и продолжаться это будет очень и очень долго.
Так стоит ли об этом беспокоиться? Нет, не стоит.
Когда я проводил сравнение системы, использующей 1 файл, и системы с 19 файлами, я испытал её с использованием различных протоколов, в том числе и HTTP/1.1. Нижеприведённая таблица очень сильно поддерживает идею о том, что больше файлов — значит лучше.
Данные о работе с 2 версиями сайта, размещённого на статическом хостинге Firebase, код которого имеет размеры 190 Кб, но, в первом случае, упакован в 1 файл, а во втором — разбит на 19
При работе в 3G и 4G-сетях на загрузку варианта сайта с 19 файлами ушло на 30% меньше времени, чем на загрузку сайта с одним файлом.
В данных, представленных в таблице, много шума. Например, один сеанс загрузки сайта по 4G (Run 2 в таблице) занял 646 мс, ещё один (Run 4) — 1116 мс, что на 73% дольше. Поэтому возникает ощущение, что говорить о том, что HTTP/2 «на 30% быстрее» — это несколько нечестно.
Я создал эту таблицу для того, чтобы посмотреть, что даёт использование HTTP/2. Но, на самом деле, единственное, что тут можно сказать, заключается в том, что применение HTTP/2, вероятно, не особо заметно влияет на загрузку страниц.
Настоящим сюрпризом стали две последних строчки в этой таблице. Тут представлены результаты для не самой новой версии Windows с IE11 и HTTP/1.1. Я, если бы заранее пытался предсказать результаты испытания, точно сказал бы, что такая конфигурация будет загружать материалы гораздо медленнее других. Правда, тут использовалось очень быстрое сетевое подключение, и мне, для подобных испытаний, вероятно, стоит пользоваться чем-то более медленным.
А теперь расскажу вам одну историю. Я, чтобы исследовать мой сайт на совсем уж древней системе, загрузил виртуальную машину Windows 7 с сайта Microsoft. Там был установлен IE8, который я решил обновить до IE9. Для этого я пошёл на страницу Microsoft, предназначенную для загрузки IE 9. Но сделать этого мне не удалось.
Кстати, если говорить об HTTP/2, хочется отметить, что этот протокол интегрирован в Node.js. Если вы хотите поэкспериментировать — можете воспользоваться написанным мной небольшим HTTP/2 сервером с поддержкой кэша ответов, gzip и brotli.
Пожалуй, о методике разделения бандлов я сказал всё, что хотел. Думаю, что единственный минус такого подхода, при использовании которого пользователям приходится загружать очень много файлов, на самом деле, не является таким уж «минусом».
Теперь поговорим о разделении кода.
Разделение кода
Основная идея методики разделения кода звучит так: «Не загружайте ненужный код». Мне говорили, что использование этого подхода имеет смысл лишь для некоторых сайтов.
Я предпочитаю, когда речь идёт о разделении кода, использовать правило 20/20, которое я только что сформулировал. Если есть какая-то часть сайта, которую посещают лишь 20% пользователей, и её функционал обеспечивают более 20% JavaScript-кода сайта, тогда этот код нужно загружать только по запросу.
Это, конечно, не абсолютные цифры, их можно подстроить под конкретную ситуацию, и в реальности существуют гораздо более сложные сценарии, чем вышеописанный. Самое важное тут заключается в балансе, и совершенно нормально совсем не пользоваться разделением кода, если для вашего сайта это не имеет смысла.
▍Разделять или нет?
Как найти ответ на вопрос о том, нужно вам разделение кода или нет? Предположим, у вас имеется интернет-магазин, и вы размышляете о том, надо ли отделить от остального кода тот код, который используется для приёма оплаты от покупателей, так как лишь 30% посетителей у вас что-то покупают.
Что тут сказать? Во-первых — вам стоило бы поработать над наполнением магазина и продавать что-то такое, что окажется интересным большему количеству посетителей сайта. Во-вторых — нужно понять то, какой объём кода совершенно уникален для того раздела сайта, где принимается оплата. Так как перед «разделением кода» следует всегда выполнять «разделение бандла», и вы, надеюсь, так и делаете, то вы, вероятно, уже знаете о том, какие размеры имеет интересующий нас код.
Возможно, этот код может оказаться меньше, чем вы думаете, поэтому, прежде чем радоваться новой возможности оптимизации сайта, стоит всё спокойно посчитать. Если у вас, например, имеется React-сайт, тогда хранилище, редьюсеры, система маршрутизации, действия, будут совместно использоваться всеми частями сайта. Уникальный для разных частей сайта код будет, в основном, представлен компонентами и вспомогательными функциями для них.
Итак, вы выяснили, что совершенно уникальный код раздела сайта, используемого для оплаты покупок, занимает 7 Кб. Размер остального кода сайта — 300 Кб. В подобной ситуации я не стал бы заниматься разделением кода по нескольким причинам:
А теперь рассмотрим пару примеров применения этой технологии.
▍Полифиллы
Я начинаю именно с этого примера, так как то, что мы тут рассмотрим, просто реализуется и применимо к большинству сайтов.
Я использую на своём сайте множество полезных штуковин в виде полифиллов. Поэтому у меня имеется файл, в котором всё это подключается. Он состоит из следующих восьми строчек:
Благодаря использованию конфигурации Webpack из предыдущего раздела, материалы полифиллов будут автоматически разделены на четыре файла, так как для их реализации используются четыре npm-пакета. Их размер составляет примерно 25 Кб, 90% браузеров они не нужны, поэтому имеет смысл загружать их динамически.
Благодаря применению Webpack 4 и использованию конструкции import() (не путайте её с ключевым словом import ), организовать условную загрузку полифиллов очень просто:
Кстати сказать, для использования import() вам понадобится плагин Babel dynamic-import. Кроме того, как сказано в документации к Webpack, команда import() использует промисы, поэтому полифилл для данной возможности нужно загружать отдельно от других полифиллов.
Как я и говорил, это очень просто. Рассмотрим теперь пример посложнее.
▍Динамическая загрузка материалов в React, основанная на маршрутах
Вернёмся к примеру с Алисой. Предположим, теперь на нашем сайте есть закрытый раздел для администраторов магазинов, куда они могут входить для того, чтобы управлять своими товарами.
В этом разделе имеется множество замечательных возможностей, куча графиков и здоровенная npm-библиотека для работы с ними. Так как на сайте уже применяется разделение бандлов, я могу понять, что всё это занимает более 100 Кб.
Причём, для этого не нужно заниматься конфигурированием.
Итоги
Полагаю, я рассказал всё, что хотел (хотя, надо отметить, мы не говорили тут о CSS). Подведём краткие итоги:
Как выглядит zip-архив и что мы с этим можем сделать. Часть 2 — Data Descriptor и сжатие
Предисловие
Доброго времени суток.
И снова в эфире у нас нетрадиционное программирование на PHP.
В прошлой статье уважаемых читателей заинтересовала тема сжатия в ZIP и сохранение потоков в zip. Попробуем сегодня хоть немного раскрыть эту тему.
Давайте взглянем на
В чем его проблема? Ну, справедливости ради, стоит заметить, что единственным его достоинством является то, что он работает, а проблем там валом, но все же.
На мой взгляд основной проблемой является то, что сначала мы должны записать Local File Header (LFH) с crc32 и длиной файла, а потом уже само содержимое файла.
Чем это грозит? Либо мы загружаем весь файл в память, считаем для него crc32, записываем LFH, а потом содержимое файла — экономно с точки зрения I/O, но недопустимо с большими файлами. Либо мы читаем файл 2 раза — сначала чтоб посчитать хеш, а потом чтоб считать содержимое и записать в архив — экономно с точки зрения оперативной памяти, но, например, во-первых создает удвоенную нагрузку на накопитель, который не обязательно SSD.
А если файл лежит удаленно и объем его, например, 1.5гб? Это ж придется либо загружать все 1.5гб в память, либо ждать пока все эти 1.5гб скачаются и мы посчитаем хеш, а потом качать их еще раз чтоб отдать содержимое. В случае же, если мы хотим на лету отдать, например, дамп бд, который мы, к примеру, читаем из stdout, это вообще недопустимо — изменились данные в бд, изменятся данные дампа, будет совершенно другой хеш и мы получим невалидный архив. Дааа, дела, конечно, скверные.
Структура Data Descriptor для потоковых записей в архиве
Но не расстраивайтесь, спецификация ZIP позволяет нам сначала записать данные, а потом прилепить структуру Data Descriptor (DD) после данных, в которой уже и будет crc32, длина упакованных данных и длина данных без сжатия. Для этого нам нужно всего 3 раза в день натощак в LFH указать generalPurposeBitFlag равным 0x0008, а crc32, compressedSize и uncompressedSize указать 0. Тогда после данных мы записываем структуру DD, которая будет выглядеть как-то так:
А в Central Directory File Header (CDFH) поменяется только generalPurposeBitFlag, остальные данные должны быть настоящими. Но это не проблема, так как CDFH мы записываем после всех данных, и хеши с длинами данных у нас известны в любом случае.
Выглядит это примерно как-то так:
Давайте попробуем это все как-то обернуть в одну функцию, чтоб мы могли удобным нам образом прочесть файл, а в конце получить его хеш и длину. А помогут нам в этом генераторы:
и теперь мы можем просто
По-моему довольно просто и удобно. При файле 1Гб пиковое потребление памяти у меня получилось 2Мб.
Теперь попробуем модифицировать код из предыдущей статьи так, чтоб мы могли этой функцией воспользоваться.
На выходе мы должны получить Zip-архив с именем test.zip, в котором будет файл с указанным выше скриптом и 100MB.bin, размером около 100Мбайт.
Сжатие в Zip-архивах
Теперь у нас есть фактически всё, чтоб сжимать данные и делать это тоже «на лету».
Подобно тому, как мы получаем хеш, отдавая функции маленькие чанки, мы можем и сжимать данные благодаря чудесной библиотеке Zlib и её функциям deflate_init и deflate_add.
Выглядит это примерно как-то так:
Я встречал вариант вроде такого, что в сравнении с предыдущим допишет в конце несколько нолей.
Но unzip ругался, поэтому от такого упрощения пришлось избавиться.
Поправим наш reader так, чтоб он сразу сжимал наши данные, а в конце возвращал нам хеш, длину данных без компрессии и длину данных с компрессией:
и попробуем на 100 мб файле:
Потребление памяти все так же показывает, что мы не загружали весь файл в память.
Давайте соберем все это и наконец-то получим действительно настоящий скрипт-архиватор.
В отличии от предыдущей версии у нас изменится generalPurposeBitFlag — теперь его значение 0x0018, а так же compressionMethod — 8 (что значит Deflate).
В итоге у меня получился архив, размером 360183 байт (очень хорошо сжался наш 100мб файл, в котором скорей всего просто набор одинаковых байт), а unzip показал, что ошибок в архиве не найдено.
Заключение
Если у меня хватит сил и времени на еще одну статью, то я постараюсь показать как и, главное, зачем это всё можно использовать.
Если вас интересует что-либо еще на данную тему — предлагайте в комментариях, я постараюсь дать ответ на ваш вопрос. Разбираться с шифрованием мы скорей всего не будем, потому что скрипт и так разросся, а в реальной жизни такие архивы, как мне кажется, используются не слишком часто.
Спасибо вам за внимание и за ваши комментарии.
Как открыть CHUNK001 файлы на вашем устройстве
CHUNK001 расширение файла
Как открыть файл CHUNK001?
При открытии открытия. CHUNK001 файлов могут быть разные причины проблем. Каждая проблема требует своего подхода, но большинство из них можно решить, следуя приведенным ниже инструкциям.
Шаг 1. Установите программу, которая поддерживает CHUNK001 файлы
Чтобы открыть CHUNK001 файл, в системе должна быть установлена соответствующая программа, которая поддерживает этот формат файлов. Ниже представлен список программ, которые поддерживают файлы с расширением CHUNK001.
Программы, открывающие файлы CHUNK001
Скачайте установщик для данного приложения и запустите его. После завершения установки CHUNK001 файлы должны быть открыты с установленным приложением по умолчанию при следующей попытке открыть файл этого типа.
Помните!
Не все перечисленные приложения могут выполнять все операции с файлами CHUNK001. Некоторые приложения могут открывать только такой файл и просматривать его содержимое, тогда как целью других может быть преобразование файлов в другие форматы файлов. Поэтому вам следует заранее проверить возможности приложений в отношении файлов CHUNK001.
Шаг 2. Свяжите данное программное обеспечение с файлами CHUNK001
Может возникнуть ситуация, когда у пользователя есть соответствующее приложение, поддерживающее файлы CHUNK001, установленные в его системе, но такое приложение не связано с файлами этого типа. Чтобы связать данное приложение с CHUNK001 файлами, пользователь должен открыть подменю файлов, щелкнув правой кнопкой мыши значок файла и выбрав опцию «Открыть с помощью». Система отобразит список предлагаемых программ, которые можно использовать для открытия файлов CHUNK001. Выберите соответствующую опцию и установите флажок «Всегда использовать выбранное приложение для открытия файлов такого типа». Система сохранит эту информацию, используя выбранную программу, чтобы открыть CHUNK001 файлы.
Шаг 3. Проверьте, нет ли других ошибок, связанных с файлами CHUNK001
Когда вышеупомянутые решения терпят неудачу, другие варианты должны быть продолжены. Возможно, файл CHUNK001 поврежден или поврежден. Наиболее распространенные причины повреждения файла: