感谢内容提供者：金牛区吴迪软件开发工作室

文章目录
前言
一、基本对象Object:
二、内置对象之Array：
三、内置对象之Math：
四、内置对象之Number：
五、内置对象之String：
六、内置对象之Date：
七、内置对象之JSON（ES5新增内置对象）
结束语

前言
JS的对象就是Object，还有独立于宿主环境的ECMAScript实现提供的内置对象：Array,String,Date,Math。。。
首先我们来学习一下JS的对象：
一、基本对象Object:
JS里有一句话叫万物皆对象（除了基本数据类型）。但是new String(’’)或者new Number()这种不属于基本数据类型，属于引用类型。
对象就是属性的无序集合。数组是有序集合。
创建对象的方法：

直接量（也叫字面量）

属性（对象的静态体征）

方法（对象的动态行为）

一个属性属性名结束后用，逗号隔开。

var stu = {
	//name与age属于静态体征
	name: '李四',
	age: 13,
	//study与eat属于动态行为
	study: function(course) {
		console.log('学习课程:' + course)
	},
	eat: function(pig) {
		console.log('吃：' + pig)
	}
}


通过构造函数创建

方法：var person = new 函数名();

通过该方法创建对象时，会自动执行该构造函数。

例如：

//构造函数的函数名首字母大写，区分与普通函数的区别，不是强制规定的，你也可以小写。
function Person(name, sex) {
	this.name = name;
	this.sex = sex,
	this.job = function() {
		alert(this.name)
	}
}
var child = new Person('Jack', '男');
Person.job();
//此代码一共会两次跳出对话框，因为创建对象时会自动执行构造函数一次。this指的是调用函数的对象。


通过new Object()创建

方法:通过object构造器new一个对象，在丰富对象信息。

var person = new Object();
person.name = 'wuxiaodi';
person.sex = 'boy';


工厂方式

function createStudent(name, age) {
	let stu = new Object();
	stu.name = name;
	stu.age = age;
	stu.study = function() {
		console.log(this.name + " 学习...");
	}
	return stu;
}


构造函数 + prototype

prototype: 原型对象

对象共享资源

_proto_:原型属性

prototype：默认每个函数对象都有prototype属性，显式属性

_proto_：默认每个对象都有 _proto_ 属性，该属性默认指向创建对应对象的构造函数中的 prototype，隐式属性

JS中的对象都是基于原型的对象。
对象属性调用：

对象名.属性名

对象名.方法名(参数列表)

或：

对象名[‘属性名’]

对象名[‘方法名’](参数列表)
先在自身空间中查找，如果有则直接使用，如果没有，则到原型中查找；如果原型中存在，则调用使用，如果原型中不存在，则继续到原型的原型(原型链)中查找，依此方式继续查找使用，如果一直不存在，会继续向原型链中查找，直到 Object.prototype（原型链终点）中。如果原型链中不存在待调用的属性，则返回 undefined

Object.create()
class 语法糖
…

删除对象属性：
var xiaoming = {
    name: '小明',
    age: 20
};
delete xiaoming.age; // 删除age属性
delete xiaoming['name']; // 删除name属性
delete xiaoming.gender; // 删除一个不存在的school属性也不会报错

判断对象是否拥有某一属性：

1.可以用 in 操作符：
var xiaoming = {
    name: '小明',
    birth: 1998
};
'name' in xiaoming; // true
'grade' in xiaoming; // false


PS:不过要小心，如果in判断一个属性存在，这个属性不一定是xiaoming的，它可能是xiaoming继承得到的：
'toString' in xiaoming; // true

因为toString定义在object对象中，而所有对象最终都会在原型链上指向object，所以xiaoming也拥有toString属性。

要判断一个属性是否是xiaoming自身拥有的，而不是继承得到的，可以用hasOwnProperty()方法：
var xiaoming = {
    name: '小明'
};
xiaoming.hasOwnProperty('name'); // true
xiaoming.hasOwnProperty('toString'); // false


二、内置对象之Array：
数组：保存一组数据
数组对象的作用是：使用单独的变量名来存储一系列的值。（动态数组：可自动根据元素个数调用长度大小）
概念：

元素：数组中所保存数据的空间
长度：数组中所保存元素的个数
下标（索引）：数组中元素的编号，从0开始编号，到（长度-1）结束

使用：

创建数组对象：
var arr = [];	//直接量
var arr = new Array();	//创建数组对象。当数组长度为0的时候括号可以不写。
var arr = [1, 2, 3, 4];		//直接量，在创建数组对象的同时初始化保存的数据
var arr = new Array(1, 2, 3, 4);
var arr = new Array(size);		//size为数字参数，表示创建数组时先预定size个空间

访问数组元素：

数组名[下标]

关于数组的变量迭代请看：

数组ES5新增的遍历迭代方法

也可以使用for循环的方式。

关于数组的常用API请看：

数组的常用方法及其使用场景

关于数组排序的算法请看：

JS常见算法小总结

三、内置对象之Math：
作用： 用来处理数字数据。

定义对象：
var num = 15;
var num = new Number(15);

API：

Math.random()

生成一个0~1之间的随机小数

如果要生成0-54之间的随机整数：

Math.floor(Math.random() * 54)


Math.floor(num)

将num向下取整，取小于等于num的最大整数，

如：

Math.floor(3.1)		//3  
Math.floor(3.999)	//3


Math.ceil(num)

将num向上取整数，取大于等于num的最小整数，

如：

Math.ceil(3.1)		//4
Math.ceil(3.999)	//4


Math.round(num)

将num四舍五入取整数
Math.pow(x, y)

求 x 的 y 次方

如：

Math.pow(5, 3)		//125


Math.sqrt(x)

求x的开方：

如：

Math.sqrt(25)	//5


Math.trunc() - - 用于去除一个数的小数部分，返回整数部分。对于非数值它会内部调用Number方法先将其转换为数值。
Math.sign()方法判断一个数是正数、负数、零或者NaN。对于非数值，会将其转换为数值。他会返回五种值：

参数为正数，返回+1；
参数为负数，返回-1；
参数为 0，返回0；
参数为-0，返回-0;
其他值，返回NaN。




四、内置对象之Number：
API：

方法：

isFinite() - - 检测是否是有限的数字,即不是Infinity。如果参数不是数字直接返回false。
isNaN() - - 判断参数是不是NaN。
parseInt() - - 将字符串转为整数【有容错能力】
parseFloat() - - 将字符串转为浮点数【有容错能力】


有容错能力的意思就是允许后面有非数字的内容。会将前面是数字的内容进行转换。无容错能力就是不会转换


Number() - - 将字符串转为数字。【无容错能力，遇到不是数字的话就会返回NaN】
isInteger() - - 用来判断一个数值是否是整数。【如果数字超过了小数点后面的十六个进制则会判断失误因为超过的被遗弃了。或者绝对值小于js能判断的最小值也会失误被转为0】


五、内置对象之String：
作用： 处理文本数据

定义对象：
var str = 'abc';
var str = new String('abc');

API:

属性：length - - 字符串的长度

方法：

charAt(index) 	-	-	获取index位置处的字符
charCodeAt(index)	-	-	获取index位置处字符的unicode编码
String.fromCharCode(code)	-	-	将unicode编码转换为对应的字符串
concat()	-	-	字符串连接
indexOf(sub)	-	-	查找符合条件的第一个字符串所在下标
lastIndexOf(sub)	-	-	查找符合条件的第一个字符串所在下标(从后往前查)
slice(start, end) -	-	截取子字符串
subString(start, end)	-	-	截取子字符串
split()	-	-	切割字符串不传值的话就是直接把字符串用数组包起来，传值就是以值为分割。比如：



请仔细看我传入的值，与最后的结果。
replace(oldString, newString)	-	-	替换
toUpperCase()	-	-	转换为大写
toLowerCase()	-	-	转换为小写
trim() - - 去掉前后空白
trimStart() - - 去除头部空白
trimLeft() - - 去除头部空白【trimStart的别名】
trimEnd() - - 去除尾部空白
trimRight() - - 去除尾部空白【trimEnd的别名】
replace(/^\s+|\s+$/g, ‘’) - - 去掉前后空白的兼容写法
includes(sub) - - 返回布尔值，表示是否找到了参数字符串。
startsWith(sub) - - 返回布尔值，表示参数字符串是否在原字符串的头部。
endsWith(sub) - - 返回布尔值，表示参数字符串是否在原字符串的尾部。

从下图可以看到这三个方法都会将数据类型进行隐式转换。



并且上述三个方法支持第二个参数，表示开始搜索的位置：



上面代码表示，使用第二个参数n时，endsWith的行为与其他两个方法有所不同。它针对前n个字符，而其他两个方法针对从第n个位置直到字符串结束。
repeat - - 返回一个新字符串，表示将原字符串重复N次。


注意：传入的如果是小数会向下取整;传入的如果是负数或者Infinity会报错;传入的如果是字符串会先进行隐式类型转换【不是纯数字的字符串会被转为0】


padStart - - 用于头部补全
padEnd - - 用于尾部补全




如果用来补全的字符串与原字符串，两者的长度之和超过了最大长度，则会截去超出位数的补全字符串。

如果省略第二个参数，默认使用空格补全长度。




matchAll() - - 返回一个正则表达式在当前字符串的所有匹配


六、内置对象之Date：
作用：
创建方法：
let date = new Date();	//系统当前时间
let date = new Date(value);		//value是距1970-1-1 0：0：0（UTC）依赖的毫秒值
let date = new Date(dateString);	//dateString表示日期时间字符串“yyyy-MM-ddThh:mm:ss”
let date = new Date(year,month[, hour[, minutes[, seconds[, milliseconds]]]]);;	//传递日期时间数字。month合理取值为0~11；

API:

获取时间：
getFullYear()	//获取四位年份
getMonth()		//获取月份，返回值是0~11
getDate()		//获取日期
getDay()		//获取星期，返回值是0~6
getHours()		//获取小时
getMinutes()	//获取分钟
getSeconds()	//获取秒
getMilliseconds()	//获取毫秒
getTime()		//获取距 1970-1-1 0:0:0 以来的毫秒值

设置时间：
setFullYear()	//设置四位年份
setMonth()		//设置月份，传值是0~11
setDate()		//设置日期
setHours()		//设置小时
setMinutes()	//设置分钟
setSeconds()	//设置秒
setMilliseconds()	//设置毫秒
setTime()		//设置距1970-1-1 0：0：0多少毫秒是什么时间（取负值的话就是1970年之前）

时间转换：
Date.parse()	//解析，将日期时间字符串转换为表示时间的毫秒值
toString()		//将日期时间字符串转换为字符串
toUTCString()	//将日期时间转换为世界标准时间的字符串
valueOf()		//返回Date对象的原始值。与getTime()一致。
tolSOString()	//将日期时间转为格式为  YYYY-MM-DDTHH:mm:ss.sssZ  的字符串 
toJSON()		//返回 Date 对象的字符串形式。

获取日期时间毫秒值:
new Date.getTime()
Date.parse()
new Date().valueOf()
+new Date()	//隐式类型转换的方法
Date.now()	//ES5的方法


七、内置对象之JSON（ES5新增内置对象）
全称：

JavaScript Object Notation(JavaScript对象表示法)
作用：

用于存储和交换数据的文本格式（XML）
API：
//将JS值转换为JSON文本字符串
JSON.stringify()	
//将JSON文本字符串解析为JS值
JSON.parse()

//编码
encodeURIComponent()
//解码
decodeURIComponent()

小案例：



JSON.stringify与JSON.parse也可以用来拷贝对象的值，我们上面的小例子就已经实现了拷贝对象。


这个小案例就实现了编码与解码的操作。

注意传入的值要是字符串才可以哦~
结束语
更多内置对象欢迎对mdn文档进行翻阅：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects

来源：http://www.cnblogs.com/seesea125/archive/2012/04/03/2431176.html




一、 面向对象，这个对象到底是什么？

 

    这个对象不是C#中的实例，C#中我们把一个类的实例也叫做对象，这种对象严格的说应该是面向对象的编程实现(OOP)中的对象，面向对象编程，也不是面向类的实例编程。对象的定义是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。也有的定义为“一切都是对象”然而面向对象也不能简单的等价理解成面向任何事物编程，面对一切编程？开玩笑，呵呵。

因此面向对象这个对象，指的是客体。所谓客体是指客观存在的对象实体和主观抽象的概念。 

 

二、 为什么要面向对象？

 

面向对象是为了解决系统的可维护性，可扩展性，可重用性，我们再进一步思考，面向对象为什么能解决系统的可维护性，可扩展性，可重用性？ 

面向对象产生的历史原因有下面两点： 

1、 计算机是帮助人们解决问题的，然而计算机终究是个机器，他只会按照人所写的代码，一步一步的执行下去，最终得到了结果，因此无论程序多么的复杂，计算机总是能轻松应付，结构化编程，就是按照计算机的思维写出的代码，但是人看到这么复杂的逻辑，就无法维护和扩展了。

2、 结构化设计是以功能为目标来设计构造应用系统，这种做法导致我们设计程序时，不得不将客体所构成的现实世界映射到由功能模块组成的解空间中，这种转换过程，背离了人们观察和解决问题的基本思路。 

    可见结构化设计在设计系统的时候，无法解决重用、维护、扩展的问题，而且会导致逻辑过于复杂，代码晦涩难懂。于是人们就想，能不能让计算机直接模拟现实的环境，用人类解决问题的思路，习惯，步骤来设计相应的应用程序？这样的程序，人们在读它的时候，会更容易理解，也不需要再把现实世界和程序世界之间来回做转换。 

    与此同时，人们发现，在现实世界中存在的客体是问题域中的主角，所谓客体是指客观存在的对象实体和主观抽象的概念，这种客体具有属性和行为，而客体是稳定的，行为不稳定的，同时客体之间具有各种联系，因此面向客体编程，比面向行为编程，系统会更稳定，在面对频繁的需求更改时，改变的往往是行为，而客体一般不需要改变，所以我们就把行为封装起来，这样改变时候只需要改变行为即可，主架构则保持了稳定。 

于是面向对象就产生了。 

然而人们追求的系统可维护性，可扩展性，可重用性又是怎么在面向对象中体现出来的呢？ 

首先看看面向对象的三大特征： 

封装：找到变化并且把它封装起来，你就可以在不影响其它部分的情况下修改或扩展被封装的变化部分，这是所有设计模式的基础，就是封装变化，因此封装的作用，就解决了程序的可扩展性。 

继承：子类继承父类，可以继承父类的方法及属性，实现了多态以及代码的重用，因此也解决了系统的重用性和扩展性，但是继承破坏了封装，因为他是对子类开放的，修改父类会导致所有子类的改变，因此继承一定程度上又破坏了系统的可扩展性，所以继承需要慎用，只有明确的IS-A关系才能使用，同时继承在在程序开发过程中重构得到的，而不是程序设计之初就使用继承，很多面向对象开发者滥用继承，结果造成后期的代码解决不了需求的变化了。因此优先使用组合，而不是继承，是面向对象开发中一个重要的经验。 

多态：接口的多种不同的实现方式即为多态。接口是对行为的抽象，刚才在封装提到，找到变化部分并封装起来，但是封装起来后，怎么适应接下来的变化？这正是接口的作用，接口的主要目的是为不相关的类提供通用的处理服务,我们可以想象一下。比如鸟会飞，但是超人也会飞，通过飞这个接口，我们可以让鸟和超人，都实现这个接口，这就实现了系统的可维护性，可扩展性。 

    因此面向对象能实现人们追求的系统可维护性，可扩展性，可重用性。面向对象是一种编程思想，起初，“面向对象”是专指在程序设计中采用封装、继承、多态等设计方法，但面向对象的思想已经涉及到软件开发的各个方面，比如现在细分为了面向对象的分析(OOA)，面向对象的设计(OOD)，面向对象的编程实现(OOP) 

 

三 面对对象编程，分为几个步骤？ 

 

面向对象是一种思想，他让我们在分析和解决问题时，把思维和重点转向现实中的客体中来，然后通过UML工具理清这些客体之间的联系，最后用面向对象的语言实现这种客体以及客体之间的联系。它分为面向对象的分析(OOA)，面向对象的设计(OOD)，面向对象的编程实现(OOP)三个大的步骤。

1、首先是分析需求，先不要思考怎么用程序实现它，先分析需求中稳定不变的客体都是些什么，这些客体之间的关系是什么。

2、把第一步分析出来的需求，通过进一步扩充模型，变成可实现的、符合成本的、模块化的、低耦合高内聚的模型。

3、使用面向对象的实现模型 

 

四 面向过程到面向对象思维如何转变？ 

 

    当我们习惯了面向过程编程时，发现在程序过程中到处找不到需要面向对象的地方，最主要的原因，是思维没有转变。程序员通常在拿到一个需求的时候，第一个反应就是如何实现这个需求，这是典型的面向过程的思维过程，而且很快可能就实现了它。而面向对象，面对的却是客体，第一步不是考虑如何实现需求，而是进行需求分析，就是根据需求找到其中的客体，再找到这些客体之间的联系。因此面向过程和面向对象的思维转变的关键点，就是在第一步设计，拿到需求后，一定先不要考虑如何实现它，而是通过UML建模，然后按照UML模型去实现它。这种思路的转变，可能需要个过程。 

 

五 面向对象和基于对象的区别 

 

    “面向对象”和“基于对象”都实现了“封装”的概念，但是面向对象实现了“继承和多态”，而“基于对象”没有实现这些。因此在我们进行WEB开发，普通三层开发中，基本上是基于对象的实现，因为只是实现了封装，但是没有使用继承和多态，不过这也正常，WEB开发，大部分功能就是简单的增删改查，中间的BLL层基本就是直接New一个DAL的实例就return了，关系数据库已经为我们做了很多工作，所以大部分的工作，就是简单读取然后显示了，因此没有复杂的需求的时候，基于过程也没什么不对，面向过程也没什么不对，实用是压倒一切的因素。

GC管理的主要区域是Java堆，一般情况下只针对堆进行垃圾回收。方法区、栈和本地方法区不被GC所管理,因而选择这些区域内的对象作为GC roots,被GC roots引用的对象不被GC回收。

详细：

GC Root

常说的GC(Garbage Collector) roots，特指的是垃圾收集器（Garbage Collector）的对象，GC会收集那些不是GC roots且没有被GC roots引用的对象。

一个对象可以属于多个root，GC root有几下种：

Class - 由系统类加载器(system class loader)加载的对象，这些类是不能够被回收的，他们可以以静态字段的方式保存持有其它对象。我们需要注意的一点就是，通过用户自定义的类加载器加载的类，除非相应的java.lang.Class实例以其它的某种（或多种）方式成为roots，否则它们并不是roots。

Thread - 活着的线程

Stack Local - Java方法的local变量或参数

JNI Local - JNI方法的local变量或参数

JNI Global - 全局JNI引用

Monitor Used - 用于同步的监控对象

Held by JVM - 用于JVM特殊目的由GC保留的对象，但实际上这个与JVM的实现是有关的。可能已知的一些类型是：系统类加载器、一些JVM知道的重要的异常类、一些用于处理异常的预分配对象以及一些自定义的类加载器等。然而，JVM并没有为这些对象提供其它的信息，因此需要去确定哪些是属于"JVM持有"的了。

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

在Java语言里，可作为GC Roots对象的包括如下几种： 

a.虚拟机栈(栈桢中的本地变量表)中的引用的对象 

b.方法区中的类静态属性引用的对象 

c.方法区中的常量引用的对象 

d.本地方法栈中JNI的引用的对象

数据库对象简述

数据库的主要组成部分就是数据库对象，而数据库中的一行数据，称为一条记录，纵列被称为字段，数据库记录，代表有一定意义的组合信息。而缺省值是说在数据库表中插入数据或创建列时，有些列或者列的数据没有予以设定具体数值，那么就会直接以预先设置的内容赋值。

数据库对象就是数据库的组成部分，主要的数据库对象包含：触发器（Trigger）、表（Table）、视图（View）、存储过程（StoredProcedure）、索引（Index）、缺省值（Default）、图表（Diagram）、用户（User）、规则（Rule）等几类。

文章目录
用户(User)
视图(View)
索引(Index)
触发器(Trigger)
序列(Sequence)
图表(Diagram)
规则(Rule)
存储过程(Stored Procedure)
表(Table )
缺省值(Default)
数据库对象语法
执行触发器(Trigger)

用户(User)
其实，用户指的就是有对数据库有权限访问的人。
视图(View)
视图也有一组数据项和命名字段，只是在用户执行查询操作的时候才会出现，其实在数据库中并不存在，通过控制用户对数据的访问权限，简化数据，只显示用户需要的数据项。
索引(Index)
索引是为了给用户提供快速访问数据的途径，时刻监督数据库表的数据，从而参照特定数据库表列建立起来的一种顺序，主要是为了便于用户访问指定数据，避免数据的重复。
触发器(Trigger)
触发器，在数据库表中属于用户定义的SQL事务命令集合。如果你对一个数据库表执行删除、插入、修改的时候，命令就能够自动去执行。
序列(Sequence)
序列，定义存储在数据字典里面，序列提供了唯一数值的顺序表从而来简化程序的设计工作。
图表(Diagram)
图表，是为了编辑表与表之间的关系，可以理解为数据库表之间的一种关系示意图。
规则(Rule)
规则是实现对数据库表中列数据的一种限制。
存储过程(Stored Procedure)
存储过程是为了实现某个特定功能而汇集在一起的一组SQL语句，经过编译之后会存储在数据库里面的SQL程序。
表(Table )
数据库，由行(Row)和列(Column)构成。列又称为字段，列的标题被称为字段名。数据库表中的行，一行数据称为一条记录，多数是同类信息组成。一般来说，一个数据库表是由一条或多条记录组成，如果是没有记录的表，则称为空表。为了惟一地确定一条记录，每个数据库表中一般都是有一个主关键字。
缺省值(Default)
缺省值，就是数据库表中插入数据或创建列时，有些列或者列的数据没有予以设定具体数值，那么就会直接以预先设置的内容赋值
数据库对象语法
for (数据库操作)(多是delete、update，insert)
as执行程序块
执行触发器(Trigger)
对数据库表执行对应操作的时候开始触发。数据库中的触发器是用户定义的SQL事务命令集合。如果你对一个数据库表执行删除、插入、修改的时候，命令就能够自动去执行。

参考文献：
数据库对象有哪些？主要的数据库对象你都知道吗？ - 简书（简单科普向）

https://www.jianshu.com/p/ec63e6937e7c
Oracle_表空间、数据库对象 - ageeklet的博客 - CSDN博客

https://blog.csdn.net/ageeklet/article/details/82457092
数据库对象 - 忠麦一生 - CSDN博客（基础概念）

https://blog.csdn.net/zhuojiajin/article/details/7748221
常用数据库对象 - 让我们来做点什么 - CSDN博客（Oracle代码向）

https://blog.csdn.net/weixin_38008316/article/details/80543453