Le nombre de jetons de limite dans le cadre d'une commande dans un Windows script batch

J'ai essayé de traiter un fichier texte dans un Windows script batch et je suis tombé sur quelque chose qui ressemble à une limitation de 31 jetons dans une boucle FOR. J'ai isolé le problème dans le code ci-dessous:

@ECHO OFF
SET DATA=01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

FOR /F "tokens=31* delims= " %%i IN ("%DATA%") DO (
    ECHO [%%i]
    ECHO [%%j]
)
ECHO.
FOR /F "tokens=32* delims= " %%i IN ("%DATA%") DO (
    ECHO [%%i]
    ECHO [%%j]
)

La sortie est:

[31]
[32 33 34 35]

[01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35]
[%j]

et je m'attendais à ce:

[31]
[32 33 34 35]

[32]
[33 34 35]

En espérant que je n'ai pas fait quelque chose de mal, je ne pouvais pas trouver cette limitation documenté dans l'aide de la commande FOR. Je suis sous Windows XP. Connaissez-vous une solution pour cela, en dehors de hachage large partie des données?

Merci.

Je viens de tomber sur cette limitation. Je ne faisais que for /F "tokens=32" %%a in ([big list of tokens])...., donc j'ai voulu la 32e jeton dans la variable %%a, et ne pense pas que je serais bosse dans toute limitation d'en obtenir juste un jeton à partir d'une liste. J'avais tort! Great post. 🙂

OriginalL'auteur Paul | 2009-06-11

Je suis venu avec une solution. Ce n'est pas élégant, mais il résout mon problème.
Lorsque l'interpréteur de ligne de commande ne peut pas aller plus loin avec les jetons, je passe le remaning des données à un APPEL :étiquette de commande. Voici un exemple:

@ECHO OFF

SET DATA=01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100

FOR /F "tokens=1,31* delims= " %%i IN ("%DATA%") DO (
    ECHO  1st token: %%i
    ECHO 31th token: %%j
    CALL :processdatatokens32-62 %%k
)

:processdatatokens32-62
SET DATA=%*
FOR /F "tokens=1,31* delims= " %%i IN ("%DATA%") DO (
    ECHO 32nd token: %%i
    ECHO 62th token: %%j
    CALL :processdatatokens63-83 %%k
)
GOTO :EOF

:processdatatokens63-83
SET DATA=%*
FOR /F "tokens=1,31* delims= " %%i IN ("%DATA%") DO (
    ECHO 63th token: %%i
    ECHO 93th token: %%j
)
GOTO :EOF

La sortie est:

 1st token: 01
31th token: 31
32nd token: 32
62th token: 62
63th token: 63
93th token: 93

Voir stackoverflow.com/a/8520993/1012053 pour un moyen plus efficace pour accéder à 64 jetons. La stratégie peut être étendu pour prendre en charge de plus de 64 ans, surtout si le jeu de caractères étendu est utilisé.
Merci, dbenham. L'additif dans votre réponse, il est vraiment hardcore. 🙂

OriginalL'auteur Paul

1

De for /?:

%i est déclarée explicitement dans la pour
déclaration et l' %et j %k sont
implicitement déclarée via les jetons=
option. Vous pouvez spécifier jusqu'à 26
jetons via les jetons= ligne, à condition
il ne provoque pas de tentative de
déclarer une variable plus élevée que la
lettre 'z' ou 'Z'. Rappelez-vous, POUR
les variables sont d'une seule lettre, en cas
sensible, mondiale, et vous ne pouvez pas avoir
plus de 52 total de l'actif à la
temps.

Merci pour l'extrait, Patrick, mais elle renvoie à une autre limite, plus précisément sur la façon dont de nombreuses variables liées à des jetons que l'on peut utiliser à l'intérieur de la boucle FOR. Dans mon exemple je suis juste à l'aide de 2 variables, %%i et %jj, et le problème est au sujet de leurs valeurs (les jetons dans les données traitées).
Désolé, j'ai mal compris votre question.

OriginalL'auteur Patrick Cuff
0

Un jeton est la plus petite unité de la syntaxe qui compte comme un gros morceau. Et un Lot de la ligne de commande dans Windows 95/98/ME a une limite maximale de 64 jetons. Plus, et la ligne de commande va générer un Bad command or file name erreur.

qui est pourquoi vous êtes probablement limité à 31 dans les DONNÉES.

Je pense que la limite maximale a augmenté en 2000/XP, etc.
Suvesh, je ne vois pas en quoi cela s'applique ...

OriginalL'auteur Suvesh Pratapa
0

Il n'y a plus d'une façon d'une boucle sur le tableau de DONNÉES:
```
@ECHO OFF
setlocal ENABLEDELAYEDEXPANSION
SET DATA=01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

for /l %%a in (0,3,150) do @echo %%a data: !data:~%%a,2!
```
Cela n'est possible que parce que les deux variables de caractères dans l' %DONNÉES% tableau. Comme vous le verrez, la limite est maintenant de 99 caractères, plutôt que de 31. Lorsque vous arrivez à la 100e et au-delà, le nombre est tronqué.

Rob

Rob, merci pour la réponse. Je vois ce que tu veux dire, mais cette solution est basée sur la cueillette exactement 2 caractères des positions différentes dans les DONNÉES, ce qui n'est pas ce dont j'ai besoin. Mes jetons ont différentes longueurs. Ceux que j'ai utilisé ici les DONNÉES sont juste pour les fins de l'exemple.

OriginalL'auteur RobW

J'ai créé une machine à écrire la fonction de traitement par lots (juste pour le fun) et aussi face à cette limitation. Ci-dessous un stripped-down version de vous montrer comment j'ai résolu le problème. Vous pouvez utiliser jusqu'à 8 191 caractères, y compris l'espace-séparateurs lorsqu'il est exécuté depuis la ligne de commande. Lors de l'utilisation d'une variable, la longueur maximale est de 32 767.

@echo off
::#############################################################################
 :_typeWriter <stringVariable> <skipLinefeed>
::#############################################################################
::
:: Copyleft Denny Lenselink 2018
::

%= Set local environment =%
( call ) & 2>nul setlocal EnableDelayedExpansion || exit /b 99

:: Set vars
set "_CNT=0" && set "_LEN=0" && set "_STR= %~1" && set "_TOT=0"

:_typeWriter_Loop
set /a "_CNT+=1"

:: 31 tokens limit fix. Cut the used part of the string and set counter to 1
if !_CNT! equ 32 ( set "_CNT=1" && set "_STR=!_STR:~%_TOT%!" && set "_TOT=0" )

:: Go through string (seeking words)
for /f "tokens=%_CNT% delims= " %%* in ( "%_STR%" ) do (

    :: Set word var
    set "_WRD=#%%*"

    :: Calculate word length
    for /l %%I in ( 12, -1, 0 ) do (

        set /a "_LEN|=1<<%%I"

        for %%J in ( !_LEN! ) do ( if "!_WRD:~%%J,1!"=="" set /a "_LEN&=~1<<%%I" )
    )

    :: Strip first char (used before to calculate correct word length)
    set "_WRD=!_WRD:~1!"

    :: Count chars including spaces
    set /a "_TOT=!_TOT!+!_LEN!+1"

    :: Type word or use echo
    <nul set /p "=!_WRD! "

    :: Do a loop
    goto _typeWriter_Loop
)

:: No linefeed when specified
if "%~2"=="" echo.

endlocal
exit /b

Exécuter:
C:\Temp> typewriter "this is a test that works"

Résultat:

this is a test that works

En changeant la ligne <nul set /p "=!_WRD! " à echo !_WRD!:

this
is
a
test
that
works

OriginalL'auteur FifthAxiom

Vous devez vous connecter pour publier un commentaire.