JS基础笔记_function play(name, type, blood , attack){this.nam

作者：Monodyee | 2024-04-10 13:00:19

踩

function play(name, type, blood , attack){this.name = name;this.type = t

console.log(isNaN(NaN));
console.log("abc" + 10);

var i = true;
var j = false;
console.log(i + j);

数据类型： number string boolean undefined null

//typeof 判断数据类型
console.log(typeof(j));

// var num = 11;
// console.log(isNaN(num));

// toString数据转换为字符串string类型常用*
var num = 12;
var str = num.toString();
console.log(str);
// String转换为字符串String类型强制转换
// 隐式转换
var a = 1;
console.log(a + '');
// Number数据转换为number类型：保留小数，有非数字结果为NaN;
// parseInt数据转换为number类型：取整，如遇到非数字，就返回NaN; 常用*
// parseFloat和parseInt 一样，但保留小数;

// var i = prompt('输入第一个数');
// var j = prompt('输入第二个数');
// var x = parseFloat(i) + parseFloat(j);
// alert(x);

// Boolean数据转换为bool 除了0 NaN ''空字符串 false null undefined为false, 其余都为true.
console.log(Boolean('123'));

// ++前置先自增后运算先自增后赋值先自加后返回原值；；

//后置++ 先赋值后自增先返回原值后自加；
// var a = 10;
// var b = a++;
// console.log(a); // 11
// console.log(b); // 10
// console.log(a + b); //21
//
// var i = 10;
// i++;
// var j = i++ + 2;
// console.log(j); //13

// 单等 = 是赋值，双等 == 是判断，三等 === 是全等。

// 逻辑运算符 :先与&&后或||。
// 与：&& 真真为真，其余都为假一false都false**;
// 或：|| 假假为假，其余都为真一true都true**;
// 非：！取反
console.log(false && false);
//运算优先级：1.（）
// 2.一元运算符 ++ -- ！
// 3.算数运算符先* / % 后 + -
// 4.关系运算符 > >= < <=
// 5.相等运算符 == !== === !==
// 6.逻辑运算符先&& 后 ||
// 7.赋值运算符

//三元运算符表达式：a >= b ? a : b;
var a = 1;
var b = 2;
var c = a > b ? a : b;
console.log(c);

// 控制语句流：
// if语句：
// if else
// if else if else
// var a = prompt('请输入分数？')
// if( a >= 90 ){
// alert("A");
// }
// else if( a >= 80 ){
// alert("B");
// }
// else if( a >= 70 ){
// alert("C");
// }
// else if( a >= 60 ){
// alert("D");
// }
// else if( a < 60 && a > 0 ){
// alert("E");
// }
// else{
// alert("what are you doing?");
// }

// switch语句
// switch 是比较的全等===；

// Sources 调试： Watch添加监视，
// 设置断点
// 刷新命中断点h 是比较的全等===；

// for循环：
// 双for循环：
// for( var i = 0; i < 3; i++){ //外层循环循环一次控制的是趟数
// for( var j = 0; j < 3; j++){ //内层循环循环全部控制次数
// document.write('*')
// }
// document.write('<br/>')
// }

// while循环：
// do while 不管条件成不成立都会执行一次。

// continue：继续终止本次循环，进入到下一次循环。
// break: 终止循环

// 数组 *** :存储多个值，把一组数据存到一起，并且提供方便的访问方式，
// 数组可以使用一个变量名，就可以存储多个值。
// 数组里可以是任何数据类型。
// 多个值用，隔开。
// 创建数组方法：var arr1 = new Array();通过构造函数创建函数写一个数值代表数组长度了解,
// **使用数组字面量创建数组: var arr2 = []; ***
// 通过索引获取里面的数据，索引从0开始；
var arr = ['春','夏','秋','冬'];
var str = arr[0];
var s = '|';
for( var i = 1; i < arr.length; i++){
str += s + arr[i];
}
console.log(str);
//一次取值：
console.log(arr[0]);
console.log(arr[1]);
console.log(arr[2]);
console.log(arr[3]);
//重新赋值：
arr[0] = 'A';
console.log(arr[0]);
//追加：
arr[4] = '四季';
console.log(arr[4]); //没有下标追加；
// length 增加数组容量：
arr.length = 5;
console.log(arr);

arr[arr.length] = '';

//遍历数组：
console.log(arr.length);
for( var i = 0; i < arr.length; i++){
console.log(arr[i]);
}

var a = 0;
var Arr = [5,6,7,8,9,10];
for(var i =0; i < Arr.length; i++){
a += Arr[i];
}
var p = a / Arr.length;
console.log(a);
console.log(p);

//选择数组中的最大最小值：<;
var arr1 = [12,58,32,1,50,64,85];
var max = arr1[0];
for(var i = 1; i < arr1.length; i++){
if(max > arr1[i]){
max = arr1[i];
}
}
console.log(max);

// 把大于10的数放到新的数组中：
var arr3 = [12,58,32,1,50,64,85];
var newArr = [];
for(var i = 0; i < arr3.length; i++){
if( arr3[i] > 10){
newArr[newArr.length] = arr3[i];
}
}
console.log(newArr);
//声明数组方式:
// var arr = new Array(1,2,3,4,5);
// var arr1 = [1];
// console.log(arr1);
// console.log(arr);

// 数组翻转：***
//1.
var arr = ['A','B','C','D','E'];
var newArr = [];
for( var i = 0; i < arr.length; i++){
newArr[i] = arr[arr.length - i - 1];
}
console.log(newArr);
//2.
var arr = ['A','B','C','D','E'];
var newArr = [];
for( var i = arr.length - 1; i--;){
newArr[newArr.length] = arr[i];
加粗样式 }
console.log(newArr);

//冒泡排序：是一种算法，把一系列数据按照顺序排列（从小到大，从大到小）
// 外层 length - 1；
// 内层 length - i - 1；
var arr = [5,9,43,1,8,12,50,123];
for( var i = 0; i < arr.length - 1; i++){
for( var j = 0; j < arr.length - i - 1; j++){
if(arr[j] > arr[j + 1]){
var t = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = t;
}
}
}
console.log(arr);

/ 函数：
// function 函数名(){函数体};

// 匿名函数：1.当做自调用函数 2.当做函数表达式； 3 对象的方法；
// 自调用：(function(){
// })();

// 函数也是一种数据类型：function;
// 函数可以作为参数传递：把函数当做参数传递进去的那个被传入的函数，称为回调函数，*****
// 当函数进行传递的时候，千万不要加小括号，because 加了小括号就是调用函数；
//

// return 当函数没有写return时，该函数返回undefined；
// return 后面什么都没写，该函数返回undefined；
// return 后面是什么，那么该函数的返回值就是什么；

// return 后面的代码将不再执行，跟循环里的break一样；

// arguments 用来确定用户输入了多少个实参
// 用来存储用户传递过来的实参，不管多少都存储
// 有arguments 就可以不用写形参；
// arguments 按照一种伪数组形式存储；伪数组（有长度length 有索引号没有数组的方法push、pop ）

// 作用域：变量可以起作用的范围；在函数外部的叫全局变量，函数内部叫局部变量，形参属于局部变量，
// 作用域链：按链式往上一层找；

// 预解析：1.变量提升：只提升声明，不提升赋值
// console.log(a); undefined;
// var a = 10;
// 2.函数提升：会将整个函数体进行提升；
// 如果变量名和函数冲突，优先执行函数；

// 对象：方法和属性组成的集合；
// 属性名和方法中间用, 隔开；
// 方法后面跟函数；
// 使用对象：对象名.属性名，或者对象名['属性名']；
// 使用方法：对象名.方法名() ,
// 创建对象方法：1.利用对象字面量创建对象{}；
// var Wkk = {
// name: '王可可',
// age: 5,
// color: 'red',
// cry : '汪汪汪',
// showFilm: '《后会无期》',
// can: function () {
// alert('wangwangwang')
// }
// }
// console.log(Wkk);
// console.log(Wkk.name);
// console.log(Wkk.can());

// 2.利用 new Object 创建对象：
// var stuObj = new Obect();
// stuObj.name = 'james';
// stuObj.age = 11;
// stuObj.sex = true;
// stuObj.sayHi = function(){
// alert('大家好啊~');
// }
// 构造函数：封装对象；
// 1. function 构造函数名（参数1....）{ 构造函数名首字母大写
// this.属性名 = 属性值； this在对象方法中，指当前对象；
// this.方法名 = 函数}
// 调用构造函数： new 构造函数名（），自定义构造函数调用；
// this
// 1. 函数在定义的时候this是不确定的，只有在调用的时候才可以确定
// 2. 一般函数直接执行，内部this指向全局window
// 3. 函数作为一个对象的方法，被该对象所调用，那么this指向的是该对象（谁调用指向谁）
// 是由构造函数创造的出来的实例对象；
//
// new 关键字：*****
// 1.在构造函数中创建一个新的空对象；
// 2.让 this 指向这个空对象；
// 3.完成里面的代码进行赋值；
// 4.帮我们自动返回这个对象。
// for in 遍历：for( k in 对象){ console.log(对象[k]); }
//

// 内置对象：js里面自带的一些对象，供我们开发者使用，这些对象提前内置准备好的属性和方法，可以直接使用。
// 数学对象Math:
// Math.random();
function getRandom(min, max) {
return Math.floor(Math.random() * (max - min + 1) + min);
}
var a = getRandom(13, 31);
console.log(a);
console.log(Math.round(7.55656));// 四舍五入；

// Date对象: 实例化对象，
var date = new Date(); //参数为空，则返回当前日期和时间，
var date1 = new Date('2018-12-1');//返回输入的日期和时间
// 获得毫秒数：
// 1.valueOf();
// 2.getTime();***
// 3.var date = +new Date();
// 4.console.log(Date.now()); h5方法有兼容性问题。
// 格式化日期：
// date.getFullYear(); 当前年份；
// date.getMonth(); 当前月 0 - 11
// date.getDate(); 当前日
// date.getDay(); 当前星期几 0 星期天 1星期一；
//当前时间：
function getDay() {
var date = new Date();
var arr = ['星期天', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六']
var y = date.getFullYear();
var m = date.getMonth();
var d = date.getDate();
var x = date.getDay();
var h = date.getHours();
var f = date.getMinutes();
var s = date.getSeconds();
h = h < 10 ? '0' + h : h;
f = f < 10 ? '0' + f : f;
s = s < 10 ? '0' + s : s;
return y + '年' + m + '月' + d + '日' + arr[x] + ' ' + h + ':' + f + ':' + s;

}
// setInterval(getDay(), 1000);
console.log(getDay());
//倒计时：
function getTime(start, end) {
var t = end - start;
// var d = Math.floor(t / 1000 / 60 / 60 / 24);
// var h = Math.floor(t / 1000 / 60 / 60 % 24);
// var m = Math.floor(t / 1000 / 60 % 60);
// var s = Math.floor(t / 1000 % 60);
return {
d: Math.floor(t / 1000 / 60 / 60 / 24),
h: Math.floor(t / 1000 / 60 / 60 % 24),
m: Math.floor(t / 1000 / 60 % 60),
s: Math.floor(t / 1000 % 60),
};
}
var start = new Date();
var end = new Date(2018, 11, 12);
console.log(getTime(start, end));

// 判断对象是否属于数组：
// 1.instanceof 运算符；判断是否是数组
// 2.Array.isArray;
// 数组中的方法：
// push() 追加：向数组末尾追加元素，并返回添加后的数组长度，
// pop() 删除：从末尾删出元素，并返回被删除的元素，
// unshift() : 向数组最前面追加元素，并返回添加后的数组长度，
// shift() : 从最前面删除元素，并返回被删除的元素，
// reverse() ,翻转数组；返回新数组
// sort(), 排序，返回新数组
// concat(); 合并数组，称为一个新数组；
// splice（第几开始，删除个数），删除元素；
// slice(begin,end) 截取元素，返回截取的新数组；
var arr = [1, 2, 3, 4, 5];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
newArr.push(arr[i]);
newArr.sort(function (a, b) {
return b - a;
});

// newArr.unshift(arr[i]);
}
console.log(newArr);

// indexOf(); 查询数组元素在数组中的位置，从左往右查询；
// lastIndexOf(); 从右往左查询；
// var arr = [1,0,25,0,1,0,1,3,5,8,3];
// do{
// var index = arr.indexOf(1,index + 1);
// if( index != -1){
// console.log(index);
// }
// }while ( index != -1)
//
数组去重：
// var arr = ['c','a','z','a','x','a','x','c','b'];
// var newArr = [];
// for( var i =0; i < arr.length; i++){
// if(newArr.indexOf(arr[i]) === -1){
// newArr.push(arr[i]);
// }
// }
// console.log(newArr);

// 数组字符串拼接：
// var arr = ['s','a','i','n','t'];
// console.log(toString(arr));
// console.log(arr.join(''));
// 复杂数据类型：复杂数据类型里面存储的是地址，同一地址直接调用地址。
// 基本包装类型：string是引用类型的一种，
// indexOf();查询数组元素在数组中的位置，从左往右查询
// charAt(index);根据索引号返回字符，
// charCodeAt(index); 返回ASCII 码；
// var str = 'adasdfgesrsfv';
// for(var i = 0; i < str.length; i++){
// console.log(str.charAt(i));
// }
substr(起始位置，长度); 截取字符串，
replace(被替换的字符，替换的字符) ;
// var str = 'obsessionsaint';

// while(str.indexOf('s') != -1){
// str = str.replace('s','b');
// }
// console.log(str);
split 分割字符串，转换为数组； //返回值是数组；

// var str = 'saint-obsession';
// var arr = str.split('-');
// console.log(arr);
// toUpperCase();转换为大写；**加粗样式**
// toLowerCase();转换为小写；
// 把url'http://www.itheima.com/login?name=zs&age=18&pwd=123456'；
// 把？后面的数据转换为对象 {name:zs, age:18, pwd:123456}
// var url = 'http://www.itheima.com/login?name=zs&age=18&pwd=123456';
// function getUrl(url){
var index = url.split('?')[1]; 切割
// var index = url.indexOf('?') + 1;
// var last = url.substr(index);
// var arr = last.split('&');
// var o ={};
// for( var i = 0; i < arr.length; i++){
// var newArr = arr[i].split('=');
// o[newArr[0]] = newArr[1];
// }
// return o;
// }
// console.log(getUrl(url));

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/398829