04 data type

• Original type: Undefined, Number, String, Boolean, Null
• Reference type: Object and its subclasses

var i;
alert(typeof i); // "undefined"

var k = 10;
alert(typeof k); // "number"

var f = "abc";
alert(typeof f); // "string"

var d = null;
alert(typeof d); // "Object" Null is of Null type, but the result of typeof operator is "object"

var flag = false;
alert(typeof flag); // "boolean"

var obj = new Object();
alert(typeof obj); // "object"

// sayHello is a function
function sayHello(){

}
alert(typeof sayHello); // "function"

Pay attention to differentiation

var d = null;
alert(typeof d); // "Object" Null is of Null type, but the result of typeof operator is "object"

• typeof: this operator can dynamically obtain the data type of variables in the running phase of the program
• The operation result of typeof operator is one of the following six strings: note that all strings are lowercase. “undefined”,“number”,“string”,“boolean”,“object”,“function”

Use "= =" to compare whether the strings are equal in JS. No equals

Syntax format of typeof operator:
typeof variable name

function sum(a, b){
   if(typeof a == "number" && typeof b == "number"){
	   return a + b;
   }
   alert(a + "," + b + "All must be numbers!");
}

4.1 undefined

When a variable is not assigned manually, the system assigns an undefined value by default, or you can assign an undefined value to a variable manually

var i; // undefined
var k = undefined; // undefined

alert(i == k); // true

var y = "undefined"; // "undefined" is a string type
alert(y == k); // false

4.2 Number

Number types include integer, decimal, positive, negative, not numeric, infinite, etc
-101 22 2.3 3.14 100... NaN Infinity, etc. all belong to Number

// Infinity (when the divisor is 0, the result is infinite)
alert(10 / 0);

4.2.1 NaN

Indicates Not a Number, which is Not a Number, but is of type Number. The result of the operation should have been a Number. When it is Not a Number, the result is NaN

var a = 100;
var b = "Chinese";
alert(a / b); // Obviously, the final result of the division sign should be a number, but in the process of operation, the final result is not a number, so the final result is NaN

var e = "abc";
var f = 10;
alert(e + f); // "abc10", but the plus sign here should not be a number, but the splicing of strings

4.2.2 function of Number

isNaN() function

• is Not a Number
• IsNaN (data). If the result is true, it means it is not a number. If the result is false, it means it is a number

function sum(a, b){
   if(isNaN(a) || isNaN(b)){
	   alert("Those involved in the operation must be numbers!");
	   return;
   }
   return a + b;
}
sum(100, "abc");
alert(sum(100, 200));

parseInt() or parseFloat(),

• Can automatically convert strings to numbers
• And rounding

alert(parseInt("3.9999")); // 3
alert(parseInt(3.9999)); // 3

// parseFloat(): can automatically convert strings into numbers
alert(parseFloat("3.14") + 1); // 4.14
alert(parseFloat("3.2") + 1); // 4.2

Math.ceil()

• Round up

// Math.ceil()
alert(Math.ceil("2.1")); // 3

4.3 Boolean

Corresponding to true and false

// Rule: "if there is" it will be converted to true, "if there is no" it will be converted to false
alert(Boolean(1)); // true
alert(Boolean(0)); // false
alert(Boolean("")); // false
alert(Boolean("abc")); // true
alert(Boolean(null)); // false
alert(Boolean(NaN)); // false
alert(Boolean(undefined)); // false
alert(Boolean(Infinity)); // true

The Boolean() function is used to convert non Boolean types to Boolean types

Syntax format:
Boolean (data)

4.4 Null

null is just a value, which should be distinguished from typedf

// Null type has only one value, null
alert(typeof null); // "object"

4.5 String

String is a built-in class that can be used directly. The parent class of string is Object

In JS, single quotation marks or double quotation marks can be used for strings

//There are two ways to create objects, but the types of objects created are different
//First:
var s = "abc";
//The second type (using JS built-in support class String): 
var s2 = new String("abc");

// Small string (belonging to the original type String)
var x = "king";
alert(typeof x); // "string"

// Large string (of Object type)
var y = new String("abc");
alert(typeof y); // "object"

4.5.1 common functions

Function name	function
indexOf	Gets the index of the first occurrence of the specified string in the current string
lastIndexOf	Gets the index of the last occurrence of the specified string in the current string
replace	Replace (only the first one is replaced)
substr	Intercept substring
substring	Intercept substring
toLowerCase	Convert lowercase
toUpperCase	Convert to uppercase
split	Split string

alert("http://www.baidu.com".indexOf("http")); // 0
alert("http://www.baidu.com".indexOf("https")); // -1

// Determine whether a string contains a substring?
alert("http://www.baidu.com".indexOf("https") >= 0 ? " Include ":" but not "); / / not include

// replace (Note: only the first one is replaced)
alert("name=value%name=value%name=value".replace("%","&")); // name=value&name=value%name=value

// If you continue to call the replace method, you will replace the "second" one
// If you want to replace all of them, you need to use regular expressions
alert("name=value%name=value%name=value".replace("%","&").replace("%", "&")); // name=value&name=value&name=value

4.5.2 differences between substr and substring

The subscript of JS starts from 0

// substr(startIndex, length)
alert("abcdefxyz".substr(2,4)); //cdef, (subscript, length)
// substring(startIndex, endIndex) Note: endIndex is not included
alert("abcdefxyz".substring(2,4)); //cd, (start subscript, end subscript)

4.6 Object

Object type is a superclass of all types, and any custom type inherits object by default

JS defines the syntax of the class:

The first way:
    function Class name(Formal parameter){

    }
The second way:
    Class name = function(Formal parameter){

    }

Syntax for creating objects:

new Constructor name(Argument); // The constructor name is consistent with the class name.

Class definition and discussion of js

// Define a student class
function Student(){
   alert("Student.....");
}

// As a normal function call
Student();

// Create objects as classes
var stu = new Student();
alert(stu); // [object Object]

• The definition of a class in JS is also the definition of a constructor
• In JS, the definition of class and constructor are put together
• js function parameter calls can be executed with one or more, because they are weak types

function User(a, b, c){ // a b c is a formal parameter and belongs to a local variable
   // Declare attributes (this represents the current object)
   // There are three attributes in the User class: sno/sname/sage
   this.sno = a;
   this.sname = b;
   this.sage = c;
}

// create object
var u1 = new User(111, "zhangsan", 30);
// Accessing the properties of an object
alert(u1.sno);
alert(u1.sname);
alert(u1.sage);

var u2 = new User(222, "jackson", 55);
alert(u2.sno);
alert(u2.sname);
alert(u2.sage);

// You can also use this syntax to access the properties of an object
alert(u2["sno"]);
alert(u2["sname"]);
alert(u2["sage"]);

You can also define classes in another way

Product = function(pno,pname,price){
   // attribute
   this.pno = pno;
   this.pname = pname;
   this.price = price;
   // function
   this.getPrice = function(){
	   return this.price;
   }
}

var xigua = new Product(111, "watermelon", 4.0);
var pri = xigua.getPrice();
alert(pri); // 4.0

Attributes include: prototype attribute (commonly used, mainly this one): it is used to dynamically extend attributes and functions for classes.

// You can dynamically extend attributes and functions to classes through the attribute prototype
Product.prototype.getPname = function(){
   return this.pname;
}

// Call the late extended getPname() function
var pname = xigua.getPname();
alert(pname)

// Extend a function to String
String.prototype.suiyi = function(){
   alert("This is for String A function of type extension, called suiyi");
}

"abc".suiyi();

4.7 null, NaN and undefined

• Inconsistent data types
• ==(equivalence operator: only judge whether the values are equal)
  ===(congruence operator: judge whether the values are equal and whether the data types are equal)
• null and undefined can be equivalent

// null NaN undefined data types are inconsistent
alert(typeof null); // "object"
alert(typeof NaN); // "number"
alert(typeof undefined); // "undefined"

// null and undefined can be equivalent
alert(null == NaN); // false
alert(null == undefined); // true
alert(undefined == NaN); // false

// There are two special operators in JS
alert(null === NaN); // false
alert(null === undefined); // false
alert(undefined === NaN); // false