JavaScript基础入门笔记（总结）

绝地灬酷狼 2023-05-22 04:39 16阅读 0赞

# JS #

## 简单介绍 ##

变量的声明；

var变量名字；

var num ；

变量初始化

var 变量名字=值；———>字面量的方式赋值

Var str =“您好啊”；

js中大小写是区分的

js中的字符串可以使用单引号，也可以使用双引号–暂时推荐使用双引号。

js中每行代码结束要有分号;

### 数据类型 ###

js中的原始书记类型：number,string,boolean,undefined,null,object

Null和undefined数据是没有太大意义的，null是很有意义的—对象位置讲

nan—不是一个数字，不是一个数字和一个数字计算—>结果就是nan

isnan()—>判断这个变量或者这个值是不是 不是一个数字—如果不是一个数字结果是true，结果是一个数字结果false

number数据类型—无论是整数还是小数都是number数据类型的

string数据类型—字符串，获取字符串的长度：变量名.length

boolean数据类型—两个值，true,false

null — 只有一个，null

Undefined—只有一个,undefined，一个变量声明了，没有赋值

Object—对象———面向对象内容

### 类型转换 ###

其他类型转数字

Parseint()——>转整数

Parsefloat()——>转小数

number()———>转数字——要比上面两个严格

其他类型转字符串

.tostring()

string();

其他类型转布尔类型

boolean()——>要么是true要么是false

### 运算符 ###

算术运算符：+ - / %

复合运算符：+= -= \*= /= %=

赋值运算符：=优先级别是最低的

一元运算符：++ ——

三元运算符：？ ：

关系运算符：> < >= <= == === != !==

逻辑运算符：&& || ！

关系运算符的结果是布尔类型

逻辑运算符的结果是布尔类型

## 第一部分 ##

js分三个部分

ECMAscript 标准——js的基本语法

DOM—document object model 文档对象模型

BOM——browser object model 浏览器对象模型

### 书写注意事项 ###

在一对script的标签中有错误的JS代码，那么该错误的代码后面的js代码不会执行

如果第一对的script标签中有错误，不会影响 后面的script标签中的js代码执行

script的标签中可以写什么内容type=“text/javascript” 是标准写法或者为language="javascript"可以省略是因为现在HTML基于H5的标准的

script可以出现多对

script一般是写在body最后有的时候能写在head中，如果script是引入外部文件，那里面不要写任何代码

### 变量 ###

操作的数据都是在内存中操作的

js中存储数据使用变量方式(名字，值——>数据)

js中声明变量都用var ——>存储数据，数据应该有对应的数据类型

Js中的字符串类型的值都用双引号或者单引号

变量的声明(有var 有变量名字 没有值)

变量初始化 (var 有变量名字 有值)

声明方式var 变量名字

### 变量注意事项 ###

1.变量的名字要有意义

2.变量名有一定的规范；一般以字母，$符号，下划线开头，中间或者后面可以有,符号,字母，数字

3.变量名一般都是小写的

4.变量如果是多个单词，第一个单词的首字母是小写的，后面的所有单词的首字母都是大写的，这种命名方式成为：驼峰命名法

5.不能使用关键词(系统自带的一些单词，不能使用 )

6.不会单词用拼音，拼音也要遵循驼峰命名法。

### 变量的交换 ###

//借助第三方的变量值进行交换
    var num1=10;
    var num2=20;
    var temp=num1;
    num1=num2;
    num2=temp;
    // 第二种方式交换：一般用于数字交换
    // 先相加在减的一种逻辑

### 数字类型转换 ###

转数字类型的三种方法

1.parseint

2.parseFloat 转小数

3.Number 转数字

其他类型转字符串类型

1.  tostring
2.  大写的string传参数 如果变量有意义调用. tostring()使用转换 如果没有意义使用大写的string()转换
    
    其他类型转布尔类型
    
    1.boolean值

### 操作符 ###

操作符：用来计算的一些符号

算术运算符 加减乘除

一元运算符 只需要一个操作数的就可以运算的符号

二元运算符 同理用两个

三元运算符 同理是用三个

复合运算符 复合连接起来的表达式

关系运算符 由关系运算符连接起来的表达式

关系运算表达式的结果是布尔类型

逻辑运算符 && 逻辑与—— 并且|| 逻辑或 或者

## 第二部分 ##

### 一元运算符 ###

\++ ——都是运算符

\++ ——可以分为：前+ 前— 后。。。。

如果++在后面：如：num++ +10 参与运算

先参与运算，运算结束后自身在加1

如果++在前面：先参与运算在输出结果

### 流程控制 ###

代码的执行过程

一共有三种方式

1.顺序结构：从上到下，从左到右的执行的顺序

2.分支结构：if / if-else if-else if

// if 语句：主要是判断用
    // 语法
    if (表达式) { 
    代码块
    }
     // 执行过程：
     // 先判断表达式的结果是true还是false 如果是T则执行

三元表达式

运算符号：？ ：

语法：

Var 变量=表达式1?表达式2:表达式3；

执行过程：

表达式1的结果是true还是false,如果是true则执行表达式2，然后把结果给变量

如果表达式1的结果是false，则执行表达式3，把结果给变量

### while循环 ###

// 语法
    计数器
    var 变量=0
    while(循环的条件) { 
      循环体；
      计数器++；
    }
    do-while 循环
    do { 
      循环体
    }while(条件)；
    执行过程：
    先执行一次循环体，然后判断条件是否成立，不成立，则跳出循环，则执行循环体，然后再判断条件是否成立，成立则继续循环，否则跳出。。。。
    // 例子
    var i=0;
    do { 
      console.log("哈哈，我又边帅了")
      i++;
    }while(i<10);

### 总结循环 ###

while循环特点：先判断，后循环，有可能一次循环体都不执行

do-while循环特点：先循环，后判断，至少执行一次循环体

### for循环 ###

for(表达式1；表达式2；表达式3) \{

循环体；

执行过程：先执行一次表达式1，然后判断表达式2；如果不成立则直接跳出循环

如果表达式2成立，执行循环体的代码，结束后，跳到表达式3执行，然后跳到表达式2，判断表达式2是否成立，不成立，则直接跳出循环

如果表达式2成立，则执行循环体，然后在跳到表达式3，再跳到表达式2，判断是否成立，一直如此。

// 所有偶数的和
    var sum1=0;
    for (var i=1; i<=100;i++) { 
      if(i%2==0){ 
        sum1=sum1+i
      }
    }

### for循环案例-五角星 ###

// 控制五角星行数
    for(var i=0; i<5; i++){ 
      for(var j=0; j<5; j++){ 
        // 五角星的整体循环
    documenet.write("⭐️")；
    }
    documenet.write("<br/>")
    }

### for案例-九九乘法表 ###

for(var i=1; i<=9; i++){ 
      // 控制每一行有多少个表达式
      for(var j=1;j<=i;j++){ 
        document.write(i+"*"+j+"="+i*j);
      }
      document.write(<br/>)
      }
      // 表格版本
      document.write("<table border='1' cellpadding='0' cellspacing='0'>") ;
      for(var i=1; i<=9;i++){ 
        // 控制行数
        document.write("<tr>");
        for(var i=1;i<=9;i++){ 
          document.write("<td>")
          document.write(i+"*"+j+"="+i*j);
          document.write("</td>")
        }
        document.write("</tr>");
      }
      document.write("</table>");

### 调试代码 ###

调试代码—高级程序员都是从调试开始的

调试：写代码—打开浏览器—F12(开发人员工具)—》source—双击文件，在某一行代码前面点击一下(出现的东西就是断点）

## 第三部分 ##

### break、continue、数字、函数 ###

### break ###

如果再循环中使用，遇到了break,则立即跳出当前所在的循环

### continue ###

在循环中如果遇到continue关键字，直接开始下一次循环

### 数组 ###

一组数据，有序的数据

数组的作用：可以一次性存储多个数据

### 数组定义 ###

1.通过构造函数创建数组

语法：

var 数组名=new array( );

同过构造函数的方式定义一个数组

数组的名字如果直接输出，那么直接就可以把数组中的数据显示出来，如果没有数据，就看不到数据

var 数组名=new array();

如果数组中没有数据但是有长度那么直接就显示对应个数的undefined

构造函数的方式创建数组的时候，如果在Array(一个数组)——》表示的是数组的长度，

如果是在Array（多个值）中；这个数组中就有了数据了，数组的长度就是里面数据的个数

var arr=new array; 没有数组，空数组

2.通过字面连的方式创建数组

var 数组名=\[ \]；空数组

Var array= \[ \];

无论是构造函数的方式还是字面量的方式，定义的数组，如果有长度，那么默认就是undefind

数组：一组有序的数据

数组长度：数组中存储的每个数据，都可以叫数组的元素，比如：存储了三个数据，数组中3个元素

数组长度：就是数组的元素的个数，比如有3个元素，就说，这个数组的长度是3

数组索引(下标)：用 来存储或者访问数组中的数据的

数组的索引和数组的长度的关系，长度减一就是最大的索引值

如何设置数组中某个位置的值

数组名\[下标\]=值

arr\[3\]=100；

如何获取数组中某个位置的值

var result = 数组名\[下标\]；

Console.log(result);

### 数组注意的问题 ###

数组中存储的数据类型一定是一样的吗？

类型可以不一样

数组的长度是不是可以改变呢？

### 数组总结 ###

数组：存储一组有序的数据

数组的作用：一次性存储多个数据

数组的定义方式：

1.构造函数定义数组：var 数组名=new array();

2.字面量方式定义数组：var 数组名=\[\]

var 数组名=new array();空数组

var 数组名=new array(值)；数组定义了，有长度

var 数组名= new array(值1，值2，值3。。。)；定义数组并且有多个数据

var 数组名=\[ \]；空数组

var 数组名=\[值1，值2，值3\]；有三个数据

数组元素：就是数组中存储的数据

数组长度：就是数组中元素的个数

数组索引(下标)：从0开始，到数组的长度减1结束

通过下标设置数组的元素值：数组名\[索引\]=值

通过下标访问数组的元素值：数组名\[索引\]

var arr1=new Array();//空数组
    var arr2=new Array(5);// 长度为5的数组，每个数据的值是undefinedvar arr3=new Array(1,2,3,4,5);// 长度为5分数组,var arr4=[];//空数组
    var arr5=[1,2,3];// 长度为3的数组
    var arr6=[ "red" , "blue", "green" , 1, true];//数组中元素的值的类型可以不一样
    var arr7=[] ;
    //设置数组的元素arr7[0]=10;

### 数组案例求总成绩及平均值 ###

案例1:求数组中所有元素的和

var arr1=[10,20,30,40,50];
    var sum=0;
    for(var i=0; i<arr1.length;i++){ 
      sum+=arr[i];
    }
    console.log(sum);

案例2:求数组中所有元素的平均值

var arr2=[1,2,3,4,5];
    var sum2=0;
    for (var i=0;i<arr2.length;i++) { 
      sum2+=arr2[i];
    }
    console.log(sum2/arr2.length)；

案例3:求数组中所有元素中的最大值

var arr3=[1,3,2,5,10,100,50];
    // 假设max变量中存储的是最大值
    var max=arr3[0]
    for (var i=0;i<arr3.length;i++) { 
      // 判断这个变量的值和数组中每个元素的值是不是最大值
      if(max<arr3[i]) { 
        max=arr3[i];
      }
    }
    console.log("最大值:"+max);

案例4:求数组中所有元素的最小值

var arr4=[10,20,30,40,50];
    var min=arr4[0];// 假设min里存储的是最小值
    for (var i=0;i<arr4.length;i++){ 
      if(min>arr4.length){ 
        min=arr4[i]
      }
    }
    console.log("最小值："+min);

案例5:倒序循环遍历数组

var arr5=[10,20,30,40,50,100];
    // 正序
    for(var i=0; i<arr5.length;i++) { 
      console.log(arr5[i]);
    }
    // 倒序
     for(var i=arr5.length-1;i>=0;i--){ 
       console.log(arr5[i]);
     }

案例6:把数组中每个元素用拼接到一起产生-一个字符串并输出

var names=["名字1"，"名字2","名字3","名字4","名字5","名字6","名字7"]；
    var str=""; // 空的字符串
    for(var i=0; i<names.length-1;i++){ 
      str+=names[i]+"|";
    }
    console.log(str+names[names.length-1]);

案例7:去掉数组中重复的0

var arr = [10,0,20,0,30,0,50];
    var newarr=[];// 新数组，用来存放第一个数组中所有非零的数据；
    for(var i=0; i<arr.length;i++){ 
      if(arr[i]!=0){ 
        newarrp[newarr.length]=arr[i];
      }
    }
    // 把新数组的长度作为下标使用，数组的长度是可以改变的
    console.log(newarr);

案例8:反转数组—把数组中的数据的位置调换

var array=[10,20,30,40,50];
    // 循环的目底是控制交换的次数
    for(var i=0;i<array.length/2；i++){ 
      // 先把第一个元素的值放在第三方变量中
       var temp=array[i];
      array[i]=array[array.length-1-i];
      array[array.length-1-i]=temp; 
    }
    console.log(array);

案例9:提示用户输入班级人数，求总成绩，平均值，最高分,最低分

// 提示用户输入人数，并转成数字类型
    var percount = parseint(prompt("请输入班级人数"));
    // 定义数组存储班级的每个人的成绩
    var perscores=[];
    // 循环的方式录入每个人的成绩
    for(var i=0; i<percount;i++){ 
      // 把每个人的成绩存储到数组中
      perscores[perscores.length]=parseint(prompt("请输入第"+(i+1)+"个人的成绩："))；
    }
    console.log(perscores);
    // 求成绩综合
    var sum = 0;
    var avg = 0; // 平均值
    var max = perscores[0]; // 最大值
    var min = perscores[0]; // 最小值
    for (var i =0; i < perscores.length; i++) { 
      sum+=perscores[i]; // 求和
      // 求最大值
      if(max<perscores[i]){ 
        max=perscores[i];
      }
      // 求小值
      if(min>perscores[i]){ 
        min=perscores[i];
      }
    }
    // 求平均值 
    avg = sum / perscores.length;
    console.log("和为："+sum);
    console.log("平均值："+sum);
    console.log("最大值："+sum);
    console.log("最小值："+sum);

案例10:冒泡排序

// 把所有的数据，按照一定顺序进行排列(从小到大，从大到小)
     var arr=[10,0,100,20,60,30];
    // 循环控制比较的轮数
    for(var i=0;i<arr.length-1;i++){ 
     	// 控制每一轮的比较的次数
      for(var j=0;j<arr.length-1-i;j++){ 
        if(arr[j]>arr[j+1]){ 
          var temp=arr[j];
          arr[j]=arr[j+i];
          arr[j+1]=temp;
        }
      }
    }
    console.log(arr)

### 函数 ###

把一坨重复的代码封装，在需要的时候直接调用即可

### 作用 ###

代码的重复

### 函数的定义 ###

function 函数名字() { 
    函数体----一坨重复的代码
    }
    // 例子 函数的定义
    function cook() { 
      console.log("1111");
        console.log("1111")
        console.log("1111")
        console.log("1111")
        console.log("1111")
    }
    // 调用
    cook()

### 注意问题 ###

函数需要先定义，然后才能使用

函数名字：要遵循驼峰命名法

函数一旦重名，后面会把前面的覆盖

一个函数最好就是只有一个功能

### 函数参数 ###

在函数定义的时候，函数名字后面的小括号里面的变量就是参数，目的是函数在调用的时候，用户传进来的值操作

此时函数定义的时候后面的小括号里的变量的参数；写了两个变量，就有两个参数，

在函数调用的时候，按照提示的方式，给变量赋值——》就叫传值，把这个值就传到了变量中

### 实参 ###

函数在调用的时候小括号里传入的值叫实参

### 形参 ###

函数在定义的时候小括号里的变量叫形参

### 函数返回值 ###

Set：设置

get:获取

函数的返回值：在函数内部有return关键字，并且在关键字后面有内容，这个内容被返回了，当函数调用之后，需要这个返回值，那么就定义变量 接受，即可

函数定义：有参数有返回值的函数

如果一个函数中有return，那么这个函数就有返回值

如果没有那么这个函数就没有返回值

函数没有返回值，但是调用的时候接收了，那么结果就是undefined

变量声明了没有赋值也是undefined

如果一个函数中没有明确的返回值，结果调用的时候接收了那么结果还是undefined

有没有明确返回值的区别是，return后面有没有跟内容

return下面的代码是不会执行的

如果一个函数有参数，有参数的函数

如果没有那就是没有参数的函数

形参的个数可以和实参个数不一致

## 第四部分 ##

### 函数案例 ###

### 伪数组 ###

Arguments用于存储数组

### 函数的其他调用方法 ###

函数自调用，没有名字，调用—声明的同时直接调用

——一次性的

### 函数也是一种数据类型 ###

如何获取某个变量的类型？typeof

函数是有数据类型，数据类型：是function类型的

### 函数作为参数使用 ###

函数可以作为参数使用，如果一个函数作为参数，那么我们说这个参数(函数)可以叫回调函数

只要是看到一个函数作用参数使用了，那就是回调函数

### 函数作为返回值使用 ###

函数可以作为返回值使用的

### 作用域：使用范围 ###

块级作用域：

全局变量：声明的变量是使用var声明的，那么这个变量就是全局变量，全局变量可以在页面任何位置使用

除了函数以外，其他的任何位置定义的变量都是全局变量

局部变量：在函数内部定义的变量，是局部变量，外面不能使用。

全局变量，如果页面不关闭，那么就不会释放，就会占用空间，消耗内存

全局作用域：全局变量的使用范围

局部作用域：局部变量的使用范围

块级作用域：一对大括号就可以看成是一块，在这块区域中定义的变量，只能在这个区域中使用，但是在js中在这个块级作用域中定义的变量，外面也能使用；

说明：js没有块级作用域，只有函数除外

隐式全局变量:声明的变量没有var，就叫隐式全局变量

全局变量是不能被删除的，隐式全局变量是可以删除的

定义变量使用var是不会被删除的，没有var是可以删除的

### 作用域链 ###

自己需要的数据，在多层函数的最里面开始找，一直找到零级作用域位置。找到零级作用域的时候报错

### 预解析 ###

提前解析代码

含义：就是在解析代码之前

预解析做什么事？

把变量的声明提前了——提前到当前所在的作用域的最上面

函数的声明也会被提前—提前到当前所在作用域的最上面

预解析中变量的提升只会在当前的作用域中提升，提前到当前的作用域的最上面

函数中的变量只会提前到函数的作用域中的最前面，不会出去

预解析会分段(多对script标签中函数重名，预解析的时候不会冲突)

## 第五部分 ##

### 对象的编程思想 ###

把一些生活中做事的经验融入到程序中

### 面相过程 ###

凡事都要亲力亲为，每件事的具体过程都要知道，

### 面向对象 ###

根据需求找对象，所有的事都用对象来做，注重的是结果

### 面向对象特性 ###

封装，继承，多态(抽象性)

JS不是面向对象的语言，但是可以模拟面向对象的思想

JS是一门基于对象的语言：

一切万物皆对象：————》

js是一门什么样的语言？

是一门解释性的语言

是一门脚本语言

是一门弱类型的语言

是一门基于对象的语言

是一门动态类型的语言

### 什么是对象？ ###

看的见，摸得到了，具体特指的某个东西

### 找对象 ###

通过描述找对象

分析对象有什么特点：特征和行为

总结什么是对象

创建对象

### 对象 ###

有特征和行为，具体特指的某一个事物

有属性和方法，具体特指的某个事物

对象：js中就是一组无序的属性的集合

属性—特征

方法-----行为

### 创建对象的方式 ###

1.通过调用系统的构造函数创建对象 new object()

实例化对象

var 变量名 = new object( );

注：对象有特征—属性和行为—方法

添加属性——如何添加属性？对象名点名字等于值

obj.name=“aaaa”;

Obj.age=“111”,

添加方法—如何添加方法？对象.名字=函数

Obj.eat=function() \{

console.log(“aaaaaaaa”)

\};

Obj.play=function() \{

\};

2.自定义构造函数创建对象（结合第一种和需求通过工厂模式创建对象）

3.字面量的方式创建对象

### 如何获取该变量(对象)是不是属于什么类型 ###

语法：

变量 instanceof 类型的名字———》布尔类型，true就是这种类型，false不是这种类型

\#\#\#如何一次性创建多个对象？把创建的对象的代码封装在一个函数里

function create object (name,agr) { 
      var obj = object(); //创建对象
      // 添加属性
      obj.name = name ;
      obj.age = age;
      // 添加方法 
      obj.sayhi = function () { 
        console.log("aaaaaaaa,aa:"+this.name+"aaaaaa"+this.age)
      };
      return obj;
    }
    var per1 = create object("11",20);
    pre1.hayHI();
    // 创建一个人的对象
    var per2 = createobject("111"30);
    pre2.sayHI();

### 自定义构造函数创建对象 ###

自定义构造函数创建对象，我要自定义一个构造函数，自定义构造函数创建对象

函数和构造函数的区别就是名字是不是大写（首字母大写）

function Person(name,age) { 
      this.name=name;
      this.age=age;
      this.sayHi=function() { 
        console.log("我叫："+this.name+",年龄是："+this.age);
      };
    }
    // 自定义构造函数创建对象：先自定义一个构造函数，创建对象
    var obj=new Person("小明",10);
    console.log(boj.name);
    console.log(obj.age);
    obj.sayHI();

### 自定义构造函数创建对象做了四件事 ###

1.在内存中开辟（申请一块空闲的空间）空间，存贮创建新的对象

2.把this设置为当前的对象

3.设置对象的属性和方法

4.把this这个对象返回

### 创建对象流程图 ###

1.调用构造函数创建对象

Var obj=new object();

2.自定义构造函数创建对象

function Person(name,age) \{

This.name=name;

This.age=age;

this.sayHI=function() \{

Console.log(“您好我叫：”+this.name);

\};

创建对象—实例化一个对象，并初始化

Var per=new Person(“小明”，20)；

### 字面量的方式创建对象 ###

### 对象总结 ###

字面量创建对象的缺陷：

一次性的对象

var obj={ 
      name:"晨光",
      age:38,
      sex:"女"，
    }；
    obj.name="小三"
    console.log(obj.name);

### 点语法 ###

对象.名字=值；对象.名字=函数

js是一门什么样的语言?

是一门解释性的语言

是一门脚本语言

是一门弱类型语言，声明变量都用var

是一门基于对象的语言

是一门动态类型的语言：

1.代码（变量）只有执行到这个位置的时候，才知道这个变量中到底存储的是什么，如果是对象，就有对象的属性和方法，如果是变量就是变量的作用

2.对象没有什么，只要点了，同过点语法，那么就可以为对象添加属性或者方法。

### 设置和获取属性的另一种写法 ###

对象获取和设置对象可以采用\[ \]来代替，不过中括号中需要用双引号阔住

### JSON格式的数据遍历 ###

对象：有属性和方法，特指的某个事物的

对象：一组无序属性的集合的键值对

JSON格式的数据：一般都是成对的，是键值对

// json也是一个对象，数据都是成对的，一般json格式的数据无论是键值还是值都是用双引号括起来的
    var obj={ 
      name:"小明"
    }
    var json={ 
      "name":"小明"，
      "age"="10",
      "sex"="男"
    }
    // key是一个变量，这个变量是存储的是该对象的所有的属性的名字
    for(var key in json){ 
      console.log(key); // json对象中的属性名字
      console.log(key+"--------"+json[key])
    }

### 遍历对象，是不能通过for循环遍历的/可以通过for-in循环 ###

### 简单类型和复杂类型 ###

原始数据类型：number,string,boolean,undefined,null,object

基本类型(简单类型)，值类型:number,string,boolean

复杂类型(引用类型):object

空类型:undefined,unll

值类型的值在哪一块空间中存储？栈中存储

引用类型的值在哪一块空间中存储？对象在堆上存储，地址在栈上存储

var num=10; // 值类型、简单类型 存储在栈里
    var obj={ }; // 复杂类型，对象在堆上，地址在栈里
    var num2=num;
    //

### JS学习中三种对象： ###

1.内置对象—js系统自带的对象

2.自定义对象—自己定义的对象

3.浏览器对象

### math对象 ###

实例对象：通过构造函数创建出来，实例化方法

静态对象：不需要创建，直接就是一个对象，方法（静态方法）直接通过这个对象名字调用

实例方法必须通过实例对象调用

静态方法必须通过大写的对象调用

## 第六部分 ##

### 内置对象-Date ###

系统自带的函数

参考MDN文档

格式化后的指定格式的日期和时间—封装一个函数

function getdate(dt) { 
      // 获取年
      var year = dt.getfullyear();
      // 获取月
      var month = dt.getmonth() + 1;
      // 获取日
      var day = dt.getdate();
      // 获取小时
      var hour = dt.gethours;
      // 获取分钟
      var minute = dt.getminutes();
      // 获取秒
      var second = dt.getseconds();
      moth = month < 10 ? "0" + month : month;
        day = day < 10 ? "0" + day : day;
        hour = hour < 10 ? "0" + hour : hour;
        minute = minute < 10 ? "0" + minute : minute;
       second = second < 10 ? "0" + second : second;
      return year + "年" + month + "月" + day +"日" + your + ":" + minute + ":" + second;
    }
    console.log(getdate(new date()));

### string对象 ###

js中无论是单引号还是双引号的都是字符串

一些有特殊功能的字符可以通过转义字符的形式放入字符串中

var str = 'hello'; // 可以看成是一个字符数组

String—— 》是一个对象

字符串可以看成是字符组成的数组，但是JS中没有字符类型

字符是一个一个的，在别的语言中字符中一对单引号括起来的

在js中字符串可以使用单引号也可以使用双引号

因为字符串可以看成是数组，所以，可以通过for循环进行遍历

### 字符串的特性 ###

不可变性，字符串的值是不能改变

字符串的值看起来是改变的，那只是指向改变了不是值改变了

不可以同过索引改变字符串的值，但可以重新赋值

var str="hello";
    str[1]="W"; // 字符串可以通过索引访问字符串中的某个值，但是，是可以访问--读取--只读

### string对象下的方法 ###

### 字符串的常用属性 ###

.langth————>字符串的长度

.charat(索引)，返回值是指定索引位置的字符串，超出索引就是空字符串

.froncharcode(数字值，可以是多个参数)，会返回数值对应的ASKMII值

.concat(字符串1，字符串2，……)；返回的是新的字符串

.indexof(要找的字符串，从某个位置开始的索引)；返回的是这个字符串的索引的值，否则返回-1

.lastindexof(要找的字符串)，从后向前找，但是索引依然是从左往右，没有找到返回-1

.replace（“原来的字符串”，“新的字符串”）用来替换字符串

.slice(开始的索引，结束的索引)；从所以开始提取到结束前，提出出来，并且返回

.split（“要干掉的字符串”，切割后留下的个数）；切割字符串

.substr(开始的位置，截取的个数)；返回的是截取后的字符串

.substring(开始的索引，结束的索引)，返回截取后的字符串，不包含结束索引的字符串

.tolocalelowercase() 转小写

.tolocaleuppercase() 转大写

.trim() 切掉字符串两端的空格

### 实例方法——》必须要通过new的方式创建的对象（实例对象）来调用方法 ###

### 静态方法——》直接通过大写的构造函数的名字调用的方法 ###

### 字符串案例 ###

var str="我爱吃炸鸡"；
    var key="炸鸡"；
    // 先获取要截取的字符串的索引的位置
    var index=str.indexof(key);
    // 从指定的位置开始截取，截取两个即可
    str=str.substr(index,2);
    console.log(str);

var str2="hello wod odd ott fbo nhyo"
    var index=0; // 开始的位置
    var key="o"; //要找的字符串
    while((index=str2.indexof("key",index))!=-1) { 
          // 如果是-1的情况，说明找完了
      console.log(index);
      index+=key.length;
          }

// 案例：这个这个字符串中每个字符串出现了多少次
    var str3="asdasfasfhgsgnsdfh";
    // 第一步：把所有的字母全部变成小写
    str3=str3.tolocalelowercase();
    // 第二部:创建一个空对象，目的：把字母作为键，次数作为值
    var obj={ };
    // 第三部，遍历字符串，获取每个字母
    for(var i=0;i<str3.length;i++) { 
      // 判断obj这个对象中有没有这个字母(字母---键)
      var key = str3[i]; //每个字母
      if(obj[key]){  // 判断obj中有没有这个键
        // 对象中有这个字母了
        obj[key]++;
      }else { 
        对象中没有这个字母，那就把字母加到对象中，并且给这个字母一个出现的次数，默认一次
        obj[key] = 1;
      }
    }
    // 遍历对象,显示每个字母的次数
    for(var key in obj){ 
      console.log(key+"这个字母出现了"+obj[key]+"次");
    }

### Array对象 ###

Array.isArray(对象)———>判断这个对象是不是数组

Instanceof 关键字 同上

.concat(数组，数组，数组,…)组合新的数组

.every(函数)—返回值是布尔类型，函数作为参数使用，有三个参数，第一个是元素的值，第二个参数是索引，第三个是原来的数组（没有用）；

.filter(函数);返回的是数组中每一个元素都符合条件的新数组

.push(值)；———》把值追加到数组中，加到最后

.pop；删除数组中最后一个数

.shift;删除数组中第一个数

.unshift;向数组的第一个元素前面插入一个新的元素；返回值是数组的长度

.forEaach();—遍历数组用—相当于for

.join(“字符串”);—返回的是字符串