java script DAY(二) 「运算符」、「数据类型」、「数据类型转换」、「if分支」

最新推荐文章于 2024-11-15 18:38:47 发布

左偲璠

最新推荐文章于 2024-11-15 18:38:47 发布

阅读量415

点赞数

本文链接：https://blog.csdn.net/SISIZ2/article/details/122436983

版权

运算符

赋值运算符：
1. = ：赋值运算符 x = 10; //将10赋值给x
```
var x;

x=20; //将20赋值给x

x=30; //将20赋值给x

console.log(x); //结果输出x=30
```
2. +=： x+=3; 等价于x=x+3; 将左边的x和右边的3求和，重新赋值给x
```
var x=20;

x+=3;  //x=x+3

console.log（x）;  //输出x=23
```
3. -=: x-=3; 等价于x=x-3; 将左边的x和右边的3求差，重新赋值给x
```
var x=20；

x—=2; //x=x-2

console.log(x);  //输出x=18
```
4. *=: x*=3; 等价于x=x*3; 将左边的x和右边的3求乘积，重新赋值给x
```
var x=20；

x*=2； //x=x*2

console.log（x）;  //输出x=40
```
5. /=: x/=3; 等价于x=x*3; 将左边的x和右边的3求商，重新赋值给x
```
var x=20；

x/=2； //x=x/2

console.log（x）;  //输出x=10
```
6. %=: x%=3; 等价于x=x*3; 将左边的x和右边的3求余数，重新赋值给x
```
var x=20；

x%=2； //x=x%2

console.log（x）;  //输出x=0
```

算术运算符：

+ ： 1.求和（数字和数字，数字和布尔）

var x=10；

var y=20；

console.log(x+y);  //数字和数字相加，30

console.log(x+true)；  //数字和布尔相加，11

2.拼接 (字符串和数字)

var x=10；

var z='hello'；

console.log(x+z);  //数字和字符串相拼接  10hello

3.正号

var x=10；

console.log（+x）；  //正的x，10

-：求差

var x=10；
var y=20；
console.log（y—x）； //10

* : 乘积

 var x = 10;
 var y = 20;
 console.log(x*y); // 200

/: 求商

 var x = 10;
 var y = 20;
 console.log(x/y); // 0.5

%: 求余数: 取出不能被整除的那一部分
 var x = 10;
 var y = 20;
 console.log(x%y); // 10

3.关系运算符：

比较两个数字的关系，获取的是一个布尔值(true、false)

> :大于

<:小于

>=：:大于等于

==:等于 (比较的只是值是否相等，不比较类型)

!=：不等于

===：全等 (比较的只是值是否相等，也比较类型)

除了全等以外，其他符号，都比较的是值，不比较类型
    console.log(5>=3); //true
    console.log(5>=5); //true
    console.log(5==5);//true
    console.log(5=='5');  //true
    console.log(5==='5'); //false
    console.log(5!=5); //false
    console.log(5!=3);//true

    console.log(5>'3'); // true

4. 逻辑运算符：

&&:

含义：并且

特点：一假即假,全部为真，整个表达式才是真的
   console.log(5>3&&4<2); // fasle
   console.log(4==4&&3>=1&&true&&0!=1); // true
   console.log(4==4&&3>=1&&false&&0!=1);//false
||：

含义：或者

特点：一真即真, 有一个条件为真，整个表达式的结果就是真的
   console.log(5>3||2==1||9==0); // true
!:

含义：取相反

特点：颠倒真假
console.log(!(4==4&&3>=1&&false&&0!=1)); //true
console.log(!false);//true
console.log(!true);//false

5.自加自减运算符：

++

使用：a++ / ++a

区别：单独使用，a++和++a都是自身加1

参与赋值，输出等操作时，a++和++a有区别?

++a先加1，再进行输出，赋值操作
    var a = 10;
    console.log(++a); //11   输出操作， ++a 先自身加1，再输出
    console.log(a);
a++先输出，赋值操作，再自身加1
      var a  =10;
      console.log(a++); //10   输出操作，a++先输出a，再自身加1
      console.log(a);

--：同++

数据类型

基本数据类型：

数字类型：number

字符串类型：string

布尔类型：boolean

未定义类型：undefined

空类型：null

typeof 关键字用来检测数据类型：

   关键字: typeof

语法:

typeof 要检测的变量

typeof(要检测的变量)

   结果:

你检测的变量的数据类型

以字符串的形式给你

注意: typeof的结果必然是一个字符串类型

当多个typeof连写的时候, 结果必然是string

   两个语法的区别

   ()

当你需要检测两个内容的运算结果的时候, 必须要使用 () 包裹
 var x = 10;
  //  检测x变量的数据类型
  console.log(typeof x); //'number'
  console.log(typeof (x));//'number'


  var y = true;
  console.log(typeof y);//'boolean'


  var str = '123456';
  console.log(typeof str);//'string'


  var z;
  console.log(typeof z);// 'undefined'


  var n = null;
  console.log(typeof n); //'object'
  // 检测  typeof x结果的类型
  console.log(typeof typeof x);//string
  //  等价于  console.log(typeof 'number'); //string
  console.log(typeof typeof y);//string
  //  需求：在页面中弹出一个输入框   只要是输入框类型的，结果都是字符串（"123"）
  var num = prompt('请输入...');//将你输入的内容存储到num变量中
  console.log(num); // "123"
  console.log(typeof num); // "string" 检测输入内容的类型
// typeof n 和 typeof(n)的区别
  console.log(typeof 10 + 20);//"number20"   检测数字10的数据类型 ，然后和20求和或者求拼接
  console.log(typeof(10 + 20));//  "number"  检测10和20运算结果的数据类型

数据类型转换：

   将字符串转为数字：

1. 为什么要转换

利用输入框求两个数字的和

var x = prompt('请输入...');//

var y = prompt('请输入...');//

console.log(x+y);// 是字符串和字符串的拼接

将字符串类型转为数字类型：parseInt()、parseFloat()、Number()

   1.Number()

     语法: Number(你要转换的内容)

       返回值(结果): 转换后的数值类型

   转换规则:

把你要转换的内容当做一个整体

如果整体是一个合法数字, 那么就是这个数字

如果整体不是合法数字, 那么结果就是NaN(notanumber)
var x = "123"; // 合法数字
  // 把x转为数字类型
  console.log(Number(x)); //是一个什么类型呢？可以通过typeof进行检测
  console.log(typeof Number(x));//'number'  将字符串x转为number类型啦

  var y = "pxabc"; // 不是合法数字 
  console.log(Number(y)); // 转换失败就转为了NaN // NaN

  // Number(x)：  x只能是纯数字字符串才可以转为数字 ，其他的都转为NaN

  console.log(Number('px123')); //Nan
  console.log(Number('123px'));//NaN
  console.log(Number("123"));// 123
注意:

可以把true转为1，false转为0
  console.log(Number(true)); // 1
  console.log(Number(false)); // 0
2. parseInt()

语法: parseInt(你要转换的内容)

     返回值(结果): 转换后的数值类型(整数)

   转换规则:

从左到右一定会一位一位的看待

如果第一位就不能转换成合法数字, 那么直接给出NaN的结果, 停止转换

如果第一位可以转换, 那么保留, 继续查看第二位

以此类推, 直到某一位不能转换, 或者到达末尾

   把保留的内容当做结果

       特点: 不认识小数点

"123pxabc"-->123

"abc1243"--->NaN

parseInt('100px');//100

parseInt('pa100');//NaN

parseInt(true)-->NaN
  console.log(parseInt('100px'));//100
  console.log(parseInt('px100'));//NaN
  console.log(parseInt('100.1px'));//100
3. parseFloat()

语法: parseFloat(你要转换的内容)

返回值(结果): 转换后的数值类型

转换规则: 和parseInt一模一样

区别: 认识小数点
  console.log(parseFloat('100px'));//100
  console.log(parseFloat('px100'));//NaN
  console.log(parseFloat('100.1px'));//100.1

  console.log(parseInt(true));//NaN
4. 转为数字（隐式转换）

- * / % （加号不行，正号可以）

console.log("10" + 0);// 字符串100

console.log(+"10");// 数字10

console.log("10" - 0);// 数字10

console.log("10" * 1);// 数字10

console.log("10" / 1);// 数字10
  console.log(typeof("10" - 0));// 数字10
  console.log(typeof("10" * 1));// 数字10
  console.log(typeof("10" / 1));// 数字10

数字类型转为字符串：

1.String()

=> 语法: String(你要转换的数据)

=> 返回值: 转换好的字符串类型

=>什么数据类型都可以转换

2.toString()

=> 语法: 你要转换的数据.toString()

=> 返回值: 转换好的字符串类型

=> 注意: 不能转换null和undefined
 var x = 10;
// 把数字x转为字符串
console.log(typeof String(x));
console.log(typeof x.toString());
3. 拼接

数字+字符串
var abc = 123;
console.log(String(abc)+5); //"123"+5

转布尔类型：

     在JS内, 只有5个内容转换成false

     数值0

     空字符串''

     数值NaN

     undefined

     null

       其他所有内容都转换成true
// Boolean()可以将0，NaN，'', undefined,null转为 false，其他的全部是true 
 console.log(Boolean(0));//false
 console.log(Boolean(NaN));//false
 console.log(Boolean(''));//false
 console.log(Boolean(null));//false
 console.log(Boolean(undefined));//false

 console.log(Boolean('1'));//true
 console.log(Boolean(1));//true
 console.log(Boolean('我'));//true
 console.log(Boolean('-'));//true
 console.log(Boolean('000'));//true
Boolean()

语法: Boolean(你要转换的内容)

返回值: 转换好的布尔值内容

验证不是一个数：
验证是否一个数字不是数字：

       只能检测是不是一个合法数字

     语法: isNaN(你要检测的数据)

返回值: 一个布尔值

true: 说明是一个非数字, 证明不是一个数字

      false: 说明不是一个非数字, 证明是一个数字
```
    console.log(isNaN('我是文字'));//不是数字就是true
    console.log(isNaN(1000));//是数字的就是false
```
if分支结构：

选择结构：
   1.if语法：

       语法: if (条件) { 代码 }

       意义: 条件为 true 的时候, 执行 {} 内的代码, 条件为 false, 不执行
```
    var x = Number(prompt('请输入数字...')); //将字符串内容转为数字
    if (x >= 10) {
        console.log('x大于10');
    } else {
        console.log('x小于10');
    }
```
2. if else 语句（双分支，只能走其中的一条）

语法: if (条件) { 代码 } else { 代码 }

意义:

条件为 true 的时候, 执行 if 后面的 {} 内部的代码

     条件为 false 的时候, 执行 else 后面的 {} 内部的代码

   两个 {} 内的代码, 必然会执行一个

     举例子：

if(false){ 语句一}else{语句二}----> 语句二

if(true){ 语句一}else{语句二}----> 语句一
```
    var a=Number(prompt('请输入数字...')); //输入

    if (a < 50) {
        console.log('不及格')
    } else if (a >= 60 && a <= 70) {
        console.log('良好')
    } else if (a > 70 && a <= 80) {
        console.log('不错')
    } else if (a > 90) {
        console.log('优秀')
    }
```
例子：判断一个数字是奇数还是偶数
```
 var x = Number(prompt('请输入'));
 if (x%2==0) { //偶数
     console.log(x+"是偶数");
 }else{
     console.log(x+"是奇数");
 }
```
目录

运算符

数据类型

数据类型转换：

if分支结构：