CompareToIgnoreCase: Unterschied zwischen den Versionen

Aus JACK Wiki
Zur Navigation springen Zur Suche springen
KKeine Bearbeitungszusammenfassung
 
(10 dazwischenliegende Versionen von 4 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
===Zugehörige Evaluatoren===
*'''MathEvaluator'''
=== Beschreibung ===
=== Beschreibung ===
Die Funktion ''compareToIgnoreCase'' bestimmt wie sehr zwei Zeichenketten lexikografisch voneinander abweichen. Im Gegensatz zu [[CompareTo]] werden dabei Groß- und Kleinschreibung nicht berücksichtigt. Die Funktion erwartet zwei Strings und gibt eine Zahl zurück.
Die Funktion ''compareToIgnoreCase'' bestimmt wie sehr zwei Zeichenketten lexikografisch voneinander abweichen. Hier wird nicht zwischen Groß- und Kleinschreibung unterschieden. Die Funktion erwartet zwei Strings und gibt eine Zahl zurück.


=== Syntax ===
=== Syntax ===
  compareToIgnoreCase(String zeichenkette1, String zeichenkette2)
  compareToIgnoreCase([[Zeichenkette]] zeichenkette1, [[Zeichenkette]] zeichenkette2)


=== Parameter ===
=== Parameter ===
Zeile 15: Zeile 18:
==== Standardfälle ====
==== Standardfälle ====
  compareToIgnoreCase('hallo','hallo')  --> returns 0
  compareToIgnoreCase('hallo','hallo')  --> returns 0
  compareToIgnoreCase('hallo','JACK')  --> returns -2
  compareToIgnoreCase('hallo','JACK')  --> returns -2
  compareToIgnoreCase('JACK','jack')  --> returns 0
  compareToIgnoreCase('JACK','jack')  --> returns 0


==== Benutzung von Variablen ====
==== Benutzung mit Variablen ====
compareToIgnoreCase('[pos=1]','text')
compareToIgnoreCase('text','[var=a]')
compareToIgnoreCase('[var=a]','[pos=1]')


====JUnit Tests====
compareToIgnoreCase('text', [var=a])
<span class="mw-customtoggle-myDivision">[Anzeigen]</span>
compareToIgnoreCase([var=a], [var=b])  
<syntaxhighlight lang="java" class="mw-collapsible mw-collapsed" id="mw-customcollapsible-myDivision">
@BeforeClass
public static void beforeTest() {
compareToIgnoreCaseFillInVariableMap.put(1, OMConverter.toObject("<OMOBJ><OMSTR>hallo</OMSTR></OMOBJ>"));


compareToIgnoreCaseExerciseVariableMap.put("a",
==== Benutzung mit studentischen Eingaben ====
OMConverter.toObject("<OMOBJ><OMSTR>hallo</OMSTR></OMOBJ>"));
}


@Test
'''Jack2:'''
public void testCompareToIgnoreCase1() {
compareToIgnoreCase('[pos=1]','text')
assertEquals(0, Evaluator.getNumberResult("compareToIgnoreCase('Hallo','HAlLo')",
compareToIgnoreCase('[var=a]','[pos=1]')
compareToIgnoreCaseExerciseVariableMap, compareToIgnoreCaseFillInVariableMap), 0.0);
}
 
@Test
public void testCompareToIgnoreCase2() {
assertEquals(0, Evaluator.getNumberResult("compareToIgnoreCase('Hallo','Hallo')",
compareToIgnoreCaseExerciseVariableMap, compareToIgnoreCaseFillInVariableMap), 0.0);
}
 
@Test
public void testCompareToIgnoreCase3() {
assertEquals(0, Evaluator.getNumberResult("compareToIgnoreCase('jack','JACK')",
compareToIgnoreCaseExerciseVariableMap, compareToIgnoreCaseFillInVariableMap), 0.0);
}
 
@Test
public void testCompareToIgnoreCase4() {
assertTrue(0 < Evaluator.getNumberResult("compareToIgnoreCase('paluno','JACK')",
compareToIgnoreCaseExerciseVariableMap, compareToIgnoreCaseFillInVariableMap));
}
 
@Test
public void testCompareToIgnoreCase5() {
assertTrue(0 > Evaluator.getNumberResult("compareToIgnoreCase('JACK','paluno')",
compareToIgnoreCaseExerciseVariableMap, compareToIgnoreCaseFillInVariableMap));
}
 
@Test
public void testCompareToIgnoreCaseWithInput() {
assertTrue(0 > Evaluator.getNumberResult("compareToIgnoreCase('[pos=1]','Hello')",
compareToIgnoreCaseExerciseVariableMap, compareToIgnoreCaseFillInVariableMap));
}
 
@Test
public void testCompareToIgnoreCaseWithVariables() {
assertTrue(0 > Evaluator.getNumberResult("compareToIgnoreCase('[var=a]','Hello')",
compareToIgnoreCaseExerciseVariableMap, compareToIgnoreCaseFillInVariableMap));
}
 
@Test(expected = ParserException.class)
public void testCompareToIgnoreCaseWithWrongInputCharacter() {
Evaluator.getNumberResult("compareToIgnoreCase(ba,'hallo')", compareToIgnoreCaseExerciseVariableMap,
compareToIgnoreCaseFillInVariableMap);
}
 
@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testCompareToIgnoreCaseWithOneArgument() {
Evaluator.getNumberResult("compareToIgnoreCase('hallo')", compareToIgnoreCaseExerciseVariableMap,
compareToIgnoreCaseFillInVariableMap);
fail();
}
 
@Test
public void testCompareToIgnoreCaseWithOneRationalAndOneTextArgument()
throws EvaluatorException, OpenMathException {
assertNotEquals(0, Evaluator.getNumberResult("compareToIgnoreCase(12, 'hallo')", compareToIgnoreCaseExerciseVariableMap,
compareToIgnoreCaseFillInVariableMap),0.0);
}
 
@Test
public void testCompareToIgnoreCaseWithTwoRationalArguments() {
assertNotEquals(0, Evaluator.getNumberResult("compareToIgnoreCase(17, 8)", compareToIgnoreCaseExerciseVariableMap,
compareToIgnoreCaseFillInVariableMap),0.0);
}
 
@Test(expected = FunctionInvalidNumberOfArgumentsException.class)
public void testCompareToIgnoreCaseWithThreeArguments() {
Evaluator.getNumberResult("compareToIgnoreCase('hallo', 'hallo', 'hallo')",
compareToIgnoreCaseExerciseVariableMap, compareToIgnoreCaseFillInVariableMap);
fail();
}
 
@Test(expected = UndefinedExerciseVariableException.class)
public void testCompareToIgnoreCaseWithMissingExcerciseVariable() {
Evaluator.getNumberResult("compareToIgnoreCase('[var=j]', 'test')", compareToIgnoreCaseExerciseVariableMap,
compareToIgnoreCaseFillInVariableMap);
fail();
}


@Test(expected = UndefinedFillInVariableException.class)
'''Jack3:'''
public void testCompareToIgnoreCaseWithMissingInput() {
compareToIgnoreCase([input=field1], 'text')
Evaluator.getNumberResult("compareToIgnoreCase('[pos=42]', 'test')", compareToIgnoreCaseExerciseVariableMap,
compareToIgnoreCase([var=a], [input=field1]')
compareToIgnoreCaseFillInVariableMap);
fail();
}
</syntaxhighlight>


=== Hinweise ===
=== Hinweise ===
* Steht der erste String lexikografisch vor dem zweiten String, ist die Rückgabe negativ. Umgekehrt ist die Rückgabe entsprechend positiv.
* Steht der erste String lexikografisch vor dem zweiten String, ist die Rückgabe negativ. Umgekehrt ist die Rückgabe entsprechend positiv.
* Bei der Funktion [[compareTo]] wird zwischen Groß- und Kleinschreibung unterschieden.
* Wenn Variablen genutzt werden muss darauf geachtet werden, dass diese die Voraussetzung erfüllen.
* Wenn die Eingabe der Studierenden genutzt wird muss auch hier darauf geachtet werden, dass die Voraussetzungen erfüllt sind und ob diese an der Stelle genutzt werden können.


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

Aktuelle Version vom 15. April 2024, 12:32 Uhr

Zugehörige Evaluatoren

  • MathEvaluator

Beschreibung

Die Funktion compareToIgnoreCase bestimmt wie sehr zwei Zeichenketten lexikografisch voneinander abweichen. Hier wird nicht zwischen Groß- und Kleinschreibung unterschieden. Die Funktion erwartet zwei Strings und gibt eine Zahl zurück.

Syntax

compareToIgnoreCase(Zeichenkette zeichenkette1, Zeichenkette zeichenkette2)

Parameter

  • zeichenkette1 - erste zu vergleichende Zeichenkette
  • zeichenkette2 - zweite zu vergleichende Zeichenkette

Return Value

  • Gibt eine Ganzzahl zurück

Beispiele

Standardfälle

compareToIgnoreCase('hallo','hallo')   --> returns 0

compareToIgnoreCase('hallo','JACK')   --> returns -2

compareToIgnoreCase('JACK','jack')   --> returns 0

Benutzung mit Variablen

compareToIgnoreCase('text', [var=a])
compareToIgnoreCase([var=a], [var=b])

Benutzung mit studentischen Eingaben

Jack2:
compareToIgnoreCase('[pos=1]','text')
compareToIgnoreCase('[var=a]','[pos=1]')

Jack3:
compareToIgnoreCase([input=field1], 'text')
compareToIgnoreCase([var=a], [input=field1]')

Hinweise

  • Steht der erste String lexikografisch vor dem zweiten String, ist die Rückgabe negativ. Umgekehrt ist die Rückgabe entsprechend positiv.
  • Bei der Funktion compareTo wird zwischen Groß- und Kleinschreibung unterschieden.
  • Wenn Variablen genutzt werden muss darauf geachtet werden, dass diese die Voraussetzung erfüllen.
  • Wenn die Eingabe der Studierenden genutzt wird muss auch hier darauf geachtet werden, dass die Voraussetzungen erfüllt sind und ob diese an der Stelle genutzt werden können.
Abgerufen von „https://wiki.uni-due.de/jack/index.php?title=CompareToIgnoreCase&oldid=10508“