StartsWith: Unterschied zwischen den Versionen

Aus JACK Wiki
Zur Navigation springen Zur Suche springen
 
(8 dazwischenliegende Versionen von 4 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
=== Zugehörige Evaluatoren ===
*'''MathEvaluator'''
=== Beschreibung ===
=== Beschreibung ===
Die Funktion ''StartsWith'' prüft, ob eine Zeichenkette ab einer bestimmten Position mit einer bestimmen Zeichenkette anfängt. Die Funktion erwartet eine zu prüfende Zeichenkette, eine Zeichenkette die gesucht wird und eine Position, ab der geprüft werden soll. Fängt an der gegebenen Position die gesuchte Zeichenkette in der zu prüfenden Zeichenkette an, liefert die Funktion true zurück, ansonsten false
Die Funktion ''StartsWith'' prüft, ob eine Zeichenkette ab einer bestimmten Position mit einer bestimmen Zeichenkette anfängt. Die Funktion erwartet eine zu prüfende Zeichenkette, eine Zeichenkette die gesucht wird und eine Position, ab der geprüft werden soll. Fängt an der gegebenen Position die gesuchte Zeichenkette in der zu prüfenden Zeichenkette an, liefert die Funktion true zurück, ansonsten false


=== Syntax ===
=== Syntax ===
  startsWith(String zeichenkette, String gesuchterString, [Integer startPosition])
  startsWith([[Zeichenkette]] zeichenkette, [[Zeichenkette]] gesuchterString, [ [[Ganzzahl]] startPosition ])


===Parameter ===
===Parameter ===
Zeile 11: Zeile 14:


=== Return Value ===
=== Return Value ===
* Gibt einen Boolean-Wert zurück
* Gibt einen [[Boolean]] zurück


=== Beispiele ===
=== Beispiele ===
====Standardfälle====
====Standardfälle====
  startsWith('hello','he',0)  --> returns true
  startsWith('hello','he',0)  --> returns ''true''
  startsWith('hello','he')  --> returns true
  startsWith('hier klappt es nicht','hello',10)  --> returns false
  startsWith('hello','he')  --> returns ''true''
  startsWith('hier klappt es nicht','hello',10)  --> returns ''false''


==== Benutzung mit Variablen ====
====Benutzung mit Variablen====
startsWith('[pos=1]','test',0)
  startsWith('[var=a]','o',4)
  startsWith('[var=a]','o',4)


====JUnit Tests====
====Benutzung mit studentischen Eingaben====
<span class="mw-customtoggle-myDivision">[Anzeigen]</span>
'''JACK2:'''
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
startsWith('[pos=1]','test',0)
@BeforeClass
public static void beforeTest() {
fillInVariableMap.put(7, OMConverter.toObject("<OMOBJ><OMSTR>ll</OMSTR></OMOBJ>"));
fillInVariableMap.put(8, OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
fillInVariableMap.put(9, OMConverter.toObject("<OMOBJ><OMSTR>hello</OMSTR></OMOBJ>"));
 
exerciseVariableMap.put("g", OMConverter.toObject("<OMOBJ><OMI>0</OMI></OMOBJ>"));
exerciseVariableMap.put("ll", OMConverter.toObject("<OMOBJ><OMSTR>ll</OMSTR></OMOBJ>"));
exerciseVariableMap.put("hello", OMConverter.toObject("<OMOBJ><OMSTR>hello</OMSTR></OMOBJ>"));
}
 
@Test
public void testStartsWith1() {
assertTrue(Evaluator.getBooleanResult("startsWith('hello','he',0)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWith2() {
assertTrue(Evaluator.getBooleanResult("startsWith('hello','ll',2)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWith3() {
assertTrue(Evaluator.getBooleanResult("startsWith('hello','o',4)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWith4() {
assertTrue(!Evaluator.getBooleanResult("startsWith('hello','ll',0)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWith5() {
assertTrue(Evaluator.getBooleanResult("startsWith('','',0)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWith6() {
assertTrue(!Evaluator.getBooleanResult("startsWith('',' ',0)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWithInput1() {
assertTrue(
Evaluator.getBooleanResult("startsWith('hello','he',[pos=8])", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWithInput2() {
assertTrue(
Evaluator.getBooleanResult("startsWith('hello','[pos=7]',2)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWithInput3() {
assertTrue(Evaluator.getBooleanResult("startsWith('[pos=9]','o',4)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWithVariables1() {
assertTrue(
Evaluator.getBooleanResult("startsWith('hello','he',[var=g])", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWithVariables2() {
assertTrue(
Evaluator.getBooleanResult("startsWith('hello','[var=ll]',2)", exerciseVariableMap, fillInVariableMap));
}
 
@Test
public void testStartsWithVariables3() {
assertTrue(
Evaluator.getBooleanResult("startsWith('[var=hello]','o',4)", exerciseVariableMap, fillInVariableMap));
}
 
@Test(expected = ParserException.class)
public void testStartsWithWithWrongInputCharacter() {
Evaluator.getBooleanResult("startsWith(ab)", exerciseVariableMap, fillInVariableMap);
fail();
}
 
@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testStartsWithWithOneArgument() {
Evaluator.getBooleanResult("startsWith('hello')", exerciseVariableMap, fillInVariableMap);
fail();
}
 
@Test
public void testStartsWithWithTwoArguments() {
Evaluator.getBooleanResult("startsWith('hello', 'he')", exerciseVariableMap, fillInVariableMap);
}
 
@Test(expected = UndefinedExerciseVariableException.class)
public void testStartsWithWithMissingExerciseVariable() {
Evaluator.getBooleanResult("startsWith('[var=j]', '[var=j]', '[var=j]')", exerciseVariableMap,
fillInVariableMap);
fail();
}
 
@Test(expected = UndefinedFillInVariableException.class)
public void testStartsWithWithMissingInput() {
Evaluator.getBooleanResult("startsWith('[pos=42]', '[pos=42]', '[pos=42]')", exerciseVariableMap,
fillInVariableMap);
fail();
}
</syntaxhighlight>


=== Hinweise ===
'''JACK3:'''
startsWith([input=field1],'test',0)


[[Kategorie:Evaluatorfunktion]]
[[Kategorie:Math-Evaluatorfunktion]][[Kategorie:Testfunktionen]][[Kategorie:Zeichenkettenfunktionen]][[Kategorie:JACK2]][[Kategorie:JACK3]]

Aktuelle Version vom 18. April 2024, 10:34 Uhr

Zugehörige Evaluatoren

  • MathEvaluator

Beschreibung

Die Funktion StartsWith prüft, ob eine Zeichenkette ab einer bestimmten Position mit einer bestimmen Zeichenkette anfängt. Die Funktion erwartet eine zu prüfende Zeichenkette, eine Zeichenkette die gesucht wird und eine Position, ab der geprüft werden soll. Fängt an der gegebenen Position die gesuchte Zeichenkette in der zu prüfenden Zeichenkette an, liefert die Funktion true zurück, ansonsten false

Syntax

startsWith(Zeichenkette zeichenkette, Zeichenkette gesuchterString, [ Ganzzahl startPosition ])

Parameter

  • zeichenkette - die Zeichenkette, die geprüft werden soll,
  • gesuchterString - die Zeichenkette, auf dessen vorkommen geprüft wird,
  • startPosition - der Postion ab der überprüft wird - optional (default=0)

Return Value

Beispiele

Standardfälle

startsWith('hello','he',0)   --> returns true

startsWith('hello','he')   --> returns true

startsWith('hier klappt es nicht','hello',10)   --> returns false

Benutzung mit Variablen

startsWith('[var=a]','o',4)

Benutzung mit studentischen Eingaben

JACK2:
startsWith('[pos=1]','test',0)

JACK3:
startsWith([input=field1],'test',0)
Abgerufen von „https://wiki.uni-due.de/jack/index.php?title=StartsWith&oldid=10734“