JS（Javascript）自总结

本文主要是介绍JS（Javascript）自总结，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

javascript(网页脚本语言)，简称JS，文件以 .exe明名，在代码中写在script标签中。给网页添加功能，交互的行为。

外链 <script src="xx.js">

1.  alert           弹出输入框
2.  prompt          弹出输入框
3.  console.log     打印日志
4.  document.write  在页面中输出（在文档中写内容）

变量

变量的初始化：声明一个变量并赋值，称之为初始化。

同时声明多个变量，多个变量以逗号隔开，最后以分号结尾。
只声明变量不赋值，输出结果为underfined；不声明不赋值直接使用，会报错，后面代码不执行。

数据类型

String 字符串型 ；  number 数字型 ；Boolean 布尔型 ；null 空值 ；undefined 未定义的 ；object 对象 ；NaN (not a number)
检查数据类型用typeof运算符 ；ture代表 1 ；false代表 0；

字符串型 String

1. toString( ) 转换为支付串 ( 不可以转换 null undefined  (会报错))；
2. String( ) 强制转换为字符串；
3. 加号(+)拼接支付串      只要和字符串拼接的结果都是字符串。

数字型 number

NaN是数字型，但不是一个数字
1. parseInt( )函数  转换成整数数值型
2. parseFloat( )函数  转成浮点数数值型
3. number( )强制转换函数  转换成数值型

布尔型 Boolean

数字0会转换为false，null会转换为false，undefined会转换为false，NaN会转换为false，' '  " "都会转换为false,有空格的字符串会转换为true，其他都会转换为true。

隐式转为布尔值的方法 if ( ); var bool=!!'sss'；

运算符（操作符）

算术运算符

+(加) -(减) *(乘) %(除(取余))

递增运算符

  ++num(前置递增)  num++(后置递增) --num(前置递减)  num--(后置递减)   
口诀：前置先自加一(减一)，后返回值  后置先自加一(减一)，后返回值
      一般使用后置，代码独占一行

比较运算符

<(小于号) >(大于号) >=(大于等于号) <=(小于等于号) ==(等于号) !=(不等号) ===（全等于） !==(全不等) =(赋值)

赋值运算符

概念：用来把数据赋值给变量的运算符作用：将等号右边结果赋值给等号左边的变量

= 直接赋值  
+=，-= 加,减一个数然后再赋值
*=，/=，%= 乘,除,取模然后再赋值

逻辑运算符

&& "逻辑与"简称"and",两侧都为真，结果才为真；一侧为假，都是假。
|| "逻辑或"简称"or",两侧只要有一个为真，就是真；两侧都是假，结果才是假。
!  逻辑非  取反

逻辑中断：在多个表达式中，左边的表达式可以确定结果时，就不再继续运算右边的表达式。

if else语句 ( 双分支语句)

条件成立 执行if里面的代码，否则执行else里面的代码。
if(条件表达式){
    //（如果）条件成立，执行的代码
}else{
    //(否则)执行的代码
}

总结：双分支语句if else之中只能有一个语句执行；双分支语句是多选一的过程。

多分支语句

多分支语句也是多选一的过程，最后只能执行一个语句
else if 理论上可以是任意多个
else if 中间必须空一格

三元(目)运算符

语法构：条件？表达式1：表达式2;
执行思路：如果条件结果为真，则返回表达式1的值；如果条件为假，则返回表达式2的值；

循环

for循环

for循环：重复执行某些代码若干次
for循环语法结构：
    for (初始化变量; 条件表达式; 操作表达式) {
        循环体
    }
初始化变量：就是用var声明一个普通变量，通常用于作为计算器使用，
条件表达式：就是用来决定每一次循环是否继续执行，就是终止循环的条件，
操作表达式：就是每次循环最后执行的代码，经常用于计算器变量进行更新（递增或递减）

断点调试

断点调试：我们可以通过给程序打断点的方式，观察这个程序的执行过程，
通过这个断点来观察程序的运行过程  source  来源
设置断点：1.在行号上点一下，    2.刷新浏览器
取消断点：1.在行号上点一下      2.刷新浏览器
浏览器按F12     -->  source   --->   找到要调试的文件 ---->  在程序的某一行设置断点 WATCH  ：监视，通过watch可以监视变量的值得变化，非常好用
F11 ：程序单步执行，让程序一行一行的执行，

打印n行n列的星星

var rows = prompt('请输入你的行数：'); 
        var cols = prompt('请输入你的列数：');
        var str = '';
        for (var i = 1; i <= rows; i++) {
            for (var j = 1; j <= cols; j++) {
                str = str + '★' + '\t';
            }
            str = str + '\n'; 
        }
        console.log(str);
        
        //外层for循环控制行数，内层for循环控制列数。

打印99乘法表

1.一共9行，但是每行的个数不一样，因此需要用到双重for循环 2.外层的for循环控制行数i 循环9次可以打印9行 3.内层的for循环控制每行的公式j 4.核心算法：每一行公司的个数正好和行数一致 j<=i 5.每行打印完毕，都需要重新换一行

var str = '';
for (var i = 1; i <= 9; i++) {
    for (var j = 1; j <= i; j++) {
        str += j + '×' + i + '=' + j * i + '\t' + '\t';
        //str=str+j + '×' + i + '=' + j * i + '\t' + '\t'
    }
    str += '\n';
}
console.log(str);

while循环

while循环：第二种循环语句，可以在条件表达式为真的情况下，循环执行一定的代码，直到表达式不为真的时候结束循环
语法结构 while 当.......的时候，就是当条件表达式为真的时候，就执行里面的代码

while(条件表达式){
    循环语句
}

1到100之间的数字的和

var sum = 0; 
        for (var i = 1; i <= 100; i++) {
            sum += i;
        }
        console.log(sum);

1求1到100之间所有数字的平均值

 var average = 0; 
 var sum = 0; 
 for (var i = 1; i <= 100; i++) {
      sum += i; 
    }
    console.log('1到100之间数字的和为：' + sum); 
    average = sum 
    console.log('1到100之间数字的平均数为：' + average);

求1到100之间奇数的和与偶数的和

var even = 0;
var odd = 0;
for (var i = 1; i <= 100; i++) {
    if (i % 2 == 0) {
        even = even + i;
    } else {
        odd = odd + i;
    }
}
console.log('1到100之间所有的偶数的和为：' + even); 
console.log('1到100之间所有的奇数的和为：' + odd);

数组

1.什么是遍历数组：就是把我们的数组从头到尾访问一次，称为遍历
2.通过什么来遍历数组里面的元素：for循环可以实现这个效果
3.for里面的i是什么，当什么使用？for里面的数组元素怎么写： for里面的i是计算器，当做索引号使用，arr[i]是数组元素第i个数组元素
4.怎么获取数组的长度：length
5.数组索引号和数组的长度的关系：没有关系，数组索引号是从0开始的，数组的长度就是你有多少个元素

数组求和和平均值

var arr = [2, 6, 1, 7, 4];
var sum = 0; 
var average = 0; 
for (var i = 0; i < arr.length; i++) {
    sum += arr[i];
}
console.log(sum);
average = sum / arr.length;
console.log(average);

遍历数组中的最大值

var arr = [2, 6, 1, 77, 52, 25, 7, 102, 89, 98, 253];
var max = arr[0];
for (var i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
}
console.log('这个数组的最大值就是：' + max);

遍历数组中的最小值

var arr = [20, 61, 11, 17, 42, 5, 1, -4, 75, -10];
var min = arr[0];
for (var i = 0; i < arr.length; i++) {
    if (arr[i] < min) {
        min = arr[i];
    }
}
console.log('这个数组的最小值就是：' + min);

将数组转化为字符串

var arr = ['关羽', '张飞', '刘备', '诸葛亮'];
var str = '';
var sep = '/';
for (var i = 0; i < arr.length; i++) {
    str += arr[i] + sep;
}
console.log(str);

新增数组元素

//1.新增数组元素  通过修改length长度  增加空元素
var arr = ['关羽', '张飞', '刘备', '诸葛亮'];
console.log(arr.length); //4
arr.length = 7; //把我的数组长度改为7，里面应该有7个数组元素  本来就4个，强制改成7，就会在原来基础上加上3个空元素
console.log(arr); //['关羽', '张飞', '刘备', '诸葛亮','empty','empty','empty'];
console.log(arr[4]); //新增的空元素只是声明了，没有给赋值，所以就是undefined
console.log(arr[5]); //新增的空元素只是声明了，没有给赋值，所以就是undefined
console.log(arr[6]); //新增的空元素只是声明了，没有给赋值，所以就是undefined

//2.新增数组元素  通过修改索引号 追加数组元素  增加或者替换实体元素
var arr1 = ['关羽', '张飞', '刘备', '诸葛亮'];
console.log(arr1); //['关羽', '张飞', '刘备', '诸葛亮']
arr1[4] = '赵云';
console.log(arr1); //索引号没出现的叫做追加元素/['关羽', '张飞', '刘备', '诸葛亮','赵云']
arr1[5] = '马超';
console.log(arr1); //索引号没出现的叫做追加元素
arr1[0] = '曹操';
console.log(arr1); //索引号出现的叫做替换
arr1 = '三国混战';
console.log(arr1); //千万不要直接给数组名字赋值，否则里面的数组元素都没有了

筛选大于等于十的数

var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7, 105];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
    if (arr[i] >= 10) {
        newArr[newArr.length] = arr[i];
    }
}
console.log(newArr);

删除指定元素

var arr = [2, 0, 6, 1, 3, 3, 3, 77, 0, 52, 0, 2, 2, 25, 7];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
    if (arr[i] != 0) {
        newArr[newArr.length] = arr[i];
    }
}
console.log(newArr);

翻转数组

var arr = ['关羽', '张飞', '赵云', '马超', '诸葛亮', '曹操'];
var newArr = [];
for (var i = arr.length - 1; i >= 0; i--) {
    newArr[newArr.length] = arr[i];
}
console.log(newArr);

冒泡排序

var arr = [1, 3, 4, 5, 2];
for (var i = 0; i < arr.length - 1; i++) { //外层循环的趟数
    for (var j = 0; j < arr.length - i - 1; j++) { //里层循环管理每次交换的次数
        //内部交换2个变量的值，  前一个和后一个元素相比较
        if (arr[j] > arr[j + 1]) {
            //交换两个变量的值  可以借助临时变量
            var temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}
console.log(arr);

函数

函数：就是封装了一段可以被重复执行调用的代码块，目的：就是让大量代码重复使用

函数的返回值

break，continue，return的区别
- break：结束当前的循环体。
- continue：跳出本次循环，继续执行下次循环。
- return：不仅可以退出循环，还能够返回return语句中的值，同时还可以结束当前的函数体中的代码。

利用函数的封装求1-100之间的累加和

1.声明函数
function getSum() {
    var sum = 0;
    for (var i = 1; i <= 100; i++) {
        sum += i;
    }
    console.log(sum);
}
2.调用函数
getSum();

//1.函数是做什么用的：他的最大的目的是大量代码可以重复使用，这是他最终的目的，函数就是封装了一个可以被重复调用执行的代码块，这是函数
//2.声明函数使用什么关键字：function
//3.如何调用函数  函数名()
//4.封装是什么意思：简单理解封装就是打包，把咱们的函数整合成一个整体

利用函数求和

1.利用函数求任意两个数的和

function getSum(num1, num2) { //num1=1   num2=3
    console.log(num1 + num2);
}
getSum(1, 3); //4
getSum(3, 8); //11
//2.利用函数求任意两个数之间的和
function getSums(start, end) { //start=1  开始   end=100 结束
    var sum = 0;
    for (var i = start; i <= end; i++) {
        sum += i;
    }
    console.log(sum);
}
getSums(1, 100); //5050
getSums(1, 10); //55

利用函数求任意数组中的最大值

function getArrMax(arr) { //arr 是一个形参，接受一个数组 就相当于arr=[5,2,99,101,67,77]
    var max = arr[0];
    for (var i = 1; i <= arr.length - 1; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}
getArrMax([5, 2, 99, 101, 67, 77]) //实参是一个数组传递过去
// 在我们实际开发中， 我们经常用声明一个变量接收函数的返回结果吗， 使用更加简单
var re = getArrMax([5, 2, 99, 101, 67, 77]);
console.log(re);

利用arguments求任意个数的最大值

function getMax() { //这里的arguments就相当于数组[1,2,3,4]  就是求数组[1,2,3,4]中的最大值
    var max = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
        if (arguments[i] > max) {
            max = arguments[i];
        }
    }
    return max;
}
console.log(getMax(1, 2, 3, 4));

利用函数的方法封装翻转数组

function reverse(arr) {
    var newArr = [];
    for (var i = arr.length - 1; i >= 0; i--) {
        newArr[newArr.length] = arr[i];
    }
    return newArr;
}
var arr1 = reverse([1, 3, 4, 6, 9]);
console.log(arr1);

利用函数封装的方法实现冒泡排序

function sort(arr) {
    for (var i = 0; i < arr.length - 1; i++) {
        //外层for循环
        for (var j = 0; j < arr.length - i - 1; j++) {
            //内层for循环
            if (arr[j] > arr[j + 1]) {
                //先是判断，然后交换两个变量  声明一个中间变量承接以下
                var temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    //循环遍历之后，输出arr
    return arr;
}
var arr1 = sort([1, 9, 8, 5, 2, 4, 7, 3, 6]);
console.log(arr1);

利用函数封装的方法判断是否是闰年

 function isRunYear(year) {
    //如果是闰年，返回true 否则是平年 返回是false
    var flag = false;
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        flag = true;
    }
    return flag;
}
console.log(isRunYear(2000)); 
console.log(isRunYear(1999));

冒泡排序

function Array() {
    this.nine = function() {
        for (var i = 0; i < arguments.length - 1; i++) {
            for (var j = 0; j < arguments.length - 1; j++) {
                if (arguments[j] > arguments[j + 1]) {
                    temp = arguments[j]
                    arguments[j] = arguments[j + 1]
                    arguments[j + 1] = temp
                }
            }
        }
        return arguments
    }
}
var win = new Array();
console.log(win.nine(1, 65, 22, 56, 23, 657, 245));

封装函数

函数的封装是一个或者多个功能通过函数的方式封装起来，对外只提供一个简单的函数接口。

调用函数

函数名();
调用函数的时候，小括号不能忘。

构造函数

构造函数要用new调用，且首字母要大写

function 构造函数名（）{
    this.属性 = 值;
    this.方法 = function（）{}
}
var fn = new 构造函数名（）;
console.log(fn.构造函数名（传参）)

arguments

当我们不确定有多少个参数传递的时候，可以用arguments来获取，在Javascript中，arguments实际上是当前函数的一个内置对象，所有函数都内置了一个arguments对象，arguments对象中储存了传递的所有实参。
只有函数有arguments对象。
arguments不是数组，是一个类数组（伪数组）
- 1.具有数组的length属性
- 2.按照索引的方式进行储存
- 3.他没有真正数组的一些方法；如pop();push()等等。

任意数组的和

function Get() {
this.max = function() {
var mac = arguments[0];
for (var i = 0; i < arguments.length; i++) {
            mac += arguments[i]
        }
        return mac
    }
}
var cp = new Get()
console.log(cp.max(1, 2, 3, 4, 5, 6, ));

任意两个数中的最大值

function Max() {
this.max = function(num1, num2) {
        if (num1 > num2) {
            return num1
        } else {
            return num2
        }
    }
}
var cp = new Max()
console.log(cp.max(44, 96));

任意数的最大值

function Max() {
this.max = function() {
var mac = arguments[0];
        for (var i = 0; i < arguments.length; i++) {
            if (mac < arguments[i]) {
                mac = arguments[i]
            }
        }
        return mac
    }
}
var sp = new Max()
console.log(sp.max(5, 3, 98, 254));

翻转任意数组

function Array() {
this.arr = function() {
        var newArray = [];
        for (var i = arguments.length - 1; i >= 0; i--) {
            newArray += arguments[i] + ','
        }
        return newArray
    }
}
var mac = new Array()
console.log(mac.arr(1, 2, 3, 1, 2, 3, 1, 312));

Math.random 猜数字游戏

function getRandom(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min;
}
var random = getRandom(2, 8);

while (true) {
var num = prompt('你来猜？输入1~10之间的一个数字');
        if (num > random) {
            alert('你猜大了');
        } else if (num < random) {
            alert('你猜小了');
        } else {
            alert('你好棒啊，猜对了');
        break;
    }
}

数组

有一个包含工资的数组[1500,1200,2000,2100,1800],要求把数组中的工资超过2000的删除，剩余的放到新的数组里面

var arr =[1500,1200,2000,2100,1800];
var newArr=[];
for (var i = 0; i < arr.length;i++){
    if (arr[i]<1500){
        //newArr[newArr.length] = aee[i]
        newArr.push(arr[i])
    }
}
console.log(newArr);

Date日期对象

是一个构造函数，必须使用new来调用创建日期对象。

1.创建Date对象，如果没有参数，返回系统当前的时间。
```
var date = new Date();
console.log(date);
```
2.参数常用的写法，数字型：2021，04，14 或字符串型：“ 2021-4-14 21：46：30 ”。
```
var date1=new Date(2021-4-14  21:46:30);
console.log(date1);
var date2=new Date(2021-4-14  21:46:30);
console.log(date2);
```

年月日时分秒

var date = new Date()
var year = date.getFullYear(); //年
var month = date.getMonth() + 1; //月
var oneDay = date.getDate(); //日
var day = date.getDay(); //星期
var hours = date.getHours(); //小时
var minutes = date.getMinutes(); //分钟
var seconds = date.getSeconds(); //秒数
console.log('今天是' + year + '年' + month + '月' + oneDay + '日' + '星期' + day + ' ' + hours + '点' + minutes + '分' + seconds + '秒');

时间戳

计算机的起始时间是：1970年1月1号开始的。

1.通过valueOf(); getTime();

var date = new Date();
console.log(date.valueOf());
console.log(date.getTime());

2.简单的写法，也就是最常用的方法。

var date1 = +new Date();
console.log(date1);

3.H5新增的一种写法

console.log(Date.now());

倒计时

核心算法：输入的时间减去现在的时间就是剩余的时间，即倒计时的时间，但是不能用时分秒相减。
用时间戳来做，用户输入的时间总的毫秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒数。
把剩余的时间总的毫秒数转换为天，时，分，秒。
计算天数：总秒数/60/60/24 计算小时：总秒数/60/60%24 计算分钟：总秒数/60%60 计算当前秒数：总秒数%24

function countDown(time) {
    var nowTime = +new Date(); //返回的是当前距离1970年的时间总的毫秒数
    var inpuTime = +new Date(time); //返回的是用户输入时间总的毫秒数
    var times = (inpuTime - nowTime) / 1000; // times剩余时间总的毫秒数
    var d = parseInt(times / 60 / 60 / 24); //天
    d = d < 10 ? '0' + d : d;
    var h = parseInt(times / 60 / 60 % 24); //时
    h = h < 10 ? '0' + h : h;
    var m = parseInt(times / 60 % 60); //分
    m = m < 10 ? '0' + m : m;
    var s = parseInt(times % 60); //秒
    s = s < 10 ? '0' + s : s;
    return '距离活动开始还剩：' + d + '天' + h + '时' + m + '分' + s + '秒';
}
console.log(countDown("2021 12 30 18:00:00"));

对象

创建对象

利用数组字面量
```
var arr = [1,2,3];
console.log(arr);
```

利用new Array()

var arr1 = new Array(); //创建一个空对象
var arr1 = new Array(3); //表示数组长度3，里面有3个空元素
var arr1 new Array(1,2,3); //等价[1,2,3] 表示里面有3个数组元素是1，2，3
console.log(arr1);

添加数组元素

push() 在数组的末尾添加一个或多个数组元素
```
var arr = [1,2,3];
console.log(arr.push(3,4))
```
1.push是可以给数组追加新元素

2.push() 参数直接写数组元素

3.push完毕后，返回的结果是新的数组的长度

4.原数组也会发生变化
unshift() 在我们数组的开头添加一个或多个数组元素
```
var arr=['red','green'];
console.log(arr.unshift('1','2'));
```
1.unshift 是可以给数组前面追加新元素

2.unshift()参数直接写数组元素

3.unshift 完毕后，返回的结果是新数组的长度

4.原数组也会发生变化

删除数组元素

pop() 删除数组中的最后一个元素
```
var arr=[1,2,3];
console.log(arr.pop());
```
1.pop 是可以删除数组中的最后一个元素，一次只能删一个

2.pop() 没有实参

3.pop完毕后，返回值是删除的那个数组元素

4.原数组方式生了变化
shift() 可以删除数组中的第一个元素
```
var arr=[1,2,3];
console.log(arr.shift());
```
1.shift 可以删除数组中的第一个元素，一次只能删除一个

2.shift()没有实参

3.shift 完毕后，返回值是删除的那个数组元素

4.原数组也发生了变化

数组内置方法

unshift():在数组头部插入元素；
shift():删除数组中第一个元素；
pop():删除数组末尾元素；
push();在数组末尾添加元素；
concat():数组合并；
slice(start,end):截取数组[start,end),返回一个新数组；
splice:会影响原数组；
- splice(index,how many):删除数组元素；
- splice(index,how many,item):先删除再添加；
join(sp)与split相反使用指定字符数组元素拼接为字符串 arr.join(',');
forEach(fn) fn有三个参数 item(元素本身) index(索引）arr( 元素本身）
some(fn) 判断数组中是否有满足规则的；
every(fn): 判断数组中是均满足条件；
filter(fn) element(数组元素) index(索引) self(数组自身) 过滤重复元素；
reverse():倒置数组元素；
sort(): arrayObject.sort(方法函数，可选)，使用方法函数.按照方法函数排序，不适用，按照Unicode排序；

String 对象方法

str.link('url'): 使字符串变成链接；
str.charAt(index): 查找指定字符串；
str.indexOf(): 查找指定字符串第一次出现的位置，找不到返回-1；
str.replace('谁被替换'，‘替换的内容’):替换字符串；
str.slice([start,end)):提取部分字符串；
str.split(','):分割字符串；
截取字符串：
- str.substr(start,length):start:开始位置，length：截取长度；从0开始；
- str.substring([start,stop)):start:开始位置，stop：停止位置；
- str.toLowerCase():将指定字符串转换为小写；
- str.toUpperCase():将字符串转化为大写；
- str.tim():去除首字母空格；
逆转字符串：str.split('').revese().join('')

练习题

字符串 'ajdflajlksjdflkajj2378r90ud9f87ssjfh546rg4dv8' ,统计字符串中数字型字符串的个数

// var string = 'ajdflajlksjdflkajj2378r90ud9f87ssjfh546rg4dv8';

function fn() {
    var num = 0;
    for (var i = 0; i < string.length; i++) {
    if (0 <= string[i] || string[i] <= 9) {
        num++
        }
    }
    return num
}
console.log(fn());

字符串'dsg4rdyssbf87fg45278ds45gbdsf754g5dfs7hdf45',统计字符串中数字型字符串的个数

var string = 'dsg4rdyssbf87fg45278ds45gbdsf754g5dfs7hdf45';
function fn() {
    var num = 0;
    for (var i = 0; i < string.length; i++) {
    var sum = string.charAt(i)
    if (Number(sum) == sum) {
        num++
        }
    }
    return num
}
console.log(fn());

将所有的数字挑选出来，组成一个新的字符串并输出

var string = 'ajdflajlksjdflkajj2378r90ud9f87ssjfh546rg4dv8';
    function fn() {
        var num = 0;
        var newArr = '';
        for (var i = 0; i < string.length; i++) {
            if (0 <= string[i] || string[i] <= 9) {
                num++
                newArr += string[i]
            }
        }
        console.log('新数组是：' + newArr);
        return num
}
console.log(fn());

将所有的数字挑选出来，组成一个新的字符串并输出

var string = 'dsg4rdyssbf87fg45278ds45gbdsf754g5dfs7hdf45';
function fn() {
    var num = 0;
    var newArr = '';
    for (var i = 0; i < string.length; i++) {
        var sum = string.charAt(i)
        if (Number(sum) == sum) {
            num++
            newArr += string[i]
        }
    }
    console.log('新数组是：' + newArr);
    return num
}
console.log(fn());

一张纸厚度是0.07毫米，假设这张纸可以无限次对折，问对折几次可以超过珠峰？8848米

// 原0.07
// 对折一次0.07*2 =0.07*1*2
// 对折两次0.07*2*2 =0.07*2*2
// 对折三次0.07*2*2*2 =0.07*3*2
// ......
function fn() {
    for (var i = 1; i > 0; i++) {
        if (0.07 * i * 2 == 8848 * 1000) {
            return ('对折' + i + '次可以超过珠穆朗玛峰')
        }
    }
}
console.log(fn());

国际象棋 64 格。第一个放一粒米，后面每一格都放上一格的 2 倍。问第 64 个格上会放多少粒米 ?

// 1 格  1粒
// 2 格  2粒 
// 3 格  4粒
// 4 格  8粒
// 5 格  16粒
function xn() {
    var num = 1;
    for (var i = 1; i <= 64; i++) {
        if (i == 64) {
            // console.log(i);
            // console.log('第64格放：' + num + '粒米');
            return ('第64格放：' + num + '粒米');
        } else {
            num = num * 2
        }
    }
}
console.log(xn())

求取某个日期是星期几(例如： 2021 / 5 / 25)

var date = new Date(2021, 05, 25)
var day = date.getDay()
function dn() {
    if (day == 3) {
            var xingqi = "日"
        } else if (day == 4) {
            var xingqi = "一"
        } else if (day == 5) {
            var xingqi = "二"
        } else if (day == 6) {
            var xingqi = "三"
        } else if (day == 0) {
            var xingqi = "四"
        } else if (day == 1) {
            var xingqi = "五"
        } else if (day == 2) {
            var xingqi = "六"
        } else {
            var xingai = null
        }
        return ('这个日期是星期' + xingqi)
    }
console.log(dn());

有字符串 '46yewy5s_4weryuwvcwuywywj____4gyfd___d'', 将字符串中替换为 *

var arr='46yewy5s_4weryuwv___cwuywywj________________4gyfd___d';
function fn(str, oldChar, newChar) {
    var index = str.indexOf(oldChar)
    while (index !== -1) {
        index = str.indexOf(oldChar, index + 1)
        str = str.replace(oldChar, newChar)
    }
    return str
}
console.log(fn(str, '_', '*'));

删除字符串中的数字 'dfag465fdg1bs5574gdr8t4ret574dfsg5ggda5255sa'

var str = 'odfag465fdg1bs5574gdr8t4ret574dfsg5ggda5255sa'
var newStr = ''
function fn() {
    for (var i = 0; i < str.length; i++) {
        if (0 <= str[i] || str[i] < 10) {
        } else {
            newStr += str[i]
        }
    }
    return newStr
}
console.log(fn());

反转字符串 'sgfdsga4xdggfsd ---->rfgai'

var str = 'sgfdsga4xdggfsd      ---->rfgai'
console.log(str.split('').reverse().join(''));

将字符串用空格隔开 'HowAreYou' 'How Are You'

var str = 'HowAreYou'
function fn() {
    var s = ''
    for (var i = 0; i < str.length; i++) {
        if (str[i] >= 'A' && str[i] <= 'Z') {
            if (i == 0) {
                s += str[i]
            } else {
                s = s + ' ' + str[i]
            }
        } else {
            s += str[i]
        }
    }
    return s
}
console.log(fn());

改变传入的数组，将数组中第n(从0开始算) 个元素放到数组的开头(用函数实现)

var arr = ['a', 's', 'd', 'f', 'e', 'h', 't', 'd', 'y']
function fn(arr, n) {
    var p = arr.slice(n, n + 1)
    arr.splice(n, 1)
    arr.unshift(p[0])
    return arr
}
console.log(fn(arr, 1));

将数组中数字内容求和 arr=[5,'张三',9,80,true,28]

var arr = [5, '张三', 9, 80, true, 28, -1, 4];
var num = 0
function fn(arr) {
    for (var i = 0; i < arr.length; i++) {
        if (typeof(arr[i]) == 'number') {
            num += arr[i]
        }
        // if (Number(arr[i])) {
            //     num += arr[i]
        // }
    }
return num
}
console.log(fn(arr));

这篇关于JS（Javascript）自总结的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！