标签：模型 补充 表格排序 大写 价格 idt 其他 return 规则
对象的定义：无序属性的集合，其属性可以包含基本值，对象或是函数
1. 面向：将脸朝向… -> 关注，用
2. 面向过程 -> 使用过程的方式开发
关注过程，步骤，细节，顺序。 就是自己动手丰衣足食
3. 面向对象开发 -> 使用对象的方式开发
要做什么，找到对象，告诉他做，等结果
4. 面向对象不是面向过程的替代，是面向过程的封装，可以理解为面向对象编程就是面向编程的一种简化
在实际开发中，对象是一个抽象的概念，可以简单理解为： 数据集或功能集。可以混合使用
给页面中所有的div和p添加边框，设置宽高
<body>
<!-- 给页面中所有的div和p添加边框，设置宽高 -->
<div>div1</div>
<p>p标签</p>
<div>div2</div>
</body>
<script>
/* 获得所有div */
var divs = document.getElementsByTagName(‘div‘);
var ps = document.getElementsByTagName(‘p‘);
/* 设置样式 */
/* 由于 getby 获取的是 伪数组 */
for ( var i = 0; i < divs.length; i++ ) {
divs[ i ].style.border = ‘1px solid red‘;
divs[ i ].style.width = ‘300px‘;
divs[ i ].style.height = ‘200px‘;
}
for ( var i = 0; i < ps.length; i++ ) {
ps[ i ].style.border = ‘1px solid blue‘;
ps[ i ].style.width = ‘300px‘;
ps[ i ].style.height = ‘200px‘;
}
</script><script>
/* 利用函数封装较长的功能 */
function tag ( tagName ) {
return document.getElementsByTagName( tagName );
}
var divs = tag(‘div‘);
var ps = tag(‘p‘);
for ( var i = 0; i < divs.length; i++ ) {
divs[i].style.border = ‘1px solid red‘;
divs[i].style.width = ‘300px‘;
divs[i].style.height = ‘200px‘;
}
for ( var i = 0; i < ps.length; i++ ) {
ps[i].style.border = ‘1px solid blue‘;
ps[i].style.width = ‘300px‘;
ps[i].style.height = ‘200px‘;
}
<script><script>
function tag ( tagName ) {
return document.getElementsByTagName( tagName );
}
function addCss( array, border, width, height ) {
for( var i = 0; i < array.length; i++ ) {
array[i].style.border = border;
array[i].style.width = width;
array[i].style.height = height;
}
}
var divs = tag( ‘div‘ );
var ps = tag(‘p‘);
addCss( divs, ‘1px solid red‘, ‘400px‘, ‘50px‘ );
addCss( ps, ‘1px solid blue‘, ‘300px‘, ‘50px‘ );
</script><script>
function tag ( tagName ) {
return document.getElementsByTagName( tagName );
}
function addCss( array, styles ) {
for( var i = 0; i < array.length; i++ ) {
for( var k in styles ) {
array[i].style[k] = styles[k];
}
}
}
var divs = tag(‘div‘);
var ps = tag(‘p‘);
addCss( divs, {
‘border‘: ‘1px solid red‘,
‘width‘: ‘400px‘,
‘height‘: ‘50px‘
});
addCss( ps, {
‘border‘: ‘1px solid red‘,
‘width‘: ‘400px‘,
‘height‘: ‘50px‘
});
</script><script>
var jespon = {
tag: function( tagName ) {
return document.getElementsByTagName( tagName );
},
addCss: function( array, styles ) {
for( var i = 0; i < array.length; i++ ) {
for( var k in styles ) {
array[i].style[k] = styles[k];
}
}
}
}
var divs = jespon.tag(‘div‘);
var ps = jespon.tag(‘p‘);
jespon.addCss( divs, {
‘border‘: ‘1px solid red‘,
‘width‘: ‘400px‘,
‘height‘: ‘50px‘,
‘background‘: ‘green‘
});
jespon.addCss( ps, {
‘border‘: ‘1px solid red‘,
‘width‘: ‘400px‘,
‘height‘: ‘50px‘
});
</script><script>
var jespon = {
tag: function( tagName ) {
return document.getElementsByTagName( tagName );
},
addCss: function( array, styles ) {
for( var i = 0; i < array.length; i++ ) {
for( var k in styles ) {
array[i].style[k] = styles[k];
}
}
}
attr: ...,
getId: ...
}
<script> var arr = [1, 2, 3];
console.log( typeof arr ); //object
console.log( Object.prototype.toString.apply(arr) ); // [object Array] // 联想内存逻辑图
var arr1 = [ 1, 2, 3, 4 ];
var arr2 = [
{ name: ‘张三‘, age: 19, gender: ‘男‘ },
{ name: ‘李四‘, age: 18, gender: ‘男‘ },
{ name: ‘小李‘, age: 17, gender: ‘女‘ }
];var a = 123;
var b = ‘abc‘;
var c = true;赋值：将原变量中的数据拷贝一份，然后存储到给定变量中
值类型
var a = 123; // 有个盒子a，里面存了123
var b ; // 有个盒子 b， 里面什么都没有 （undenfied）
b = a; // 将 a 中存储的东西赋值一份，然后赋值为 b，即存储在 b 中引用类型
var o1 = { num:123 };
var o2;
// 赋值
o2 = o1; //o1 中存储的是引用，或‘地址’什么是函数参数传递
函数要调用，一般会给函数传递参数
在调用函数的时候，会将参数中表示的数据拷贝一份，然后给参数赋值
值类型传递
function foo ( num ) {
console.log( ‘num:‘ + num ); // 123
num++;
console.log( ‘num:‘ + num ); // 124
}
// 调用
var a = 123;
console.log( a ); // 123
foo( a ); // 调用就是执行，将 a 中存的值，拷贝一份
// 然后进入 函数 foo
// 给参数赋值，相当于 num = a;
// 进入函数体，开始执行函数
console.log( a ); // 123 function foo ( num ) {
console.log( ‘nu====m:‘ + num[ 0 ] ); // 123
num[ 0 ]++;
console.log( ‘num:‘ + num[ 0 ] ); // 124
}
// 调用
var a = [ 123 ];
console.log( a[ 0 ] ); // 123
foo( a );
console.log( a[ 0 ] ); // 124此时的赋值特性与前面介绍的值类型引用类型的赋值是一个特点
什么是拷贝: 就是创建一个与目标数据一模一样的数据
var p = { name: ‘张三‘ };
var p1 = p; // 是否存在拷贝
// 一般描述拷贝是指拷贝对象
p1 = {};
p1.name = p.name;// 才是拷贝给 对象 p 提供一个 clone 方法, 完成拷贝
- 浅拷贝：如果对象的属性也是一个引用类型, 拷贝的时候不重新创建一个新的对象来实现该属性的拷贝, 那么就是浅拷贝.即任何不完全的拷贝都是浅拷贝
- 深拷贝：将两个对象完全从内存中隔离开, 就是深拷贝. 即每一个引用属性, 以及引用属性的引用属性, … 全部拷贝出来.
js 中对象的动态特性, 即 想要什么属性就可以给什么属性
var o = {}; // 这时 o 对象没有 name 属性
o.name = "aaa"; // 这时 o 对象拥有了 name 属性且值为 “aaa”在 js 中 对象如果没有指定的属性, 只需要利用赋值就 可以给对象 动态 提供该属性.
- 点语法与关联数组语法
o.name = ‘jim‘; // 点语法赋值
console.log( o.name ); // 点语法取值
o[ ‘name‘ ] = ‘tom‘; // 关联数组语法赋值
console.log( o[ ‘name‘ ] ); // 关联数组语法取值 var p = {}; // 什么都没有的对象
// 根据需要添加成员
p.name = ‘张三‘;
p.age = 30;
p.gender = ‘男‘; function createPerson( name, age, gender ) {
var p = {};
p.name = name;
p.age = age;
p.gender = gender;
return p;
}
var p1 = createPerson( ‘jepson‘, 19, ‘男‘ );
var p2 = createPerson( ‘lucy‘, 18, ‘女‘ );这个( 这种类型 )的函数就是用来创建对象的, 即生产对象. 常常将这类函数, 称为 **‘工厂函数‘**。
构造器中不需要 return 语句. 一般也可以不写
调用构造器的时候, 使用 new 运算符引导
在构造器中 this 表示当前对象. 给对象提供成员使用 this.xxx 的 方式
javascript
function createPerson( name, age, gender ) {
this.name = name;
this.age = age;
this.gender = gender;
}
// 调用构造器创建对象
var p = new createPerson( ‘jepson‘, 19, ‘男‘ );
javascript
function Person( name, age, gender ) {
this.name = name;
this.age = age;
this.gender = gender;
}
// 调用构造器创建对象
var p = new Person( ‘jepson‘, 19, ‘男‘ );
try catch 语法
1) try-catch 形态
try {
代码
} catch ( e ) {
代码
}2) try-catch-finally 形态
自定义抛出异常
一般可以封装函数完成特定的功能
抛出异常的语法
throw 对象
标签：模型 补充 表格排序 大写 价格 idt 其他 return 规则
原文地址：http://blog.csdn.net/qq_16415157/article/details/52940466
