使用COPY命令组合文件并获取奇数字符

Question

我有一堆小PowerShell函数，每个函数都在它们自己的文件中，我试图将它们合并到一个更大的文件中。

使用Windows的低技术含量的做法做复制命令：copy /Y /A functions\*.ps1 super.ps1工作正常，但是当两个文件都加入了它被插入：我»¿

我猜这是换行符显示出来（编码差异），但是如何防止这些字符出现？

Answer 1

这些字符是unicode字节顺序标记，它们将无形地位于.ps1内容之前。

我不知道你如何将它们在纯DOS下剥离 - 在这一点上，我会转向使用脚本语言来完成这项工作。您可以使用.net System.IO功能编写PowerShell脚本来加入它们。

Answer 2

你如何试图/ B为二进制停止OEM字符集转换

谁知道

或在记事本中打开脚本，并将其保存为ANSI然后试着和你正常的拷贝命令没有/ B连接要求

Answer 3

这些字符是字节顺序标记（BOM），正如Steve Gilham所说。 删除BOM最简单的方法是在支持utf-8的文本编辑器中打开所有文件，进行小的编辑并再次保存。 Gearny是一个理想的候选人。它支持utf-8，不保存BOM并且免费。 它只适用于Windows，但我假设您可以访问Windows窗口。 我不知道任何DOS程序能够去掉BOM（在DOS时代，utf-8只是一个项目）

一旦你剥离了BOM，你可以使用复制方法，但在二进制模式下（/ b） ，否则当多字节字符出现时，最可能的结果将是乱码文本。

Answer 4

这里有一个有趣的方向采取

http://msdn.microsoft.com/en-us/library/aa368046(VS.85).aspx（不能得到这个吸盘链接）

这有两个解决方案，以复制这似乎是Unicode到ANSI的PowerShell脚本。一种解决方案用VB编写的其他PowerShell中

一旦安思跟着大家的推荐

Answer 5

我强烈建议你不要使用DOS批处理读/写的二进制文件，它不适合这样做，一批非常较差的。

这是一个脚本，使用“fc”和“certutil”的黑客来做到这一点。但只适用于小文件。

@echo off 
cls 
cd /d "%~dp0" 
setlocal enableextensions 
setlocal enabledelayedexpansion 

rem ___________________________________________________________________________ 

rem Liste des fichiers à concaténer. 
set FILE_1=Fichier 1.txt 
set FILE_2=Fichier 2.txt 
set FILE_3=Fichier 3.txt 
set FILE_4=Fichier 4.txt 



rem Nom du fichier concaténé. 
set OUTPUT_FILE=Final.txt 



rem ___________________________________________________________________________ 

rem Liste des Byte Order Mark (BOM). 
set "BOM_UTF8=EFBBBF" 
set "BOM_UTF16_LE=FFFE" 
set "BOM_UTF16_BE=FEFF" 
set "BOM_UTF32_LE=FFFE0000" 
set "BOM_UTF32_BE=0000FEFF" 

rem Taille maximum d'un BOM, ici 4 octets avec l'UTF-32. 
set /a BOM_MAX_SIZE=4 

rem Fichiers temporaires pour les commandes "fc" et "certutil". 
set "TEMP_FILE_1=script_tmp_1.txt" 
set "TEMP_FILE_2=script_tmp_2.txt" 
set "TEMP_FILE_OUTPUT_1=script_tmp_3.txt" 
set "TEMP_FILE_OUTPUT_2=script_tmp_4.txt" 

set error_message_1=Erreur, le fichier : "!FILE_1!" n'existe pas. ^& echo.Ce script va s'arreter. 
rem error_message_1=Error, the file: "!FILE_1!" doesn't exist. ^& echo.This script will stop. 
set /a switch=0 
:define_variable 
set error_message_2=Erreur : Le Byte Order Mark de "!CURRENT_FILE!" est "!FILE_BOM!" au lieu de "!FIRST_FILE_BOM!". ^& echo.Ce script va s'arreter. 
rem error_message_2=Error: The Byte Order Mark in "!CURRENT_FILE!" is "!FILE_BOM!" instead of "!FIRST_FILE_BOM!". ^& echo.This script will stop. 
if %switch% EQU 1 (goto variable_defined) 
set "end_message=Operation accomplie." 
rem "end_message=Operation completed." 



echo en-US : If the files to concatenate have a Byte Order Mark, this script is limited to small files. From 10000 bytes, it will have to create more than 1254 temporary files, the operation may take a long time. Do you want to continue ? (Y/N) 
echo. 
echo fr-FR : Si les fichiers a concatener ont un Byte Order Mark, ce script se limite aux petits fichiers. A partir de 10000 octets, il devra creer plus de 1254 fichiers temporaires, l'operation risque de durer longtemps. Voulez-vous continuer ? (Y/N) 
echo. 
echo. 
set RESPONSE= 
set /P RESPONSE=Type your answer: %=% 
if "%RESPONSE%"=="y" (goto yes) 
if "%RESPONSE%"=="n" (goto no) 
if "%RESPONSE%"=="Y" (goto yes) 
if "%RESPONSE%"=="N" (goto no) 
:no 
exit /b 0 
:yes 
echo. 
rem "echo." affiche une ligne vide, on peut aussi utiliser "echo(". 



rem Si le premier fichier n'existe pas, on stoppe le programme en renvoyant le code d'erreur -1. 
if not exist "%FILE_1%" (
    echo %error_message_1% 
    echo. 
    pause 
    exit /b -1 
) 

rem On détecte le BOM du premier fichier. 
set "FILE_BOM=NONE" 
call:my_function_read_bom "%FILE_1%",FILE_BOM 
set "FIRST_FILE_BOM=%FILE_BOM%" 
echo %FILE_1% : %FIRST_FILE_BOM% 

rem On crée le fichier de sortie. 
copy /v /y /b "%FILE_1%" "%OUTPUT_FILE%" /b 
echo. 

rem S'il n'y a pas de BOM sur le premier fichier, c'est du binaire, de l'ASCII ou de l'ANSI, donc on copie tout. 
rem On prend chaque fichier suivant avec une boucle while en utilisant un nom de variable dynamique (avec la commande "goto"). 
set /a count_loop=2 
set "CURRENT_FILE=!FILE_%count_loop%!" 
rem Cette concaténation de variables ne fonctionne pas dans un bloc if. 
:while_loop_1 
    if "%FIRST_FILE_BOM%"=="NONE" (
     copy /V /Y /B "%OUTPUT_FILE%" + /B "%CURRENT_FILE%" "%OUTPUT_FILE%" /B 
    ) else (goto end_loop_1) 
    set /a count_loop=count_loop+1 
    set "CURRENT_FILE=!FILE_%count_loop%!" 
    if exist "%CURRENT_FILE%" (goto while_loop_1) 
    echo. 
    echo %end_message% 
    echo. 
    pause 
    exit /b 0 
:end_loop_1 

set /a count_loop=2 
set "CURRENT_FILE=!FILE_%count_loop%!" 
:while_loop_2 

    rem On vérifie son BOM. 
    set "FILE_BOM=NONE" 
    call:my_function_read_bom "!CURRENT_FILE!",!FILE_BOM! 
    echo !CURRENT_FILE! : !FILE_BOM! 

    rem Si le BOM est différent, on stoppe avec le code d'erreur -2. 
    if not "!FILE_BOM!"=="!FIRST_FILE_BOM!" (
     echo. 
     set /a switch=1 
     goto define_variable 
     :variable_defined 
     echo %error_message_2% 
     echo. 
     pause 
     exit /b -2 
    ) 

    rem On crée une copie temporaire du fichier à ajouter mais sans son BOM. 
    if "!FILE_BOM!"=="UTF8" (set /a SIZE_OF_BOM=3) 
    if "!FILE_BOM!"=="UTF16LE" (set /a SIZE_OF_BOM=2) 
    if "!FILE_BOM!"=="UTF16BE" (set /a SIZE_OF_BOM=2) 
    if "!FILE_BOM!"=="UTF32LE" (set /a SIZE_OF_BOM=4) 
    if "!FILE_BOM!"=="UTF32BE" (set /a SIZE_OF_BOM=4) 
    if "!FILE_BOM!"=="NONE" (exit /b -3) 
    call:my_function_split_file "!CURRENT_FILE!",!SIZE_OF_BOM! 

    rem On ajoute la copie temporaire. 
    copy /V /Y /B "%OUTPUT_FILE%" + /B "!CURRENT_FILE!_part.2" "%OUTPUT_FILE%" /B 
    echo. 

    rem Puis on supprime le fichier temporaire. 
    del /F /Q "!CURRENT_FILE!_part.2" >nul 2>&1 

    rem Tous les programmes (donc toutes les commandes) ont 3 flux : 
    rem Standard Input = Le flux des entrées (clavier pour la console) 
    rem Standard Output = Le flux des sorties (interface utilisateur et écran) 
    rem Standard Error = Le flux des erreurs (messages d'erreur affichés) 
    rem L'indicatif 1>nul ou par défaut >nul annule le flux des sorties, la commande n'affiche rien sauf en cas d'erreur. 
    rem L'indicatif 2>nul annule le flux des erreurs, la commande affiche tout sauf les erreurs. 
    rem L'indicatif 2>&1 permet de réorienter le flux des erreurs sur le flux des sorties. 
    rem Donc >nul 2>&1 permet de ne jamais rien afficher, même en cas d'erreur. 

    set /a count_loop=count_loop+1 
    set CURRENT_FILE=!FILE_%count_loop%! 
    if exist "%CURRENT_FILE%" (goto while_loop_2) 
echo. 
echo %end_message% 
echo. 
pause 
exit /b 0 
rem Il ne faut pas oublier le "exit" sinon les fonctions qui suivent seront à nouveau lues comme du code simple et cela causera des problèmes. 



rem ___________________________________________________________________________ 

:my_function_read_bom 
    rem On supprime le fichier temporaire s'il existe déjà. 
    del /F /Q "%TEMP_FILE_1%" >nul 2>&1 
    del /F /Q "%TEMP_FILE_OUTPUT_1%" >nul 2>&1 

    rem On crée le fichier temporaire et on le remplit de zéros selon la taille à comparer. 
    rem Arrêt si le fichier temporaire n'a pas pu être créé. 
    fsutil file createnew "%TEMP_FILE_1%" !BOM_MAX_SIZE! >nul || goto :eof 

    set /a COUNT_LINE=1 
    >%TEMP_FILE_OUTPUT_1% (
     rem Pour lire le fichier en binaire, on utilise un hack de la commande "fc". 
     rem La commande "fc" permet d'afficher une comparaison binaire octet par octet entre deux fichiers. 
     rem Elle n'affiche que les octets qui ne correspondent pas, donc elle n'affichera pas les zéros. 
     rem On utilise la boucle "for /f" pour extraire les octets du résultats de la commande "fc". 
     rem Avec "skip", on saute la première ligne. 
     rem Avec "delims", on sépare chaque ligne selon les caractères deux-points et espace. 
     rem Avec "tokens", on place le contenu séparé dans 2 variables (i et j). 
     rem Donc la variable i contiendra l'offset et la variable j contiendra l'octet. 
     for /f "skip=1 tokens=1,2 delims=: " %%i in ('fc /b %1 "%TEMP_FILE_1%"') do (
      if not "%%i"=="FCÿ" (
       set /a OFFSET=0x%%i 

       rem Si l'octet est 00, la commande "fc" ne les affiche pas. 
       for /l %%k in (!COUNT_LINE!,1,!OFFSET!) do (<nul set /p "=00") 

       rem On écrit l'octet dans le fichier. 
       <nul set /p "=%%j" 

       set /a COUNT_LINE=OFFSET+2 
      ) 
     ) 
     rem Si les derniers octets sont 00, la commande "fc" ne les affiche pas. 
     for /l %%i in (!COUNT_LINE!,1,!BOM_MAX_SIZE!) do (<nul set /p "=00") 
    ) 
    del /F /Q "%TEMP_FILE_1%" >nul 2>&1 

    rem Le fichier de sortie contient les premiers octets du fichier à lire. 
    rem On lit les premiers caractères de ce fichier de sortie. 
    rem On utilise la boucle "for /f" pour lire le fichier ligne par ligne. 
    rem Avec "usebackq", on peut lire les noms de fichiers ayant des espaces. 
    for /f "usebackq tokens=* delims=" %%i in ("%TEMP_FILE_OUTPUT_1%") do (
     set "LINE_READ=%%i" 

     rem On en déduit le BOM du fichier. 
     if "!FILE_BOM!"=="NONE" (
      set BOM_READ=!LINE_READ:~0,8! 
      if !BOM_READ!==%BOM_UTF32_LE% (set "FILE_BOM=UTF32LE") 
     ) 
     if "!FILE_BOM!"=="NONE" (
      set BOM_READ=!LINE_READ:~0,8! 
      if !BOM_READ!==%BOM_UTF32_BE% (set "FILE_BOM=UTF32BE") 
     ) 
     if "!FILE_BOM!"=="NONE" (
      set BOM_READ=!LINE_READ:~0,6! 
      if !BOM_READ!==%BOM_UTF8% (set "FILE_BOM=UTF8") 
     ) 
     if "!FILE_BOM!"=="NONE" (
      set BOM_READ=!LINE_READ:~0,4! 
      if !BOM_READ!==%BOM_UTF16_LE% (set "FILE_BOM=UTF16LE") 
     ) 
     if "!FILE_BOM!"=="NONE" (
      set BOM_READ=!LINE_READ:~0,4! 
      if !BOM_READ!==%BOM_UTF16_BE% (set "FILE_BOM=UTF16BE") 
     ) 
    ) 
    del /F /Q "%TEMP_FILE_OUTPUT_1%" >nul 2>&1 
goto :eof 

:my_function_split_file 
    rem On importe le nom du fichier et on retire les guillemets. 
    set INPUT_FILE=%1 
    set INPUT_FILE=%INPUT_FILE:"=% 
    set /a BUFFER=7800 

    rem Cette ligne permet de remplacer le caractère " par [rien]. 
    rem Pour remplacer " par ', il faut écrire : set INPUT_FILE=%INPUT_FILE:"='% 
    rem Pour remplacer World par Bob (insensible à la casse) : 
    rem set variable="Hello World!" 
    rem set variable=%variable:World=Bob% 

    rem On supprime les fichiers temporaires. 
    rem Le préfixe "/A:H" est indispensable pour pouvoir aussi supprimer les fichiers cachés. 
    del /F /Q "%TEMP_FILE_2%" >nul 2>&1 
    del /F /Q /A:H "%TEMP_FILE_OUTPUT_2%_part.*" >nul 2>&1 

    rem Pour écrire dans un fichier en binaire, on utilise un hack de la commande "certutil". 
    rem Cette commande crée un fichier texte plus gros que le fichier d'origine. 
    rem La commande crée un fichier texte contenant une vue du fichier à la façon d'un éditeur hexadécimal. 

    rem Elle découpe le fichier en lignes de 16 octets. Chaque ligne se compose de... 
    rem Trois caractères qui indiquent un numéro de ligne : 000, 001, 002... 009, 00a, 00b... 00f, 010, 011, 012... fff. 
    rem La commande est donc limitée à 4096 lignes (de 0 à fff). Donc la taille du fichier est limitée à 65536 octets. 
    rem Puis il y a un 0 (30) et une tabulation (09). 
    rem Puis le code hexadécimal est écrit au format ASCII en deux groupes de 8 octets séparés par un espace. 
    rem Puis il y a 3 espaces (ou plus, pour que la partie suivante arrive à la colonne 57 du fichier texte). 
    rem Puis le code binaire du fichier est recopié en remplaçant chaque caractère non-textuel par un point (2E). 
    rem Exemple d'un fichier en UTF-8 contenant la ligne "abcdefghijklm". 
    rem Cela donne "0000 EF BB BF 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d ...abcdefghijklm". 
    rem Enfin la ligne se termine par un retour à la ligne (0D0A). 

    rem Le paramètre "f" sert à écraser le fichier existant (force overwrite). 
    certutil -encodehex -f "%INPUT_FILE%" "%TEMP_FILE_2%" >nul 

    set /a SIZE=%2 

    if not defined SIZE (echo SIZE undefined. & goto :eof) 
    if !SIZE! LEQ 0 (echo SIZE not valid. & goto :eof) 

    rem Si SIZE est la taille du fichier à séparer donc un nombre d'octets, 
    rem et si LENGTH la longueur de la chaîne de caractères écrivant ces octets, 
    rem alors il faut multiplier par 2 car un octet s'écrit avec 2 caractères. 
    set /a LENGTH=%SIZE%*2 

    set "HEXADECIMAL_STRING=" 
    set /a HEXADECIMAL_STRING_LENGTH=0 
    set /a PART=1 

    rem On lit le fichier texte créé, et on le découpe en mettant chaque ligne en un fichier différent. 
    rem Le délimitateur est le caractère "Tabulation" (09). 
    for /f "usebackq tokens=2 delims= " %%i in ("%TEMP_FILE_2%") do (
     set "CURRENT_LINE=%%i" 

     rem On extrait les 48 premiers caractères pour n'obtenir que la partie hexadécimale. 
     rem Avec notre exemple, on obtient donc : "ef bb bf 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d". 
     set HEXADECIMAL_STRING=!HEXADECIMAL_STRING!!CURRENT_LINE:~0,48! 

     rem On supprime les espaces. 
     rem Avec notre exemple, on obtient donc : "efbbbf6162636465666768696a6b6c6d". 
     set HEXADECIMAL_STRING=!HEXADECIMAL_STRING: =! 

     if !HEXADECIMAL_STRING_LENGTH! GEQ 32 (
      set /a HEXADECIMAL_STRING_LENGTH=HEXADECIMAL_STRING_LENGTH+32 
     ) 
     if !HEXADECIMAL_STRING_LENGTH! LSS 32 (
      call:my_function_strlen HEXADECIMAL_STRING_LENGTH HEXADECIMAL_STRING 
     ) 
     echo %INPUT_FILE% : !HEXADECIMAL_STRING_LENGTH!/%BUFFER% 

     rem Si la taille de la ligne est >= la taille à extraire, 
     rem donc si on a atteint la fin de la partie à extraire, 
     rem on sauvegarde la partie à extraire dans un fichier. 
     if !HEXADECIMAL_STRING_LENGTH! GEQ !LENGTH! (
      set /a REST=HEXADECIMAL_STRING_LENGTH-LENGTH 
      for %%i in (!REST!) do (
       (echo(!HEXADECIMAL_STRING:~0,-%%i!)>>%TEMP_FILE_OUTPUT_2%_part.!PART! 
       rem Avec notre exemple, on obtient donc : "ef bb bf" suivi d'un retour à la ligne (0D0A). 

       rem On cache le fichier. Mettre "-h" pour le démasquer. 
       attrib +h "%TEMP_FILE_OUTPUT_2%_part.!PART!" >nul 

       rem La variable contient le reste de la ligne, dans notre exemple : "6162636465666768696a6b6c6d". 
       set HEXADECIMAL_STRING=!HEXADECIMAL_STRING:~-%%i! 
       set /a HEXADECIMAL_STRING_LENGTH=REST 
      ) 
      rem On utilise "certutil" pour créer un fichier binaire à partir d'un fichier texte contenant une chaîne de caractères hexadécimaux. 
      certutil -decodehex -f "%TEMP_FILE_OUTPUT_2%_part.!PART!" "%INPUT_FILE%_part.!PART!" >nul 

      set /a PART=PART+1 
      set /a LENGTH=%SIZE%*2 
     ) 
     rem Si la taille de la ligne est >= une taille maximum de sécurité, 
     rem on sauvegarde la ligne dans un fichier et on réinitialise. 
     if !HEXADECIMAL_STRING_LENGTH! GEQ !BUFFER! (
      (echo(!HEXADECIMAL_STRING!)>>%TEMP_FILE_OUTPUT_2%_part.!PART! 
      attrib +h "%TEMP_FILE_OUTPUT_2%_part.!PART!" >nul 
      set "HEXADECIMAL_STRING=" 
      set /a HEXADECIMAL_STRING_LENGTH=0 

      set /a LENGTH=!LENGTH!-!BUFFER! 
      if !LENGTH! LSS 0 (set /a LENGTH=0) 
     ) 
    ) 
    rem Au final, il reste la variable contenant le reste de la ligne, on l'extrait dans un autre fichier. 
    echo !HEXADECIMAL_STRING!>>%TEMP_FILE_OUTPUT_2%_part.!PART! 
    attrib +h "%TEMP_FILE_OUTPUT_2%_part.!PART!" >nul 
    certutil -decodehex -f "%TEMP_FILE_OUTPUT_2%_part.!PART!" "%INPUT_FILE%_part.!PART!" >nul 

    del /F /Q "%TEMP_FILE_2%" >nul 2>&1 
    del /F /Q /A:H "%TEMP_FILE_OUTPUT_2%_part.*" >nul 2>&1 

    rem Inutile ici mais pour créer un fichier vide, il faut écrire : 
    rem echo. 2>"fichier_vide.txt" 

    rem On fusionne toutes les autres parties dans la deuxième. 
    if !PART! GEQ 3 (
     for /l %%i in (3,1,!PART!) do (
      copy /V /Y /B "%INPUT_FILE%_part.2" + /B "%INPUT_FILE%_part.%%i" "%INPUT_FILE%_part.2" /B >nul 
      del /F /Q "%INPUT_FILE%_part.%%i" >nul 2>&1 
     ) 
    ) 

    rem On supprime la première partie. 
    del /F /Q "%INPUT_FILE%_part.1" >nul 2>&1 
goto :eof 

:my_function_strlen 
    set "STRING_TO_COUNT=!%~2!" 
    rem Écrire %~2 au lieu %2 permet de supprimer les guillemets. 

    rem Attention, les caractères comme !^ou % ne sont pas gérés, ils tronquent la chaîne. 
    rem echo String to count: %STRING_TO_COUNT% 

    rem Cette astuce permet de faire 3 boucles quelle que soit le nombre de caractères. 
    set /a STRING_LENGTH=1 
    for %%i in (4096 2048 1024 512 256 128 64 32 16 8 4 2 1) do (
     if "!STRING_TO_COUNT:~%%i,1!" NEQ "" ( 
      set /a "STRING_LENGTH+=%%i" 
      set "STRING_TO_COUNT=!STRING_TO_COUNT:~%%i!" 
     ) 
    ) 
    set /a %1=%STRING_LENGTH% 
goto :eof 

我推荐你使用VBScript来完成这些简单的任务。

' Liste des fichiers à concaténer. 
FILE_1 = "Fichier 1.txt" 
FILE_2 = "Fichier 2.txt" 
FILE_3 = "Fichier 3.txt" 
FILE_4 = "Fichier 4.txt" 



' Nom du fichier concaténé. 
OUTPUT_FILE = "Final.txt" 



' _____________________________________________________________________________ 

' Liste des Byte Order Mark (BOM). 
BOM_UTF8  = "EFBBBF" 
BOM_UTF16_LE = "FFFE" 
BOM_UTF16_BE = "FEFF" 
BOM_UTF32_LE = "FFFE0000" 
BOM_UTF32_BE = "0000FEFF" 

' Taille maximum d'un BOM, ici 4 octets avec l'UTF-32. 
BOM_MAX_SIZE = 4 

error_message_1 = """Erreur, le fichier : """""" & FILE_1 & """""" n'existe pas."" & vbCrLf & ""Ce script va s'arrêter.""" 
'     """Error, the file: """"""  & FILE_1 & """""" doesn't exist."" & vbCrLf & ""This script will stop.""" 
error_message_2 = """Erreur : Le Byte Order Mark de """""" & current_file_name & """""" est """""" & FILE_BOM & """""" au lieu de """""" & FIRST_FILE_BOM & """"""."" & vbCrLf & ""Ce script va s'arrêter.""" 
'     """Error: The Byte Order Mark in """""" & current_file_name & """""" is """""" & FILE_BOM & """""" instead of """""" & FIRST_FILE_BOM & """"""."" & vbCrLf & ""This script will stop.""" 
end_message  = "Opération accomplie." 
'     "Operation completed." 
error_code  = 0 
exit_delay  = 5000 
' On attend 5 secondes (5000 millisecondes) au cas où le script serait exécuté en mode console. 

dim file_system_object 
set file_system_object = CreateObject("Scripting.FileSystemObject") 
dim current_directory 
set current_directory = file_system_object.GetFolder(".") 

' Si le premier fichier n'existe pas, on stoppe le programme en renvoyant le code d'erreur -1. 
if (file_system_object.FileExists(FILE_1) = FALSE) then 
    Execute "WScript.Echo(" & error_message_1 & ")" 
    WScript.Sleep exit_delay 
    WScript.Quit(-1) 
end if 

' On détecte le BOM du premier fichier. 
FILE_BOM = "NONE" 

error_code = my_function_read_bom(FILE_1, FILE_BOM) 
If error_code <> 0 Then 
    WScript.Sleep exit_delay 
    WScript.Quit(error_code) 
End If 

FIRST_FILE_BOM = FILE_BOM 
' WScript.Echo(FILE_1 & " : " & FIRST_FILE_BOM) 

' On crée le fichier de sortie. 
file_system_object.CopyFile current_directory & "\" & FILE_1, current_directory & "\" & OUTPUT_FILE, TRUE 
' TRUE = Écraser le fichier s'il existe déjà. 

' On prend chaque fichier suivant avec une boucle while en utilisant un nom de variable dynamique (avec la commande "Execute"). 
dim input_file 
dim output_file 
set output_file = file_system_object.OpenTextFile(OUTPUT_FILE, 8, FALSE, 0) 
current_file_name = FILE_2 
file_number  = 2 
Do While (file_system_object.FileExists(current_file_name) = TRUE) 
    ' Execute "WScript.Echo ""Current file: "" & FILE_" & file_number 

    If FIRST_FILE_BOM = "NONE" Then 
     set input_file = file_system_object.OpenTextFile(current_file_name, 1, FALSE, 0) 
     Do Until input_file.AtEndOfStream 
      output_file.Write(input_file.Read(1)) 
     Loop 
     input_file.Close 
    Else 
     ' On vérifie son BOM. 
     FILE_BOM = "NONE" 
     error_code = my_function_read_bom(current_file_name, FILE_BOM) 
     If error_code <> 0 Then 
      WScript.Sleep exit_delay 
      WScript.Quit(error_code) 
     End If 
     ' WScript.Echo current_file_name & " : " & FILE_BOM 

     ' Si le BOM est différent, on stoppe avec le code d'erreur -2. 
     If FIRST_FILE_BOM <> FILE_BOM Then 
      Execute "WScript.Echo(" & error_message_2 & ")" 
      WScript.Sleep exit_delay 
      WScript.Quit(-2) 
     End If 

     ' On ajoute dans le fichier de sortie le contenu du fichier mais sans son BOM. 
     Select Case FILE_BOM 
     Case "UTF8" 
      SIZE_OF_BOM = 3 
     Case "UTF16LE", "UTF16BE" 
      SIZE_OF_BOM = 2 
     Case "UTF32LE", "UTF32BE" 
      SIZE_OF_BOM = 4 
     Case Else 
      WScript.Sleep exit_delay 
      WScript.Quit(-3) 
     End Select 

     count_character = 1 
     set input_file = file_system_object.OpenTextFile(current_file_name, 1, FALSE, 0) 
     Do Until input_file.AtEndOfStream 
      If count_character > SIZE_OF_BOM Then 
       output_file.Write(input_file.Read(1)) 
      Else 
       input_file.Read(1) 
      End If 
      count_character = count_character + 1 
     Loop 
     input_file.Close 
    End If 

    file_number = file_number + 1 
    Execute "current_file_name = FILE_" & file_number 
    ' WScript.Echo "Next file: " & current_file_name 
Loop 
output_file.Close 

WScript.Echo(end_message) 
WScript.Sleep exit_delay 
WScript.Quit(0) 



' ___________________________________________________________________________'' 

Function my_function_read_bom(Byval file_name, ByRef FILE_BOM) 
    dim input_file 
    ' 1 = ForReading 2 = ForWriting 8 = ForAppending (écrire à partir de la fin). 
    ' FALSE = Ne pas créer le fichier s'il n'existe pas. 
    ' -1 = TristateTrue (ouvre en UTF-16 LE, par groupe de 2 octets) 0 = TristateFalse = 0 (en ASCII, lit octet par octet, mode par défaut) -2 = TristateUseDefault = -2 (selon l'encodage par défaut du système d'exploitation). 
    set input_file = file_system_object.OpenTextFile(file_name, 1, FALSE, 0) 

    offset_read = 0 
    byte_read = "" 
    byte_string = "" 

    Do Until input_file.AtEndOfStream 
    ' Ou Do While Not input_file.AtEndOfStream 

     byte_read = UCase(CStr(Hex(Asc(input_file.Read(1))))) 
     byte_read = String(2 - Len(byte_read), "0") & byte_read 
     byte_string = byte_string & byte_read 
     byte_read = "" 
     offset_read = offset_read + 1 

     If offset_read >= BOM_MAX_SIZE Then 
      Exit Do 
     End If 
    Loop 
    input_file.Close 

    If FILE_BOM = "NONE" Then 
     If Left(UCase(byte_string), 8) = BOM_UTF32_LE Then 
      FILE_BOM = "UTF32LE" 
     Else If Left(UCase(byte_string), 8) = BOM_UTF32_BE Then 
      FILE_BOM = "UTF32BE" 
     Else If Left(UCase(byte_string), 6) = BOM_UTF8 Then 
      FILE_BOM = "UTF8" 
     Else If Left(UCase(byte_string), 4) = BOM_UTF16_LE Then 
      FILE_BOM = "UTF16LE" 
     Else If Left(UCase(byte_string), 4) = BOM_UTF16_BE Then 
      FILE_BOM = "UTF16BE" 
     Else 
      my_function_read_bom = -4 
     End If 
     End If 
     End If 
     End If 
     End If 
    End If 

    my_function_read_bom = 0 
End Function