Versions-Historie des Beitrags „Korrigiert, getestet und erläutert...“

Korrigiert, getestet und erläutert...

bearbeitet von Raketenwilli 01.08.2022 11:36

> ~~~js
> arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));
> ~~~
>
> Ich finde das erste grenzwertig und das zweite scheußlich 😉

Die dritte (von mir stehen gelassene) Variante wäre demnach „toll“? Das bedarf aber einer Korrektur (die Zahl der Klammern stimmt nicht...) und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt:

~~~JS
"use strict";

/* Nur zum Verschönern der Ausgabe: */
function humanVisible( v ) {
return JSON.stringify( v )
.replace( /,/g, ' , ')
.replace( /\[/g, '[ ' )
.replace( /\]/g, ' ]' )
.replace( /\{/g, '{ ' )
.replace( /\}/g, ' }' )
;
}

/* Naja. Die Funktion, welche die Werte verändert */
function korrekturFunktion( v ) {
return ( v * 1.1 );
}

/* Ladys & Gentlemen! Es folgen die Werte in einem Array */
var arr = [0,1,2,3,4,5];

/* use strict erfordert eine Deklaration */
var arrG = [];
var arrU = [];

/* Was das tut:
* Für jedes Element des Arrays arr als Variable item
* WENN item % 2 „truly“ (e.g. != 0 ) ist,
* DANN füge dem Array „arrU“ den korrigierten Wert hinzu,
* SONST füge „arrG“ den korrigierten Wert hinzu,
*
*/
arr.forEach(
item => ( item % 2 )
? arrU.push( korrekturFunktion( item ) )
: arrG.push( korrekturFunktion( item ) )
);
/* Hint(0):
* Man kann das also schöner als in einer Zeile notieren.
*
* Hint(1):
* Die Variable item ist danach nicht mehr definiert.
*
* Hint(2):
* Es wird ausgenutzt, dass in der Array-Methode arr.forEach
* Variablen in der „übergeordneten Umgebung“ (a.k.a. scope,
* hier „arrG“ und “arrU“) überschrieben werden können.
*
* Letzteres halte ich für einen „Hirnfurz“ der Konstrukteure von JS
*/

/* „Schöne“ Ausgaben */
console.log(
"Array korrigierter gerader Zahlen:\n\t"
+ humanVisible( arrG )
+ "\n\nArray korrigierter ungerader Zahlen:\n\t"
+ humanVisible( arrU )
);

/*
* Ausgaben:
/*
Array korrigierter gerader Zahlen:
[ 0 , 2.2 , 4.4 ]

Array korrigierter ungerader Zahlen:
[ 1.1 , 3.3000000000000003 , 5.5 ]

*
* Der von mir erwähnte „Fehler“ durch die binäre
* Speicherung ist in der zweiten Ausgabe sehr gut zu sehen
*/
~~~

Korrigiert, getestet und erläutert...

bearbeitet von Raketenwilli 01.08.2022 11:59

> ~~~js
> arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));
> ~~~
>
> Ich finde das erste grenzwertig und das zweite scheußlich 😉

Die dritte (von mir stehen gelassene) Variante wäre demnach „toll“? Das bedarf aber einer Korrektur (die Zahl der Klammern stimmt nicht...) und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt:

~~~JS
"use strict";

/* Nur zum Verschönern der Ausgabe: */
function humanVisible( v ) {
return JSON.stringify( v )
.replace( /,/g, ' , ')
.replace( /\[/g, '[ ' )
.replace( /\]/g, ' ]' )
.replace( /\{/g, '{ ' )
.replace( /\}/g, ' }' )
;
}

/* Naja. Die Funktion, welche die Werte verändert */
function korrekturFunktion( v ) {
return ( v * 1.1 );
}

/* Ladys & Gentlemen! Es folgen die Werte in einem Array */
var arr = [0,1,2,3,4,5];

/* use strict erfordert eine Deklaration */
var arrG = [];
var arrU = [];

/* Was das tut:
* Für jedes Element des Arrays arr als Variable item
* WENN item % 2 „truly“ (e.g. != 0 ) ist,
* DANN füge dem Array „arrU“ den korrigierten Wert hinzu,
* SONST füge „arrG“ den korrigierten Wert hinzu,
*
*/
arr.forEach(
item => ( item % 2 )
? arrU.push( korrekturFunktion( item ) )
: arrG.push( korrekturFunktion( item ) )
);
/* Hint(0):
* Man kann das also schöner als in einer Zeile notieren.
*
* Hint(1):
* Die Variable item ist danach nicht mehr definiert.
*
* Hint(2):
* Es wird ausgenutzt, dass in der Array-Methode arr.forEach
* Variablen in der „übergeordneten Umgebung“ (a.k.a. scope,
* hier „arrG“ und “arrU“) überschrieben werden können.
*
* Letzteres halte ich für einen „Hirnfurz“ der Konstrukteure von JS
*/

/* „Schöne“ Ausgaben */
console.log(
"Array korrigierter gerader Zahlen:\n\t"
+ humanVisible( arrG )
+ "\n\nArray korrigierter ungerader Zahlen:\n\t"
+ humanVisible( arrU )
);

/*
Array korrigierter gerader Zahlen:
[ 0 , 2.2 , 4.4 ]

Array korrigierter ungerader Zahlen:
[ 1.1 , 3.3000000000000003 , 5.5 ]

*
* Der von mir erwähnte „Fehler“ durch die binäre
* Speicherung ist in der zweiten Ausgabe sehr gut zu sehen
*/
~~~

Korrigiert, getestet und erläutert...

bearbeitet von Raketenwilli 01.08.2022 11:57

> ~~~js
> arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));
> ~~~
>
> Ich finde das erste grenzwertig und das zweite scheußlich 😉

Die dritte (von mir stehen gelassene) Variante wäre demnach „toll“? Das bedarf aber einer Korrektur (die Zahl der Klammern stimmt nicht...) und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt:

~~~JS
"use strict";

/* Nur zum Verschönern der Ausgabe: */
function humanVisible( v ) {
return JSON.stringify( v )
.replace( /,/g, ' , ')
.replace( /\[/g, '[ ' )
.replace( /\]/g, ' ]' )
.replace( /\{/g, '{ ' )
.replace( /\}/g, ' }' )
;
}

/* Naja. Die Funktion, welche die Werte verändert */
function korrekturFunktion( v ) {
return ( v * 1.1 );
}

/* Ladys & Gentlemen! Es folgen die Werte in einem Array */
var arr = [0,1,2,3,4,5];

/* use strict erfordert eine Deklaration */
var arrG = [];
var arrU = [];

/* Was das tut:
* Für jedes Element des Arrays arr als Variable item
* WENN item % 2 „truly“ (e.g. != 0 ) ist,
* DANN füge dem Array „arrU“ den korrigierten Wert hinzu,
* SONST füge „arrG“ den korrigierten Wert hinzu,
*
*/
arr.forEach(
item => ( item % 2 )
? arrU.push( korrekturFunktion( item ) )
: arrG.push( korrekturFunktion( item ) )
);
/* Hint(0):
* Man kann das also schöner als in einer Zeile notieren.
*
* Hint(1):
* Die Variable item ist danach nicht mehr definiert.
*
* Hint(2):
* Es wird ausgenutzt, dass in der Array-Methode arr.forEach
* Variablen in der „übergeordnetern Umgebung“ (a.k.a. scope,
* hier „arrG“ und “arrU“) überschrieben werden können.
*/

/* „Schöne“ Ausgaben */
console.log(
"Array korrigierter gerader Zahlen:\n\t"
+ humanVisible( arrG )
+ "\n\nArray korrigierter ungerader Zahlen:\n\t"
+ humanVisible( arrU )
);

/*
Array korrigierter gerader Zahlen:
[ 0 , 2.2 , 4.4 ]

Array korrigierter ungerader Zahlen:
[ 1.1 , 3.3000000000000003 , 5.5 ]

*
* Der von mir erwähnte „Fehler“ durch die binäre
* Speicherung ist in der zweiten Ausgabe sehr gut zu sehen
*/
~~~

Korrigiert, getestet und erläutert...

bearbeitet von Raketenwilli 01.08.2022 11:56

> ~~~js
> arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));
> ~~~
>
> Ich finde das erste grenzwertig und das zweite scheußlich 😉

Die dritte (von mir stehen gelassene) Variante wäre demnach „toll“? Das bedarf aber einer Korrektur (die Zahl der Klammern stimmt nicht...) und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt:

~~~JS
"use strict";

/* Nur zum Verschönern der Ausgabe: */
function humanVisible( v ) {
return JSON.stringify( v )
.replace( /,/g, ' , ')
.replace( /\[/g, '[ ' )
.replace( /\]/g, ' ]' )
.replace( /\{/g, '{ ' )
.replace( /\}/g, ' }' )
;
}

/* Naja. Die Funktion, welche die Werte verändert */
function korrekturFunktion( v ) {
return ( v * 1.1 );
}

/* Ladys & Gentlemen! Es folgen die Werte in einem Array */
var arr = [0,1,2,3,4,5];

/* use strict erfordert eine Deklaration */
var arrG = [];
var arrU = [];

/* Was das tut:
* Für jedes Element des Arrays arr als Variable item
* WENN item % 2 „truly“ (e.g. != 0 ) ist,
* DANN füge dem Array „arrU“ den korrigierten Wert hinzu,
* SONST füge „arrG“ den korrigierten Wert hinzu,
*
*/
arr.forEach(
item => ( item % 2 )
? arrU.push( korrekturFunktion( item ) )
: arrG.push( korrekturFunktion( item ) )
);
/* Hint(0):
* Man kann das also schöner als in einer Zeile notieren.
*
* Hint(1):
* Die Variable item ist danach nicht mehr definiert.
*
* Hint(2):
* Es wird ausgenutzt, dass in der Array-Methode arr.forEach
* Variablen in „übergeordneter Umgebung“ (a.k.a. scope,
* hier „arrG“ und “arrU“) überschrieben werden können.
*/

/* „Schöne“ Ausgaben */
console.log(
"Array korrigierter gerader Zahlen:\n\t"
+ humanVisible( arrG )
+ "\n\nArray korrigierter ungerader Zahlen:\n\t"
+ humanVisible( arrU )
);

/*
Array korrigierter gerader Zahlen:
[ 0 , 2.2 , 4.4 ]

Array korrigierter ungerader Zahlen:
[ 1.1 , 3.3000000000000003 , 5.5 ]

*
* Der von mir erwähnte „Fehler“ durch die binäre
* Speicherung ist in der zweiten Ausgabe sehr gut zu sehen
*/
~~~

Korrigiert, getestet und erläutert...

bearbeitet von Raketenwilli 01.08.2022 11:53

> ~~~js
> arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));
> ~~~
>
> Ich finde das erste grenzwertig und das zweite scheußlich 😉

Dasie dritte (von mir stehen gelassene) Variante wäre demnach „toll“? Das bedarf aber einer Korrektur (die Zahl der Klammern stimmt nicht...) und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt:

~~~JS
"use strict";

/* Nur zum Verschönern der Ausgabe: */
function humanVisible( v ) {
return JSON.stringify( v )
.replace( /,/g, ' , ')
.replace( /\[/g, '[ ' )
.replace( /\]/g, ' ]' )
.replace( /\{/g, '{ ' )
.replace( /\}/g, ' }' )
;
}

/* Naja. Die Funktion, welche die Werte verändert */
function korrekturFunktion( v ) {
return ( v * 1.1 );
}

/* Ladys & Gentlemen! Es folgen die Werte in einem Array */
var arr = [0,1,2,3,4,5];

/* use strict erfordert eine Deklaration */
var arrG = [];
var arrU = [];

/* Was das tut:
* Für jedes Element des Arrays arr als Variable item
* WENN item%2 „truly“ (e.g. != 0 ) ist,
* DANN füge dem Array „arrU“ den korrigierten Wert hinzu,
* SONST füge „arrG“ den korrigierten Wert hinzu,
*
*/
arr.forEach(
item => ( item % 2 )
? arrU.push( korrekturFunktion( item ) )
: arrG.push( korrekturFunktion( item ) )
);
/* Hint(0):
* Man kann das also schöner als in einer Zeile notieren.
*
* Hint(1):
* Die Variable item ist danach nicht mehr definiert.
*
* Hint(2):
* Es wird ausgenutzt, dass in der Array-Methode arr.forEach
* Variablen in „übergeordneter Umgebung“ (a.k.a. scope,
* hier „arrG“ und “arrU“) überschrieben werden können.
*/

/* „Schöne“ Ausgaben */
console.log(
"Array korrigierter gerader Zahlen:\n\t"
+ humanVisible( arrG )
+ "\n\nArray korrigierter ungerader Zahlen:\n\t"
+ humanVisible( arrU )
);

/*
Array korrigierter gerader Zahlen:
[ 0 , 2.2 , 4.4 ]

Array korrigierter ungerader Zahlen:
[ 1.1 , 3.3000000000000003 , 5.5 ]

*
* Der von mir erwähnte „Fehler“ durch die binäre
* Speicherung ist in der zweiten Ausgabe sehr gut zu sehen
*/
~~~

Korrigiert, getestet und erläutert...

bearbeitet von Raketenwilli 01.08.2022 11:49

> ~~~js
> arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));
> ~~~
>
> Ich finde das erste grenzwertig und das zweite scheußlich 😉

Das dritte (von mir stehen gelassene) Variante wäre demnach „toll“? Das bedarf aber einer Korrektur und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt:

~~~JS
"use strict";

/* Nur zum Verschönern der Ausgabe: */
function humanVisible( v ) {
return JSON.stringify( v )
.replace( /,/g, ' , ')
.replace( /\[/g, '[ ' )
.replace( /\]/g, ' ]' )
.replace( /\{/g, '{ ' )
.replace( /\}/g, ' }' )
;
}

/* Naja. Die Funktion, welche die Werte verändert */
function korrekturFunktion( v ) {
return ( v * 1.1 );
}

/* Ladys & Gentlemen! Es folgen die Werte in einem Array */
var arr = [0,1,2,3,4,5];

/* use strict erfordert eine Deklaration */
var arrG = [];
var arrU = [];

/* Was das tut:
* Für jedes Element des Arrays arr als Variable item
* WENN item%2 „truly“ (e.g. != 0 ) ist,
* DANN füge dem Array „arrU“ den korrigierten Wert hinzu,
* SONST füge „arrG“ den korrigierten Wert hinzu,
*
*/
arr.forEach(
item => ( item % 2 )
? arrU.push( korrekturFunktion( item ) )
: arrG.push( korrekturFunktion( item ) )
);
/* Hint(0):
* Man kann das also schöner als in einer Zeile notieren.
*
* Hint(1):
* Die Variable item ist danach nicht mehr definiert.
*
* Hint(2):
* Es wird ausgenutzt, dass in der Array-Methode arr.forEach
* Variablen in „übergeordneter Umgebung“ (a.k.a. scope)“,
* Hhier „arrG“ und “arrU“) überschrieben werden können.
*/

/* s„Schöne“ Ausgaben */
console.log(
"Array korrigierter gerader Zahlen:\n\t"
+ humanVisible( arrG )
+ "\n\nArray korrigierter ungerader Zahlen:\n\t"
+ humanVisible( arrU )
);

/*
Array korrigierter gerader Zahlen:
[ 0 , 2.2 , 4.4 ]

Array korrigierter ungerader Zahlen:
[ 1.1 , 3.3000000000000003 , 5.5 ]

*
* Der von mir erwähnte „Fehler“ durch die binäre
* Speicherung ist in der zweiten Ausgabe sehr gut zu sehen
*/
~~~

Korrigiert, getestet und erläutert...

bearbeitet von Raketenwilli 01.08.2022 11:48

> ~~~js
> arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));
> ~~~
>
> Ich finde das erste grenzwertig und das zweite scheußlich 😉

Das dritte (von mir stehen gelassene) Variante wäre demnach „toll“? Das bedarf aber einer Korrektur und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt:

~~~JS
"use strict";

/* Nur zum Verschönern der Ausgabe: */
function humanVisible( v ) {
return JSON.stringify( v )
.replace( /,/g, ' , ')
.replace( /\[/g, '[ ' )
.replace( /\]/g, ' ]' )
.replace( /\{/g, '{ ' )
.replace( /\}/g, ' }' )
;
}

/* Naja. Die Funktion, welche die Werte verändert */
function korrekturFunktion( v ) {
return ( v * 1.1 );
}

/* Ladys & Gentlemen! Es folgen die Werte in einem Array */
var arr = [0,1,2,3,4,5];

/* use strict erfordert eine Deklaration */
var arrG = [];
var arrU = [];

/* Was das tut:
* Für jedes Element des Arrays arr als Variable item
* WENN item%2 „truly“ (e.g. != 0 ) ist,
* DANN füge dem Array „garrU“ den korrigierten Wert hinzu,
* SONST füge „uarrG“ den korrigierten Wert hinzu,
*
*/
arr.forEach(
item => ( item % 2 )
? arrU.push( korrekturFunktion( item ) )
: arrG.push( korrekturFunktion( item ) )
);
/* Hint(0):
* Man kann das also schöner als in einer Zeile notieren.
*
* Hint(1):
* Die Variable item ist danach nicht mehr definiert.
*
* Hint(2):
* Es wird ausgenutzt, dass in der Array-Methode arr.forEach
* Variablen in „übergeordneter Umgebung(a.k.a. scope)“
* Hier „arrG“ und “arrU“ überschrieben werden können
*/

/* schöne Ausgaben */
console.log(
"Array korrigierter gerader Zahlen:\n\t"
+ humanVisible( arrG )
+ "\n\nArray korrigierter ungerader Zahlen:\n\t"
+ humanVisible( arrU )
);

/*
Array korrigierter gerader Zahlen:
[ 0 , 2.2 , 4.4 ]

Array korrigierter ungerader Zahlen:
[ 1.1 , 3.3000000000000003 , 5.5 ]

*
* Der von mir erwähnte „Fehler“ durch die binäre
* Speicherung ist in der zweiten Ausgabe sehr gut zu sehen
*/
~~~

Korrigiert, getestet und erläutert...

bearbeitet von Raketenwilli 01.08.2022 11:45

> ~~~js
> arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));
> ~~~
>
> Ich finde das erste grenzwertig und das zweite scheußlich 😉

Das dritte (von mir stehen gelassene) Variante wäre demnach „toll“? Das bedarf aber einer Korrektur und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt:

~~~JS
"use strict";

/* Nur zum Verschönern der Ausgabe: */
function humanVisible( v ) {
return JSON.stringify( v )
.replace( /,/g, ' , ')
.replace( /\[/g, '[ ' )
.replace( /\]/g, ' ]' )
.replace( /\{/g, '{ ' )
.replace( /\}/g, ' }' )
;
}

/* Naja. Die Funktion, welche die Werte verändert */
function korrekturFunktion( v ) {
return ( v * 1.1 );
}

/* Ladys & Gentlemen! Es folgen die Werte in einem Array */
var arr = [0,1,2,3,4,5];

/* use strict erfordert eine Deklaration */
var arrG = [];
var arrU = [];

/* Was das ~~Folgende~~ tut:
* Für jedes Element des Arrays arr als Variable item
* WENN item%2 „truly“ (e.g. != 0 ) ist,
* DANN füge dem Array „g“ den korrigierten Wert hinzu,
* SONST füge „u“ den korrigierten Wert hinzu,
*
*/
arr.forEach(
item => ( item % 2 )
? arrGU.push( korrekturFunktion( item ) )
: arrUG.push( korrekturFunktion( item ) )
);
/* Hint(0):
* Man kann das also schöner als in einer Zeile notieren.
*
* Hint(1):
* Die Variable item ist danach nicht mehr definiert.
*
* Hint(2):
* Es wird ausgenutzt, dass in der Array-Methode arr.forEach
* Variablen in „übergeordneter Umgebung(a.k.a. scope)“
* Hier „arrG“ und “arrU“ überschrieben werden können
*/

/* schöne Ausgaben */
console.log(
"Array korrigierter gerader Zahlen:\n\t"
+ humanVisible( arrG )
+ "\n\nArray korrigierter ungerader Zahlen:\n\t"
+ humanVisible( arrU )
);

/* ~~Ausgaben:~~
Array korrigierter gerader Zahlen:
[ ~~1.1~~0 , 32.~~3000000000000003~~2 , 54.54 ]

Array korrigierter ungerader Zahlen:
[ 01.1 , 23.23000000000000003 , 45.45 ]

*
* Der von mir erwähnte „Fehler“ durch die binäre
* Speicherung ist in der zwersiten Ausgabe sehr gut zu sehen:
* „3.3000000000000003“ müsste „3.3“ sein)
*/
~~~

Korrigiert, getestet und erläutert...

bearbeitet von Raketenwilli 01.08.2022 11:44

> ~~~js
> arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert));
> ~~~
>
> Ich finde das erste grenzwertig und das zweite scheußlich 😉

Das dritte (von mir stehen gelassene) Variante wäre demnach „toll“? Das bedarf aber einer Korrektur und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt:

~~~JS
"use strict";

/* Nur zum Verschönern der Ausgabe: */
function humanVisible( v ) {
return JSON.stringify( v )
.replace( /,/g, ' , ')
.replace( /\[/g, '[ ' )
.replace( /\]/g, ' ]' )
.replace( /\{/g, '{ ' )
.replace( /\}/g, ' }' )
;
}

/* Naja. Die Funktion, welche die Werte verändert */
function korrekturFunktion( v ) {
return ( v * 1.1 );
}

/* Ladys & Gentlemen! Es folgen die Werte in einem Array */
var arr = [0,1,2,3,4,5];

/* use strict erfordert eine Deklaration */
var arrG = [];
var arrU = [];

/* Was das Folgende tut:
* Für jedes Element des Arrays arr als Variable item
* WENN item%2 „truly“ (e.g. != 0 ) ist,
* DANN füge dem Array „g“ den korrigierten Wert hinzu,
* SONST füge „u“ den korrigierten Wert hinzu,
*
*/
arr.forEach(
item => ( item % 2 )
? arrG.push( korrekturFunktion( item ) )
: arrU.push( korrekturFunktion( item ) )
);
/* Hint(0):
* Man kann das also schöner als in einer Zeile notieren.
*
* Hint(1):
* Die Variable item ist danach nicht mehr definiert.
*
* Hint(2):
* Es wird ausgenutzt, dass in der Array-Methode arr.forEach
* Variablen in „übergeordneter Umgebung(a.k.a. scope)“
* Hier „arrG“ und “arrU“ überschrieben werden können
*/

/* schöne Ausgaben */
console.log(
"Array korrigierter gerader Zahlen:\n\t"
+ humanVisible( arrG )
+ "\n\nArray korrigierter ungerader Zahlen:\n\t"
+ humanVisible( arrU )
);

/* Ausgaben:
Array korrigierter gerader Zahlen:
[ 1.1 , 3.3000000000000003 , 5.5 ]

Array korrigierter ungerader Zahlen:
[ 0 , 2.2 , 4.4 ]

*
* Der von mir erwähnte „Fehler“ durch die binäre
* Speicherung ist in der ersten Ausgabe sehr gut zu sehen:
* „3.3000000000000003“ müsste „3.3“ sein)
*/
~~~

Rückspeichern in Argument

bearbeitet von Raketenwilli 01.08.2022 11:37

> ~~~js > arg1.forEach(wert => (wert % 2 ? anzUngerade : anzGerade).push(korr005(wert)); > ~~~ > > Ich finde das erste grenzwertig und das zweite scheußlich 😉 Das dritte (von mir stehen gelassene) wäre demnach „toll“? Das bedarf aber einer Korrektur und einer Kommentierung, weil nicht leicht ersichtlich ist, warum das funktioniert. Außerdem bedarf sowas eines anschaulichen Tests, der die Funktion zeigt: ~~~JS "use strict"; /* Nur zum Verschönern der Ausgabe: */ function humanVisible( v ) { return JSON.stringify( v ) .replace( /,/g, ' , ') .replace( /\[/g, '[ ' ) .replace( /\]/g, ' ]' ) .replace( /\{/g, '{ ' ) .replace( /\}/g, ' }' ) ; } /* Naja. Die Funktion, welche die Werte verändert */ function korrekturFunktion( v ) { return ( v * 1.1 ); } /* Ladys & Gentlemen! Es folgen die Werte in einem Array */ var arr = [0,1,2,3,4,5]; /* use strict erfordert eine Deklaration */ var arrG = []; var arrU = []; /* Was das Folgende tut: * Für jedes Element des Arrays arr als Variable item * WENN item%2 „truly“ (e.g. != 0 ) ist, * DANN füge dem Array „g“ den korrigierten Wert hinzu, * SONST füge „u“ den korrigierten Wert hinzu, * */ arr.forEach( item => ( item % 2 ) ? arrG.push( korrekturFunktion( item ) ) : arrU.push( korrekturFunktion( item ) ) ); /* Hint(0): * Man kann das also schöner als in einer Zeile notieren. * * Hint(1): * Die Variable item ist danach nicht mehr definiert. * * Hint(2): * Es wird ausgenutzt, dass in der Array-Methode arr.forEach * Variablen in „übergeordneter Umgebung(a.k.a. scope)“ * Hier „arrG“ und “arrU“ überschrieben werden können */ /* schöne Ausgaben */ console.log( "Array korrigierter gerader Zahlen:\n\t" + humanVisible( arrG ) + "\n\nArray korrigierter ungerader Zahlen:\n\t" + humanVisible( arrU ) ); /* Ausgaben: Array korrigierter gerader Zahlen: [ 1.1 , 3.3000000000000003 , 5.5 ] Array korrigierter ungerader Zahlen: [ 0 , 2.2 , 4.4 ] * * Der von mir erwähnte „Fehler“ durch die binäre * Speicherung ist in der ersten Ausgabe sehr gut zu sehen: * „3.3000000000000003“ müsste „3.3“ sein) */ ~~~