ExtJS是一个强大的javascript框架,如果想真正的掌握ExtJS,那么我们必须要对javascript有一定的认识。
需要掌握的内容有:
- javascript之数据类型、变量、变量操作符javascript之数组
- javascript之函数
- javascript之对象、面向对象
- javascript之原型
javascript里面有6种基本类型的值:number、string、boolean、object、function和undefined。
- number:就是数字值,包括整数、小数、NaN、正负无穷。
- string:字符串类型、单双引号引起来的内容。
- boolean:true、false
- object:表示所有的javascript对象,不用多说
- function:我们熟悉的方法,也就是函数类型,是javascript特有的数据类型。
- undefined:表示变量声明了但是并没有被赋值。
举例:
Ext.onReady(function(){
//NUmber/String/Boolean/Object/Undefined/Function
//Number
// var num1 = 10;
// var num2 = 10.5;
// var num3 = .6; //0.6
// var num4 = 070; //56
// var num5 = 1/0; //正无穷
// var num6 = window.parseInt("dasdsada"); //NaN not a number
//String 单双引号表示的字符串
//Boolean true/false
//Object
// var date = new Date();
// var arr = new Array();
// var obj = {name:'ddd',age:10};
// alert(obj.hasOwnProperty('name'));
//ECMA5
//Undefined 变量声明了但是没有被赋值 其实也等同于Null
// var a;
// alert(a);
// alert(undefined == null); //true
// alert(undefined === null); //false
// alert(typeof null); //object 表示的就是一个空对象的引用
//
//Function
function fun(){
console.info('fun...');
}
fun();
alert(typeof fun); //Function
});
- javascript声明变量用var关键字+name表示。
- javascript变量是弱变量类型,所谓的弱变量类型其实就是根据赋值决定变量的类型。
- javascript变量分为全局变量和局部变量,所有在方法里声明的变量,都是局部变量,在方法外声明的变量都是全局变量。
- javascript之运算操作符:
- javascript里运算符和java基本一样,typeof 操作符是判断数据类型的操作符,非常的实用。
javascript 更不建议使用全局变量(查找的时候效率比较低,大型程序开发时不安全)
javascript之数组
数组是javascript里最常用的对象了,它类似于java里的容器,可以承装不同类型的元素,容器的长度也可以任意。数组操作非常灵活,且里面有很多常用的方法。
push、pop
shift、unshift
splice、slice
concat、join
sort、reverse
ECMA5也对Array扩展了很多实用的方法,比如forEach、filter、some等..
//Array
// var arr = [1,2,3,4,5];
// arr.forEach(function(item){
// alert(item);
// });
var arr1 = [10,21,35,32,13];
var newarr1 = arr1.filter(function(item){
if(item > 20){
return true;
}else{
return false;
}
});
alert(newarr1);
javascript之函数
对于Ext开发者,我还是希望你能对javascript原生的东西非常了解、甚至熟练掌握运用。那么函数,无疑是非常重要的概念。首先在前面一讲,我们知道了函数也是一种数据类型,创建函数一共有三种方式。每种方式他们都会有区别,分别为:
- function语句形式
- 函数直接量形式
- 构造函数形式
函数中的arguments对象
- argument的作用一:接受函数的实际参数
- argument的作用二:用于做递归操作
//Function 函数
//前两种创建函数的主要区别:function语句形式,javascript解释器直接会去找,其他的代码就从上到下顺序执行
//1:function语句形式
fun1();
alert(fun2); //undefined
fun2(); //出错
function fun1(){
alert('fun1...');
};
//2:函数直接量的形式
var fun2 = function(){
alert('fun2...');
};
//第三种构造函数式,它具有的作用域与前两种不同,它具有顶级作用域
//3:构造函数形式
var fun3 = new Function('x','y','return x+y;');
alert(fun3(10,20));
//var k = 1;
//function test(){
// var k = 2;
// //创建三种方式的函数:
// function f(){return k;}; //f()=2
// var f = function(){return k}; //f()=2
// var f = new Function('return k;'); //f()=1 相当于在最外层,顶级域声明
// alert(f());
//};
//
//test();
arguments对象
//arguments对象,每一个函数内部都有一个arguments对象
//function test(x,y){
// //第一个作用:接受函数的实际参数
// alert(arguments); //object arguments
// alert(arguments.length); //3
//
//
// alert(arguments[2]); //3
//};
//test(1,2,3);
//第二个作用:通常用于递归操作
function fact(number){
if(number <= 1){
return 1;
}else {
return number * fact(number - 1);
}
};
alert(fact(5));
var fact2 = fact;
fact2(5);
//下面写法出错
var fact2 = fact;
fact = null;
fact2(5);
//修改:
function fact(number){
if(number <= 1){
return 1;
}else {
return number * arguments.callee(number - 1);
}
};
//下面写法不会出错
了var fact2 = fact;
fact = null;
fact2(5);
javascript之函数
this关键字的使用
this关键字总是指向调用者,谁调用函数,this就指向谁
call、apply的使用
call和apply主要应用与框架底层,用于绑定函数的执行环境/作用域
块的概念
和高级程序语言不同,js里没有块的概念,我们一般用小括号包裹块级作用域
闭包:掌握闭包必须要深入清楚的概念
- 执行环境
- 作用域链
- 垃圾回收机制
this的使用:
//This 关键字在javascript里的使用
function test(){
alert(this.x);
};
test.x = 10;
//alert(test.x); //10
test(); //undefined 相当于window.test();
//如果在定义一个变量如下
var x = 5; //相当于window.x=5
function test(){
alert(this.x);
};
test.x = 10;
test(); //弹出框显示5,
call apply:
//call apply 主要作用是绑定作用域
var color = 'red';
var obj = {color:'yellow'};
function showColor(x,y,z){
alert(x+y+z);
alert(this.color);
};
showColor(); //red
//call . apply 绑定一个函数,到你指定的作用域内执行
showColor.call(window,10,10,30);
showColor.call(obj,10,10,30);
showColor.apply(obj,[2,3,4]);//参数是数组
块的概念:
//块的概念:
function test(){
for(var i = 1;i<=5;i++){
alert(i);
}
alert(i); //这里也能执行 显示了6
};
test();
function test(){
(function(){
for(var i = 1;i<=5;i++){
alert(i);
}
})();
alert(i); //这里执行 显示错误
};
test();
//注意,在javascript中,要想直接执行一个函数,可以使用(function(){...})();形式
闭包:
//闭包:执行环境、作用域、js垃圾回收
//函数碰到return直接返回,没有return返回结果undefined
function test(){
return function(){
alert('这是闭包体代码。。。');
};
};
alert(test()); //返回的是:function(){ alert('这是闭包体代码。。。');};
var f = test();
alert(typeof f); //function
f();
function test(){
var temp = 10;
return function(){
alert(temp);
};
};
test()(); //10
闭包的一个作用是局部变量实现全局变量的功能例如做一个网页上按钮点击次数的例子,网页上有一个按钮,点击一次显示一次点击次数,每点击一次加1
一种做法是:
<body>
<input type="button" value="点击" onclick="test();"> <br>
</body>
var i = 0;
function test(){
alert(++i);
};
定义一个全局变量i,点击一次自动加1另一种做法使用闭包:
<body>
<input type="button" value="点击" onclick="<span style="color:#ff0000;">inp.getCount();</span>"> <br>
</body>
var inp = (function(){
var i = 0;
return {
getCount:function(){
alert(++i);
}
};
})();
javascript之对象、面向对象
使用json对象(JavaScript Object Notation)
- JS对象的特性
- 对于js来说json对象非常的重要,我们要学会如何操作json对象
面向对象的概念
- 如何定义一个类、如何实例化对象、如何扩展对象(原型prototype)
- 单体模式:简单单体、闭包单体、惰性单体、分支单体
- 对象的定义其他方式(工厂模型、稳妥对象、聚合对象)
- 原型的使用、原型链
- 原型的继承(多种方式实现:组合继承、借用构造函数继承、混合继承、掺元类等)
- 链式编程
- javascript契约书:接口(注释法、属性检测法、鸭式辨型法)
设计模式:如果能够掌握JS的设计模式,我相信在以后的Ext学习中,慢慢的研读,体会Ext底层代码的设计,是非常有帮助的。
json对象
Ext.onReady(function(){
//var obj = new Object(); 一种定义对象的方法
var obj = {name:'zzz',age:30};//json对象
// obj.sex = '男'; //新增属性
// obj.age = 25; //修改属性的值
// delete obj.name; //删除对象的属性
//枚举对象内置属性的循环
for(var attr in obj){
alert(attr + ":" + obj[attr]);
}
});
对象的定义,实例化
var Person = function(name,age){
this.name = name;
this.age = age;
//private
var _sex = '男'; //js私有属性
this.getSex = function(){
return _sex;
};
this.setSex = function(sex){
_sex = sex;
};
};
//实例化一个对象
var p = new Person('张三',30);
alert(p.name);
对对象的各种扩展(属性和方法):
var Person = function(name,age){
this.name = name;
this.age = age;
//private
var _sex = '男'; //js私有属性
this.getSex = function(){
return _sex;
};
this.setSex = function(sex){
_sex = sex;
};
};
Person.prototype.id = 10; //扩展对象属性
Person.prototype.method = function(){ //扩展对象方法
alert(this.age);
};
//实例化一个对象
var p = new Person('张三',30);
alert(p.name);
alert(p.id);
p.method();
要注意,实例化的语句要放在扩展之后: //原型对象的构造器总是指向当前对象的模板
Person.prototype = { //另一种扩展对象的方法,推荐使用
constructor:Person,
id:10,
method:function(){
alert('method...');
}
};
//实例化一个对象
var p = new Person('张三',30);
alert(p.name);
alert(p.id);
p.method();
单体模式:
//单体模式:
var ZCD = {};
ZCD.Array = {
each:function(){
alert('each');
},
filter:function(){
alert('filter');
}
};
ZCD.staticMethod = function(){
alert('我是单体下的静态方法');
};
ZCD.Array.each();
ZCD.staticMethod();
闭包单体:
//单体模式:闭包单体
var ZCD = (function(){
var Array = {
each:function(){
alert('each...');
}
};
return {
arrayEach:function(){
Array.each();
}
};
})();
ZCD.arrayEach();