string 对象内置方法
| 方法 | 说明 |
|---|---|
| charAt(index) | 返回在指定位置的字符 |
| concat() | 连接两个或更多字符串，并返回新的字符串 |
| indexOf() | 返回某个指定的字符串值在字符串中首次出现的位置 |
| includes() | 查找字符串中是否包含指定的子字符串 返回值（true/false) |
| split() | 把字符串分割为字符串数组 |
| slice(start,[end]) | 提取字符串的片断，并在新的字符串中返回被提取的部分 |
| substr(start ,length) | 从起始索引号提取字符串中指定数目的字符 |
| substring(from,to) | 提取字符串中两个指定的索引号之间的字符 from to 都是正数 如果from>to 自动 交换位置 |
| toLowerCase() | 把字符串转换为小写 |
| toUpperCase() | 把字符串转换为大写 |
| trim() | 去除字符串两边的空白 |
| match() | 查找找到一个或多个正则表达式的匹配 找到 返回是元素组成数组，找不到返回 null |
| replace() | 在字符串中查找匹配的子串，并替换与正则表达式匹配的子串 |
| replaceAll() | 在字符串中查找匹配的子串，并替换与正则表达式匹配的所有子串 |
| search() | 查找与正则表达式相匹配的值 |
// 1.charAt(index)
for(let i=0;i<str.length;i++){
let ele= str.charAt(i);
console.log(ele);
console.log(str[i]);
}
//2.concat()
// let str1="hello";
// let str2= str1.concat("world",'10',4,6);
// console.log(str2,str1);
//3.indexOf(item,[start]) lastIndexOf()
// let str1="hello";
// let index= str1.indexOf("l");//2
// console.log(index);
//"hellol"字符串所有l出现的位置以及次数
let str1="hellol";
let index= str1.indexOf("l");
let num=0;
while(index!=-1){
console.log(index);
num++;
index= str1.indexOf("l",index+1)
}
console.log(num);
// 4.includes()
console.log(str1.includes("o"));//true
console.log(str1.indexOf("o")!=-1);//true
//5.split()
// let arr= str1.split("");
// console.log(arr);//['h', 'e', 'l', 'l', 'o', 'l']
let arr= str1.split("l");
console.log(arr);//6.
let str="helloworld";
let newstr= str.slice(2,6);// [2,6)
console.log(newstr);//"llow"
newstr= str.slice(2);
// newstr= str.slice(-2)
console.log(newstr);//"lloworld"
//7.substr()
newstr= str.substr(2);
console.log(newstr);"lloworld"
newstr= str.substr(2,3)//"llo"
console.log(newstr);
//8.substring()
newstr= str.substring(2,6)
console.log(newstr);//"llow"
newstr= str.substring(6,2);
console.log(newstr); let str="HellLo";
// str= str.toLowerCase();
// console.log(str);//"helllo"
str= str.toUpperCase()
console.log(str);//'HELLLO'
let str1=" hello world ";
console.log(str1);
str1= str1.trim();
console.log(str1); //"hello world"
// ------------
let str2="redblueRedblue";
//需求 有没有 "red"的字符串,找出来
let arr= str2.match(/red/g);
console.log(arr);
// 8.返回一个只包含数字类型的数组（例如：afjasoeigjs123sgdhedhhe456osddhnofd789=>[123,456,789]）（用原生和不原生两种方法来做）
let str3="afjasoeigjs123sgdhedhhe456osddhnofd789";
let arr1= str3.match(/\d+/g);// [0-9]+
\d表示数字 +表示1个或多个
console.log(arr1);//['123', '456', '789']
//replace(searchvalue，newvalue) 不写正则的话，只参替换一行，替换行可以用循环
// 2.去掉字符串中的空格
let str4=" hello world ";
// str4= str4.replace(/\s+/g,"");
// \s 空白字符 +表示1或多个
console.log(str4);
str4= str4.replaceAll(" ","")
console.log(str4);Chp - 9 函数
1.函数的概念
函数：就是封装了一段可被重复调用执行的代码块。通过此代码块可以实现大量代码的重复使用。 函数对任何语言来说都是一个核心的概念，通过函数可以封装任意多条语句，而且可以在任何地方，任何时候调用执行。
2.函数的使用
函数在使用时分为两步：声明函数和调用函数。
1.声明函数
// 声明函数
语法结构：
function 函数名() {
//函数体代码
}function 是声明函数的关键字,必须小写
2.调用函数
语法结构：
函数名(); // 通过调用函数名来执行函数体代码调用的时候千万不要忘记添加小括号 口诀：函数不调用，自己不执行。 注意：声明函数本身并不会执行代码，只有调用函数时才会执行函数体代码
3. 函数的封装
函数的封装是把一个或者多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口 简单理解：封装类似于将电脑配件整合组装到机箱中( 类似快递打包）
案例1
利用函数计算1-100之间的累加和
// 声明函数
function getSum(){
let sumNum = 0;// 准备一个变量，保存数字和
for (let i = 1; i <= 100; i++) {
sumNum += i;// 把每个数值 都累加 到变量中}
console.log(sumNum);
}// 调用函数
getSum();3.函数的参数
1. 形参和实参
在声明函数时，可以在函数名称后面的小括号中添加一些参数，这些参数被称为形参，而在调用该函数时， 同样也需要传递相应的参数，这些参数被称为实参。
形参
// 带参数的函数声明
function 函数名(形参1, 形参2 , 形参3...) {
// 可以定义任意多的参数，用逗号分隔
函数体
}实参
// 带参数的函数调用函数名(实参1, 实参2, 实参3...);function getSum(num1, num2) {
console.log(num1 + num2);
}
getSum(1, 3); // 4
getSum(6, 5); // 11总结：
-
调用的时候实参值是传递给形参的
-
形参简单理解为：不用声明的变量
-
实参和形参的多个参数之间用逗号（,）分隔
2. 函数形参和实参个数不匹配问题
function getSum(num1, num2) {
console.log(num1 + num2);
}
getSum(100,200);
//形参和实参个数相等，输出正确结果
getSum(100,200,600,300);
//实参个数多于形参，只取到形参的个数
getSum(200);
//实参个数少于形参，多的形参定义为undefined,结果为NaN注意：在JavaScript中，形参的默认值是undefined。
4.函数的返回值
1.return语句
有的时候，我们会希望函数将值返回给调用者，此时通过使用 return 语句就可以实现。return 语句的语法格式如下
// 声明函数
function 函数名（）{
...return 需要返回的值;
}
// 调用函数
let 返回值变量=函数名();
console.log(返回值变量);
// 此时调用函数就可以得到函数体内return 后面的值在使用 return 语句时，函数会停止执行，并返回指定的值 如果函数没有 return ，返回的值是 undefined
//声明了一个sum()函数，该函数的返回值为666
// 声明函数
function sum（）{
...return 666;
}
// 调用函数
console.log(Sum()) ;// 此时 sum 的值就等于666，因为 return 语句会把自身后面的值返回给调用者案例 2
//利用函数求任意两个数的最大值
function getMax(num1, num2) {
return num1 > num2 ? num1 : num2;
}
console.log(getMax(1, 2)); //2
console.log(getMax(11, 2));// 11案例 3
//利用函数求任意一个数组中的最大值
//定义一个获取数组中最大数的函数
function getMaxFromArr(numArray){
let maxNum = numArray[0];
for(let i =0;i < numArray.length;i++){
if(numArray[i] > maxNum){
maxNum = numArray[i];
}
}
return maxNum;
}
let arrNum = [5,2,99,101,67,77];
let maxN = getMaxFromArr(arrNum); // 这个实参是个数组
console.log('最大值为：'+ maxN);2.return 终止函数
return 语句之后的代码不被执行。
function add(num1，num2){
//函数体
return num1 + num2; // 注意：return 后的代码不执行
console.log('我不会被执行，因为前面有 return');
}
let resNum = add(21,6);
// 调用函数，传入两个实参，并通过 resNum 接收函数返回值
console.log(resNum); // 273.return的返回值
return 只能返回一个值。如果用逗号隔开多个值，以最后一个为准
function number(num1,num2){
//函数体
return num1,num2;
}
let endNum=number(7,12);
console.log(endNum); //12案例4
//创建一个函数，实现两个数之间的加减乘除运算，并将结果返回
let a=parseFloat(promt('请输入第一个数'));
let b=parseFloat(promt('请输入第二个数'));
function count(a,b){
let arr=[a+b,a-b,a*b,a/b];
return arr;
}
let result=count(a,b);
console.log(result);4.函数没有return返回undefined
函数都是有返回值的
-
如果有return 则返回 return 后面的值
-
如果没有return 则返回 undefined
5.break,continue,return 区别
-
break ：结束当前的循环体（如 for、while）
-
continue ：跳出本次循环，继续执行下次循环（如 for、while）
-
return ：不仅可以退出循环，还能够返回 return 语句中的值，同时还可以结束当前的函数体内的代码
案例5
// 判断闰年
// function isRunYear(year){
// if(year%4==0&&year%100!=0||year%400==0){
// return true;
// }
// return false;
// }
function isRunYear(year){
let flag=false;
if(year%4==0&&year%100!=0||year%400==0){
flag= true;
}
return flag;
}
let flag= isRunYear(2024);
console.log(flag);//true
if( isRunYear(2024)){
console.log(year+"是闰年");
}else{
console.log(year+"平年");
}函数可以调用另外一个函数
因为每个函数都是独立的代码块，用于完成特殊任务，因此经常会用到函数相互调用的情况。
function fn1() {
console.log(111); //111
fn2();
console.log('fn1'); // fn1
}
function fn2() {
console.log(222); //222
console.log('fn2'); // fn2
}
fn1();案例6
//用户输入年份，输出当前年份2月份的天数
function getTwoMonth(year){
if(isRunYear(year)){
// console.log(year+"是闰年"+"二月的天数是29天");
return year+"是闰年"+"二月的天数是29天"
} else{
// console.log(year+"是平年"+"二月的天数是28天");
return year+"是平年"+"二月的天数是28天"
}
}
let str= getTwoMonth(2024);
console.log(str);5.函数的两种声明方式
1.自定义函数方式(命名函数)
利用函数关键字 function 自定义函数方式。
// 声明定义方式
function fn() {
...
}
// 调 用
fn();因为有名字，所以也被称为命名函数 调用函数的代码既可以放到声明函数的前面，也可以放在声明函数的后面
2 函数表达式方式(匿名函数）
利用函数表达式方式的写法如下
// 这是函数表达式写法，匿名函数后面跟分号结束
var fn = function(){...};
// 调用的方式，函数调用必须写到函数体下面
fn();-
因为函数没有名字，所以也被称为匿名函数
-
这个fn 里面存储的是一个函数
-
函数表达式方式原理跟声明变量方式是一致的
-
函数调用的代码必须写到函数体后面
3.闭包函数
闭包：在一个函数内部有权访问另一个函数 作用域中的变量 包外：闭包在一个函数内部有权访问另一个函数作用域中的变量，并且将这个 函数返回,当返回的函数被外部调用时，产生闭包
表现形式：是函数外部能调用函数内部定义的变量。 缺点： 由于闭包会使用函数中的变量一直被保存在内存中，内存消耗很大，所以闭包的滥用可能会降代程序的处理速度，造成内存消耗的问题（内存泄露）
优点： 避免全局变量污染 延伸了变量的作用范围
//1.闭包
function fn(){
let i=1;
return function(){
i++;
console.log(i);
}
}
let count= fn();
console.log(count);
count();//返回函数一旦被调用就形了闭包
count();
count();4.递归函数
递归函数：如果一个函数在内部可以调用其本身，那么这个函数就是递归函数。简单理解:函数内部自己调用自己, 这个函数就是递归函数 递归调用是函数嵌套调用中一种特殊的调用。它指的是一个函数在其函数体内调用自身的过程。（所有的递归都是以相反的顺序相继结束）
// 递归函数
let i=0;
function fn1(){
i++;
console.log(i);
if(i==5){
//出口
return;
}
fn1()
}
fn1(); // 1 // 2 // 3 // 4 // 5
// 求n的阶乘 1*2*3*4*。。。*n
// n*(n-1)
function jieCheng(n){
//出口
if(n==1){
return 1;
}
return n*jieCheng(n-1)
}
/*
let res=5*jieCheng(4)
4*jieCheng(3)
3*jieCheng(2)
2*jieCheng(1)
1
*/
let res= jieCheng(5);
console.log(res);//1205.回调函数
在项目开发中，若想要函数体中某部分功能由调用者决定，此时可以使用回调函数。
所谓回调函数指的是一个函数A作为参数传递给一个函数B,然后在B的函数体内调用函数A.
此时，我们称函数A为回调函数。 匿名函数常作为函数的参数传递。
//回调函数
let callback= function(){
console.log("回调函数");
}
function fn3(fn){
fn();
}
fn3(callback); //回调函数6.箭头函数
(参数)=>{ 代码}
注意： 无参时 （） 不能省略
有两个或以上（）也不能省略
(1)如果形参只有一个参数，可以省略()
(2) 如果 代码部分 只有一句代码，可以省略{}
并且是返回值 return都可以省略
let fn= function (){
console.log('曲终人散！');
}//曲终人散！
let fn = () => {
console.log('零~~');
}
fn();//零~~
let fn = a => console.log('霜花~~'+a);
fn(10); //霜花~~10
let fn = a => '雪~~'+a;
console.log(fn(10)); //雪~~10 
扫一扫
1831
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
