switch case with the user given array elements - batch - arrays

Question

I need the solution to the following problem in batch file,
The user gives the input with a space in between every next input element.
The inputs need to be stored in an array as array elements.
The input has to be taken as the case name and the particular case need to be executed.
Hence every case with the name of the array element need to be executed
The array size is not predetermined. It varies as the user may give any number of inputs
The algorithm needs to be like this,
User input numbers are 1 2 4 6 which are stored in the array a[i]
a[i] = {1,2,4,6}
for i = 1 to len(a[i])
CALL :CASE_%a[i]% # jump to :CASE_1, :CASE_2, etc.
:CASE_1
Echo “am in case1”
:: go to the for loop
:CASE_2
Echo “am in case2”
:: go to the for loop
:CASE_3
Echo “am in case3”
:: go to the for loop
:CASE_4
Echo “am in case4”
:: go to the for loop
:CASE_5
Echo “am in case5”
:: go to the for loop
:CASE_6
Echo “am in case6”
:: go to the for loop
:CASE_7
Echo “am in case7”
:: go to the for loop
:CASE_8
Echo “am in case8”
:: go to the for loop
End for
Case_1, Case_2, Case_4, Case_6 only need to be executed as the input is 1 2 4 6.
Is this possible in batch file?

Answer 1

I will split the problem in three parts. Putting the data into the array, getting the data from the array and simulating a case instruction, not present in batch.
#echo off
setlocal enableextensions enabledelayedexpansion
set /p "data=Input data:"
Let's assume the user inputs only numeric values (to avoid all the necessary check and look only to the problem) as indicated, space separated. Put them into a "array". No, arrays are not present in batch scripts, but can be simulated giving to variables the proper names.
set "arrayLength=0"
for %%e in (%data%) do (
set /a "arrayLength+=1"
set "a[!arrayLength!]=%%e"
)
This iterates over the input data, and for each element, a counter is incremented and a variable named a[+counter value+] is created. No, it is not an array, just a variable with a name to allow us simulate the array sintax. As the counter (arrayLength) is beeing changed inside the loop, delayed expansion is needed to read this changed value, and sintax for variable read changes from %var% to !var!
Now, data is in the "array". We are going to iterate over the "array", checking its contents.
for /l %%i in (1 1 %arrayLength%) do (
echo element %%i is : !a[%%i]!
)
The sintax to read the content of each of the elements requires delayed expansion too. In this case we are not changing the value inside the block, but the name of the readed variable is being generated dinamically in each iteration. Remember, no arrays, just variables with an adecuated name. And we generate the name using the for variable.
How to test for the values of the "array"?
echo Test IF
for /l %%i in (1 1 %arrayLength%) do (
if "!a[%%i]!"=="1" (
echo Case 1
) else if "!a[%%i]!"=="2" (
echo Case 2
) else if "!a[%%i]!"=="3" (
echo Case 3
) else if "!a[%%i]!"=="4" (
echo Case 4
) else if "!a[%%i]!"=="5" (
echo Case 5
) else if "!a[%%i]!"=="6" (
echo Case 6
) else (
echo NO CASE
)
)
This iterates over the "array" and uses a cascaded IF sintax to check for the allowed values. It's easy to code, fast but not the most comfortable to maintain if there are frequent changes to the cases.
An alternative to the IF cascade is the usage of subroutines. Depending on the value of the "array" element, call one label or other. Just name the labels adequately.
Then you can test if the label/subroutine exists and then call it.
Or you can call it directly without previous check and test for errors in the call that will indicate the label does not exist.
Or a table of routines can be defined.
For a sample, if the following labels are defined
:case[1]
echo Case 1
goto :eof
:case[2]
echo Case 2
goto :eof
:case[3]
echo Case 3
goto :eof
:case[4]
echo Case 4
goto :eof
:case[5]
echo Case 5
goto :eof
:case[6]
echo Case 6
goto :eof
the code to call this subroutines with a previous check of existence in batch file (%~f0 is the current batch file with full path) could be
rem Use labels in batch with previous test of existence
for /l %%i in (1 1 %arrayLength%) do (
findstr /l /c:":case[!a[%%i]!]" "%~f0" > nul 2>nul
if not errorlevel 1 (
call :case[!a[%%i]!]
) else (
echo NO CASE
)
)
This uses findstr to read the current batch file searching for the :case[n] label. On no error, the label has been found and the call is made. But having to read the batch file to test for the label existence is not the fastest operation.
To not check for label existence and directly do the call, this code can be used
rem Use labels in batch without check
for /l %%i in (1 1 %arrayLength%) do (
ver>nul
call :case[!a[%%i]!] 2>nul
if errorlevel 1 echo NO CASE
)
The 'ver>nul` line symply ensures errorlevel is cleared before calling the subroutine. The call is made and errorlevel is checked. But there is no way of knowing if the errorlevel comes from the call instruction or from the inside of the called subroutine.
Other option is to have a table of rutines to call for each of the posible values of the elements in the array. So if a table for each of the allowed elements is created, pointing the the labels of the subroutines
set "func[1]=:case[1]"
set "func[2]=:case[2]"
set "func[3]=:case[3]"
set "func[4]=:case[4]"
set "func[5]=:case[5]"
set "func[6]=:case[6]"
The following code can call the adecuated subroutine, cheching if the function for the value is defined
for /l %%i in (1 1 %arrayLength%) do (
for %%v in (!a[%%i]!) do if defined func[%%v] (
call !func[%%v]!
) else (
echo NO CASE
)
)
The inner for is needed to get a reference to the value inside the "array" to be used to access the name of the function inside the func "array".
And ..... anything better anyone could imagine.
After all this, Which code should be used? What works for you. It all depends of the real problem to solve
The IF cascade is fast and easy but for a problem with frequent changing cases, is harder to maintain.
The findstr is time consuming.
The call without check can be a real nigntmare.
The function table is in the middle. Is not as fast as having all the code in the block as in the IF solution, but is faster than the findstr while checking for subroutine definition. It is not hard to code, but for small problems is innecesary.
For simple cases, IF constructs are all you need. For complex problems, if the code is long and cases needs to be changed, added, ... the function table makes things easier.
So, it can result in
#echo off
setlocal enableextensions enabledelayedexpansion
set /p "data=Input data:"
set "arrayLength=0"
for %%e in (%data%) do (
set /a "arrayLength+=1"
set "a[!arrayLength!]=%%e"
)
rem func[ allowedValue ] = label to call
set "func[1]=:handleCase_1"
set "func[2]=:handleCase_2"
set "func[3]=:handleCase_3"
set "func[4]=:handleCase_4"
set "func[5]=:handleCase_5"
set "func[6]=:handleCase_6"
for /l %%i in (1 1 %arrayLength%) do (
for %%v in (!a[%%i]!) do if defined func[%%v] (
call !func[%%v]!
) else (
echo NO CASE
)
)
for /l %%i in (1 1 %arrayLength%) do (
if "!a[%%i]!"=="1" (
echo Case 1
rem Or, we can
rem call :handleCase_1
) else if "!a[%%i]!"=="2" (
echo Case 2
) else if "!a[%%i]!"=="3" (
echo Case 3
) else if "!a[%%i]!"=="4" (
echo Case 4
) else if "!a[%%i]!"=="5" (
echo Case 5
) else if "!a[%%i]!"=="6" (
echo Case 6
) else (
echo NO CASE
)
)
endlocal
exit /b
:handleCase_1
echo Case 1
goto :eof
:handleCase_2
echo Case 2
goto :eof
:handleCase_3
echo Case 3
goto :eof
:handleCase_4
echo Case 4
goto :eof
:handleCase_5
echo Case 5
goto :eof
:handleCase_6
echo Case 6
goto :eof

Answer 2

Windows batch does not have true support for arrays, but they can be emulated via clever use of variable names. For example, a[1] and a.len are ordinary variable names, the script does not know of any object named a. I tend to use dot notation instead: a.1, a.2, ... a.len. You are free to develop your own style.
#echo off
setlocal enableDelayedExpansion
set a[1]=1
set a[2]=2
set a[3]=4
set a[4]=6
set a.len=4
:: You can also do multiple numerical assignments on one line using SET /A
:: set /a "a[1]=1, a[2]=2, a[3]=4, a[4]=6, a.len=4"
for /l %%i in (1 1 %a.len%) do (
call :CASE_!a[%%i]!
)
:: You must exit the script so you don't fall into the subroutines after the loop finishes
exit /b
:CASE_1
Echo am in case1
exit /b
:CASE_2
Echo am in case2
exit /b
:CASE_3
Echo am in case3
exit /b
:CASE_4
Echo am in case4
exit /b
:CASE_5
Echo am in case5
exit /b
:CASE_6
Echo am in case6
exit /b
:CASE_7
Echo am in case7
exit /b
:CASE_8
Echo am in case8
exit /b

Answer 3

I reviewed your problem and, in my opinion, it does not require the use of an array. I think you are talking about a list. This way, the stated problem may be solved using a list this way:
#echo off
rem The user gives the input with a space in between every next input element.
set /P input=
rem The input has to be taken as the case name and the particular case need to be executed.
rem Hence every case with the name of the array element need to be executed.
for %%i in (%input%) do call :CASE_%%i
goto :EOF
:CASE_1
Echo am in case1
exit /B
:CASE_2
Echo am in case2
exit /B
:CASE_3
Echo am in case3
exit /B
:CASE_4
Echo am in case4
exit /B
:CASE_5
Echo am in case5
exit /B
:CASE_6
Echo am in case6
exit /B
For example:
C:\> test
1 2 4 6
am in case1
am in case2
am in case4
am in case6
Any solution that is forced to use an unnecessary array would be more complicated...