Ergebnisse scheinen(sic: „scheinen“) korrekt zu sein; Teil einer Sortierfunktion
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot"));
> // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ... Da die Länge der Strings identisch ist und die verwendeten Zeichen aus ASCII sind sollte das keine Probleme bereiten...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh"));
> // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
> Wo ist sonst der Sinn eines case-sensitive Vergleichs?
Ich vermute genau das: Der case-sensitive Vergleich ist Teil und „Abfallprodukt“ einer Sortierfunktion.
---
Hinweis zum Forum:
Bei Google findet fand ich soeben just Deinen gelöschten Beitrag...
Ergebnisse scheinen(sic: „scheinen“) korrekt zu sein; Teil einer Sortierfunktion
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot"));
> // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ... Da die Länge der Strings identisch ist und die verwendeten Zeichen aus ASCII sind sollte das keine Probleme bereiten...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh"));
> // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
> Wo ist sonst der Sinn eines case-sensitive Vergleichs?
Ich vermute genau das: Der case-sensitive Vergleich ist Teil und Abfallprodukt einer Sortierfunktion.
---
Hinweis zum Forum:
Bei Google findet fand ich soeben just Deinen gelöschten Beitrag...
Ergebnisse scheinen(sic: scheinen) korrekt zu sein.
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot"));
> // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ... Da die Länge der Strings identisch ist und die verwendeten Zeichen aus ASCII sind sollte das keine Probleme bereiten...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh"));
> // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
> Wo ist sonst der Sinn eines case-sensitive Vergleichs?
Ich vermute genau das: Der case-sensitive Vergleich ist Teil und Abfallprodukt einer Sortierfunktion.
---
Hinweis zum Forum:
Bei Google findet fand ich soeben just Deinen gelöschten Beitrag...
Ergebnisse scheinen(sic: scheinen) korrekt zu sein.
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot"));
> // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ... Da die Länge der Strings identisch ist und die verwendeten Zeichen aus ASCII sind sollte das keine Probleme bereiten...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh"));
> // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
> Wo ist sonst der Sinn eines case-sensitive Vergleichs?
Ich vermute genau das: der case-sensitive Vergleich ist Teil und Abfallprodukt einer Sortierfunktion.
---
Hinweis zum Forum:
Bei Google findet fand ich soeben just Deinen gelöschten Beitrag...
Ergebnisse scheinen(sic: scheinen) korrekt zu sein.
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot"));
> // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ... Da die Länge der Strings identisch ist und die verwendeten Zeichen aus ASCII sind sollte das keine Probleme bereiten...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh"));
> // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
---
Hinweis zum Forum:
Bei Google findet fand ich soeben just Deinen gelöschten Beitrag...
Ergebnisse scheinen(sic: scheinen) korrekt zu sein.
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot"));
> // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ... Da die Länge der Strings identisch ist und die verwendeten Zeichen aus ASCII sind sollte das keine Probleme bereiten...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh"));
> // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
---
Hinweis zum Forum:
Bei Google findet man just Deinen gelöschten Beitrag...
Ergebnisse scheinen(sic: scheinen) korrekt zu sein.
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot"));
> // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ... Da die Länge der Strings identisch ist und die verwendeten Zeichen aus ASCII sind, sollte das keine Probleme bereiten...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh"));
> // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
---
Hinweis zum Forum:
Bei Google findet man just Deinen gelöschten Beitrag...
Intl.Collator und case-sensitivity
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot"));
> // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ... Da die Länge der Strings identisch ist und die verwendeten Zeichen aus ASCII sind, sollte das keine Probleme bereiten...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh"));
> // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
---
Hinweis zum Forum:
Bei Google findet man just Deinen gelöschten Beitrag...
Intl.Collator und case-sensitivity
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot")); // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ... Da die Länge der Strings identisch ist und die verwendeten Zeichen aus ASCII sind, sollte das keine Probleme bereiten...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh")); // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
---
Hinweis zum Forum:
Bei Google findet man just Deinen gelöschten Beitrag...
Intl.Collator und case-sensitivity
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ **Umsortierung**)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot")); // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ **Keine Umsortierung**: Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh")); // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ **Umsortierung**: Hier wäre also tatsächlich 1 zu erwarten.
Hinweis zum Forum:
Bei Google findet man just Deinen gelöschten Beitrag...
Intl.Collator und case-sensitivity
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung **nach** zweitem String. (→ Umsortierung)
* -1 - Erster String steht in aufsteigender Sortierung **vor** zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot")); // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ Hier wäre also tatsächlich -1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh")); // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ Umsortierung: Hier wäre also tatsächlich 1 zu erwarten.
Hinweis zum Forum:
Bei Google findet man just den gelöschten Beitrag...
Intl.Collator und case-sensitivity
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung nach zweitem String.
* -1 - Erster String steht in aufsteigender Sortierung vor zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot")); // -1 (erwarte 1)
> ~~~
Warum? (Ich sortiere mal im Linux-Terminal ...)
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ Hier wäre also tatsächlich 1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh")); // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ Hier wäre also tatsächlich -1 zu erwarten.
Hinweis zum Forum:
Bei Google findet man just den gelöschten Beitrag...
Intl.Collator und case-sensitivity
bearbeitet von RaketenwilliHm.
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator> „sagt“:
> Beachten Sie, dass die im obigen Code angezeigten Ergebnisse je nach Browser und Browserversion variieren können. Dies liegt daran, dass die Werte implementierungsspezifisch sind. Das heißt, die Spezifikation erfordert lediglich, dass die Vorher- und Nachher-Werte negativ und positiv sind.
Ich vermute, die Regeln sind diese
* 0 - Strings sind identisch.
* 1 - Erster String steht in aufsteigender Sortierung nach zweitem String.
* -1 - Erster String steht in aufsteigender Sortierung vor zweitem String.
> ~~~js
> console.log(caseCollate.compare("roh", "Rot")); // -1 (erwarte 1)
> ~~~
Warum?
~~~BASH
echo -e "roh\nRot" | sort
roh
Rot
~~~
→ Hier wäre also tatsächlich 1 zu erwarten.
> ~~~js
> console.log(caseCollate.compare("Rot", "roh")); // 1 (erwarte -1)
> ~~~
~~~BASH
echo -e "Rot\nroh" | sort
roh
Rot
~~~~
→ Hier wäre also tatsächlich -1 zu erwarten.
Hinweis zum Forum:
Bei Google findet man just den gelöschten Beitrag...