标签(空格分隔): JavaScript
- - 第一个字符必须是字母、下划线或美元
- - 驼峰大小写格式
ECMAScript5 引入,定义了一种解析和执行模型。此时,ECMAScript3 中的一些不确定行为将得到处理,对某些不安全的操作也会抛出错误。
- "use strict";
关键字 | 关键字 | 关键字 | 关键字 |
---|---|---|---|
break | do | instanceof | typeof |
case | else | new | var |
catch | finally | return | void |
continue | for | switch | while |
debugger[^newAdd] | function | this | with |
default | if | throw | |
delete | in | try |
保留字 | 保留字 | 保留字 | 保留字 |
---|---|---|---|
abstract | enum | int | short |
boolean | export | interface | static |
byte | extends | long | super |
char | final | native | synchronized |
class | float | package | throws |
const | goto | private | transient |
debugger | implements | protected | volatile |
double | import | public |
用 var 定义的变量将成为定义该变量的作用域中的局部变量。
- function test() {
- var message = "hi"; //局部变量,函数退出后就会被销毁
- }
- test();
- alert(message); //Uncaught ReferenceError: message is not defined
省略 var 可以创建全局变量
5 种简单的数据类型(基本数据类型)
- 注意大小写
1 种复杂数据类型
- 注意大小写
- typeof message;
- typeof (message);
- typeof 9;
,上面第二行代码中的括号可以加上,但不是必需的。
- typeof是操作符,不是函数
这是因为 null 被认为是空的对象引用。
- typeof null; //object
实际上,undefined 值派生自 null 值,因此规范规定两者的相等性测试返回 true
- typeof null; //返回object
- undefined == null; //true(转换了操作数)
- undefined === null: //false
即
- 数据类型 | 什么值能转换成true | 什么值能转换成false
- Boolean|true|false
- String|非空字符串|""
- Number|非零数字,包括无穷大|0和NaN
- Object|任何对象|null
- Undefined|N/A(不适用)|undefined
流控制语句如 if 语句能自动执行 Boolean 转换。如
- Boolean(false); //false
- Boolean(""); //false
- Boolean(0); //false
- Boolean(Nan); //false
- Boolean(null); //false
- Boolean(undefined); //false
- var message="hi";
- if(message){
- //这里会被执行
- }
- var num = 079; //无效的八进制,会被解析成79
isNaN() 确实也适用于对象。在基于对象调用 isNaN() 函数时,会首先调用对象的 valueOf() 方法,然后确定该方法返回的值是否可以转换为数值。如果不能,则基于这个返回值再调用 toString() 方法,再测试返回值。
- isNaN(NaN); //true
- isNaN(10); //false
- isNaN("10"); //转换成数字10,false
- isNaN("abc"); //不能被转换成数值,true
- isNaN(true); //可以被转成数值1,false
将非数值转换为数值的三个函数:
例子:
- Number('Hello World'); //NaN
- Number(''); //0
- Number('000011'); //11
- Number(true); //1
它会忽略字符串前面的空格,直至找到第一个非空格字符。如果第一个字符不是数字字符或者负号,parseInt() 就会返回 NaN;也就是说,用 parseInt() 转换空字符串会返回 NaN(Number() 对空字符返回 0)。如果第一个字符是数字字符,parseInt() 会继续解析第二个字符,直到解析完所有后续字符或者遇到了一个非数字字符。 例子:
- parseInt("123blue') //123
- parseInt('')//NaN
- parseInt("0xA")//10
- parseInt("22.5")//22
- parseInt('070')//70
- parseInt('070',8)//56
- parseInt('70')//70
- parseInt('0xf')//15
- parseInt("AF", 16); //175
- parseInt("AF"); //NaN
也是从第一个字符(位置 0)开始解析每个字符。而且也是一直解析到字符串末尾,或者解析到遇见一个无效的浮点数字字符为止。也就是说,字符串中的第一个小数点是有效的,而第二个小数点就是无效的了,因此它后面的字符串将被忽略。它始终都会忽略前导的零。parseFloat() 可以识别前面讨论过的所有浮点数值格式,也包括十进制整数格式。但十六进制格式的字符串则始终会被转换成 0。由于 parseFloat() 只解析十进制值,因此它没有用第二个参数指定基数的用法。最后还要注意一点:如果字符串包含的是一个可解析为整数的数(没有小数点,或者小数点后都是零),parseFloat() 会返回整数。 例子:
- parseFloat('1234blue')//1234
- parseFloat('0xA')//0
- parseFloat('22.5')//22.5
- parseFloat('22.34.5')//22.34
- parseFloat('0908.5')//908.5parseFloat('3.125e7) //31250000
实际操作过程如下:首先创建一个能容纳 10 个字符的新字符串,然后在这个字符串中填充 "Java" 和 "Script",最后一步是销毁原来的字符串 "Java" 和字符串 "Script",因为这两个字符串已经没用了。
- varlang='Java';lang+='Script';
例子:
- var age = 11;
- var ageAsString = age.toString(); // 字符串"11"
- var found = true;
- var foundAsString = found.toString(); //字符串"true"
null 和 undefined 值没有 toString() 方法 toString() 可以接受参数:输入数值的基数
- var num = 10;
- alert(num.toString()); // "10"
- alert(num.toString(2)); // "1010"
- alert(num.toString(8)); // "12"
- alert(num.toString(10)); // "10"
- alert(num.toString(16)); // "a"
- var value1 = 10;
- var value2 = true;
- var value3 = null;
- var value4;
- alert(String(value1)); // "10"
- alert(String(value2)); // "true"
- alert(String(value3)); // "null"
- alert(String(value4)); // "undefined"
- var o = new Object();
- var o = new Object; //不传递参数的情况下,可以省去括号。不推荐
即 ++ 和 --
- 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 s1 = "2";
- var s2 = "z";
- var b = false;
- var f = 1.1;
- var o = {
- valueOf: function() {
- return - 1;
- }
- };
- s1++; // 值变成数值3(字符串包含有效数字字符,则先将其转为数字值,再加减1)
- s2++; // 值变成NaN(字符串中没有有效字符,将变量值设置为NaN,对NaN加减1还是NaN)
- b++; // 值变成数值1(先将false转为0,再加减1。同理,true会转成1)
- f--; // 值变成0.10000000000000009(由于浮点舍入错误所致)
- o--; // 值变成数值-2(先调用对象的valueOf方法以取得可操作的值,再加减1。)
即 + 和 - 对非数值应用一元加 (减) 操作符时,该操作符会像 Number()转型函数一样对这个值执行转换。 换句话说,布尔值 false 和 true 将被转换为 0 和 1,字符串值会被按照一组特殊的规则进行解析,而 对象是先调用它们的 valueOf()和(或)toString()方法,再转换得到的值。
- var s1 = "01";
- var s2 = "1.1";
- var s3 = "z";
- var b = false;
- var f = 1.1;
- var o = {
- valueOf: function() {
- return - 1;
- }
- };
- s1 = +s1; // 值变成数值1
- s2 = +s2; // 值变成数值1.1
- s3 = +s3; // 值变成NaN
- b = +b; // 值变成数值0
- f = +f; // 值未变,仍然是1.1
- o = +o; // 值变成数值-1
- var s1 = "01";
- var s2 = "1.1";
- var s3 = "z";
- var b = false;
- var f = 1.1;
- var o = {
- valueOf: function() {
- return - 1;
- }
- };
- s1 = -s1; // 值变成了数值-1
- s2 = -s2; // 值变成了数值-1.1
- s3 = -s3; // 值变成了NaN
- b = -b; // 值变成了数值0
- f = -f; // 变成了-1.1
- o = -o; // 值变成了数值1
- var num1 = 25; // 二进制00000000000000000000000000011001
- var num2 = ~num1; // 二进制11111111111111111111111111100110
- alert(num2); // -26
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 AND = 0000 0000 0000 0000 0000 0000 0000 0001
- var result = 25 & 3;
- alert(result); //1
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 OR = 0000 0000 0000 0000 0000 0000 0001 1011
- var result = 25 | 3;
- alert(result); //27
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 XOR = 0000 0000 0000 0000 0000 0000 0001 1010
- var result = 25 ^ 3;
- alert(result); //26
- var oldValue = 2; // 等于二进制的10
- var newValue = oldValue << 5; // 等于二进制的1000000,十进制的64
- var oldValue = 64; // 等于二进制的1000000
- var newValue = oldValue >> 5; // 等于二进制的10 ,即十进制的2
- var oldValue = 64; // 等于二进制的1000000
- var newValue = oldValue >>> 5; // 等于二进制的10 ,即十进制的2
- //负数以其绝对值的二进制补码形式表示
- var oldValue = -64; // 等于二进制的11111111111111111111111111000000
- var newValue = oldValue >>> 5; // 等于二进制的00000111111111111111111111111110,十进制的134217726
- alert(!false); // true
- alert(!"blue"); // false
- alert(!0); // true
- alert(!NaN); // true
- alert(!""); // true
- alert(!12345); // false
- alert( !! "blue"); //true
- alert( !! 0); //false
- alert( !! NaN); //false
- alert( !! ""); //false
- alert( !! 12345); //true
如果第一个操作数是对象,则返回第二个操作数; 如果第二个操作数是对象,则只有在第一个操作数的求值结果为 true 的情况下才会返回该 对象; 如果两个操作数都是对象,则返回第二个操作数; 如果有一个操作数是 null,则返回 null; 如果有一个操作数是 NaN,则返回 NaN; 如果有一个操作数是 undefined,则返回 undefined。
- Infinity * 0 //NaN
- Infinity * NaN //NaN
- Infinity * 3 //Infinity
- Infinity * -3 //-Infinity
- Infinity * Infinity //Inifinity
先转换类型再比较 == != 规则:
- null == undefined //true
- true == 1 //true
- "NaN" == NaN //false
- true == 2 //false
- 5 == NaN //false
- undefined == 0 //false
- NaN == NaN //false
- null == 0 //false
- NaN != NaN //true
- "5" == 5 //true
- false == 0 //true
=== !== 只在两个操作数未经转换就相等的情况下返回 true
- var result1 = ("55" == 55); //true,因为转换后相等
- var result2 = ("55" === 55); //false,因为不同的数据类型不相等
- null === undefiened; //false,因为它们是不同类型的值
语法: with(expression) statement; 目的主要是为了简化多次编写同一个对象的工作。例如:
- varqs= location.search.substring(1);
- varhostName= location.hostname;
- varurl= location.href;
上面几行代码都包含 location 对象。如果使用 with 语句,可以把上面的代码改写成如下所示:
- with(location){
- varqs=search.substring(1);
- varhostName=hostname;
- varurl=href;
- }
使用 with 语句关联了 location 对象。这意味着在 with 语句的代码块内部,每个变量首先被认为是一个局部变量,而如果在局部环境中找不到该变量的定义,就会查询 location 对象中是否有同名的属性。如果发现了同名属性,则以 location 对象属性的值作为变量的值。
ECMAScript 函数不介意传递进来多少个参数,也不在乎传进来参数是什么数据类型。也就是说,即便你定义的函数只接收两个参数,在调用这个函数时也未必一定要传递两个参数。可以传递一个、三个甚至不传递参数,而解析器永远不会有什么怨言。之所以会这样,原因是 ECMAScript 中的参数在内部是用一个数组来表示的。函数接收到的始终都是这个数组,而不关心数组中包含哪些参数(如果有参数的话)。如果这个数组中不包含任何元素,无所谓;如果包含多个元素,也没有问题。实际上,在函数体内可以通过 arguments 对象来访问这个参数数组,从而获取传递给函数的每一个参数。 ECMAScript 中的所有参数传递的都是值,不可能通过引用传递参数。 未指定返回值的函数返回的是一个特殊的 undefined 值。
- function add(){
- }
- vara=add(); //undefined
ECMAScript 函数不能像传统意义上那样实现重载。而在其他语言(如 Java)中,可以为一个函数编写两个定义,只要这两个定义的签名(接受的参数的类型和数量)不同即可。如前所述,ECMAScirpt 函数没有签名,因为其参数是由包含零或多个值的数组来表示的。而没有函数签名,真正的重载是不可能做到的。 如果在 ECMAScript 中定义了两个名字相同的函数,则该名字只属于后定义的函数:
- function addSomeNumber(num) {
- return num + 100;
- }
- function addSomeNumber(num) {
- return num + 200;
- }
- var result = addSomeNumber(100); //300
通过检查传入函数中参数的类型和数量并作出不同的反应,可以模仿方法的重载。 [^newAdd]:ECMAScript5 新增
来源: http://www.cnblogs.com/caiyanhu/p/6803670.html