JAVA SCRIPT 简介：
- JS是‘ 面向Web ‘的一门 ‘高端’的‘动态’的‘弱类型’的专为‘网页交互’而设计的‘控制浏览器行为’的‘脚本语言’。
- ECMAScript是JS的核心提供核心语法功能。
- 文档对象模型(DOM)—提供访问和操作网页内容的方法和接口（针对XML但经过扩展用于HTML的应用程序编程接口(API）DOM把整个页面映射成一个多层次节点结构
- 浏览器对象模型(BOM)—提供与浏览器交互的方法和接口。
动态语言与静态类型语言的区别：
- 动态类型语言：在运行期间才能确定的数据类型，在编程时无需声明数据类型;(python js)
- 静态类型语言：在编译期间就确定的数据类型，在编程时就要明确其数据类型;(C# VB)
JS数据类型： 分为原始类型(基本数据类型)和对象类型(引用类型)。
- JS原始类型(基本数据类型)：Undefined、Null、Boolean、Number和String。
- JS对象类型(引用类型)：Object、array、function、data。
- js中也可以使用if-else while do-while for switch continue break
JS中let和var的使用区别：
- var：没有块级作用域，var声明变量，而且JS只有函数作用域和全局作用域，没有块级作用域。
- let：有块级作用域，使用let在for 内声明的i不受外界干扰，使用Let在if或for中声明的变量，只在let命令所在的代码块内有效(拥有块级作用域)。
函数预解析：
//1.函数有预解析功能，在一个标签内，所有在执行之前会将所有的函数先进行预解析；重名函数，后面的函数会“替代”前面的函数
//2.变量和函数一样也具有预解析功能，在函数代码执会优先使用局部变量，先解析函数中“声明”的变量
alert(a); //undefined 已声明未赋值
var a = 2; //下面声明，上面可以访问变量，但是预编译不解析赋值语句，未赋值的变量
var d = function() {
alert(a); //undefined //变量预解析，不解析赋值语句，只解析声明语句，全局变量与局部变量冲突时，优先使用局部变量
var a = 1;
alert(a); //1
}
d();
alert(a); //2 此时函数已经执行完毕，（函数内定义的变量只作用于函数体内（函数内的作用域范围））此时输出的a变量的值是全局变量的a的值，访问不到函数体内的值
////局部变量的优先级高于全局变量，对于重名的变量，在内部访问'''全局变量会被覆盖.
日期函数中ValueOf方法：
//日期函数的valueOf方法可以返回它的一个内部表示：1970.1.1以来的毫秒数
var nDate = new Date('2019/11/28');//使用指定日期创建日期对象
var data = new Date();
alert(data.valueOf()); //1574870400000毫秒
JS数组：
//1.function（）{}
(function (x, y) { alert(x + y); })(1, 2);//匿名函数的自调用
//2.
var f1 = new Function('x, y', 'alert(x + y)');//两个引号引起来的参数和函数体
f1(1, 3);
//和eval函数的不同就是，eval函数的变量在外界可以访问，并且改变变量的值，而匿名函数中的变量外界无法访问
eval('var a=1;var b=2;alert(a+b);');
JS数组冒泡排序实例：
var intlist = [1, 3, 5, 8, 6, 4, 9, 7, 2];//升序
var newlist = intlist.sort(function (x, y) { return x-y; });
alert(newlist.toString());
//----------------------------------------------------------------------
fintlist = [1, 8, 5, 2, 3, 6, 7, 4];
function getNewArraylist(Arraylist, fn) {
var temp, i, j
for (var i = 0; i < Arraylist.length - 1; i++) {
for (var j = 0; j < Arraylist.length - 1 - i; j++) {
if (fn(Arraylist[j], Arraylist[j + 1]) > 0) {
temp = Arraylist[j];
Arraylist[j] = Arraylist[j + 1];
Arraylist[j + 1] = temp;//升序
}
}
}
}
function cmd2(obj1, obj2) {
return obj1 - obj2;
}
getNewArraylist(fintlist, cmd2);
alert(fintlist.toString());
JS中的继承和函数扩展(原型对象)
- 每创建一个实例，都会把该函数中的属性和方法拷贝一份给该实例，增加内存开销，降低了浏览器执行效率(负担)，原型对象存放共用函数，随用随取，不用缓存给每一个对象
- 原型对象是只读的（保存在原型对象中的栈中的数据是不可变的）
- 数组是引用类型，存储原型对象栈中的地址不可修改，但是通过地址可以修改其堆中的数据。
function Person(name, sex, age) {
this.user_name = name;
this.user_sex = sex;
this.user_age = age;
Person.prototype.Tell = "112121112121";//将电话属性放入原型对象
}
//原型对象存放共用函数，随用随取，不用缓存给每一个对象
Person.prototype.SayHi = function () { alert(this.user_name + "" + this.user_sex + "" + this.user_age) };
Person.prototype.firents = ["小红", "小亮", "小明"];
Person.prototype.tell = 12313;
var p = new Person('张三', '男', 14);
//p.SayHi = null; //报错终止执行 //每个对象之间都是相对独立的，栈中的数据是唯一不可改变的
Person.prototype.firents = ["小红", "小亮", "小明"];
var p = new Person('张三', '男', 14);
p.firents[0] = '小狗'; //会影响P1的值，通过栈中的地址修改了firnend里面的值
//JS中没有类的概念，继承的实现是对象与对象之间的继承
function Person(name, sex, age) {
this.pname = name;
this.psex = sex;
this.page = age;//this指声明它的对象的属性，本身Person构造函数并没有属性(使用Person点不出来)
}
//为person注册原型对象，每次创建它的实例并不会直接注册并缓存给它的实例(公共Person函数)
Person.prototype.sayhi = function () { alert(this.pname + "" + this.psex + "" + this.page); }
function Students(stuno) {
this.stuNo = stuno;
}
var p = new Person('张三', '男', 15);
p.sayhi();//可以写相当于C#中的扩展方法。
//--------------------扩展String------------------------------------------------------
//编写一个string类型的原型对象的扩展方法
String.prototype.GetMax = function () {
for (var i = 0; i < this.length; i++) {
var maxnum = this[0];
if (this[i] > maxnum) {
maxnum = this[i];
}
}
return maxnum; //------成功
};
var s = "1548719";
newstr = s.GetMax();
alert(newstr); //类似于C#中扩展方法,但是并不推荐使用！
//---------------------------------------------------------------------------------------------
Students.prototype = p; //这个Students类型继承的是Person对象，而不是函数对象 (继承了Perosn对象就拥有了该函数对象内的所有属性和方法)
Students.prototype.sahellow = function () { alert("我是注册在对象P的方法！"); }
var stu = new Students('1001');
stu.pname = "刘大厨";//重新定值
stu.psex = "女";
stu.page = 18;
stu.sayhi();
stu.sahellow();
JS键值对集合(JSON)：
//键值对集合本身可以作为对象来使用
//键值对集合里面的元素是可以多层嵌套的
//循环：for (var item in persondict) {}
var doict = {
'zs': '张三'
};
if ('lisi' in doict) {
alert("存在！");
} else {
doict['lisi'] = "李四";
alert("添加成功！");
}
//只能通过键来访问修改和添加 修改和添加，实现存在就是修改否则直接添加。
//-JSON格式的数组数据(对象)----------------------------------
var persondict = [{
"name": "张三",
"age": "18",
"sex": "男"
}, {
"name": "李四",
"age": "15",
"sex": "男"
}];
//persondict[i].name
JS面向对象：
JS中没有类的概念，当使用new关键字的时候表示要创建对象（这个函数呢也称为构造函数），如果定义的函数要被创建对象就是用帕斯卡命名方式（每个首字母大写）。
- 判断某个实例是否是某个类型： alert(p instanceof Person);//判断p是否是从Person实例分配
- JS是动态语言，可以手动编写相关信息(直接写p.name p.sayhi() …)
- 使用键值对集合方式创建对象，代码如下：
//使用键值对集合的方式创建对象
var stu = {
'name': '张三', 'age': 15, 'sex': '男',
'sayhi': function () {
alert("你好，我在键值对创建的对象里！");
}
}
//调用对象
stu.sayhi();
JS协议停止超链接跳转：
<a onclick="return false;" href="http://www.baidu.com">百度一下，我就知道</a>
<!--return false不跳转-->
<!--利用协议不跳转-->
<a href="javascript:alert('链不过去了吧！')">连接失败了吧</a>
<a href="javascript:void(0)">连不过去了吧</a>
JS闭包：
- 含义： 在一个函数体内又定义了一个函数，内部函数能访问外部函数作用域范围的变量。这时内部函数就叫做闭包
- 闭包(函数体内部函数)包含了其上的所有作用域，闭包不释放外面的函数体就无法释放
- Why：函数对象内部有个字段指向作用域的数组（内部作用域链），依次去寻找要使用的变量(从内而外直到全局变量)
- var user_age = 18;在函数体内使用VAR声明变量可以理解为私有变量(只作用于函数体内)，可以通过两个方法进行赋值，返回该值。
function sPerson() {
var user_age = 18;
//可以理解为私有变量，可以通过两个方法去访问
//通过该函数可以为user_age赋值
this.SetAge = function (age) {
user_age = age;
}
//(注册给对象这个函数)通过该函数可以直接访问user_age变量
this.GetAge = function () {
return user_age;
}
}
JS中的this关键字：
- this关键字指向哪个对象，取决于当前函数是哪个对象的函数（注册给了哪个对象）
function f(){
alert(this);//此时的this指向Window对象(整个页面的对象)
}
f();
window.f();//效果一样，都指向window窗体
//-------------------------
function f() {
alert(this); //此时的this指向Window对象(整个页面的对象)
}
f();
window.f(); //效果一样，都指向window窗体
