发表更新学习笔记43 分钟读完 (大约6410个字)0次访问

JS 基础总结

基础总结

初始JavaScript

  • JavaScript 是一种运行在客户端的脚本语言

  • 脚本语言：不需要编译，运行过程中由 js 解释器( js 引擎）逐行来进行解释并执行

  • 现在也可以基于 Node.js 技术进行服务器端编程

浏览器执行JS简介

浏览器分成两部分：渲染引擎和 JS 引擎

  • 渲染引擎：用来解析HTML与CSS，俗称内核，比如 chrome 浏览器的 blink ，老版本的 webkit
  • JS 引擎：也称为 JS 解释器。 用来读取网页中的JavaScript代码，对其处理后运行，比如 chrome 浏览器的 V8

JS 引擎执行代码时逐行解释每一句源码（转换为机器语言），然后由计算机去执行

JS的组成

JavaScript 包括 ECMAScript、DOM、BOM

在这里插入图片描述

ECMAScript

ECMAScript 规定了JS的编程语法和基础核心知识，是所有浏览器厂商共同遵守的一套JS语法工业标准。

DOM文档对象模型

文档对象模型（Document Object Model，简称DOM），是W3C组织推荐的处理可扩展标记语言的标准编程接口。通过 DOM 提供的接口可以对页面上的各种元素进行操作（大小、位置、颜色等）。

BOM浏览器对象模型

浏览器对象模型（Browser Object Model，简称BOM），提供了独立于内容的、可以与浏览器窗口进行互动的对象结构。通过BOM可以操作浏览器窗口，比如弹出框、控制浏览器跳转、获取分辨率等。

JS初体验

JS引入方式

  • 行内式
1
<input type="button" value="" onclink="javascript:alert('Hello World')" />
  1. 可以将单行或少量JS代码写在HTML标签的事件属性中(以on开头的属性)，如： onclink
  2. 注意单双引号的使用：在HTML中我们推荐使用双引号，JS中我们推荐使用单引号
  • 内嵌式JS
1
2
3
<script>
     alert('Hello World!');
</script>
  1. 可以将多行JS代码写到<script>标签中
  2. 内嵌 JS 是学习时常用的方式
  • 外部JS
1
<script src="my.js"></script>
  1. 引用外部JS文件的script标签中间不可以写代码

基本语法

注释

  • 单行注释
1
//  单行注释
  • 多行注释
1
2
3
/*
	多行注释
*/

输入输出语句

方法 说明 归属
alert(msg); 浏览器弹出警示框 浏览器
console.log(msg); 浏览器控制台打印信息（主要给程序员看） 浏览器
prompt(info); 浏览看弹出输入框，用户可以输入 浏览器

变量

初始化

  1. var是一个JS关键字，用来声明变量(variable变量的意思)。使用该关键字声明变量后，计算机会自动为变量分配内存空间。
  2. age 是程序员定义的变量名，我们要通过变量名来访问内存中分配的空间
1
2
3
4
//声明变量同时赋值为18
var age = 18; 
//同时声明多个变量时，只需要写一个 var， 多个变量名之间使用英文逗号隔开。
var age = 18, address ='火影村',salary = 15000;

特殊情况

情况 说明 结果
var age; console.log(age); 只声明，不赋值 undefined
console.log(age) 不声明 不赋值 直接使用 报错
age = 10;console.log(age); 不声明 只赋值 10

命名规范

数据类型

JavaScript 是一种弱类型或者说动态语言。这意味着不用提前声明变量的类型，在程序运行过程中，类型会被自动确定。

  • 在代码运行时，变量的数据类型是由 JS引擎 根据 = 右边变量值的数据类型来判断 的，运行完毕之后， 变量就确定了数据类型。
  • JavaScript 拥有动态类型，同时也意味着相同的变量可用作不同的类型
1
2
var x = 6;		//x为数字
var x = "Bill";	//x为字符串

基本数据类型

简单数据类型 说明 默认值
Number 数字型，包含整型值和浮点型值，如21，0.21 0
Boolean 布尔值类型，如true，false ，等价于1和0 false
Undefined var a; 声明了变量a但是没有赋值，此时a=undefined undefined（未定义的）
string 字符串类型，如“张三” “”
Null var a = null; 声明了变量a为空值 null

数字型Number

1
2
var age = 12;		//整数
var Age = 21.3747;	//小数
  • 在JS中八进制前面加0，十六进制前面加 0x

  • 数字型范围

    • 最大值：Number.MAX_VALUE
    • 最小值：Number.MIN_VALUE

  • 三个特殊值

    • Infinity：无穷大
    • -Infinity：无穷小
    • NaN：Not a Number ,代表任何一个非数值

  • isNaN()：方法用来判断非数字，并且返回一个值，如果是数字返回的是false，如果不是数字返回的是true

1
2
3
4
5
6
var userAge = 21;
var isOk = isNan(userAge);
console.log(isOk);		//false,21不是一个非数字

var userName = "andy";
console.log(isNan(userName));	//true,"andy"是一个非数字

字符串型string

1
2
var strMsg = "我爱北京天安门";		//使用双引号表示字符串
var strMsg = '我爱北京';			//使用单引号表示字符串
  • 字符串引号嵌套
1
2
var strMsg ='我是一个"高富帅"' //可以用 ' ' 包含 " "
var strMsg2 ="我是'高富帅'" //可以用" "  包含  ''

  • 字符串转义符

  • 字符串长度：通过length属性获取

1
2
var strMsg = "我是高富帅！";
alert(strMsg.length);     //显示6
  • 字符串拼接
    • 多个字符串之间可以使用 + 进行拼接，其拼接方式为 字符串 + 任何类型 = 拼接之后的新字符串
    • 拼接前会把与字符串相加的任何类型转成字符串，再拼接成一个新的字符串

布尔型Boolean

  • 布尔型和数字型相加的时候， true 的值为 1 ，false 的值为 0。
1
2
var flag = true;
console.log(flag + 1); // 2 true当加法来看当1来看，flase当0来看

未定义undefined

  • 一个声明后没有被赋值的变量会有一个默认值 undefined ( 如果进行相连或者相加时，注意结果
1
2
3
4
5
6
// 如果一个变量声明未赋值，就是undefined 未定义数据类型
var str;
console.log(str);				//undefined
var variable = undefined;
console.log(variable + 'Pink'); //undefinedPink   undefined 和 字符串 相加，会拼接字符串
console.log(variable + 18); //NaN   undefined 和 数字相加，最后结果是NaN

空值

  • 一个声明变量给 null 值，里面存的值为空
1
2
3
var space = null;
console.log(space + 'pink'); //nullpink
console.llog(space + 1); // 1

typeof

  • typeof 可用来获取检测变量的数据类型, 空值结果为object

数据类型转换

使用表单、prompt 获取过来的数据默认是字符串类型的，此时就不能直接简单的进行加法运算，而需要转换变量的数据类型。

转换为字符串型

方式 说明 案例
toString() 转成字符串 var num = 1; alert(num.toString());
String()强制转换 转成字符串 var num = 1; alert(String(num));
加号拼接字符串 和字符串拼接的结果都是字符串 var num =1; alert(num+“我是字符串”);

转换为数字型

方式 说明 案例
parselnt(string)函数 将string类型转成整数数值型 parselnt(‘78’)
parseFloat(string)函数 将string类型转成浮点数数值型 parseFloat(‘78.21’)
Number()强制转换函数 将string类型转换为数值型 Number(‘12’)
js 隐式转换**( - * / ) ** 利用算术运算隐式转换为数值型 ‘12’-0

转换为布尔型

方法 说明 案例
Boolean()函数 其他类型转成布尔值 Boolean(‘true’);
  • 代表空，否定的值会被转换为false，如 ’ ’ , 0, NaN , null , undefined
  • 其余的值都会被被转换为true

运算符

运算符（operator）也被称为操作符，是用于实现赋值、比较和执行算数运算等功能的符号

算数运算符

1
+ - * / %
  • 浮点数精度问题： 浮点数值的最高精度是17位小数，但在进行算数计算时其精确度远远不如整数
1
2
var result = 0.1 +0.2;     //结果不是0.3，0.30000000000000004
console.log(0.07 * 100);   //结果不是7，而是7.000000000000001

递增和递减运算符

比较运算符

运算符名称 说明 案例 结果
< 小于号 1 < 2 true
> 大于号 1 > 2 false
>= 大于等于号(大于或者等于) 2 >= 2 true
<= 小于等于号(小于或者等于) 3 <= 2 false
== 判等号(会隐式转型) 37 == 37 true
!= 不等号 37 != 37 false
=== 全等 要求值和数据类型都一致 37 === ‘37’ false

逻辑运算符

&& || ！

赋值运算符

= += -= *= /= %=

流程控制

分支，循环

数组

创建数组

  • 利用new创建数组
1
var arr = new Array(); //创建一个新的空数组
  • 数组字面量创建
1
2
3
4
5
6
// 1.利用数组字面量方式创建空的数组 
var 数组名 = [];
// 2.使用数组字面量方式创建带初始值的数组
var 数组名 = ['小白','小黑','小黄','瑞奇'];
// 3.数组中可以存放任意类型的数据，例如字符串，数字，布尔值等
var arrStus = ['小白', 12, true, 28.9];

数组索引（下标）

遍历数组

for循环

数组长度

1
2
var arrStus = [1,2,3];
alert(arrStus.length);  // 3

数组中新增元素

  • 通过修改length长度新增数组元素

    • 可以通过修改 length 长度来实现数组扩容的目的
    1
    2
    3
    4
    5
    6
    var arr = ['red', 'green', 'blue', 'pink'];
    arr.length = 7;
    console.log(arr);
    console.log(arr[4]);
    console.log(arr[5]);
    console.log(arr[6]);  //其中索引号是 4，5，6 的空间没有给值，就是声明变量未给值，默认值就是 undefined
    • length 属性是可读写的

  • 通过修改数组索引新增数组元素

    • 可以通过修改数组索引的方式追加数组元素
    1
    2
    3
    var arr = ['red', 'green', 'blue', 'pink'];
    arr[4] = 'hotpink';
    console.log(arr);

函数

函数声明

  • 利用函数关键字function自定义函数
1
2
3
4
5
6
//声明函数
function fn(){
     //函数体代码
}
// 调用 可以写在函数声明前面
fn();
  • 函数表达式声明
1
2
3
4
// 这是函数表达式写法，匿名函数后面跟分号结束
var fn = function(){...};
// 调用的方式，函数调用必须写到函数体下面
fn();

调用函数

1
2
//调用函数
函数名(); //通过调用函数名来执行函数体代码

函数的参数

1
2
3
4
5
6
7
8
// 声明函数
function getSum(num1,num2){
    console.log(num1+num2)
}

// 调用函数
getSum(1,3) //4
getSum(6，5) //11
  • 形参和实参个数不匹配
参数个数 说明
实参个数等于形参个数 输出正确结果
实参个数多于形参个数 只取到形参的个数
实参个数小于形参个数 多的形参定义为undefined，结果为NaN 
1
2
3
4
5
6
7
8
9
function sum(num1, num2) {
    console.log(num1 + num2);
}
sum(100, 200);             // 300，形参和实参个数相等，输出正确结果

sum(100, 400, 500, 700);   // 500，实参个数多于形参，只取到形参的个数

sum(200);                  // 实参个数少于形参，多的形参定义为undefined，结果为NaN

函数的返回值

  • 如果函数没有return，返回的值是undefined

  • 函数只能返回一个值，如果用逗号隔开多个值，以最后一个为准

arguments的使用

当我们不确定有多少个参数传递的时候，可以用 arguments 来获取。在 JavaScript 中，arguments 实际上它是当前函数的一个内置对象。所有函数都内置了一个 arguments 对象，arguments 对象中存储了传递的所有实参。

  • arguments展示形式是一个伪数组，因此可以进行遍历
    • 具有length属性
    • 可以按索引存储数据
    • 不具有数组的push，pop等方法

作用域

JavaScript (ES6前) 中的作用域有两种：

  • 全局作用域
  • 局部作用域(函数作用域)

全局作用域

作用于所有代码执行的环境(整个 script 标签内部)或者一个独立的 js 文件

局部（函数）作用域

作用于函数内的代码环境，就是局部作用域。 因为跟函数有关系，所以也称为函数作用域

  • JS没有块级作用域(在ES6之前)
1
2
3
4
5
if(true){
    int num = 123;
    System.out.println(num);	// 123
}
System.out.println(num);		// 123

变量的作用域

在JavaScript中，根据作用域的不同，变量可以分为两种：全局变量和局部变量

全局变量

在全局作用域下声明的变量叫做全局变量(在函数外部定义的变量）

  • 全局变量在代码的任何位置都可以使用
  • 在全局作用域下 var 声明的变量 是全局变量
  • 特殊情况下，在函数内不使用 var 声明的变量也是全局变量

局部变量

  • 局部变量只能在该函数内部使用
  • 在函数内部 var 声明的变量是局部变量
  • 函数的形参实际上就是局部变量

作用域链

1
2
3
4
5
6
7
8
9
10
11
// 作用域链: 内部函数访问外部函数的变量，采取的是链式查找的方式来决定取哪个值，这种结构我们称为作用域链表

var num = 10;
funtion fn() { //外部函数
    var num = 20;
    
    function fun() { //内部函数
        console.log(num);  // 20 ,一级一级访问
    }
}
//作用域链：采取就近原则的方式来查找变量最终的值。

预解析

JavaScript 代码是由浏览器中的 JavaScript 解析器来执行的。JavaScript 解析器在运行 JavaScript 代码的时候分为两步：预解析和代码执行

  • 预解析：js引擎会把js里面所有的 var 还有 function 提升到当前作用域的最前面
  • 代码执行：从上到下执行JS语句

变量预解析

变量预解析也叫做变量提升

变量提升: 变量的声明会被提升到当前作用域的最上面，变量的赋值不会提升

1
2
3
4
5
6
7
8
console.log(num);  // 结果是多少？
var num = 10;   
// undefined

//相当于执行了以下代码
var num;		// 变量声明提升到当前作用域最上面
console.log(num);
num = 10;		// 变量的赋值不会提升

函数预解析

函数预解析也叫做函数提升

函数提升： 函数的声明会被提升到当前作用域的最上面，但是不会调用函数

  • 匿名函数(函数表达式方式): 函数调用必须写在函数声明的下面
1
2
3
4
5
6
7
8
9
10
11
12
// 匿名函数(函数表达式方式):若我们把函数调用放在函数声明上面
fn();
var  fn = function() {
    console.log('22'); // 报错
}

//相当于执行了以下代码
var fn;
fn();      //fn没赋值，没这个，报错
var  fn = function() {
    console.log('22'); //报错
}

对象

在 JavaScript 中，对象是一组无序的相关属性和方法的集合，所有的事物都是对象，例如字符串、数值、数组、函数等

创建对象

利用字面量创建对象

对象字面量：就是花括号 { } 里面包含了表达这个具体事物（对象）的属性和方法

{ } 里面采取键值对的形式表示

1
2
3
4
5
6
7
8
9
10
var star = {
    name : 'pink',
    age : 18,
    sex : '男',
    sayHi : function(){
        alert('大家好啊~');
    }
};
// 多个属性或者方法中间用逗号隔开
// 方法冒号后面跟的是一个匿名函数
  • 对象调用
    • 属性调用：1.对象.属性名 2.对象[‘属性名’]
    • 函数调用：对象.方法名()
1
2
3
console.log(star.name)     // 调用名字属性
console.log(star['name'])  // 调用名字属性
star.sayHi();              // 调用 sayHi 方法,注意，一定不要忘记带后面的括号

利用new Object创建对象

创建方式：var 对象名 = new Object();

使用格式：对象.属性 = 值

1
2
3
4
5
6
7
8
9
10
11
var obj = new Object(); //创建了一个空的对象
obj.name = '张三丰';
obj.age = 18;
obj.sex = '男';
obj.sayHi = function() {
    console.log('hi~');
}

console.log(obj.name);
console.log(obj['sex']);
obj.sayHi();

利用构造函数创建对象

构造函数 ：是一种特殊的函数，主要用来初始化对象，即为对象成员变量赋初始值，它总与 new 运算符一起使用。

1
2
3
4
5
6
7
//构造函数的语法格式
function 构造函数名() {
    this.属性 = 值;
    this.方法 = function() {}
}
new 构造函数名();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//1. 构造函数名字首字母要大写
//2. 构造函数不需要return就可以返回结果
//3. 调用构造函数必须使用 new
//4. 我们只要new Star() 调用函数就创建了一个对象
//5. 我们的属性和方法前面必须加this
function Star(uname,age,sex) {
    this.name = uname;
    this.age = age;
    this.sex = sex;
    this.sing = function(sang){
        console.log(sang);
    }
}
var ldh = new Star('刘德华',18,'男');
console.log(typeof ldh) // object对象，调用函数返回的是对象

console.log(ldh.name);
console.log(ldh['sex']);
ldh.sing('冰雨');
//把冰雨传给了sang

var zxy = new Star('张学友',19,'男');

  • 构造函数名字首字母要大写
  • 函数内的属性和方法前面需要添加 this ，表示当前对象的属性和方法。
  • 构造函数中不需要 return 返回结果。
  • 当我们创建对象的时候，必须用 new 来调用构造函数。

遍历对象的属性

  • for...in 语句用于对数组或者对象的属性进行循环操作
1
2
3
4
5
for(var k in obj) {
    console.log(k);		//这里的 k 是属性名
    console.log(obj[k]);//这里的 obj[k] 是属性值
}

内置对象

  • JavaScript 中的对象分为3种：自定义对象 、内置对象、 浏览器对象
  • JavaScript 提供了多个内置对象：Math、 Date 、Array、String等

Math对象

Math 对象不是构造函数，它具有数学常数和函数的属性和方法。跟数学相关的运算（求绝对值，取整、最大值等）可以使用 Math 中的成员。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Math.PI		 			// 圆周率
Math.floor() 	 		// 向下取整
Math.ceil()             // 向上取整
Math.round()            // 四舍五入版 就近取整   注意 -3.5   结果是  -3 
Math.abs()		 		// 绝对值
Math.max()/Math.min()	// 求最大和最小值 
Math.random()			// 随机返回一个小数，取值为[0，1),

console.log(Math.PI);  
console.log(Math.max(1,99,3)); // 99

// 得到两个数之间的随机整数，并且包含这两个整数
function getRandom(min,max) {
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(getRandom(1,10));

Date()日期对象

  • Date 对象和 Math 对象不一样，他是一个构造函数，所以我们需要实例化后才能使用
  • Date 实例用来处理日期和时间

Date()方法的使用

1
2
3
4
5
6
7
8
9
10
var now = new Date();  //首先要实例化，没有参数则返回当前系统的时间
console.log(now);

// 2.参数常用的写法 数字型 2019,10,1  字符串型 '2019-10-1 8:8:8' 时分秒
// 如果Date()里面写参数，就返回括号里面输入的时间 
var data = new Date(2019,10,1);
console.log(data);  // 返回的是11月不是10月

var data2 = new Date('2019-10-1 8:8:8');
console.log(data2);

日期格式化

方法名 说明
getFullYear() 获取当年
getMonth() 获取当月**(0-11)**
getDate() 获取当天日期
getDay() 获取星期几**(周日0到周六6)**
getHours() 获取当前小时
getMinutes() 获取当前小时
getSeconds() 获取当前秒钟
valueOf() 得到现在时间距离1970.1.1总的毫秒数
getTime() 得到现在时间距离1970.1.1总的毫秒数

获取日期总的毫秒形式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 获取Date总的毫秒数 不是当前时间的毫秒数 而是距离1970年1月1号过了多少毫秒数

// 实例化Date对象
var date = new Date();

// 1 .通过 valueOf()  getTime() 用于获取对象的原始值
console.log(date.valueOf());  //得到现在时间距离1970.1.1总的毫秒数
console.log(date.getTime());

// 2.简单的写法
var date1 = +new Date();  // +new Date()返回的就是总的毫秒数，
console.log(date1);

// 3. HTML5中提供的方法 获得总的毫秒数 有兼容性问题
console.log(Date.now());

倒计时效果

在这里插入图片描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function() countDown(time){
    var nowTime = +new Date();                //没有参数，返回的是当前时间总的毫秒数
    var inputTime = +new Date(time);          // 有参数，返回的是用户输入时间的总毫秒数
    var times = (inputTime - nowTime) / 1000      //剩余时间的总的秒数
    
    var d = parseInt(times / 60 / 60 / 24);   //天数
    d < 10 ? '0' + d : d;
    var h = parseInt(times / 60 / 60 % 24); //小时
    h < 10 ? '0' + h : h;
    var m = parseInt(times / 60 % 60); //分
    m < 10 ? '0' + m : m;
    var s = parseInt(times % 60); //秒
    s < 10 ? '0' + s : s;
    return d + '天' + h + '时' + m + '分' + s + '秒';
}

数组对象

创建方式

1
2
var arr1 = [1, 2, 3];        //1.字面量方式
var arr2 = new Array(2, 3);  //2.new Array()

检测是否为数组

  • instanceof 运算符，可以判断一个对象是否属于某种类型
  • Array.isArray() 用于判断一个对象是否为数组，isArray() 是 HTML5 中提供的方法
1
2
3
4
5
6
var arr = [1, 23];
var obj = {};
console.log(arr instanceof Array); // true
console.log(obj instanceof Array); // false
console.log(Array.isArray(arr));   // true
console.log(Array.isArray(obj));   // false

添加删除数组元素

方法名 说明 返回值
push(参数1…) 末尾添加一个或多个元素，会修改原数组 并返回新的长度
pop() 删除数组最后一个元素 返回它删除的元素的值
unshift(参数1…) 向数组的开头添加一个或更多元素，注意修改原数组 并返回新的长度
shift() 删除数组的第一个元素，数组长度减1，无参数，修改原数组 并返回第一个元素

数组排序

方法名 说明 是否修改原数组
reverse() 颠倒数组中元素的顺序，无参数 该方法会改变原来的数组，返回新数组
sort() 对数组的元素进行排序 该方法会改变原来的数组，返回新数组 
1
2
3
4
5
6
7
var arr = [1,64,9,61];
arr.sort(
    function(a,b) {
     return b - a;  //降序的排列
     return a - b;  //升序
 	}
)

查找元素索引

方法名 说明 返回值
indexOf() 数组中查找给定元素的第一个索引 如果存在返回索引号，如果不存在，则返回-1
lastIndexOf() 在数组的最后一个索引，从后向前索引 如果存在返回索引号，如果不存在，则返回-1

数组转换为字符串

方法名 说明 返回值
toString() 把数组转换成字符串，逗号分隔每一项 返回一个字符串
join(‘分隔符’) 方法用于把数组中的所有元素转换为一个字符串 返回一个字符串 
1
2
3
4
5
6
7
8
// 1.toString() 将我们的数组转换为字符串
var arr = [1, 2, 3];
console.log(arr.toString()); // 1,2,3
// 2.join('分隔符')
var arr1 = ['green', 'blue', 'red'];
console.log(arr1.join()); // 不写默认用逗号分割
console.log(arr1.join('-')); //  green-blue-red
console.log(arr1.join('&')); // green&blue&red

其他方法

方法名 说明 返回值
concat() 连接两个或多个数组 不影响原数组 返回一个新的数组
slice() 数组截取slice(begin,end) 返回被截取项目的新数组
splice() 数组删除splice(第几个开始要删除的个数) 返回被删除项目的新数组，这个会影响原数组

字符串对象

基本包装类型

为了方便操作基本数据类型，JavaScript 还提供了三个特殊的引用类型：String、Number和 Boolean。

1
2
var str = 'andy';
console.log(str.length);

按道理基本数据类型是没有属性和方法的，而对象才有属性和方法，但上面代码却可以执行，这是因为 js 会把基本数据类型包装为复杂数据类型，其执行过程如下 ：

1
2
3
4
5
6
// 1.生成临时变量,把简单类型包装为复杂数据类型
var temp = new String('andy');
// 2.赋值给我们声明的字符变量
str = temp;
// 3.销毁临时变量
temp = null;
  • 字符串不可变：指的是里面的值不可变，虽然看上去可以改变内容，但其实是地址变了，内存中新开辟了一个内存空间。

返回字符索引

字符串所有的方法，都不会修改字符串本身(字符串是不可变的)，操作完成会返回一个新的字符串

方法名 说明
indexOf(‘要查找的字符’，开始的位置) 返回指定内容在元字符串中的位置，如果找不到就返回-1，开始的位置是index索引号
lastIndexOf() 从后往前找，只找第一个匹配的

返回索引字符

charAt(index) 返回指定位置的字符(index字符串的索引号) str.charAt(0)
charCodeAt(index) 获取指定位置处字符的ASCII码(index索引号) str.charCodeAt(0)
str[index] 获取指定位置处字符 HTML,IE8+支持和charAt()等效

字符串操作方法

方法名 说明
concat(str1,str2,str3…) concat() 方法用于连接两个或对各字符串。拼接字符串
substr(start,length) 从 start 位置开始(索引号), length 取的个数。
slice(start,end) 从 start 位置开始，截取到 end 位置 ，end 取不到 (两个都是索引号)
substring(start,end) 从 start 位置开始，截取到 end 位置 ，end 取不到 (基本和 slice 相同，但是不接受负)

其他方法

方法名 说明
replace(‘a’, ‘b’) 用于在字符串中用一些字符替换另一些字符
split() 用于切分字符串，它可以将字符串切分为数组。在切分完毕之后，返回的是一个新数组
toUpperCase() 转换大写
toLowerCase() 转换小写 
1
2
3
var str = 'a,b,c,d';
console.log(str.split(','));
// 返回的是一个数组 ['a', 'b', 'c', 'd']
#
关注我

最新文章

分类

标签

AI算法2
C++2
CSS1
C语言2
JavaScript5
Typescript1
axios1
vue33
二分2
刷题2
前端9
双指针3
数组2
笔记5
算法4
链表1
项目4

链接

×