There are 5 simple data types in ECMAScript (also named as basic data type): Undefined, Null, Boolean, Number, String.
Because ECMAScript is interpreted and loosely typed, so we need a method that we can check the specified variable's data type, that's it, the typeof provides that functionality, we use typeof operator for checking a variable, and it may return one of the following string list.
'function': the variable is a function.
Attention please, typeof is an operator, not a function, so brackets aren't mandatory, you can use it like the following case:
var message = 'some string';
alert(typeof message);
Undefined type only has one value, it's undefined, and when we declare a variable, but don't give any value, the variable's value is undefined.
So we have no need to declare a variable and give it undefined explicitly. Its significance is used for comparing; we can distinguish null object pointer and uninitialized variables.
var message; // declare a variable, its value is undefined.
alert(message); // it'll show undefined.
Alert(age); // it'll make error.
That above code, the first warning box will display the message variable's value, it's 'undefined'. But for the second warning box, it'll make an error.
For undefined variable, we can only do an operation, that's use typeof for checking its data type.
But, misleadingly, the result for checking uninitialized variable is undefined, and the result for checking undefined variable is also undefined, that's confused! See the following sample:
var message;
alert(typeof message); // undefined
alert(typeof(age)); // undefined
In this case, if I want to judge whether a variable is uninitialized or is undefined, what should we do?
The answer is typeof can't give correct judgment, but we can solve it by convention.
Null type is the second one which only contains one value, that only value is Null. From a couple of logic perspectives, null value means null object pointer, that's why its return value of checking type is 'object' via typeof operator.
Actually, undefined value derives from null value, so ECMA-262 rules their parity testing should be true.
Though null and undefined have such a relationship, but their uses are totally different.
Boolean type is one of the commonest type in ECMAScript, it contains two values:trueandfalse. you should pay attention please: these two values are case sensitive, True and False aren't value of Boolean Type, they are Identifiers, and 1 & 0 are also equal to true & false.
Although Boolean type only has two values, but all types' values can convert to Boolean type, you can use the Boolean() function for converting, for example:
var message = 'Hello world';
var messageAsBoolean = Boolean(message);
Data Type | Value will be convert as true | Value will be convert as false |
Boolean | true | false |
String | all string are not null | '' (it means a string without any character) |
Number | all number are not equal to 0 | 0 or NaN |
Object | all object except null | null |
Undefined | n/a (it means not applicable) | undefined |
These rules help us understand some process control sentences, please see the following code:
var message = 'Hello word!';
if(message){
alert('Value is true');
}
Run the above code, it'll pop up a warning message box, that's because the message variable is changed to Boolean value before comparing.
Number type is the most concerned data type in ECMAScript, it uses IEEE754 format to describe integer & float. ECMAScript defines some different literals format.
The most basic format is decimal integer, for example:
var intNum = 98;
Except for decimal integer description, the integer also could describe by octal number & hexadecimal number.
And the octal number should be started with 0, and could only contain that number between 0 and 7, if it doesn't observe that rule, it'll be regarded as decimal integer, for example:
var octalNum1 = 070; // octal number:56
var octalNum2 = 079; // invalid octal number, it'll be regarded as 79
var octalNum3 = 08; // invalid octal number, it'll be regarded as 8
Hexadecimal number should be started with 0x, and could only contain number (0~7) and character (A~Z), never mind their case, fox example:
var hexNum1 = 0xA; // it's equal to 10 (decimal system).
var hexNum2 = 0x1f; // it's equal to 31 (decimal system).
String type is used to describe that char sequence makes up by zero or a couple of 16-bit Unicode char, it's string, it could express by ' or ", the following two style of writing are both correct:
var firstName = "Nicholas";
var lastName = 'Zakas';
String literal
String type contains some specific string literal, also named transferred meaning sequence, they are used to express non-printing characters.
Literal | Meaning |
\n | Line feed |
\t | Tabulation |
\b | Blank space |
\r | Enter |
\f | Form feed |
\\ | Slash |
\' | Single quotes |
\" | Double quotation marks |
\xnn | Express a character via hexadecimal code |
\unnnn | Express an Unicode character via hexadecimal code |
These string literals could place at random location of a string, and will regard as a character, for example:
var text = "This is the letter sigma: \u03a3.";
Characteristic of string
String is unchanged in ECMAScript, in other words, its value won't be changed after creation, if you want to change a variable's value, the js run-time environment will destroy the last value, and create a new string for filling this variable.
In ECMAScript, Object is a group of data and function's collection. Object could be created by thenew operator, for example:
var o = new Object();
var o = new Object;
Every instance of Object contains the following properties and functions:
because all objects are based on the Object in ECMAScript, so all objects have these above properties and functions.
=======================================================
ECMAScript中有五种简单数据类型(也称为基本数据类型):Undefined, Null, Boolean, Number, String.
另外一个复杂数据类型——Object,Object本质上由一系列无序键值对组成。ECMAScript不支持任何用户自定义类型,所有的值最终都是以上的六种数据类型。
因为ECMAScript是松散类型的,因此我们需要一个方法来检测变量的数据类型——typeof就是负责提供这方面信息的操作符。我们使用typeof操作符检查一个变量,它可能返回以下列表中的一项。
“undefined”: 这变量是未定义的
“boolean”:这个值是布尔值