JS基础复习

最新推荐文章于 2024-11-04 16:17:23 发布

程程小序序

最新推荐文章于 2024-11-04 16:17:23 发布

阅读量202

点赞数

分类专栏： js复习文章标签： javascript linq webview

本文链接：https://blog.csdn.net/weixin_57112170/article/details/124687360

版权

js复习专栏收录该内容

1 篇文章 0 订阅

订阅专栏

// 声明变量

// 在js中使用var关键字来声明一个变量

var a;

// 为变量赋值

a=123;

a=456;

// 声明和赋值同时进行

var b=789;

console.log(b);

</script>

<p>

<!--

可以将js代码编写到外部js文件中，然后通过scipt标签引入

写到外部文件中可以在不同页面中同时引用，也可以利用到浏览器

的缓存机制推荐使用的方式

-->

<!--

script标签一旦用于引入外部文件了，就不能在编写代码了，既是编写了浏览器也会沪铝

如果需要则可以在创建一个新的script标签用于填写内部代码

-->

alert("我是内部伞兵")

</script>

<!-- <script type="text/javascript">

// 控制浏览器弹出一个警告框

// alert("sanbinglaile")

// 让计算机在页面中输出一个内容

// document.write("伞兵又来了")可以向body中输出一个内容

// 向控制台输出一个内容

// console.log("丧病将来");

</script> -->

</p>

// boolran 布尔值

// 布尔值有两个，主要用来做逻辑判断

// true -表示真

// false -表示假

// 使用typeof检查一个布尔值，会返回Boolean

var bool=true;

console.log(typeof bool);

// 将其他的数据类型转换为boolean

// 使用boolean()函数

// -数字----->布尔

// -除了0和NAN，其余的都是true

// -字符串----->布尔

// -除了空串，其余的都是true

// null和undefined都是false

// 对象也会转换成true

var a=123; // true

a=-123;// true

a=0;// false

a=Infinity;// true

a=NaN;// false

// 调用boolean()函数来将a转换为布尔值

a=Boolean(a);

console.log(typeof a);

console.log(a);

</script>

// 算数运算符

// 当对非Number类型的值进行运算时，会将这些值转换为Number然后

// 任何值和NAN做运算都得NAN

// 可以对两个值进行加法运算，并将结果返回

// 如果对两个字符串进行加法运算，则会做

var a=123;

var result=typeof a;

// console.log(typeof result);

result=a+1;

result=456+789;

result=true+false;

result=2+null;

result=2+NaN;

result="123"+"456";

console.log(result);

// 符合两边只有一个操作数的符号就是一元运算符；主要有两种：“++”“--”

// 当不出现赋值时，执行自增(自减)运算；但是出现赋值时，先赋值，后运算；

// “++”运算符他是一种自增运算符，eg：var a=2; a++; console.log(a); 结果为：3、、a++相当于a=a+1

// “--”运算符他是一种自减运算符，eg：var a=2; a--; console.log(a); 结果为：1、、a++相当于a=a-1;

// 运算符后置(eg:a++)

var a=5;

var b=a++;//先赋值，后运算

console.log(a);// a=6

console.log(b);b=5

// 运算符前置(eg:++a)

// 当不出现赋值时，执行自增(自减)顺序，但出现赋值时，先赋值，后运算。

var a=5;

var b=++a;//先运算，后赋值；

console.log(a);//a=6

console.log(b);//b=6

// ++num相当于num=num+1;

// num–相当于num=num-1;

// 前置型是在进行算术运算之前再进行自增或自减运算。

// 后置型实在进行算术运算之后再进行自增自减运算。

var a = 2,

b = 6,

a++;

b--;

console.log(a); //3

console.log(b); //5

c = (a++) + (++b) + (a--) + (a+b) + b;

对c的运算进行拆分

var a1 = a++; //3

var a2 = ++b; //6

var a3 = a--; //3

var a4 = a+b; //9

var a5 = b; //7

c = a1 + a2 + a3 + a4 + a5; //28

console.log(c); //28

JavaScript 中的逻辑运算符可用来确定变量或者是值之间的逻辑关系。通常用于布尔型值，

会返回一个布尔值true 或 false。而 &&、|| 运算符能够使用非布尔值的操作数，

此时会返回一个非布尔型值。

//逻辑与操作符

// 逻辑与 &&操作符，如果第一个操作数为 true，计算结果就是第二个操作数。

// 如果第一个操作数为 false，结果就是 false（特殊数值除外）

console.log(true && true); // true 操作数为true则结果为第二个操作数

console.log(true && false); // false

console.log(true && 10); // 10

console.log(true && (4 > 7)); // false

console.log(false && 10); // false 操作数为false则结果为false

console.log(false && ""); // false

console.log(" " && 0); // 0

console.log(2 && 7); // 7

// 逻辑或 || 操作符，如果第一个操作数能够转为 true（不是 false），结果就是第一个操作数，

// 否则结果是第二个操作数。

console.log(true || true); // true 第一个操作数为true则结果为第一个操作数

console.log(true || false); // true

console.log(true || 10); // true

console.log(true || (4 > 7)); // true

console.log(false || 10); // 10 第一个操作数不是true，则结果为第二个操作数

console.log(false || ""); //

console.log(false || 0); // 0

console.log(0 || 7); // 7

// 逻辑非 ! 操作符，首先把数据转化为布尔值，然后取反，结果为 true 或 false。

//例如true 本来就是布尔值，取反会得到 false。false 取反会得到 true：

console.log(!true); // false

console.log(!false); // true

console.log(!0); // true

console.log(!""); // true

console.log(![1, 2, 3]); // false

// 非布尔值的与运算是短路的，即在判断第一个为false后，就不会再判断第二个

var a = 123 && 0;

console.log(a);//a = 123

var a = 0 && 123;

console.log(a);//a = 0；第一个为0，直接返回，不再判断123

var a = NaN && 0;

console.log(a);//a = NaN

// 非布尔值的或运算也是短路的，即在判断第一个为true后，就不会再判断第二个

var a = 123 || 0;

console.log(a);//a = 123；第一个为true则直接返回该值，不再判断第二个

var a = 0 || 123;

console.log(a);//a = 123

var a = NaN || 0;

console.log(a);//a = NaN

var a = "" || "123";//""判断为false

console.log(a);//a = "123"

// 用于进行比较的运算符称作为关系运算符：小于(<)、大于(>)、小于等于(<=)、大于等于(>=)、相等(==)、不等(!=)、

// 全等(恒等)(===)、不全等(不恒等)(!==)

1、两个操作数都是数值，则数值比较;

2、两个操作数都是字符串，则比较两个字符串对应的字符编码值;

3、两个操作数有一个是数值，则将另一个转换为数值，再进行数值比较;

4、两个操作数有一个是对象，则先调用valueOf()方法或toString()方法，再用结果比较;

var box=3 > 2; //true

var box=3 > 22; //false

var box= '3' > 22; //false

var box= '3' > '22'; //true

var box= 'a' > 'b'; //false a=97,b=98

var box= 'a' > 'B'; //true B=66

var box= 1 > "对象"; //false，如果有toString()或valueOf()则返回1 > 返回数的值

1.一个操作数是布尔值，则比较之前将其转换为数值，false转成0，true转成1;

2.一个操作数是字符串，则比较之前将其转成为数值再比较;

3.一个操作数是对象，则先调用valueOf()或toString()方法后再和返回值比较;

4.不需要任何转换的情况下，null和undefined是相等的;

5.一个操作数是NaN，则==返回false，!=返回true;并且NaN和自身不等;

6.两个操作数都是对象，则比较他们是否是同一个对象，如果都指向同一个对象，则返回true，否则返回false。

7.在全等和全不等的判断上，比如值和类型都相等，才返回true，否则返回false。

var box = 2 == 2; //true

var box = '2' == 2; //true，'2'会转成成数值2

var box = false == 0; //true，false转成数值就是0

var box = 'a' == 'A'; //false，转换后的编码不一样

var box = 2 == {}; //false，执行toString()或valueOf()会改变

var box = 2 == NaN; //false，只要有NaN，都是false

var box = {} == {}; //false，比较的是他们的地址，每个新创建对象的引用地址都不同

var age = {};

var height = age;

var box = age == height; //true，引用地址一样，所以相等

var box = '2' === 2 //false，值和类型都必须相等

var box = 2 !== 2 //false，值和类型都相等了

//条件运算符是唯一的三元运算符，其语法格式如下：

// b ? x : y

// 如果操作数 b 的返回值为 true，则执行 x 操作数，并返回该表达式的值。

// 如果操作数 b 的返回值为 false，则执行 y 操作数，并返回该表达式的值。

//定义变量 a，然后检测 a 是否被赋值，如果赋值则使用该值；否则设置默认值。

var a = null; //定义变量a

typeof a != "undefined" ? a = a : a = 0; //检测变量a是否赋值，否则设置默认值

console.log(a); //显示变量a的值，返回null

//条件运算符可以转换为条件结构：

if(typeof a != "undefined"){ //赋值

a = a;

}else{ //没有赋值

a = 0;

}

console.log(a);

// 也可以转换为逻辑表达式：

(typeof a != "undefined") && (a =a) || (a = 0); //逻辑表达式

console.log(a);

</script>

if语句：

语法：

if(判断条件){

代码块;

}

执行规则：

当判断条件成立(true)时，执行代码块

// 例

var a=10;

if(a<=5){

console.log('run');

}

console.log('end');

// 例

var score=prompt('请输入成绩');//弹出输入框

if(score>=80){

alert('考试合格');

}

alert('不合格');

// if......else语句的语法

if...else 语句

语法：

if(判断条件){

代码块1;

}else{

代码块2;

}

执行：当判断条件成立时，执行代码块1;否则，执行代码块2

var score=prompt('请输入考试成绩');

if(score>=80){

alert('合格');

}else{

alert('补考');

}

// if......else if....多分支语句的语法

// if..else if... 多分支语句

// 语法：

// if(判断条件1){

// 代码块1;

// }else if(判断条件2){

// 代码块2;

// }

// ...

// else if(判断条件n){

// 代码块n;

// }else{

// 代码块;

// }

// 执行规则：若判断条件1成立，则执行代码块1

// 若判断条件2成立，执行代码块2

// 若以上条件均不成立，则执行else

// 例

// 根据用户输入输出结果：若今天是星期日，则出去旅游；星期六，去游泳，其它时间上班

var week=prompt('请输入今天是星期几？');

if(week=='星期六'){

console.log('去游泳');

}else if(week=='星期日'){

console.log('去旅游');

}else{

console.log('上班');

}

// 例

var age=prompt('请输入您的年龄：');

if(age>65){

console.log('老年');

}else if(age>35){

console.log('中年');

}else if(age>22){

console.log('青年');

}else if(age>18){

console.log('青少年');

}else{

console.log('未成年');

}

// 定义一个变量，表示当前的钱数

var money=1000;

// 定义一个计数器

var count=0;

// 定义一个while循环来计算每年的钱数

while (money<5000){

money*=1.05;

// 使count自增

count++;

}

console.log("一共需要"+count+"年");

</script>

arr=[1,2,3,4];

//普通for循环

for(i=0;i<arr.length;i++){

console.log(i,arr[i]);

}

//for..in，遍历对象的属性(数组下标也算)。

for (property in arr) {

console.log(property, arr[property]);

}

// 用for..of遍历数组对象。只会遍历属于数组本身的值。

for (element of arr) {

console.log(element);

}

/*用iterable.forEach(callbackFn,?thisArg)`遍历。

ES6标准引入了新的iterable类型， Array、Map和Set都属于iterable类型。

具有iterable类型的集合可以通过新的for ... of循环来遍历。

arr.forEach(function(value,key,arr){

console.log(key,value,arr);

})

</script>

在页面中接收一个用户输入的数字，并判断该数是否是质数

质数：只能被1和它自身整除的数，1不是质数也是合数，质数必须必要是大于1的自然数

var num=prompt("请输入一个大于1的整数:")

// 判断这个值是否合法

if(num<=1){

alert("该值不合法！");

}else{

// 创建一个变量来保存当前的数的状态

// 默认当前num是质数

var flag=true;

// 判断num是否是质数

// 获取2-num之间的数

for(var i=2;i<num;i++){

// 判断num是否能被i整除

if(num%i==0){

// 如果num能被i整除，则说明num一定不是质数

flag=false;

}

// 如果num是质数则输出

if(flag){

alert(num+"是质数！！！");

}else{

alert("这个不是质数！")

}

</script>

let items=[

{id: 0, name: '01', url: '..1'},

{id: 1, name: '02', url: '..1'},

{id: 2, name: '03', url: '..1'},

{id: 4, name: '04', url: '..1'},

]

var nums = 4;//预设值

var dataSize = items.length;

var columns = dataSize/ nums;

var ul = '';

var li = '';

for(let i= 0; i< dataSize; i++){

for(let j= 0; j< columns; j++){

if(i/ nums == j){

li = '';//这里置空li，避免重复塞入

for(let m= i; m< (j+ 1)* nums ; m++){

li += '<li>'+items[m].name+'</li>'

}

ul += '<ul class="wrap">'+li+'</ul>'

}

console.log(ul);//这里完成。

// for循环练习

// 九九乘法表

for(var i=1;i<=9;i++){

for(var j=1;j<=i;j++){

document.write("<span>"+j+"*"+i+"="+i*j+"   ");

}

// 输出一个换行

document.write("<br/>");

}

</script>

<style>

body{

width: 2000px;

}

span{

/* display: inline-block; */

width: 80px;

}

</style>

// break和continue都是用来控制循环结构的，主要是停止循环。

// 在某种条件出现的时候终止循环而不是等到循环条件为false才终止。

// 这时可以使用break来完成。break用于完全结束一个循环，跳出循环体执行循环后面的语句。

function fn(){

for(var i=0;i<5;i++){

if(i%2!=0){

break;//结束结构

}

console.log(i);

}//0

console.log("ha");

}

// continue只是终止本次循环，接着还执行后面的循环

function fn() {

for(var i=0;i<5;i++){

if(i%2==0){

continue;

}

console.log(i);

}//1 3

console.log("ha")

}

fn();

// return

// return 停止了这个for循环，跳出循环并且停止执行fn函数里后边的语句

function fn() {

for(var i = 0; i < 5; i++) {

if(i == 3) {

return;

}

console.log(i);

}

console.log("ha")

}

fn();

</script>

程程小序序

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录