js语法学习，注意点1 -

fireq3

浏览: 37987 次
性别:
来自: 北京

最近访客更多访客>>

magicfish1981

空谷悠悠

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

js语法学习，注意点1

1.变量

var test = 5;

test = "hello";

newtest = "no declare";

JS是弱类型语言，变量可以存放不同类型的值。

不一定需要声明，会在初始化，给变量名创建一个全局变量，再进行初始化

ECMAScript原始类型：Undefined,Null,Number,Boolean,String.

原始值大小是不变的，所以放在栈中，引用值，数据大小是可变化的，会降低变量查询速度，所以不放在栈中，放在堆中

1.1 typeof

t = "fw";

typeof(t);

对值或变量的调用将返回以下值

1."undefined" 当变量是Undefined时

2."boolean" 当变量是Boolean时

3."string" 当变量是String时

4."number" 当变量是数值时

5."object" 当变量为Null或引用类型时

1.2 Undefined

var t;

typeof(t);//the value is undefined

typeof(t1);//the value is undefined

alert(typeof(t)==typeof(t1))//the value is true

alert(t == undefined)//the value is true

alert(t1 == undefined)//exception

JS函数什么都不返回时，默认返回的是undefined

1.3 Null

alert(null == undefined); //return is true

1.4 Number

var x = 21;

x = 07;//八进制数

x = 0xab;//十六进制数

x = 0xAB;

alert(0xab == 0xAB);//true

输入可以是八进制，也可以是十六进制的，但经过数值计算返回的都是十进制

浮点数可以表示为

x = 9.32e8;

x = 9.323-e8;

最大的浮点数为Number.MAX_VALUE,最小的浮点数为Number.MIN_VALUE

所以有数都必须在他们之间，但计算的结果可以例外

+无穷大为 Number.POSITIVE_INFINITY

-无穷大为 Number.NEGATIVE_INFINITY

注意 Number.POSITIVE_INFINITY == Number.POSITIVE_INFINITY 为true

函数isFinite()可以判断函数是否为无穷大 isFinite(a*b)

NaN 发生在数值转换失败时，表示非数

NaN == NaN return false

isNaN()判断值是否是数值类型 isNaN("ewjifj")

2 转换

三种基本对象Number,String,Boolean 都是伪对象

2.1 转换成字符串

可以调用他们的toString()方法，转换为字符串

Boolean

var t = true;

t.toString()

Number 两种模式

默认模式

var t = 89;

t.toString();

基模式

t.toString(2);

t.toString(7);

2.2转换成数值

调用parseInt(),parseFloat()

会检查，从左开始，遇到无效数字退出

parseInt('977y009') //return 977

parseFloat('97e7.0e09') //return

parseInt('89',n) n为整数//基模式

2.3 强制类型转换

Boolean 如果值是空字符串，数字0,undefined,或null 时，返回的值是 false

var t1 = Boolean('');

var t2 = Boolean(0);

var t3 = Boolean(undefined);

var t4 = Boolean(null );

Number 将字符串强制解释为数值，如果不能解释，返回NaN值

Number(undefined) // return NaN

Number('8eee'); // return NaN

String 强制类型转换与toString 几乎一样，只是，对null及undefined也适用

var t = String(null); // t values is null

var t1 = null;

var t2 = t1.toString(); // will be error

3 引用类型

var t = new Object();

t = new Object;//除非有参数，否则()并不是必须的

Boolean

var test = new Boolean(false);

test的值为false;

但进行Boolea比较时，Boolean表达式中，所有的对象都会转为true 所以test && true 为true

Number

var numObject = new Number(55);

var iNum = numObject.valueOf(); //output 55

iNum = numObject.toFix(2);//output 55.00 2 指定要显示的小数位数

iNum = numObject.toExponential(1) // output 5.5e2 1 指定要输出的小数位数

iNum = numObject.toPrecision(3) //out 55.0 3 指定要输出的数的总位数自己判断，输出最有意思的形式

String

charAt() "ewjfowj".charAt(3) // return 'f' 从0开始

charCodeAt() "ewjfowj".charCodeAt(3) // return 102

indexOf()

lastIndexOf()

localCompare() "aaaa".localCompare("aaaa");//return 0; 相等

"aaaa".localCompare("abbb");//return -1(为负数，一般情况下为-1);aaaa排前面

"aaaa".localCompare("aaa");//return 1(为正数，一般情况下为-1);aaaa排后面

slice() "Hello".slice(0);//return "Hello"

"Hello".slice(-5) /return "Hello"

"Hello".slice(-5,1) /return "H"

substring() "Hello".substring(0);//return "Hello"

"Hello".substring(-1) /return "Hello" substring 将负数与0等同

"Hello".slice(-5,1) /return "H"

split() "ewif,ewfew".split(",");输出数组如果"re".split("")//return["r","e"]

instanceof

typeof(引用类型) 返回的都是object

所以得用instanceof var test = "you";

test instanceof String;//return true;

4. 运算符

delete

delete删除以前定义的对象属性或方法引用

var o = new Object();

o.name = "you"; //vaule is you

delete o.name; //o.name vaule is undefined

delete 不能删除ECMA原有的对象属性或方法引用

void

<a href="javascript:windows.open('about:blank')">fwe</a> 点击之后，页面会显示[object]

++和--用法，和java一样

一元加法及减法

一元加减法，对数字没有影响

而对于字符串，会将字符串进行类型转换

var num = "010";

num = +num;//return 10;

var num = "0x10";

num = +num;//return 16; typeof is number

位运算符

补码，就是正数反码加1

var n = -18;

n.toString();//return -10010 显示进行了处理，并不是补码形式

not运算符~

var n = -18;

n = ~n;//return 17;就是反码,也即符号相反-1

and运算符&,都是1时是1

or运算符|,有是1时才是1

xor运算符^,有一个是1时才是1

>> << 都是有符号位移，32位，保持不动

>>>是无符号样移，一起移动

逻辑not !

逻辑and &&

对于操作数是Boolean类型的，与JAVA语法一致

//如果两个操作数都是对象，返回后一个对象

//NaN,null，相当于false,返回NaN,null

//如果，操作数，读到了对象没有定义时，抛出异常

逻辑or ||

对于操作数是Boolean类型的，与JAVA语法一致

//如果两个操作数都是对象，返回前一个对象

//NaN,null，相当于false,返回NaN,null

//如果，操作数，读到了对象没有定义时，抛出异常

关系运算符

字符串比较，因为字符串比较是，通过每个字符的编码比较，所以应转换大小写，再进行比较

字符串与数字比较，字符串会强制转换数字再进行比较，如果字符串转换数字失败，则会返回NaN,而关系表达示有NaN，

会直接返回false

等性运算符

等号与非等号

如果式子两边的类型不一样，会进行类型转换再比较

全等号与非全等号

与等号的区别就是，不进行类型转换就比较了

条件运算符

A?B:C 与java中的语法一样

语句

js中的语句的一般用法，与java中的一样

if else / do while / while / for

不过在对condition来说，并不一定要求其是boolean类型的，会自动转型

for in 用法是枚举对象的属性

for(prop in window){

alert(prop);

}

标签及break,continue用法，与java中的一样

switch用法与java中的几乎相同

有两点不一样的，则是

1.switch语句可以使用字符串 switch("wfew")

2.可以用变量说明问题

var t = "wefw"

case t: break;

with

with("ewf"){

alert(toString());

}

语句可能是with的对象的方法，会先检查是否是本地方法，再检查是否是对象方法

5 函数

function

function methodname(argment1,...){

statement;

}

返回值由具体返回值确定，无返回值时，默认返回undefined

函数不支持重载

函数代码中有特殊对象arguments，使用的是，参数的数组，可以通过它来达到函数重载相同的效果

因为function其实是对象，定义function的过程，可以表示为

var function_name = new Function(arg1,arg2,...,function_body);
这样，所以的函数其实都可以看作是function的实例

js支持闭包-即可以使用函数外定义的变量

--------------------------------------------------------------------

对象

对象的引用：访问对象，都是通过对象的引用值进行访问

对象的废除：ECMAScript有无用存储单元收集程序，将所有的引用都设为null时，程序会将对象销毁

早绑定,晚绑定

绑定指在对象和其类型间建立关联的过程

早绑定指在对象申明的时候就和他的类型建立了关联

晚绑定是指我们的代码在运行时再检查对象是否提供了我们所需要的方法和属性

本地对象

1.Array类

初始化

var aValues = new Array();//长度可以预定义 new Array(9);

aValues[0] = 1;//Array.length=1 是无界的，随着数的增加，而增加

var aValues = [4,3];//隐含了Array对象

Array对象方法

join(c)，以c连接数组

concat(n1,n2,...) 将参数加进数组中,本身无变化

slice 截取数组，用法与string.slice类似

push 在数组后添加一个项

pop 删除数组最后一个项,并返回该项

shift 删除数组第一个项,并返回该项

unshift(c) 将c放到第一个项，其它向后移一位

reverse() 反向

sort() 排序

splice 插入数据项

2.Date类

parse() Date.parse("May 25,2004"); 转为距1970的毫秒数

UTC() Date.UTC(2004,0,5,13,5);

内置对象

1.Global

Global对象实际上并不存在；

Global对象的方法

encodeURI() 将非数字，字符，及特殊字符的进行转码

encodeURIComponent() 将非数字，字符的进行转码

decodeURI() encodeURI() 的反义

decodeURIComponent() encodeURIComponent()反义

eval(c) c为可执行代码

创建JS对象的几种方式

1。工厂方式

function createCar(iDoors) {
   var oTempCar = new Object;
   oTempCar.color = "red";
   oTempCar.doors = iDoors;

   oTempCar.showColor = function(){
       alert(this.color);
   }
}

不足之处，同一方法，不停的初始化

2.构造方式
function Car(iDoors) {
   this.color = "red";
   this.doors = iDoors;

   this.showColor = function(){
       alert(this.color);
   }
}
不足之处，同一方法，不停的初始化

3.原型方式

3.混合的构建原型方式
function Car(iDoors){
   this.color = "red";
   this.doors = iDoors;
}
Car.prototype.showColor = function(){
   alert(this.color);
}

4.动态原型方式
function Car(iDoors){
   this.color = "red";
   this.doors = iDoors;

   if(typeof(Car._init) == undefined){
       Car.prototype.showColor = function(){
           alert(this.color);
       }
   }
   Car._init = true;

}

String的+如果数据量多，效率太慢，可以考虑用Array的join

JS中的对象可以修改

1。增加新的方法

2。重定义已有的方法