JavaScript基础入门笔记（总结）

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("
")
}

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("");for(var i=1; i<=9;i++){// 控制行数
    document.write("");for(var i=1;i<=9;i++){
      document.write("")}
    document.write("");}
  document.write("
 
  
    

    
")
      document.write(i+"*"+j+"="+i*j);
      document.write("
    
  
");

调试代码

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

调试：写代码—打开浏览器—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下面的代码是不会执行的

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

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

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

第四部分

函数案例

function gearraymaxandminandsum(arrat) {
  var min=array[0];// 最小值
  var max=array[0];// 最大值
  var sum=0; // 和
  for(var i=0;i<array.length;i++;){
    sum +=array[i]; //和
    // 最大值
    if (max<array[i]) {
      max = array[i];
    } // end if
    // 最小值
    if(min>array[i]){
      min = array[i];
    }// end if
  } // end for
  var arr = [sum,min,max];
  return arr;
}

伪数组

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={}; //空对象
// 添加属性
obj.name="小白";
obj.age=10;
// 添加方法
obj.sayHi=function() {
  console.log("我是："+this.name)；
}；
obj.sayHi();
// 写法优化
var obj2={
  name:"小明"，
  age:20，
  sayHi:function(){
    console.log("woshi:"+obj2.name)
  }，
  eat:function() {
    console.log("吃了")
  }
}；

对象总结

字面量创建对象的缺陷：

一次性的对象

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(“字符串”);—返回的是字符串

.map(函数)；——》数组中的每个元素都要执行这个函数，把执行后的结果都返回到一个新的数组中

.reverse();———>反转数组

.sort();———>排序的，可能不稳定，如果不稳定，请写MDN中的固定方法

.slice(开始的索引，结束的索引)；把截取的数组的值放到一个新的数组中，但是不包含结束的索引。

.splice(开始的位置，要删除的个数，替换的元素的值)；一般是用于删除数组中的元素或者替换

// 如何判断变量是否为数组类型：两种
// 1. instanceof
var obj=[];
console.log(obj instanceof Array);
//	2.使用数组的
console.log(Array.isArray(obj));

.sort稳定的固定写法

var arr=[1,40,20,10,100];
a--arr[j];
b--arr[j+1];
arr.sort(function (a,b){
  if(a>b){
    return 1;
  }else if (a==b){
    return 0 ;
  }else{
    return -1
  }
});
console.log(arr);

基本包装类型

普通变量不能直接调用属性或者方法

对象可以直接调用属性和方法

基本包装类型：本身是基本类型，但是在执行代码的过程中，如果这种类型的变量调用的了属性或者是方法，那么这种类型就不再是基本类型了，而是基本包装类型，这个变量也不是普通的变量了，而是基本包装类型对象

如果是一个对象&&true，那么结果是true

如果是一个true&&对象，那么结果是对象