js的·介绍·

递归：
在函数内部执行自身
function fn(){
fn();
}
();

// 数学逻辑：
// 编程逻辑：
    // 逻辑，方式

// 递归：递和归
    // 递：向内
    // 归：向外
事件：行为
// 鼠标：
// 左键单击：onclick
// 双击:ondblclick
// 右键单击:oncontextmenu
// 按下:onmousedown
// 抬起:onmouseup
// 移动:onmousemove
// 进入:onmouseover / onmouseenter
// 离开:onmouseout / onmouseleave

// 键盘：
// 按下:onkeydown
// 抬起:onkeyup
// 单击:onkeypress

// 表单类：
// 获取焦点:onfocus
// 失去焦点:onblur
// 改变内容:onchange
// 输入:oninput
// 提交:onsubmit
// 重置:onreset

// 页面||浏览器：
// 加载:onload
// 滚动:onscroll
// 改变大小:onresize

// 。。。。。
// 。。。。
// 。。。

// 注意：1.找准行为；2.找准触发行为的设备(事件源)
// 并不是每个元素都能触发所有事件
// 比如：默认情况下，div不会触发键盘事件

// var box = document.getElementById("box");
// var txt = document.getElementById("txt");

// box.onclick = function(){
// box.ondblclick = function(){
// box.onmousemove = function(){
// box.onkeydown = function(){
// txt.onkeydown = function(){
// document.onkeydown = function(){
//     console.log(1);
// }

// document.onkeydown = fn;



// 如何在事件处理函数自动执行的情况下，正常绑定函数？(了解)
// 1.原本应该是什么样
// box.onclick = function(){};
// 2.现在呢？
// box.onclick = undefined;
// 3.怎么能实现初始的格式
// 改变fn的返回值，为新函数
box.onclick = fn();
function fn(){
    return function(){
        console.log("hello");
    };
}

对象类型：
// 对象由什么组成？属性名和属性值，成对出现
// 键值对
// key，value
// 每个键值对之间用什么隔开？“,”
// 键值对的键和值之间用什么连接？“:”
// 所有的键值对被放在一个花括号中，这个花括号就是一个对象

// 对象用来做什么？
//     描述一切事物，所有可被描述的事物都是对象
//     将描述的信息，使用代码表示
    // var 杯子 = {
    //     颜色：红色，
    //     形状：圆形，
    //     容量：1000ml，
    //     材质：不锈钢，
    //     功能1：function (){
    //         ....
    //     }
    // };

// 对象可以用来存储信息，还可以用来编程
    // 面向对象编程

// *对象的本质：键值对
// *对象的意义：存储数据和编程

// 创建对象：
// var obj = {};       //字面量创建
// var obj = new 任何函数;   //构造函数创建

// 构造函数:凡事通过new执行的函数，叫构造函数
// 创造对象的函数
// 只是一种新的执行方式

// function abc(){
//     console.log(123)
// }

// // var f = fn();
// var f2 = new abc();

// console.log(typeof abc)
// console.log(typeof f2)

// 习惯：为了区分正常函数，和构造函数，一般把构造函数的函数名的首字母大写（大驼峰）

// 内置函数：
//     Number()

var n1 = 3;             //字面量创建
var n = new Number(3);  //构造函数创建

console.log(typeof n);  //object
console.log(n + 1);     //4

// var o = {a:1};
// console.log( o + 1 );    //[object Object]1

String()
Boolean()
Object()
Array()
Function()

// 本地对象：由系统提供的构造函数，需要被new之后，才能使用，Number
// 内置对象：由系统提供的可以直接使用的对象（不需要被new），如：Math
// 宿主对象：不是由ECMA提供，由平台（页面、浏览器）提供，document和window

数组的概念
// 数据的组合，一组数据

// 意义：
    // 当需要操作多个数据时，需要数组

冒泡排序和选择排序：算法的雏形

// 冒泡排序：两两比较，大的放后面
// 1.确定比较次数
// 0-1 1-2 2-3 3-4      0，length-1-0
// 0-1 1-2 2-3          0，length-1-1
// 0-1 1-2              0，length-1-2
// 0-1                  0，length-1-3
function mySort(myArr){
    // 2.利用循环的嵌套实现比较次数
    for(var i=0;i<myArr.length-1;i++){
        for(var j=0;j<myArr.length-i;j++){
            // 3.正式开始比较
            if(arr[j] > arr[j+1]){
                // 4.做交换
                var ls = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = ls;
            }
        }
    }
}
var arr = [56,74,9,7,4];
console.log(arr)
mySort(arr);
console.log(arr)

选择排序：将第一个数据，依次和后面所有数据做比较，找到最小的，放在第一位；…
// 1.确定比较次数
// 0-1 0-2 0-3 0-4 0,length-1
// 1-2 1-3 1-4 1,length-1
// 2-3 2-4 2,length-1
// 3-4 3,length-1

function mySort(myarr){
    // 2.确定比较的行数
    for(var i=0;i<myarr.length-1;i++){
        // 3.假设第一位数据是最小的
        var min = arr[i];
        var minIndex = i;
        // 4.确定比较的列数
        for(var j=i+1;j<myarr.length;j++){
            // 5.验证刚才假设的最小值是否正确，不正确，保存真正的最小值
            if(min > arr[j]){
                min = arr[j];
                minIndex = j;
            }
        }
        // 6.一定要先将第一位挪走，再将最小值放在第一位
        arr[minIndex] = arr[i];
        arr[i] = min;
    }
}
var arr = [56,74,9,7,4];
console.log(arr)
mySort(arr);
console.log(arr)

计算机：
// 硬盘：存储
// 内存：运行

// 内存也是有空间，大小

// 内存颗粒：独立的软件的运行空间

// var a = 10;
// 栈：变量名，稳定，不可被修改
// 堆：数据，空间大，可被修改

// 栈和堆的关系：
//     一一对应，多对一，不能一对多

// 存取顺序：
//     栈：先进后出
//     堆：先进先出

// 值传递的数据：基本数据，一般数据，值就是地址，地址就是值，如：字符，数值，布尔
// var a = 10;
// var b = a;
// b = 20;
// console.log(a)
// console.log(b)

// 引用传递的数据：复杂数据，值是值，地址是地址，一般情况下，复制的是地址，不是值
// 导致，修改新数据，会影响复制之前的数据：这种现象被称为对象的浅拷贝
// 如：对象（数组，函数）
// var obj = {
//     name:"admin"
// }
// var obj2 = obj;
// obj2.name = "root";
// console.log(obj)
// console.log(obj2)
// console.log(obj == obj2)



// var a = 10;
// var b = {
//     a:20
// }
// function fn(data){
//     a = 11;
//     data.a = 21;
// }
// fn(b)
// console.log(a);     //11,函数中没有变量a，自动找全局a，所以修改的是全局的a
// console.log(b.a);   //21,函数中有局部变量data，不找全局，但是b是对象，对象是引用传递的数据，传参，只是简单的赋值，属于浅拷贝，所以修改新数据data，会影响老数据b




// 怎么深拷贝？

obj.name 字符
// obj.age 数值

// 解析对象中所有数据，逐个拷贝，避开了引用传递，因为里面的数据本身是值传递

// 如何解析对象内部的值？
// 操作对象：读写
    // .  语法,类似于 的 
        // 当对象的属性名是具体的值时
    // [] 语法,类似于 解析器，在内部可以放变量
        // 当对象的属性名是变量时

**json：json是一种字符，与js其实没有关系**

// json使用了ECMAScript的对象的语法

// json是一种通用数据，通用，前端和后端（php，java，python）

// 功能：前后端数据交互

// 来源：趣味性知识点

// json的格式：
//     1.必须是字符，不是编程语言，没法执行
//     2.基础格式与js中的对象的格式一致（键值对，数组，对象）
//     3.在js的对象的基础上，要求：key部分，必须放在双引号中
//     4.在json中不允许出现没有意义的 逗号 ,
//     5.在json中不允许出现函数，undefined，NaN