JS学习4（引用类型）

引用类型是一种数据结构，用于将数据和功能组织在一起。对象是某个特定引用类型的实例。新对象使用new操作符后面跟一个构造函数来创建，构造函数本身就是一个函数，只不过这个函数是出于创建新对象而定义的。

var person = new Object();

这里调用的构造函数是Object()，只为新对象定义了默认的属性和方法。

Object类型

这是ECMAScript中使用的最多的类型，大多数引用类型的实例都是Object类型的实例。

初始化

创建它有两种办法：

//方法1
var person = new Object();
person.name = "Nicholas";
person.age = 29;
//方法2
var person = {
    name : "Nicholas",
    age : 29
};
//这样也可以～
var person = {}; // new Object()
person.name = "Nicholas";
person.age = 29;

在方法2中注意，属性值是字符串，如果你输入的不是字符串，那也会被转化成字符串。

要注意的是使用字面量来定义对象的时候实际上不会调用Object()构造函数哦

在需要像函数传递大量可选参数的情况下，使用对象字面量来传递是个很好的选择。

访问

有两种方法来访问：

alert(person["name"]); //"Nicholas"
alert(person.name); //"Nicholas"

一般推荐第二种，但是第一种有特殊的用法：

var propertyName = "name"; //需要通过变量来访问属性
alert(person[propertyName]); //"Nicholas"
//属性名里包含非字母非数字等用在.方法里会出错的字符
person["first name"] = "Nicholas";

Array类型

ECMAScript中的数组也与其它语言的数组有很大区别，数组中的每一项都可以保存任何类型的数据，大小也是动态调整的。

初始化

同样的，使用数组字面量初始化数组时不会调用Array的构造函数。

var colors = new Array();
var colors = new Array(20);
var colors = new Array("red", "blue", "green");
var names = new Array("Greg");
var colors = ["red", "blue", "green"];
var names = [];

访问

使用方括号下标的方式来访问。

在别的语言中会有数组越界，在JS里，越界访问返回undefined，越界赋值则会帮你创建这个元素，如果数组原来只有3个元素，你直接设置第100个，数组长度也会变为100，前面那些没赋值的都会变成undefined，虽然这样不报错，但还是不推荐。

length属性始终会返回0或更大的值，而且有趣的是，这个属性并不是只读的，还可以设置长度，通过设置长度就可以移除不要的或添加新项。

这样的特性造成了在最后添加元素很方便：

colors[colors.length] = "black";

检测数组

ECMAScript3中使用value instanceof Array来判断一个对象是不是数组。但是当一个网页中包含多个框架时，就有可能包含多个全局执行环境，包含多个Array的构造函数，在框架之间传递数组时这样判断就会出问题。ECMAScript5为了解决这个问题创建了isArray()方法。

转换方法

alert(colors.toString()); //对数组调用toString时会对数组中的每一个元素调用toString，然后加上逗号拼成一个字符串
alert(colors.toLocaleString());//对数组调用这个方法和调用toString()方法类似，会先调用每一项的toLocaleString()方法
alert(colors.valueOf());//valueOf方法则还是返回数组
alert(colors);//直接将数组传到alert里其实是默认调用了toString再显示出来
alert(colors.join("||"));      //这个可以自定义字符串的分隔符，默认使用逗号。red||green||blue

栈方法

使数组模仿栈操作，有push()和pop()方法。push接受任意数量的参数将它们逐个添加到数组的末尾，并返回新的数组长度。pop移除最后一个元素并返回该元素。

队列方法

模仿队列操作，使用push()，shift()方法模仿。shift()方法移除第一项并返回这个元素。

还可以使用pop()和unshift()方法来模拟，unshift是在数组的最前端加上任意个项并返回新的数组长度。

这两种方法模拟队列的方向不一样，我更喜欢第一组。

重排序方法

reverse()方法会直接反转数组。

sort()方法会调用数组中每一项的toString方法，然后根据转换得来的字符串按照升序排列数组。也就是说[0,1,2,10]会被排成[0,1,10,2]。这显然不是我们想要的

sort可以接受一个参数，这个参数是一个比较函数，这个比较函数接受两个参数，如果第一个应该在第二个前面，则返回一个负数，相等返回0，否则返回正数。

function compare(value1, value2) {
    if (value1 < value2) {
        return -1;
    }
    else if (value1 > value2) {
        return 1;
    }
    else {
        return 0;
    }
}
var values = [0, 1, 5, 10, 15];
values.sort(compare);
alert(values);  //0,1,5,10,15

对于数值类型或者valueOf()方法会返回数值的直接用减法代替咯：

function compare(value1, value2){
    return value2 - value1;
}

一些方法

concat()

var colors = ["red", "green", "blue"];
var colors2 = colors.concat("yellow", ["black", "brown"]);
alert(colors);     //red,green,blue
alert(colors2);    //red,green,blue,yellow,black,brown

slice()

var colors = ["red", "green", "blue", "yellow", "purple"];
var colors2 = colors.slice(1);
var colors3 = colors.slice(1,4);
alert(colors2);   //green,blue,yellow,purple
alert(colors3);   //green,blue,yellow

splice()

var colors = ["red", "green", "blue"];
var removed = colors.splice(0,1);    //  删除第一项
alert(colors);     // green,blue
alert(removed);    // red 被删除的项  

removed = colors.splice(1, 0, "yellow", "orange");   // 在1的位置插入2项
alert(colors);     // green,yellow,orange,blue
alert(removed);    // 空的，因为没删除什么

removed = colors.splice(1, 1, "red", "purple");   //  删除1项，插入两项
alert(colors);     // green,red,purple,orange,blue
alert(removed);    // yellow 被删除的项

位置方法

indexOf和lastIndexOf方法用来查找元素在数组中的位置。接收两个参数，起始索引和要查找的元素，这两个的区别就是一个从前开始找一个从后开始找。他们只会返回他们找到的第一个元素的索引。在查找时使用===全等符号来比较。如果找不到则返回-1。

var person = { name: "Nicholas" }; var people = [{ name: "Nicholas" }];
var morePeople = [person];
alert(people.indexOf(person));     //-1 这里两个对象不是一个，并不全等alert(morePeople.indexOf(person)); //0

迭代方法

在ES5中为数组定义了5个迭代方法，这些方法都接收两个参数：要在数组每一项上运行的函数和运行该函数的作用域对象（这个对象会影响函数内this的值）。

对于作为参数被传进去的函数，它会接收到3个参数：数组项的值，数组项的索引，和数组本身。返回值每个函数不一样。

every()

如果函数对每一项都返回true，则every返回true。这个一般用来检测数组的每一项是否满足某个要求。

some()

如果函数对某一项返回true，这个函数就返回true

filter()

它返回函数返回true的项组成的数组

map()

返回在数组原始项上运行传入函数的结果返回的数组

foreach()

木有返回值

归并方法

这也是ES5里的方法：reduce()和reduceRight()。这两个方法一个从前一个从后，迭代数组的所有项，最终返回一个值。他们都接受两个参数：在每一项上调用的函数和初始值（可选）。函数接收4个参数：前一个值，当前项，项的索引和数组对象。且这个函数返回的任何值都会自动的作为下一项的第一个参数。

var values = [1,2,3,4,5];
var sum = values.reduce(function(prev, cur, index, array){      return prev + cur;
});
alert(sum); //15

Date类型

var now = new Date(); //当前时间
var someDate = new Date(Date.parse("May 25, 2004")); //这个字符串格式没有标准，有可能有的浏览器不支持呢
var someDate = new Date("May 25, 2004"); //这个其实会自动调用parse
var allFives = new Date(Date.UTC(2005, 4, 5, 17, 55, 55)); //这个比较保险
var start = Date.now(); //获取当前毫秒数，用来分析代码很有用

Date类型重写了toString(),toLocaleString(),valueOf()方法。前两个每个浏览器实现都不太一样，所以在真正用的时候也不太可能用这些方法将值呈现给用户。valueOf方法则是将时间转换为毫秒值，这个就比较有用了，这就意味着可以直接使用><来判断时间的先后。

var date1 = new Date(2007, 0, 1);    //"January 1, 2007"
var date2 = new Date(2007, 1, 1);    //"February 1, 2007"
alert(date1 < date2); //true
alert(date1 > date2); //false

那么如果想获得准确的时间信息并显示给用户我们应该怎么办呢

getFullYear()

getMonth()

getDate()

等等。。。

也有设置的方法

setFullYear()

setMonth()

等等

RegExp类型

正则表达式

var expression = / pattern / flags ;

其中pattern可以是任何简单或复杂的正则表达式，flags是标志，标志可以带多个。标志有3个：g表示全局模式，即模式会被应用到所有字符串，不会在找到第一个后就停止；i表示区分大小写；m表示多行，在到达一行文本末尾时会查找下一行。

var pattern1 = /at/g; //匹配字符串中所有at的实例
var pattern2 = /[bc]at/i; //匹配第一个bat或cat，不区分大小写
var pattern2 = new RegExp("[bc]at", "i"); //这样也是可以的
var pattern3 = /.at/gi; //匹配所有以at结尾的3个字符的组合，不区分大小写

在ES3中，使用字面量创建正则表达式与使用new创建正则表达式不一样。使用字面量创建的正则表达式始终共享一个RegExp类型实例。这就有问题了：

var re = null;
var i;
for (i=0; i < 10; i++){
    re = /cat/g;
    re.test("catastrophe");
}

在上面这段代码中每次循环都使用的是同一个RegExp实例，在第一次查找的过程中，查到了索引为3的地方。在循环到第二次的时候，因为是同一个实例，实例属性不会被重置，于是第二次循环就从第4个字符开始查找了，这样当然就找不到了。

在ES5中，修复了这个不合理的地方。字面量也是直接调用构造函数那样新建一个实例。

实例属性

global：是否设置了g

ignoreCase：是否设置了i

lastIndex：开始搜索下一个匹配项的字符位置

multiline：是否设置m

source：正则表达式的字符串表示

实例方法

exec()专为捕获组设计：

var text = "mom and dad and baby";
var pattern = /mom( and dad( and baby)?)?/gi;
var matches = pattern.exec(text);
alert(matches.index);//0
alert(matches.input);// "mom and dad and baby"
alert(matches[0]);// "mom and dad and baby"
alert(matches[1]);// " and dad and baby"
alert(matches[2]);// " and baby"

test()它接受一个字符串，在模式与该参数匹配的情况下返回true：

var text = "000-00-0000";
var pattern = /\d{3}-\d{2}-\d{4}/;
if (pattern.test(text)){
    alert("The pattern was matched.");
}

RegExp构造函数属性

这些属性基于所执行的最近的一次正则表达式操作而变化

var text = "this has been a short summer";
var pattern = /(.)hort/g;
if (pattern.test(text)){
    alert(RegExp.input);   // this has been a short summer
    alert(RegExp.leftContext);  // this has been a
    alert(RegExp.rightContext);   // summer
    alert(RegExp.lastMatch);    // short
    alert(RegExp.lastParen);   // s
    alert(RegExp.multiline);   // false
}

还有9个用于储存捕获组的构造函数属性：RegExp.$1、…RegExp.$2

var text = "this has been a short summer";
var pattern = /(..)or(.)/g;
if (pattern.test(text)){
    alert(RegExp.$1);       //sh
    alert(RegExp.$2);       //t
}

Function类型

在ES里Function实际上是对象！所以每个函数都是Function类型的实例，与其他引用类型一样具有属性和方法，至于函数名，就是一个指向函数对象的指针。所以以下3种方法声明函数都是等价的：

//1
function sum (num1, num2) {
    return num1 + num2;
}
//2
var sum = function(num1, num2){
    return num1 + num2;
};
//3
var sum = new Function("num1", "num2", "return num1 + num2");

第三种方法可以很明显的看出函数是对象的迹象，但是平时使用的时候并不推荐使用第三种办法，会导致性能问题，因为要解析字符串里的表达式。

对于函数的名字，仅仅是指向函数的指针：

//首先定义了一个名为sum的函数
function sum(num1, num2){
    return num1 + num2;
}
alert(sum(10,10));        //20
//这里不使用带圆括号的函数名，意思就是访问函数的指针而不是调用函数
//这里将sum的值赋给了anotherSum
var anotherSum = sum;
//于是anotherSum也指向了sum函数
alert(anotherSum(10,10)); //20
//将sum指向别处
sum = function (num1, num2){
  return num1 - num2;
};
//anotherSum还指向原来的sum函数
alert(anotherSum(10,10)); //20
//sum指向新函数
alert(sum(10,10));//0

函数声明和函数表达式

函数声明会被解析器率先获取并放到其所在执行环境的顶部，代码开始执行后随时可用。而函数表达式得在代码执行到其所在的代码行时才被解释。

就这点区别。

这个可以正确执行：

alert(sum(10,10));
function sum(num1, num2){
    return num1 + num2;
}

这个则会报错：

alert(sum(10,10));
var sum = function(num1, num2){
    return num1 + num2;
};

作为值的函数

函数可以作为参数传给另一个函数，也可以作为返回值。

//将一个函数作为参数，并将这个函数的返回值作为返回值
function callSomeFunction(someFunction, someArgument){
    return someFunction(someArgument);
}
function add10(num){
    return num + 10;
}
//调用时将函数的指针传入
var result1 = callSomeFunction(add10, 10);
alert(result1);   //20

直接返回一个函数：

function createComparisonFunction(m) {
  return function(o1, o2){
    return m+o1+o2;
  };
}
var func = createComparisonFunction(1)
alert(func(2,3));
alert(createComparisonFunction(1)(11,0));

函数内部属性

在函数内部有两个特殊对象arguments和this。arguments的主要用途是保存参数，不过他还有一个callee的属性，它是一个指针，指向拥有这个arguments对象的函数。于是就可以这样用：

//递归阶乘，使用callee自己调用自己就不受函数名的限制了
function factorial(num){
    if (num <=1) {
        return 1;
    } else {
        return num * arguments.callee(num-1);
    }
}

在ES5中还有caller属性，返回指向调用这个函数的函数的指针。在全局作用域中调用的函数这个属性是null

function outer(){
    inner();
}
function inner(){
    alert(inner.caller);
}
outer();

函数的属性和方法

每个函数都有2个属性：length和prototype。length表示希望接受到的命名参数的个数。prototype以后再细说。

每个函数都包含两个方法：apply()和call()。这两个方法在特定的作用域中调用函数，实际上就是手工设置函数体内this的值。

apply接受两个参数，第一个就是你要设置的作用域，第二个是函数本身要接受的参数，这个参数可以以数组的形式给出，也可以以arguments对象形式。call则是将参数直接列在上面：

function sum(num1, num2){
    return num1 + num2;
}
function callSum(num1, num2){
    return sum.call(this, num1, num2);
}
function callSum1(num1, num2){
    return sum.apply(this, arguments);
}
function callSum2(num1, num2){
    return sum.apply(this, [num1, num2]);
}
alert(callSum(10,10));   //20
alert(callSum1(10,10));   //20
alert(callSum2(10,10));   //20

ES5新定义了一个方法bind()，这个方法创建一个函数的实例，这个函数的this值会被绑定到bind的参数上。

window.color = "red";
var o = { color: "blue" };
function sayColor(){
    alert(this.color);
}
var objectSayColor = sayColor.bind(o);
objectSayColor();    //blue

基本包装类型

三个基本类型有自己的包装类，Boolean、Number、String。

var s1 = "some text";
var s2 = s1.substring(2);

是不是觉得很奇怪～s1明明是一个String类型的基本类型～怎么会有自己的方法～

在你从内存中读取这个字符串的时候其实发生了一些事情：

  • 在你开始读取这个值的时候，ES为你创建了String类型的一个实例。
  • 在实例上调用了你想调用的方法
  • 销毁这个实例

    相当于执行了下面的代码：

var s1 = new String("some text");
var s2 = s1.substring(2);
s1 = null;

自动创建的包装类只存在那一瞬间，所以为他添加属性和方法不太可能。

像上面那样显示的声明也是可以的，但是并不推荐也没有必要。对包装类实例调用typeOf会返回object，值转换时永远为true。这点一定要注意。

Object构造函数会自动识别并创建响应的包装类实例：

var obj = new Object("some text");
alert(obj instanceof String);   //true

还有一点要注意，包装类的构造函数和名字一样的转型函数要区分：

var value = "25";
var number = Number(value);
alert(typeof number);    //"number"
var obj = new Number(value);
alert(typeof obj);    //"object"

Boolean类型

重写了valueOf()，返回基本类型的true和false。重写了toString()，返回”true”,”false”。但是这个类型强烈不推荐使用，因为在转换时永远会被转换为true：

var falseObject = new Boolean(false);
var result = falseObject && true;
alert(result);  //true

Number类型

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"
alert(num.toFixed(2));     //"10.00"
alert(num.toExponential(1)); //"1.0e+1"
var num = 99;
//这个方法会自动帮你选择合适的表示法
alert(num.toPrecision(1)); //"1e+2" alert(num.toPrecision(2)); //"99" alert(num.toPrecision(3)); //"99.0"

String类型

一些基本方法

var stringValue = "hello world"; alert(stringValue.length);     //"11"
alert(stringValue.toUpperCase());        //"HELLO WORLD"
alert(stringValue.toLowerCase());        //"hello world"
alert(stringValue.charAt(1));   //"e"
alert(stringValue.charCodeAt(1));   //"101"
alert(stringValue[1]);   //"e"

concat()用来拼接字符串，不过实际中使用+更加普遍：

var stringValue = "hello ";
var result = stringValue.concat("world", "!");
alert(result);          //"hello world!"
alert(stringValue);      //"hello"

还有三个返回子字符串的方法：slice()、substr()、substring()

查找子字符串的方法：indexOf()、lastIndexOf()。和数组那个差不多，可以指定查找的子字符串和起始位置。只会返回查找到的第一个位置。

trim()删除头尾的空格：

var stringValue = "   hello world   ";
var trimmedStringValue = stringValue.trim(); alert(trimmedStringValue);     //"hello world"

匹配模式的方法：

match()：与exec()相同，接收一个正则表达式或一个RegExp对象。返回数组。

search()：与match参数相同。返回第一个匹配项的索引。

replace()：第一个参数可以是一个字符串或一个正则表达式，第二个参数可以是一个字符串或一个函数。如果第一个参数是字符串，则只能替换搜索到的第一个字。

var text = "cat, bat, sat, fat";
var result = text.replace("at", "ond");
alert(result);    //"cond, bat, sat, fat"
result = text.replace(/at/g, "ond");
alert(result);    //"cond, bond, sond, fond"

replace()有一些进阶用法：

var text = "cat, bat, sat, fat";
//这里第二个参数是字符串的时候，有一些特殊的字符序列使你可以使用最近一次匹配结果中的内容$$ $& $‘ $` $n $nn
result = text.replace(/(.at)/g, "word ($1)");
alert(result);    //word (cat), word (bat), word (sat), word (fat) 
function htmlEscape(text){
    return text.replace(/[<>"&]/g, function(match, pos, originalText){
        switch(match){
            case "<":
                return "&lt;";
            case ">":
                return "&gt;";
            case "&":
                return "&amp;";
            case "\"":
                return "&quot;";
        }
    });
}
alert(htmlEscape("<p class=\"greeting\">Hello world!</p>"));
//&lt;p class=&quot;greeting&quot;&gt;Hello world!&lt;/p&gt;

split()方法

var colorText = "red,blue,green,yellow";
var colors1 = colorText.split(",");   //["red", "blue", "green", "yellow"]
var colors2 = colorText.split(",", 2);       //["red", "blue"]
var colors3 = colorText.split(/[^\,]+/);     //["", ",", ",", ",", ""]

localeCompare()：按字母表顺序比较字符串

var stringValue = "yellow";        alert(stringValue.localeCompare("brick"));      //1 alert(stringValue.localeCompare("yellow"));      //0 alert(stringValue.localeCompare("zoo"));         //-1

fromCharCode()：

接收字符编码初始化字符串

单体内置对象

不依赖宿主环境的对象，比如Object，Array。还有两个Global和Math。

Global

终极兜底儿对象，不属于任何其他对象的属性和方法都是它的。实际上没有全局变量和全局函数，都是它的是它的。比如isNaN()等。

encodeURI()、encodeURIComponent()：

这两个是用来对URI进行编码的：

var uri = "http://www.wrox.com/illegal value.htm#start";
//"http://www.wrox.com/illegal%20value.htm#start" alert(encodeURI(uri));
//"http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.htm%23start" alert(encodeURIComponent(uri));

可见encodeURIComponent()只能用来对部分的URI（比如参数部分）来编码。

与之对应的是encodeURI()、encodeURIComponent()。encodeURI()就不会解码%23，只会解码空格这样的。所以用的时候要注意对应。

eval()方法：

执行字符串里的代码

eval("function sayHi() { alert(‘hi‘); }");
sayHi();

像undefined Date NaN RegExp Infinity Error Object EvalError Array RangeError Function ReferenceError Boolean SyntaxError String TypeError Number URIError 都是Global的属性哦。

在浏览器中，Global是作为window对象的一部分来实现的。

Math对象

属性们：Math.E、Math.LN10、Math.LN2、Math.LOG2E、Math.LOG10E、Math.PI、Math.SQRT1_2、Math.SQRT2

var max = Math.max(3, 54, 32, 16);
alert(max);    //54
var min = Math.min(3, 54, 32, 16);
alert(min);    //3
//配合apply()的使用技巧
var values = [1, 2, 3, 4, 5, 6, 7, 8];
var max = Math.max.apply(Math, values);  
alert(Math.ceil(25.9));     //26 向上取整
alert(Math.round(25.9));    //26 四舍五入
alert(Math.floor(25.9));    //25 向下取整

Math.random()方法返回一个0-1的随机数

//1-10的随机整数
var num = Math.floor(Math.random() * 10 + 1);

还有一些方法就不提了正弦什么的。

时间： 2024-11-16 15:13:08

JS学习4（引用类型）的相关文章

关于闭包的理解（JS学习小结）

前言: 啊啊啊,看书真的很痛苦啊,还是好想做项目写代码才有意思,不过我现在缺的确是将知识体系化,所以不论看书多么痛苦都一定要坚持坚持啊,这才是我现在最需要的进步的地方,加油! 因为现在期末啦,下周一也就是明天开始就有考试,所以复习是主要的事情,看书的速度比较慢了,一周大概也就184页(P110-P284), 虽然页数比较少但是其中有ES中非常最重要的两个概念——原型链和闭包,之前对于两个知识的了解算是知其然不知其所以然的,所以在那两章我也有意多花费了时间,确保我能够吃透这个概念.以下算是我自己的

JS学习笔记-OO疑问之对象创建

问一.引入工厂,解决重复代码 前面已经提到,JS中创建对象的方法,不难发现,基本的创建方法中,创建一个对象还算简单,如果创建多个类似的对象的话就会产生大量重复的代码. 解决:工厂模式方法(添加一个专门创建对象的方法,传入参数避免重复) function createObject(name,age){ var obj =new Object(); //创建对象 obj.name = name; obj.age = age; obj.run = function(){ return this.nam

JS学习笔记-数组

ECMAScript中没有提供类和接口等的定义,但它却是一门面向对象的语言,由于它能够通过其它 方式实现类似高级语言的面向对象功能,这些内容将在后面的文章中进行一步步的总结.此篇仅对JS中对象作简要说明,重点汇总一些类似于对象的数组的经常用法. 对象 创建 上篇提到创建对象的两种方式: 使用new运算符创建Object var obj = new Object(); 使用字面量方式创建 var   obj = {}; 这里值得注意的是在使用字面量(常量)创建Object时不会调用构造函数. 属性

Vue.js学习笔记：在元素 和 template 中使用 v-if 指令

f 指令 语法比较简单,直接上代码: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <title></title> <script src="https://cdn.bootcss.com/vue/2.2.

NODE.JS学习的常见误区及四大名著

NODE.JS学习的常见误区及四大名著 前段时间由于不满于社区里很多人对于NODE.JS的种种误解而写了一篇文章名为: NODE.JS之我见:http://www.cnblogs.com/pugang/p/4374681.html 收到了很多兄弟的热情回复和激烈讨论,在此深表感谢,有的朋友觉得我写的比较粗犷,没有给出具体的性能分析和对比,在此我想说的是其实好多东西的性能分析,根本就不用我写到博客上,其一是如果我写了,很多人同样会觉得不客观,不中立,其二是网上很多中立的机构,随便搜索一下,对比太多

Ext JS学习第五天 Ext_window组件（一）

此文来记录学习笔记 •第一个组件:Ext.window.Window.对于组件,也就是Ext最吸引开发者的地方,那么我们要真正的使用Ext的组件,首先必须学会阅读API文档. –xtype:组件的别名 –Hierarchy 层次结构 –Inherited mixins 混入的类 –Requires 该组件需要使用的类 –configs:组件的配置信息 –properties:组件的属性 –methods:组件的方法 –events:组件的事件 •window组件常用属性和方法讲解: •confi

JavaScript模块加载框架sea.js 学习一

简单总结sea.js 学习 文件目录结构 /sea/sea.js      下载地址  http://seajs.org/docs/#downloads /sea/jquery-sea.js   下载地址 http://jquery.com/download/ /sea/sea_config.js /sea/home.jsdata.js /sea/data.js 1.html页面代码文件 <style> .ch{height:200px;width:200px;background:#ccc;

[Pro Angular.JS]学习笔记1.1：设置开发环境

可以使用yeoman.io,很方便.我已经写了一篇随笔,介绍如何使用.这里也有一篇介绍的文章:http://www.cnblogs.com/JoannaQ/p/3756281.html 代码编辑器,在Mac下用了一下WebStorm,太恶心了.另外发现书的作者使用的开发环境是Windows + VS Express 2013,为了方便学习,我也使用VS Express 2013 Update2.VS2013用起来蛮舒服的,把WebStorm比得跟驼屎一样.也许是因为我没用习惯吧. 1.安装Nod

js 基本类型&amp;引用类型

1.基本的数据类型有:undefined,boolean,number,string,null.基本类型的访问是按值访问的,就是说你可以操作保存在变量中的实际的值 基本类型的比较是值的比较.用==比较两个不同类型的变量时会进行一些类型转换.但是当两个值的类型相同的时候,即使是==也相当于是=== 基本类型的变量是存放在栈区的(栈区指内存里的栈内存) 2.对象是属性和方法的集合.也就是说引用类型可以拥有属性和方法 引用类型的存储需要内存的栈区和堆区共同完成.栈区内存保存变量标识符和指向堆内存中该对

【转】Backbone.js学习笔记（二）细说MVC

文章转自: http://segmentfault.com/a/1190000002666658 对于初学backbone.js的同学可以先参考我这篇文章:Backbone.js学习笔记(一) Backbone源码结构 1: (function() { 2: Backbone.Events // 自定义事件 3: Backbone.Model // 模型构造函数和原型扩展 4: Backbone.Collection // 集合构造函数和原型扩展 5: Backbone.Router // 路由