JS（Javascript）自总结

2021-09-22 20:06:05 阅读：147 来源： 互联网

标签：总结 arr console log Javascript JS length 数组 var

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));

标签：总结,arr,console,log,Javascript,JS,length,数组,var
来源： https://blog.csdn.net/weixin_57844432/article/details/120421522

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

JS（Javascript）自总结

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

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

变量

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

数据类型

字符串型 String

数字型 number

布尔型 Boolean

运算符（操作符）

算术运算符

递增运算符

比较运算符

赋值运算符

逻辑运算符

if else语句 ( 双分支语句)

多分支语句

三元(目)运算符

循环

for循环

断点调试

while循环

数组

冒泡排序

函数

函数的返回值

封装函数

调用函数

构造函数

arguments

数组

Date日期对象

时间戳

倒计时

对象

创建对象

添加数组元素

删除数组元素

数组内置方法

String 对象方法

练习题