Day 26: Understand the seven basic data types of ECMAScript

Today’s Lesson summary

A data type is defined in a data structure as a set of values and a set of operations defined on that set of values. Variables are places where values are stored. They have names and data types. The data type of a variable determines how the bits representing these values are stored in the computer’s memory. When declaring a variable, you can also specify its data type. All variables have data types to determine what kind of data can be stored.

The latest ECMAScript standard defines eight data types

• Seven basic data types:
  • Undefined, like null, is a special keyword. Undefined denotes an undefined attribute of a variable.
  • Null, a special keyword that indicates a null value. JavaScript is case sensitive, sonull 与 Null,NULLOr variants that are completely different.
  • Boolean, which has two values:true 和 false.
  • A Number, an integer or a floating point Number, such as:42or3.14159.
  • Integers of arbitrary precision (BigInt) can safely store and manipulate large integers, even exceeding the safe integer limit for numbers.
  • A String is a sequence of characters representing a text value, such as “Howdy”.
  • Represents (Symbol) (a new type added in ECMAScript 6). An instance is a unique and immutable data type.
• And objects.

Although these data types are relatively few, they allow you to develop useful functionality in your programs. Objects and functions are the other two basic elements of the language. You can think of an object as a named container for values, and then a function as a step your program can perform.

what

When a declared variable is not initialized, the default value of the variable is undefined, that is, the data type and content of the value are undefined.

function test(t) {
  if (t === undefined) {
     return 'Undefined value! ';
  }
  return t;
}

let x;

console.log(typeof x);
console.log(test(x));
Copy the code

Undefined is also an attribute of _ global object _. That is, it is a variable in the global scope. The most initial value undefined is primitive data types (undefined) (https://developer.mozilla.org/zh-CN/docs/Glossary/undefined).

example

Strictly equal and undefined

var x;
if (x === undefined) {
// Execute these statements
} else {
// These statements will not be executed
}
Copy the code

Note: we must use the strict equality operator (===) instead of the standard equality operator (==), because x == undefined checks if x is null, but strict equality does not.

Null is not the same as undefined. Move to the comparison operator to see details.

Typeof operator and undefined

Alternatively, you can use Typeof

var x;
if(typeof x === 'undefined') {
    // Execute these statements
}
Copy the code

Typeof is used because it does not throw an error if a variable is not declared.

If (typeof y === 'undefined') {// There is no error, Console. log("y is "+ typeof y) // y is undefined} if(y === undefined) {// ReferenceError: y is not defined }Copy the code

However, from a technical point of view such use should be avoided. JavaScript is a statically scoped language, so whether a variable is declared can be determined by seeing if it is declared in a closed context. The only exception is the global scope, but the global scope is bound to the global object, so checking whether a variable exists in the global context can be done by checking whether the property exists on the global object (for example, using the in operator).

if ('x' in window) {
  // only x is defined globally
}
Copy the code

The Void operator and undefined

The void operator is a third alternative.

var x;
if(x === void 0) {
    // Execute these statements
}
// do not declare y
if(y === void 0) {
    // Throws a RenferenceError (compared to 'typeof')
}
Copy the code

Null

example

You can also empty a variable by setting its value to NULL.

    var temp ="";
    console.log(typeof temp);//string
    temp=null;
    console.log(typeof temp);//object
Copy the code

Boolean

attribute

tip

Any object that is not undefined and null, including Boolean objects with a value of false, is treated as true when used directly in conditional statements.

For example, the condition in the following if statement is true:

var x = new Boolean(false);
if (x) {
  // The code here will be executed} Boolean values of primitive types are not affected by this rule. For example:ifStatement condition false:var x = false;
if (x) {
  // The code here will not execute
}
Copy the code

Instead of converting a non-boolean to a Boolean by creating a Boolean object, use Boolean as a conversion function, or use double non-(!!). Operator:

var x = Boolean(expression);     / / recommend
varx = !! (expression);/ / recommend
var x = new Boolean(expression); / / not so good
Copy the code

For any object, even a Boolean object with a value of false, when passed to a Boolean function, the generated Boolean object will have a value of true.

var myFalse = new Boolean(false);   // false
var g = new Boolean(myFalse);       // true
var myString = new String("Hello");
var s = new Boolean(myString);      // true
Copy the code

Finally, do not use Boolean objects where you should use booleans of primitive types.

what

JavaScript’s Number object is an encapsulated object that lets you manipulate numeric values. The Number object is created by the Number() constructor. JavaScript’s Number type is a double precision IEEE 754 64-bit floating-point type. But it can represent both 32-bit integers and 64-bit floating-point numbers.

Recently out stage3BigInt arbitrary precision numeric type, has entered stagE3 specification.

grammar

Numeric literal

Any Number entered directly (rather than accessed from another variable) is treated as a literal of type Number. For example, the following code declares a variable that holds integer values defined by the literal 86:

    var temp = 86;
    console.log(typeof temp);//number
    console.log(temp);/ / 86
Copy the code

Octal and hexadecimal numbers

Integers can also be represented as octal (base 8) or hexadecimal (base 16) literals. Although all integers can be expressed as octal or hexadecimal literals, all mathematical operations return decimal results. Octal literals must start with 0 and can be followed by any octal digit (0-7), as shown in the following code:

    var temp = 070;
    console.log(typeof temp);//number
    console.log(temp);// Print out 56 in decimal
Copy the code

To create A hexadecimal literal, the first digit must be 0, followed by the letter X (case insensitive), and then any hexadecimal digit (0 to 9 and A to F). These letters can be uppercase or lowercase. Such as:

    var temp = 0x1f;
    console.log(temp);// Print out 31 in decimal
    temp = 0xAB;
    console.log(temp);// Print out 171 in decimal
Copy the code

Floating point Numbers

To define a floating point value, you must include the decimal point and one digit after the decimal point (for example, use 1.0 instead of 1). This is referred to as a floating-point number dimension. Such as:

    var temp = 5.0;
    console.log(temp);// Display the integer 5
    temp = 5.5;
    console.log(temp);// Displays the floating point 5.5
    temp = 5.5+"";
    console.log(typeof temp);//string
Copy the code

The interesting thing about floating-point literals is that they are actually stored as strings before being evaluated.

Scientific enumeration

Floating-point numbers can be expressed in scientific notation for very large or very small numbers, where a number can be expressed as a number (including decimal numbers) plus e (or E), followed by a multiple of 10. For minimal-value floating points, you can either cut the specified number to the number by toFixed(number), or round a number to the nearest integer using the math.round () method, but for positive integers, Use toPrecision(Number) to truncate the entire number to the specified number length.

    var temp = 5.618 e7;
    console.log(temp);
    // Display the integer 56180000 5.618 x 10^7
    temp = 8e-17;
    console.log(temp);//8e-17

    temp = 0.000000000000000000000000000001245893576484897879;
    console.log(temp);/ / 1.2458935764848978 e-30
    // Please note that only 16 decimal places are displayed after the decimal point
    console.log(temp.toFixed(2));/ / 0.00
    console.log(temp.toPrecision(2));/ / 1.2 e-30
    console.log(Math.round(temp));/ / 0

    temp = 124589357648489787900000000000000000000000000000;
    console.log(temp);/ / 1.245893576484898 e+47
    // Please note that only 15 decimal places are displayed after the decimal point
    console.log(temp.toFixed(2));/ / 1.245893576484898 e+47
    console.log(temp.toPrecision(2));/ / 1.2 e+47
    console.log(Math.round(temp));/ / 1.245893576484898 e+47
Copy the code

ECMAScript converts floating point numbers with six or more leading zeros into scientific notation by default. Floating point values can also be stored in 64-bit form based on the IEEE 754 standard, which means that a decimal value can have up to 17 decimal bits. Values after 17 bits will be trimmed, resulting in a small mathematical error.

IEEE 754 Standard is the Standard number [1] of the IEEE Standard for Floating-point Arithmetic, which is equivalent to the international Standard ISO/IEC/IEEE 60559. The standard is issued by the Microprocessor Standards Committee (MSC) of the IEEE computer Society.
The standard defines formats for representing floating-point numbers (including negative zero-0 and denormal number), special values (Inf and NaN), and "floating-point operators" for these numbers. It also specifies four numerical modification rules and five exceptions (including when exceptions occur and how exceptions are handled). The full name of the standard is IEEE Binary Floating point Arithmetic Standard (ANSI/IEEE Std 754-1985), also known as IEC 60559:1989. Binary floating-point arithmetic for microprocessor systems (originally numbered IEC 559:1989).
Later, there was the IEEE 854-1987 standard for "floating-point numbers independent of cardinality", which specified cardinality 2 and 10. Now the latest standard is "IEEE 854-2008 standard".
Copy the code
The IEEE 754 standard specifies the exchange, arithmetic format, and methods of self-stating floating-point numbers in binary and decimal systems in computer programming environments.

The special Number value

Several special values are also defined as type Number. The first two are number. MAX_VALUE and number.min_value, which define the outer bounds of the set of Number values. All ECMAScript numbers must be between these two values. However, the resulting numerical result may not fall between these two values. When the Number generated by the calculation is greater than number.max_value, it is given the value number.positive_infinity, meaning that there are no more numeric values. Similarly, calculations that generate a value less than number.min_value will also be given the value number.negative_infinity, which means no more numeric values. If the calculation returns an infinite value, the resulting result cannot be used in other calculations. In fact, there is a special value for Infinity, which is (as you guessed) Infinity. POSITIVE_INFINITY is Infinity. The value of number. NEGATIVE_INFINITY is -infinity. Since infinitely large numbers can be positive or negative, there is one way to determine whether a number is finite (rather than testing each infinite number individually). The isFinite() method can be called on any number to ensure that it is not infinite. For numbers, you can call number.isINTEGER () to verify that the data is an integer.

var temp = Number.POSITIVE_INFINITY;
console.log(isFinite(temp));//false
var temp = 5;
console.log(isFinite(temp));//true
console.log(Number.isInteger("0.55"))//false
Copy the code

The last special value is NaN, which means Not a Number. NaN is a strange special value. In general, this happens when a conversion to a type (String, Boolean, and so on) fails. For example, converting the word blue to a numeric value will fail because there is no numeric equivalent. NaN, like infinity, cannot be used in arithmetic calculations. Another peculiar thing about NaN is that it is not equal to itself.

    var temp =  NaN;
    console.log(NaN == temp);  / / output is "false"
    // For this reason, NaN values themselves are not recommended. The isNaN() function will do fairly well
    temp =  NaN;
    console.log(isNaN(temp));  / / output "true"
    temp =  Awesome!;
    console.log(isNaN(temp));  / / output is "false"
Copy the code

Number object

new Number(value); 
var a = new Number('123'); // a === 123 is false
var b = Number('123'); // b === 123 is true
a instanceof Number; // is true
b instanceof Number; // is false
Copy the code

The Number object is a wrapper object for the original value.

• Syntax for creating a Number object:

var temp=new Number("a");
console.log(temp);
/* Number {[[PrimitiveValue]]: NaN} __proto__:Number constructor:ƒ Number() toFixed:ƒ toFixed( ƒ toLocaleString() toPrecision() toString:ƒ toString() valueOf:ƒ valueOf() __proto__:Object [[PrimitiveValue]]:0 [[PrimitiveValue]]:NaN */
var tmp=Number("b");
console.log(tmp);//NaN
tmp=Number("");
console.log(tmp);/ / 0
Copy the code

• parameter

The value argument is the value of the Number object to be created or converted to a Number.

• The return value

When Number() is used as a constructor with the operator new, it returns a newly created Number object. If you call Number() as a function without the new operator, it converts its argument to a raw value and returns that value (or NaN if the conversion fails).

• Number object properties

• Number object method