Hinweise [mehr]

ECMAScript (Zahlen)

Nächste Vorherige Lösung Punkte

Mit den 3 "double" - Variablen
var a = 0.1, b = 0.2, c = 0.3;
werden Vergleiche durchgeführt. Bitte richtige Aussagen ankreuzen.
alert( (a + b) + c === a + b + c ) liefert true
alert( (a + b) + c === a + (b + c) ) liefert false
alert( a + b + c === a + (b + c) ) liefert false
Der Vergleich ( (a + 1) – 1 === a ) kann false liefern
Zu dem eingebauten Math-Objekt gehören die Konstanten
Math.PI ( Kreiszahl π, etwa 3.14 )
Math.E ( Eulersche Zahl, etwa 2.718 )
Math.LN2 ( Natürlicher Logarithmus von 2, ln(2), etwa 2.302 ),
    Math.LN10 ( Natürlicher Logarithmus von 10, lg(2), etwa 0.69310 ),
    Math.LOG2E ( Natürlicher Logarithmus von Math.E zur Basis 2, ln(e) , etwa 1.442 )
Math.SQRT1_2 ( √(1/2) , etwa 0.707 ),
    Math.SQRT2 ( √(2), etwa 1.414 )
Zu dem eingebauten Math-Objekt gehören die eingebauten Funktionen
Math.max(x,y,z,...,n) ( gibt größte Zahl zurück ),
    Math.min(x,y,z,...,n) ( gibt kleinste Zahl zurück ),
    Math.random() ( gibt eine <=0 Zufallszahl < 1 zurück )
Math.cos(x) ( Cosinus von x im Bogenmaß ),
    Math.sin(x) ( Sinus von x im Bogenmaß ),
    Math.tan(x) ( Tangens von x im Bogenmaß )
Math.acos(x) ( Arcus-Cosinus von x im Bogenmaß ),
    Math.asin(x) ( Arcus-Sinus von x im Bogenmaß ),
    Math.atan(x) ( Arcus-Tangens von x im Bogenmaß, -π/2 < x < π/2 ),
    Math.atan2(y,x) ( Arcus-tan2 von Argument-Quotienten im Bogenmaß )
Math.ceil(x) ( hoch-gerundet zur nächsten ganzen Zahl ),
    Math.floor(x) ( herunter-gerundet zur nächsten ganzen Zahl ),
    Math.round(x) ( rundet hun zur nächsten ganzen Zahl ) Math.abs(x) ( Absolutwert von x )
Math.exp(x) ( gibt ex zurück ),
    Math.log(x) ( gibt ln(x) zurück ),
    Math.pow(x,y) ( gibt x(x)y zurück ),
    Math.sqrt(x) ( gibt x(x)0.5 zurück ),
Zu dem eingebauten Math-Objekt gehören die Konstanten Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.MIN_VALUE und Number.Max_VALUE. Welche Werte werden angezeigt? Richtige Aussagen bitte ankreuzen. 
<script>
var a = [ ];
a.push('Number.NEGATIVE_INFINITY    =' + Number.NEGATIVE_INFINITY);
a.push('Number.POSITIVE_INFINITY    =' + Number.POSITIVE_INFINITY);
a.push('Number.MIN_VALUE            =' + Number.MIN_VALUE);
a.push('Number.MAX_VALUE            =' + Number.MAX_VALUE);
alert(a.join('\n') );
</script>
Die alert-Box zeigt an 
    Number.NEGATIVE_INFINITY =-Infinity
    Number.POSITIVE_INFINITY = Infinity
    Number.MIN_VALUE         = 5e-324
    Number.MAX_VALUE         = 1.7976931348623157e+308
Die Umwandlung nach Basis 16 von Number.MIN_VALUE in Hex-Ziffern mit Hilfe von Number.MIN_VALUE.toString(16) ergibt 269 hex-Ziffern nach dem Dezimalpunkt ( d.h. nach 0. )
Die Umwandlung nach Basis 16 von Number.MAX_VALUE in Hex-Ziffern mit Hilfe von Number.MAX_VALUE.toString(16) ergibt 56 hex-Ziffern.
Die Umwandlung nach Basis 2 von Number.MIN_VALUE in Bin-Ziffern mit Hilfe von Number.MIN_VALUE.toString(2) ergibt 1074 Bin-Ziffern nach dem "Komma" ( d.h. nach 0. ), wobei nur die letzte Bin-Ziffer 1 ist und alle vorherigen 0
Number.MAX_VALUE kann dargestellt werden durch parseInt('fffffffffffff8',16)*Math.pow(16,242)
Number.MAX_VALUE kann dargestellt werden durch parseInt('11111111111111111111111111111111111111111111111111111',2)*Math.pow(2,971)
Zu dem eingebauten Math-Objekt gehören die Konstanten Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY, Number.MIN_VALUE und Number.Max_VALUE Welche Werte werden angezeigt? Richtige Aussagen bitte ankreuzen. 
<script>
var k, a = [ ], o = {
'Number.NEGATIVE_INFINITY': Number.NEGATIVE_INFINITY,
'Number.POSITIVE_INFINITY': Number.POSITIVE_INFINITY,
'Number.MIN_VALUE': Number.MIN_VALUE,
'Number.MAX_VALUE': Number.MAX_VALUE,
'Number.MIN_VALUE.toString(2)': Number.MIN_VALUE.toString(2),
'Number.MAX_VALUE.toString(2)': Number.MAX_VALUE.toString(2),
'Number.NEGATIVE_INFINITY': Number.NEGATIVE_INFINITY,
'Number.POSITIVE_INFINITY': Number.POSITIVE_INFINITY,
'Number.MIN_VALUE': Number.MIN_VALUE,
'Number.MAX_VALUE': Number.MAX_VALUE,
'Number.MIN_VALUE.toString(2)': Number.MIN_VALUE.toString(2),
'Number.MAX_VALUE.toString(2)': Number.MAX_VALUE.toString(2)
}
for (k in o) { if (o.hasOwnProperty(k)) { a.push(k+"="+o[k]);}
}
alert(a.join('\n'));
</script>
alert(a.join('\n')) zeigt an: 
-Infinity
Infinity
5e-324
1.7976931348623157e+308
NaN
NaN
alert(a.join('\n')) zeigt an: 
Number.NEGATIVE_INFINITY=-Infinity
Number.POSITIVE_INFINITY=Infinity
Number.MIN_VALUE=5e-324
Number.MAX_VALUE=1.7976931348623157e+308
Number.MIN_VALUE.toString(2)=
0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001
Number.MAX_VALUE.toString(2)=
0111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Die alert-box 
alert( o["NaN" ] + ' ' + 
       o["null"] + ' ' + o["undefined"] + ' '+
       o["-0"  ] + ' ' + o["+0"       ] + ' ' + 
       o["''"  ] + ' ' + o["{ }"      ] );
soll mit dem nachfolgenden Objekt o boolsche Werte anzeigen. Richtige Aussagen bitte ankreuzen. 
var o = {      "NaN": Boolean( NaN ),
              "null": Boolean( null ),
         "undefined": Boolean( undefined ),
                "-0": Boolean( -0 ),
                "+0": Boolean( +0 ),
                "''": Boolean( '' ),
               "{ }": Boolean( { } )
        };
o["NaN"] ist false
o["null"] ist false
o["undefined"] ist false
o["-0"] und o["+0"] und o["''"] und o["{ }"] haben keine güktige ECMAScript-Syntax
o["-0"] ist false
o["+0"] ist false
o["''"] ist false
o["{ }"] ist true
Es geht um Infinity-Vergleiche. Richtige Aussagen bitte ankreuzen. 
var o = 
{ 
  b0 :  Infinity === 1/0,
  b1 :  Infinity === Number.POSITIVE_INFINITY,
  b2 :  Infinity === 1.79778e+308,
  b3 :  Infinity === Number.MAX_VALUE * 2,
  b4 :  Infinity === Number.MIN_VALUE * -2
};
o.b0 ist true
o.b1 ist true
o.b2 ist true
Weil Number.MAX_VALUE = 1.7976931348623157e+308 ist, wird o.b3 true
Weil Number.MIN_VALUE = 5e-324 ist, wird o.b4 false
Eine Gleitpunktzahl belegt eine endliche Anzahl von Byte. Eine Zahl, die keine abbrechende Binärdarstellung hat, hat einen Darstellungsfehler. Sind die Zahlen x1 und x2 gleich? Richtige Aussagen bitte ankreuzen. 
<script>
var equal = (function () { 
  var EPSILON = Math.pow(2, -53);
  return function (x, y) {
    return Math.abs(x - y) < EPSILON;
  };
}());

var x1 = 0.1 + 0.2 ,
    x2 = 0.5 - 0.2 ;
</script>
(x1 == x2) liefert true
(x1 == x2) liefert false
(x1 === x2) liefert false
equal(x1, x2) liefert true
Es geht um .toPrecision und .prototype. Richtige Aussagen bitte ankreuzen. 
<script>
var formatNum = function(format){ 
   return format === 'dec2' 
           ? this.toPrecision(String(this).length+2) 
           : format === 'div10' 
           ? Number(this/10).toPrecision(2) 
           : this; 
}
Number.prototype.format = formatNum; 
var num = 22; 
</script>
num.format('dec2') liefert die Zahl 22.00
num.format('div10'); //=> 2.2
alert( num.format('dec2') ) liefert die Zahl 22.00
alert( num.format('div10') ) liefert die Zahl 2.2
alert( (num/1000000).format('div10') ) liefert die Zahl 0.0000022
alert( (num*1e-7).format('div10') ) liefert NaN
alert( (num*1e-7).format('div10') ) liefert die Zahl 2.2e-7
Es geht um die interne Speicherung von ( untypisierten) ECMAScript-Zahlen. Zu jedem Datentyp gehört eine interne Speicherart und ein Speicherumfang. Die Art und Bedeutung von Datentypen ist Programmiersprachenspezifisch. Hinter dem Datentyp verbergen sich auf Systemebene zahlreiche "Nativ-Festlegungen", wie z.B. die Art der Speicherinitialisierung (static, Speicherinitialisierung beim Programmstart, dynamisch mit new im Heap, die Art der Speicherverwaltung, der Speicherbedarf, Zugriffsregeln, das betroffene Enviroment, Kontext, usw.).
Die kleinste "subnormal positive double Zahl" ist bin 0000 0000 0000 0001, d.h.
bin 0000 0000 0000 0001 = 2⁻¹⁰²²⁻⁵² ≈ 4.9406564584124654 x 10⁻³²⁴
Die größte "subnormal positive double Zahl" ist bin 0010 0000 0000 0000, d.h.
bin 0010 0000 0000 0000 = 2⁻¹⁰²² ≈ 2.2250738585072014 x 10⁻³⁰⁸
Die größte "subnormal positive double Zahl" ist bin 0010 0000 0000 0000, d.h.
2⁻¹⁰²² ≈ 2.2250738585072014 x 10⁻³⁰⁸
Die größte "subnormal positive double Zahl" ist bin 7fef ffff ffff ffff, d.h.
(1 + (1 - 2⁻⁵²)) x 2¹⁰²³ ≈ 1.7976931348623157 x 10³⁰⁸
Es geht um das nachfolgend deklarierte Objekt-Literal obj, das fünf key-value-Paare (Properties) hat. Es gibt die key's a, 'd', add, s, x. Die zugehörigen Werte sind in der obj-Deklaration ersichtlich. Ein Zugriff auf den Wert des obj-key a erfolgt mit obj.a 
<script>
var obj = { 
  a:  'A',
 'd': '64',
 add: function(x, y) { var r = x + y; return r; },
 s:'',
 x: 12
}; 

var v1 = obj.add(4,40);
var v2 = window.parseInt(obj.d, 16);
var v3 = v1 + v2; 
var v4 = obj.add(v3/obj.x,obj.add(-2,-6));

document.write('v1='+v1+
  '<br \/>v2='+v2+
  '<br \/>v3='+v3+
  '<br \/>v4='+v4
);
</script>
var v1 = obj.add(4, 40); entspricht var v1 = 44;
var v2 = window.parseInt(obj.d, 16); entspricht var v2 = 100;
var v3 = v1 + v2; entspricht var v3 = 144;
var v4 = obj.add(v3/obj.x, obj.add(-2,-6)); entspricht var v4 = 4;
Es geht um unterschiedliche Möglichkeit, wie das nachfolgend deklarierte Objekt-Literale und Propertiy-Zugriffe geschrieben werden können. Richtige Antworten bitte ankreuzen. 
<script>
var add = function (x, y) { var r = x + y; return r; }; /*1*/ 

function mul (x, y) { var r = x * y; return r; } /*2*/ 

var myobj = { }; /*3*/ 
    myobj.add = add;
    myobj.mul = mul;

var obj = { add: function(x, y) { var r = x + y; return r; },
/*4*/       sub: function(x, y) { var r = x - y; return r; }
          };

var /*5*/
wert2 = add(1,1), 
wert6 = myobj.add(3,3), 
wert8 = obj.add(4,4);

var sum_num    =       wert2 + wert6 + wert8; /*6*/
var sum_string = " " + wert2 + wert6 + wert8;
document.write(sum_num + sum_string);
</script>
Bei /*1*/ wird der Variablen add1 eine anonyme Funktion zugewiesen.
Bei /*2*/ wird eine Funktions-Anweisung mit dem Funktionsnamen add2 verwendet. Eine Funktions-Anweisung ist die Kurzform einer Variablenzuweisung einer anonymen Funktion an die Variable.
Bei /*3*/ wird ein leeres Objekt obj = { } angelegt.
Bei /*3*/ werden mit obj.add = add; und obj.mul = mul; in obj Paare key:value eingetragen (Properties).
Bei /*4*/ wird bei der Objekt-Deklaration obj = {key1:value1, key2:value2} als key die Funktionsnamen und als value die anonyme function() {...} eingetragen.
Ein Aufruf var wert2 = add(1,1);) bei /*5*/ ruft die Funktion unter 1 auf.
Ein Aufruf var wert6 = myobj.add(3,3); bei /*5*/ wie bei /*6*/ ruft über /*3*/ den key des Objektes myobj die add-Funktion unter 1 auf.
Ein Aufruf var wert8 = obj.add(4,4); bei /*5*/ ruft über den key des Objektes obj die objektinterne Funktion sub auf.
Bei /*6*/ ergibt var sum_num = wert2 + wert6 + wert8; die Zahl 16 und typeof sum_num liefert 'number'
Bei /*6*/ ergibt var var sum_string = " "+ wert2 + wert6 + wert8; den String 268 und typeof sum_string liefert 'string'
Das folgende Objekt obj hat die Properties add1, add2, add3.
Die Funktion add1 verwendet this.x,
die Funktion add2 verwendet obj.x,
die Funktion add3 verwendet x.
Welche Aussagen sind richtig? 
<script>
var obj = {  
    add1: function(num) { 
            this.x += num; 
            this.arr.push(this.x); return this; },
    add2: function(num) { 
            obj.x += num; 
            obj.arr.push(obj.x); return obj; },

    add3: function(num) { 
            try { x += num; 
            } catch(e) { this.arr.push(e); 
            } return obj; }, 
    x: 4711, arr:[ ]
}; 

obj.add1(-4700).add2(-2).add3(-2);

document.write(  obj.arr.join('<br />') );
</script>
Im der obj-Literaldeklaration steht das arr-Property hinter den Funktionen. Deshalb liefert jede Funktionsausführung Fehler.
Eine direkte Funktionsverkettung obj.add1(-4700).add2(-2).add3(-2); ist falsch.
Bei add3 ist try { ... } catch(e) { ... } notwendig, um einen Abbruch der Auführung zu vermeiden. Die generierte Fehlermeldung schreibt das Ausführungssystem in die "Callbac-Variablen" e
Das obige Code-Fragment liefert etwa die Ausgabe: 
11
9
ReferenceError: Undefined variable: x
Die alert-box 
alert( o["NaN" ] + ' ' + 
       o["null"] + ' ' + o["undefined"] + ' '+
       o["-0"  ] + ' ' + o["+0"       ] + ' ' + 
       o["''"  ] + ' ' + o["{ }"      ] );
soll mit von 
var o = {      "NaN": Boolean( NaN ),
              "null": Boolean( null ),
         "undefined": Boolean( undefined ),
                "-0": Boolean( -0 ),
                "+0": Boolean( +0 ),
                "''": Boolean( '' ),
               "{ }": Boolean( { } )
        };
boolsche Werte anzeigen. Richtige Aussagen bitte ankreuzen.
o["NaN"] ist false
o["null"] ist false
o["undefined"] ist false
o["-0"] und o["+0"] und o["''"] und o["{ }"] haben keine güktige ECMAScript-Syntax
o["-0"] ist false
o["+0"] ist false
o["''"] ist false
o["{ }"] ist true
Es geht um Infinity-Vergleiche. Richtige Aussagen bitte ankreuzen. 
var o = 
{ 
  b0 :  Infinity === 1/0,
  b1 :  Infinity === Number.POSITIVE_INFINITY,
  b2 :  Infinity === 1.79778e+308,
  b3 :  Infinity === Number.MAX_VALUE * 2,
  b4 :  Infinity === Number.MIN_VALUE * -2
};
o.b0 ist true
o.b1 ist true
o.b2 ist true
Weil Number.MAX_VALUE = 1.7976931348623157e+308 ist, wird o.b3 true
Weil Number.MIN_VALUE = 5e-324 ist, wird o.b4 false