数据类型

2017-07-08 本文已影响0人 flyingtoparis

变量

声明变量

var count;
var amount,level;
var count = 0, amount = 100;

命名变量
1. 区分大小写的语言
- 第一个字符是字母或下划线_,数字不能作为第一个字符
- 字符必须是字母，数字或者下滑线
- 变量名不得为保留字
1. 需要声明并初始化变量，可以为变量分配null值
2. 声明了变量但是不为其赋值。该值为undefined。
```
var current;
consoloe.log(current)  //underfined
```

null与0的行为类似，而underfined行为与NaN类似，null与undefined值他们相等。
```
var current;  //undefined
var a = null;
console.log( current == a);  //true
console.log( current === a) //false
```
1. 可以不使用var关键字声明一个变量，为隐式声明
```
noString = 'abc';
```
1. 不能使用从未声明过的变量
```
var area = length * width;    //width is not defined
```
注：underfined 是声明未定义，is not defined 是使用了从未声明过的变量

数据类型

js中有5种基本数据类型：undefined，Null，Boolean,Number,String。还有一个复杂的数据类型 object

typeof操作符

undefined -- 这个值未定义
boolean -- 布尔值
string -- 字符串
number -- 数字
object -- 对象或者null
function -- 函数

是一个操作符而不是一个函数

var message = 'some';
console.log(typeof message);
console.log(typeof(message));
两者方式都可以

undefined 类型

使用var声明变量但是未对其加以初始化，就为underfined

var message;
console.log(message);   //undefined
console.log(typeof message);  //undefined

var message;
console.log(typeof message);  //undefined
console.log(typeof a);   //undefined
console.log(a);  // a is not defined

typeof 给未初始化的变量和未声明的变量都返回了undefined的值

null类型

var car = null;
console.log(car); // null
console.log( typeof car);   //object

undefined值是派生自null值，只要保存对象，应该明确让变量保存null值，体现null作为空指针，也有助于区分null和undefined的区别

console.log(null == undefined); true

Boolean类型

var found = true;
var lost = false;  
//区分大小写，True，False只是一个标识符

其他数据转为boolean值

数据类型	true	false
string	任何非空的字符串	""(空字符串)
number	任何非零数字值	0和NaN
object	任何对象	null
undefined	不适用	undefined

var message = 'hello world';
if (message){   //参照上表对字符串进行布尔值的转化
    alert('true')
}

Number类型

最基本的字面格式是十进制 var num = 55；
还可以通过八进制或十六进制表示,八进制必须以0为开头，数字序列（0~7）
1. var num1 = 070; 有效56
2. var num2 = 079; 无效解析为79
3. 八进制在严格模式是抛出错误
十六进制前两位必须是0X，后跟数字（0_9及AF）。A~F可以大写可以小写。
1. var num1 = 0xA; 10;

在算数计算中，所有的八进制和十六进制都最终转化成十进制。

浮点数

几种形式

var floatnum1 = 1.1;
var floatnum2 = .1; //有效，但是不推荐

浮点数值的内存空间是整数数值的两倍。js会把浮点数值不失时机的转化为整数值。
e的用法小数点后有6个零以上的浮点数值转化为e的表示法

var floatnum1 = 3.125e7; //等于31250000
var floatnum2 = 3e-7; // 等于0.0000003
var num = 3.12e7;
console.log(num);     // 3125000
var num2 = 0.000000000008;    
console.log(num2)     //8e-12

浮点数值的最高精度是17位小数。0.1加0.2结果是0.30000000000000004。

console.log(0.300000.toFixed(1))  // 0.3
var s = 0.300000.toFixed(1);
console.log( typeof s);   // string

数字的范围

由于内存的问题，js能够保存的最小数字是5e-324；最大的数字是1.7976931348623157e308；如果超出的话，则换成Infinity（-Infinity）。如果超出的话是不能参与计算。可以用isFinite()判断数字是否位于最小和最大的数值之间

var result = 900;
console.log(isFinite(result))  // true
var result2 = Number.MAX_VALUE + Number.MIN_VALUE;  //表达最大和最小值
console.log(isFinite(result2));  // true
var result3 = Number.MAX_VALUE + Number.MAX_VALUE;  //表达最大和最小值
console.log(isFinite(result3))  //false

console.log(isFinite(result2));
if ( Number.MAX_VALUE > Number.POSITIVE_INFINITY){
    console.log('大于')
}else{
    console.log('小于')   // Number.MAX_VALUE 并没有达到无穷大
}
var num = Number.MAX_VALUE + Number.MAX_VALUE;
if (  num > Number.POSITIVE_INFINITY){
    console.log('大于')
}else{
    console.log('小于')   // 无穷大与无穷大并不能做比较
}

NaN

非数值的数值。在其他的语言中任何数除以0，报错，js中返回NaN。
任何涉及到NaN的操作返回都是NaN
NaN与任何数都不相等，包括NaN本身。

alert(NaN == NaN) // false

isNaN()接收到一个值，会尝试将这个值转化成数值。任何不能被转换为数字的值会返回ture；

console.log(iaNaN(NaN));  // true
console.log(isNaN('blue'));  // true
console.log(isNaN('1.32元'))  // true 内部通过valueOf()函数转化
console.log(isNaN(10))  //false
console.log(isNaN(ture)) // false

isNaN();会首先调用valueOf()方法，确定返回值是否可以转换，如果不能，基于这个返回值调用toString(),在测试返回值。

数值的转换

有3个函数运用于数值的转换：Number(),parseInt(),parseFloat();Number()可以运用于任何数据的类型，parseInt(),parseFloat()专门运用于将字符串变为数值。

Number();

可以运用于任何的数据类型
如果是Boolean值，true转化为1，false值转为0；
数字值只是简单的传入
null值，返回的是0

var a = null;
console.log(Number(a)) // 0

undefined,返回为NaN。

var a ;
console.log(Number(a)) // NaN

字符串的话

var a = '123';
console.log(Number(a)) // 123
var a = '0123214';
console.log(Number(a))  // 123214  去掉开头的0
var a = '1.234';
console.log(Number(a))  // 1.234
var a = '0xf';
console.log(Number(a))  // 15十六进制的转化为十进制
var a = '070';
console.log(Number(a))  // 70在这里八进制不能转化为十进制
var a = '';
console.log(Number(a))  // 0
var a = '   80';
console.log(Number(a))  // 80前面的空的字符串忽略
var a = '1.23元';
console.log(Number(a))  // NaN
// 除此之外的任何形式都是NaN

如果是对象，则先调用valueOf(),然后再调用toString()。后再按照前面的方法返回字符串的值；

parseInt()

忽略字符串前面的空格，一直找到第一个非空格的字符。如果第一个字符不是数字或者负号的话则返回NaN。然后解析后面的字符，直到遇到了一个非数字的字符

var a = 'fasd12314';
console.log(parseInt(a))  //  NaN
var a = '';
console.log(parseInt(a))  // NaN
var a = '1234blue';
console.log(parseInt(a))  // 1234
var a = '123.89';
console.log(parseInt(a))  // 123  . 是一个非数字的字符
var a = '0000231';
console.log(parseInt(a))  // 231

在ES3中可以识别八进制的数值进行转换为十进制，但是在ES5中不能识别，因此可以写成parseInt('a',8)或者parseInt('a',16);

console.log(parseInt('0xaf',16))   // 175
console.log(parseInt('af',16))   // 175
console.log(parseInt('af'))      // NaN
console.log(parseInt('070',8))   // 56

parseFloat()

与parseInt()类似，但是遇见一个无效的数字字符为止。第一个小数点有效，第二个小数点无效

var a = 22.34.5
console.log(parseFloat(a))  // 22.34

十六进制的字符串始终会被转为0

var a = '0xa';
console.log(parseFloat(a)) // 0

只解析十进制的值，没有第二个参数指定参数的用法

var a = '0xa';
console.log(parseFloat(a,16));  // 0

如果字符串是一个可以解析为整数的书（没有小数，或者小数点后面都是零），parseFloat()会返回一个整数。

console.log(parseFloat('1234ble')) // 1234
console.log(parseFloat('0xa'))     // 0
console.log(parseFloat('22.5'))    // 22.5
console.log(parseFloat('22.34.5'))  // 22.5
console.log(parseFloat('009765.8'))  // 9765.8
console.log(parseFloat('3.125e7'))   // 31250000

toFixed()

var s = 123.090;
console.log(s.toFixed(1));               // 123.1  四舍五入
var s = 123.000;
console.log(s.toFixed(1));               // 123.0
console.log(typeof s.toFixed(1))     //string

String类型

字符的字面量 p33

字面量	含义
\n	换行
\t	制表
\b	空格
'	单引号'
"	双引号"

转义字符只表示一个字符

var text = "this is this letter sigma: \u03a3."
console.log(text.length);  // 29

字符串的特点
- 字符串是不可变的，要改变变量保存的字符串，首先要销毁原来的字符串，然后再用一个新值的字符串填充变量
```
var lang = 'java';
lang = lang + 'script';
```

转化为字符串

toString()方法

返回相应值的字符串表现。数值，布尔值，对象和字符串都有toString方法，但是null和undefined没有

var num = 10; 
console.log(num.toString());   // 10
var on = true;
console.log(on.toString());    // true
var boo = false;
console.log(boo.toString())    // false
var now = new Date();
console.log(now.toString());   // Tue Jul 04 2017 22:02:45 GMT+0800
var arr = [1,2,3,4];
console.log(arr.toString());   // 1,2,3,4
var a;
console.log(a.toString());    // 报错
var b = null;
console.log(b.toString())     // 报错

传递参数，输出数值的基数，可以输出以二进制，八进制，十六进制，以及其他任意的有效进制格式的字符串。

var num = 10; 
console.log(num.toString())   //'10'
console.log(num.toString(2))   //'1010'
console.log(num.toString(8))   //'12'
console.log(num.toString(10))   //'10'
console.log(num.toString(16))   //'a'

String()能将任意的类型转为字符串

如果有toString()方法，调用该方法后返回相对应的结果
如果是null，则返回null
如果是undefined，则返回undefined。

var value1 = 10;
console.log(String(value1))  // '10'
var value2 = true;
console.log(String(value2))  // 'true'
var value3 = null;
console.log(String(value3))  // 'null'
var value4;
console.log(String(value4))  // 'undefined'

Object 类型

对象是一组数据和功能的集合。对象可以通过执行new创建

var o = new Object();

在js中创建实例并没有什么用处，Object类型是所有的实例基础。Object类型所具有的任何属性和方法也同样存在于更具体的对象中。
所有的Object类型都有下面的属性和方法
- constructor : 保存着用于创建当前对象的函数
- hasOwnProperty : 用于检查给定的属性在当前的对象实例中（而不是在实例原型）是否存在，如： o.hasOwnProperty('name');
- isPrototypeOf(Object) : 用于检查传入的对象是否是传入对象的原型中
- propertyIsEnumerable(name) : 检查给定的属性是否能够使用for-in语句
- toLocalString() : 返回对象的字符串表示，该字符串与执行环境的地区对应
- toString() : 返回对象的字符串表示
- valueOf() : 返回对象的字符串，数值，布尔值表示，通常与toString()方法返回值相同

操作符

一元操作符：只能操作一个值的操作符

递增和递减操作符（++,--）
前置性和后置型
前置递增和递减，变量的值都是在语句被求值以前改变的。

var age = 27;
console.log(++age); // 28

var age2 = 27;
console.log(age++)  // 27

var num1 = 2;
var num2 = 20; 
var num3 = -- num1 + num2;  //21
var num4 = num1 + num2;     // 21

var num1 = 2;
var num2 = 20;
var num3 = num1-- + num2;   // 22
var num4 = num1 + num2;     // 21

这四个操作符对任何值都适用

var s = '2';
console.log(++s) //3
console.log(typeof s)  // number
var s2 = 'z';
console.log(++s2) // NaN 
//字符串将值转换为数字再进行操作

var boo = false;
console.log(++boo)  // 1

var f = 1.1;
console.log(--f)  // 0.1000000000000009

var o = {
    valueOf : function(){
        return -1;
    }
}
console.log(--0)   // -2

//隐式类型转换，上面的几种类型都被转换成了number类型

一元加和减操作符

“+”，“-”，该操作符像Number()对这个值进行转换，而对象则会先调用他们的valueOf(),toString(),在求值。


```js
var s1 = "01";
var s2 = "1.1";
var s3 = "z";
var b = false;
var f = 1.1
var o = {
    valueOf : function(){
        return -1;
    }
}

-s1 // -1
-s2 // -1.1
-s3 // NaN
-b // 0
-f // -1.1
-o // 1

主要运用于基本的算术运算，隐式转化数据的类型

布尔操作符

逻辑非（!）,非布尔值的类型先按照Boolean()函数转换，后再取反。

逻辑与(&&)

逻辑与操作不一定返回布尔值（同时为true时才返回true），遵循以下操作

第一个操作数是对象，则返回第二个操作数
第二个操作数是对象，则只有在第一个操作数的求值结果为true才返回该对象
两个操作数都是对象，则返回第二个操作数
如果有一个操作数是null，则返回null
如果有一个操作数是undefined，则返回undefined
如果有一个操作数是NaN，则返回NaN。

var found = 'yes';
var s = 'not';
console.log((found && s))   // not

var found = true
var s = [1,2,3];
console.log((found&&s))  // [1,2,3]

console.log('fasd'&&NaN)  //NaN

如果第一个数值是false，则只能返回false，短路操作

var found = true;
console.log(found&&someundefined)   // 报错

var found = false;
console.log((found&&someundefined)) // false

逻辑或（||）

逻辑或也不一定返回布尔值（有一个为true则为true），但是有一个不是布尔值，也不一定返回布尔值。

var s = 'jfs';
console.log((s||'abc'))  // jfs 如果第一个是对象，则返回对象

console.log((false||NaN)) // NaN 如果第一求值是false，则返回第二个

console.log('adsf'||'123') // 如果都是对象则返回第一个

console.log(null||null)  // null
console.log(NaN||NaN)    //NaN
console.log(undefined|| undefined) // undefined

短路操作符，第一个操作符为true，就不对第二个数求值,利用这种方法，避免为变量赋值null或undefined

var found = true;
var result = (found || someundefined)  // true

乘性操作符

定义了3个乘性操作符：乘法，除法，求模。在操作数为非数值的情况下后台会使用Number()转化，是隐式类型转换。

乘法

乘积超过了js数值的范围，返回Infinity或者-Infinity；
一个数为NaN，结果为NaN；
Infinity与0相乘，结果为NaN；
Infinity与非0相乘，结果为Infinity或者-Infinity；
Infinity与Infinity相乘，结果为Infinity；
如果一个数不是数值，后台调用Number(),后按照上面的方法

除法

商超过了js数值的范围，返回Infinity或者-Infinity；
一个数为NaN，结果为NaN；
Infinity除以Infinity，结果为NaN；
零被零相除，结果是NaN
Infinity与0相乘，结果为NaN；
非零的有限数被零除，结果是Infinity或者-Infinity
Infinity被任何非零的数值相除，结果是Infinity或者-Infinity，符号取决于操作数的复合
如果一个数不是数值，后台调用Number(),后按照上面的方法

加法

如果一个操作数是NaN,则结果是NaN
Infinity加Infinity，结果是Infinity；
-Infinity加-Infinity，结果是-Infinity；
Infinity加-Infinity，结果是NaN；
+0加+0，结果是+0；
-0加-0，结果是-0；
+0加-0，结果是+0；
不过一个操作数是字符串，那么就应该如下规则
两个都是字符串，则是两个字符串拼接
一个是字符串，则将另一个转换为字符串，作为字符串的拼接
一个是对象，数值，布尔值，则调用他们的toString()方法取得字符串，后拼接

var a ;
var b = null;
console.log(a+b); // NaN

var num1 = 5;
var num2 = 10;
var message = 'this sum is' + num1 + num2 // this sum is 510
var message2 = 'this sum is' + (num1+num2)//this sum is 15

减法

两个都是数值，常规数值运算
一个操作数是NaN，则结果是NaN
Infinity减Infinity，结果是NaN
-Infinity减-Infinity，结果是NaN
Infinity减-Infinity，结果是Infinity
-Infinity减Infinity，结果是-Infinity
+0减+0，结果是+0；
+0减-0，结果是-0；
-0减-0，结果是+0；
其他字符串，布尔值，null，undefined，先在后台调用Number()函数。
如果是对象的话，则先调用valueOf()，如果没有则调用toString()

关系操作符（<,>,<=,>=）

两个都是数值，直接比较
两个都是字符串，则比较编码
一个是数值，则将另一个转换成数值
操作数是对象，则调用valueOf(),如果没有valueOf(),则调用toString()

var result = '23' < '3' //true
var result = '23' < 3   //false
var result = 'a' < 3  // false ,'a'转换成NaN，任何操作数与NaN比较，结果都是false

相等操作符

相等和不相等"=="和'!=',这两个操作符都会先转换操作数（强制转换），然后再比较他们的相等性
- 布尔值false => 0,true => 1;
- 一个操作数是字符串，另一是数值，比较时先将字符串变为数值
- 一个是对象，另一个不是，则调用valueOf(),得到基本值后进行比较
- null 和undefined 相等
- 在比较相等性之前，不能将null和undefined转换成任何值
- 当一个是NaN时，相等为false，不相等为true。即便是两个都是NaN的情况下，NaN不和任何值相等，也不和自己本身相等
- 如果两个都是对象，则比较他们是不是同一个对象，如果两个操作数指向同一个对象则返回true，否则返回false

null == undefined   // true  null 和 undefined 相等
'NaN' == NaN // false  NaN 与任何值都是false
NaN == NaN  // false 
NaN != NaN // true NaN自己和本身也不相等
false == 0  // true  false转化Number()为0
true == 1  // true  true  Number()为1
undefined == 0  // false
null == 0    //  false 在比较相等性之前，不能将null和undefined 转化成任何值
'5' == 5 // true  字符串5变为数值

全等和不全等（"=="和"==="）

除了在比较之前不转换操作数之外，"=="和"==="没有什么区别 "!="和"!=="

var result1 = ( '55'==55)  // true
var result2 = ( '55'===55) //false

null == undefined // true 
null === undefined // false

条件操作符

variable = boolean_expressin ? true_value : false_value;

var max = (num1 > num2) ? mun1 : mun2;  // 三目运算取两者之间较大值

赋值操作符

var num = 10;

num = num + 10 => num += 10
// *= , /= , %= , += , -= ,

逗号操作符

使用逗号可以在一条语句中执行多个操作

var num1 = 1, num2 = 2, num3 = 3;

用于赋值，逗号操作符总返回表达式的最后一项

var num = (5,1,4,8)  // num 为8

语句

if 语句

if (i > 25){
    alert('i > 25')
}else if (i < 0){
    alert('i<0')
}else{
    alert('其他数值')
}

do-while 语句

var i = 0;
do {
    i += 2;
}while(i < 10)  
// 循环体中的代码至少被执行一次
var i = 12;
do {
    i += 2;
}while(i < 10)
console.log(i)  // 14

while 语句

在循环体的代码执行之前对条件做判断，循环体的代码可能永远不会执行

var i = 0; 
while(i < 10){
    i += 2
}
console.log(i)  // 10

for 语句

for 语句也是一种前测试循环语句，他具有执行循环之前初始化变量和定义循环后要执行的代码能力
for ( initialization ; expression ; post-loop-expression ) statement

var count = 10;
for ( var i = 0; i < count; i ++){
    console.log(i)  // 0,1,2,3,4,5,6,7,8,9
}
// 功能一致
var count = 10; 
var i = 0;
while(i<count){
    console.log(i);
    i ++ ;
}

在for循环的变量初始化表达式中，也可以不使用var关键字

var count = 10;
var i ;
for (i=0; i < count; i ++){
    console.log(i)
}

js中不存在块级作用域，因此在循环内部定义的变量可以在外部访问

for ( var i = 0; i < 10 ; i ++){
    console.log(i)   // 0,1,2,3,4,5,6,7,8,9
}
console.log(i)  // 10

for 语句中的初始化表达式，控制表达式，循环后的表达式都是可选的。将这三个表达式全部省略，则是一个无限循环

for (; ;){
    doSomething()  // 无限循环
}

给出一个控制表达式就是把for循环变成了while循环

var count = 10;
var i = 0;
for ( ; i < count;){
    console.log(i);
    i ++ ;
}

for-in 语句

用来枚举对象的属性

for (var proName in window){
    console.log(proName)  // var 操作符不是必须的，但是为了保证使用局部变量，推荐使用
}

for-in 输出的属性名顺序不可预测，返回的先后顺序可能会因为浏览器而异
如果迭代对象的变量值为null 或者 undefined for-in 语句会抛错，但是ES5不再抛出错误，只是不执行循环体

label 语句

给代码中添加一个标签

break 和 continue 语句

break 语句会立即退出当前循环，强制执行循环后面的语句，continue 也是立即退出当前循环，但是会从循环的顶部继续执行

var num = 0;
for ( var i = 1 ; i < 10 ; i ++){
    if ( i % 5 == 0){
        break
    }
    console.log(num)  // 4  直接跳出for的循环
}


var num = 0;
for ( var i = 1; i < 10 ; i ++){
    if ( i%5 == 0){
        continue
    }
    console.log(num)   // 8  跳出当前循环语句，但是继续在循环顶部执行
}



var num = 0; 
outer:
for (var i = 0; i < 10 ; i ++){
    for ( var j = 0; j < 10 ; j ++){
        if ( i == 5 && j == 5){
            break;
        }
        num ++   
    }
}

// 最终num = 95； 当i= 5，j = 5 时只是跳出了j的循环，从i= 6开始


var num = 0; 
outer:
for (var i = 0; i < 10 ; i ++){
    for ( var j = 0; j < 10 ; j ++){
        if ( i == 5 && j == 5){
            break outer;
        }
        num ++   
    }
}
// 最终num = 55； 当i= 5，j = 5 时不但退出了j的循环，也退出了i的循环



var num = 0; 
outer:
for (var i = 0; i < 10 ; i ++){
    for ( var j = 0; j < 10 ; j ++){
        if ( i == 5 && j == 5){
            continue outer;
        }
        num ++   
    }
}
// 最终num = 99； 当i= 5， j = 5 时，跳出j的循环，从j= 6开始


var num = 0; 
outer:
for (var i = 0; i < 10 ; i ++){
    for ( var j = 0; j < 10 ; j ++){
        if ( i == 5 && j == 5){
            continue outer;
        }
        num ++   
    }
}
// 最终num = 95； 当i= 5， j = 5 时，跳出j的循环，从i= 6的循环开始

with语句

主要作用就是将代码的作用域设置到一个特定的对象中

var qs = location.search.substring(1);
var hostName = location.hostName;
var url = location.href;

// 可以改写成如下

with(location){
    var qs = search.substring(1);
    var hostName = hostName;
    var url = host
}

switch 语句

switch(i){
    case 25:
        alert('25');
        break;
    case 35:
        alert('35');
        break;
    case 45:
        alert('45');
        break;
    default:
        alert('other');
}

如果省略break，就会导致执行完当前的case，继续执行下个case
需要同时执行多个case的话

switch(i){
    case 25:
        /*合并两种情况*/
    case 35:
        alert('35 or 25');
        break;
    case 45:
        alert('45');
        break;
    default:
        alert('other');
}

case的值不一定是常量，可以是变量，可以是表达式，可以是字符串

switch('hello world'){  // 字符串
    case 'hello'+'world':   // 表达式
        alert('1');
        break;
    case 'good'
        alert('2');
        break;
    default :
        alert('888')
}

var num = 25;
switch(true){   // 每个case都可以返回一个布尔值
    case num < 0:
        alert('小于0');
        break;
    case num == 0 :  // 这个地方是判断
        alert(0);
        break;
}

switch 使用的是全等操作符，所以'10'与10不相等

函数

形式

function say(name , message){
    alert(name + message);
}

函数在定义时不必指定是否返回值，任何函数在任何时候都可以通过return语句后跟着要返回的值
函数在执行return语句之后停止并立即退出
return语句也可以不带有任何返回值，这个时候返回undefined

参数

js函数内部中，参数是用一个数组来表示的，所以并不关心数组中有哪些参数
函数体内可以通过arguments对象来访问这个参数数组

function say(){
    alert(arguments[0]+ arguments[1]);
}

命名形参只是提供了便利，但是不是必需的。

function doAdd(){
    if ( arguments.length == 1){
        alert(arguments[0]= 10)
    }else if ( arguments.length == 2){
        alert(arguments[0]+ arguments[1])
    }
}

arguments对象和命名参数一起使用

function doAdd(num1,num2){
    if (arguments.length == 0){
        console.log(num1+10)
    }else if (arguments.length == 2){
        console.log(num1+num2)
    }
}

arguments的值与形参一致

    var n1 = 10;
    var n2 = 20;
    doAdd(n1,n2);
    function doAdd(num1,num2){
        arguments[1] = 10;
        console.log(num2);   //10
        console.log(n2);     //20
    }

没有传递命名参数将被自动赋予undefined值
严格模式下，如果没有传入num2,即使设置arguments[1]设为10，num2 依然是undefined，重新修改arguments的值会导致错误（代码将不会执行）

没有重载

function add(num){
    return num + 100;
}
function add(num){
    return num + 200;
}
add(100)  // 300  只有覆盖，没有重载

数据类型

变量

数据类型

js中有5种基本数据类型：undefined，Null，Boolean,Number,String。还有一个复杂的数据类型 object

typeof操作符

undefined 类型

null类型

Boolean类型

Number类型

浮点数

数字的范围

NaN

数值的转换

Number();

parseInt()

parseFloat()

toFixed()

String类型

转化为字符串

toString()方法

String()能将任意的类型转为字符串

Object 类型

操作符

一元操作符：只能操作一个值的操作符

一元加和减操作符

布尔操作符

逻辑与(&&)

逻辑或（||）

乘性操作符

除法

加法

减法

关系操作符（<,>,<=,>=）

相等操作符

全等和不全等（"=="和"==="）

条件操作符

赋值操作符

逗号操作符

语句

if 语句

do-while 语句

while 语句

for 语句

for-in 语句

label 语句

break 和 continue 语句

with语句

switch 语句

函数

猜你喜欢

热点阅读