【Java】运算符

news2025/2/24 0:09:29

我不去想是否能够成功

既然选择了远方

便只顾风雨兼程

                                                                                                    —— 汪国真 

目录

1. 认识运算符 

1.1 认识运算符 

1.2 运算符的分类

2. 算术运算符

2.1 四则运算符 

 2.2 复合赋值运算符

2.3 自增 / 自减 运算符 

3.关系运算符 

4.逻辑运算符

4.1 逻辑与 &&

4.2 逻辑或 ||

4.3 逻辑非 ！ 

4.4 短路求值

4.5 记忆口诀

5.位运算符 

5.1 按位与 &

5.2 按位或 |

5.3 按位取反 ~

5.4 按位异或 ^

6.移位运算

6.1 左移  <<

5.2 右移 >>

5.3 无符号右移 >>> 

6.条件运算符

1. 认识运算符 

1.1 认识运算符 

运算符：对操作数进行操作时而用到的符号就叫做运算符（最常见的的操作便是进行数学运算），比如：+ - x  /  都是运算符。

public class Test {
    public static void main(String[] args) {
        int a = 1;// = ：是赋值运算符
        int b = 2;
        int c = 1 + 2;// + ：算术运算符
        System.out.println(c);
    }
}

上述代码中 = 和 + 就是运算符，即：对操作数进行操作时的符号就是运算符，不同运算符操作的含义不同。

1.2 运算符的分类

2. 算术运算符

2.1 四则运算符 

四则运算符：+  -  *  /  %

四则运算符 是 双目运算符

补充知识：

  • 双目运算符：有两个操作数的就叫做双目运算符
  • 单目运算符：有一个操作数的就叫做单目运算符
  1. 四则运算符两边操作数要是整型则结果就是整型
  2. 当左右两边操作数类型不一致是，则类型小会向类型大的提升

 四则运算符两边操作数可以是变量也可以是常量

①  +   -   *   / 

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(1 + 2);
    }
}

a / b：int / int = int，如果我们想要得到小数，有两种方法

方法一：强制类型转换法

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println((double) a / b);
    }
}

首先将 a 强制类型转换为 double 类型，然后除 b，当 b 看到 a 是 double 类型，则会自动提升成double 类型 

方法二：乘小数法 

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println((a * 1.0) / b);
    }
}

首先我们知道 一个数 乘 1 等于这个数本身，a * 1.0 此时相当于 int * double = double ，a * 1.0的结果是 double 类型的，然后在除 b，就相当于 double / int = double

在做除法运算的时候右操作数不能为 0 

②  %

public class Test {
    public static void main(String[] args) {
        System.out.println(7 % 2);
        System.out.println(-7 % 2);
        System.out.println(7.5 % 2);
    }
}

运行结果 ：

取余算法：

注：Java中的取余运算符左右两边操作数可以浮点数，但是C语言中取余运算符左右两边操作数必须是整数 

 在做取余运算的时候右操作数不能为 0 

 2.2 复合赋值运算符

复合赋值运算符：+=   -=    *=     /=      %=    <<=   等等

复合赋值运算符作用：将操纵的结果赋值给左操作数。比如：（a = 1；）  a += 7；  相等于  a = a + 7；

public class Test {
    public static void main(String[] args) {
        int a = 1;
        a += 6;//等价于 a = a + 6 ，a = 7
        System.out.println(a);
        a -= 1;//等价于 a = a - 3 ，a = 6;
        System.out.println(a);
        a /= 2;//等价于 a = a / 2 ，a = 3;
        System.out.println(a);
        a *= 7;//等价于 a = a * 3 ，a = 21;
        System.out.println(a);
        a %= 5;//等价于 a = a % 3 ，a = 1;
        System.out.println(a);
        a += 7 + 1;//等价于 a = a + (7 + 1) ，a = 9;
        System.out.println(a);
    }
}

注：复合赋值运算符左操作数必须是变量，因为常量不允许被修改 

当不同类型使用复合赋值运算符是会自动发生类型转换，不需要我们自己强制转换 

public class Test {
    public static void main(String[] args) {
        int a = 1;
        a += 1.5;//等价于：a = (int)(a + 1.5)
        System.out.println(a);
    }
}

2.3 自增 / 自减 运算符 

自增 / 自减 运算符 ：++   --

自增 / 自减 运算符的作用：对变量的值进行 加一 或 减一

自增可以分为 前置++ 和 后置++

  • 前置++：先加一，后运算
  • 后置++：先运算，后加一 

自减可以分为 前置-- 和 后置--

  • 前置--：先减一，后运算
  • 后置--：先运算，后减一
public class Test {
    public static void main(String[] args) {
        int a = 9;
        System.out.println(++a);//先将a的值加一（a = 10），然后在打印。打印结果为：10
        System.out.println(a++);//先将a的值打印，然后在加一（a = 11）。打印结果为：10
        System.out.println(--a);//先将a的值减一（a = 10），然后在打印。打印结果为：10
        System.out.println(a--);//先将a的值打印，然后在减一（a = 9）。打印结果为：10
    }
}

虽然 ++a ，看似没有给 a 赋值，但是 a 中的值依然会 +1

自增 / 自减 运算符看似没有给变量赋值，但是变量中的值依然发改变 

注：只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改 

3.关系运算符 

关系运算符：>  <   >=   <=    !=   == 

关系运算符的作用：用于判断是否为 true 或者是 false

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a > b);//10 > 20 为假，打印false
        System.out.println(a >= b);//10 >= 20 为假，打印false
        System.out.println(a < b);//10 < 20 为真，打印true
        System.out.println(a <= b);//10 <= 20 为真，打印true
        System.out.println(a != b);//10 != 20 为真，打印true
        System.out.println(a == b);//10 == 20 为假，打印false
        System.out.println(1 > 2);//1 > 2为假，打印false
        System.out.println(1 < 2);//1 < 2为真，打印true
    }
}
  • Java 中 true 表示真，false 表示假
  • >=：表示大于或者等于 两者只用满足一个就为true
  • !=：表示不等于
  • ==：Java中两个等号才表示相等（一个等号表示赋值）
  • 关系运算符两边操作数可以是变量也可以是常量 

4.逻辑运算符

逻辑运算符：&&    ||     ！ 

逻辑运算符的作用 ：用于判断是否为 true 或者是 false

4.1 逻辑与 &&

&&： 双目运算符，左右两边都是表达式，表达式的结果都是 boolean 类型

&&语法规则：表达式1 && 表达式2，表达式1结果为true ， 表达式2 结果为true，整个表达式的结果才为true

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a < b && c > b);//true && true，打印true
        System.out.println(a < b && c < b);//true && false，打印false
        System.out.println(a > b && c > b);//false && true，打印false
        System.out.println(a > b && c < b);//false && false，打印false
    }
}

注：boolean 类型只有两个值，一个是true ，还有一个是 false

4.2 逻辑或 ||

||：双目运算符，左右两边都是表达式，表达式的结果都是 boolean 类型 

|| 语法规则：表达式1 || 表达式2，表达式1结果 或者 表达式2结果 至少有一个为为true，整个表达式的结果才为true 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        System.out.println(a < b || c > b);//true || true，打印true
        System.out.println(a < b || c < b);//true || false，打印true
        System.out.println(a > b || c > b);//false || true，打印true
        System.out.println(a > b || c < b);//false || false，打印false
    }
}

4.3 逻辑非 ！ 

！：单目运算符，只有一个操作数。表达式的结果都是 boolean 类型 

！语法规则：!（表达式），表达式的结果为为 true，则整个表达式的结果就为 false；表达式的结果为 false，则整个表达式的结果就为false

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(!(a > b));//10 > 20,结果为false，然后经过逻辑非结果就是true
        System.out.println(!(a < b));//10 > 20,结果为true，然后经过逻辑非结果就是false
    }
}

4.4 短路求值

对于 && 和 || ，都是遵循短路求值规则

① && 的短路求值 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println((a > b) && ((++a) > b));
        System.out.println(a);
    }
}

上述代码运行结果： 

代码解析： 

&& 两边操作数都为真，结果为真；要是有一个结果为假，则结果为假。 当执行 表达式1 时发现为假，则整个表达式的结果为假。如果为真，则继续判断下一个 表达式2 的结果 ，表达式2 的结果为真，则整个表达式的结果为真，如果 表达式2 的结果为假，则整个表达式的结果为假

a > b ---->  10 > 20 ,表达式为假，则不会执行（++a）> b。所以整个表达式的结果为假，并且 a 的值不变

② || 的短路求值 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println((a < b) || ((++a) < b));
        System.out.println(a);
    }
}

上述代码运行结果：

代码解析： 

|| 两边操作数的结果至少有一个为真，则整个表达式为真；都为假，则整个表达式为假 。当执行表达式1 的时候如果结果为真，则不会去执行 表达式2 ，整个表达式的结果就为真。当执行 表达式1 的时候，如果结果为假，则去执行 表达式2 ，表达式2 的结果为真，则整个表达式的结果就为真，要是 表达式2 的结果为假，则整个表达式的结果为假

4.5 记忆口诀

&&：全真得真

||：见真得真

!  : 非真即为假，非假即为真

5.位运算符 

位运算符，见名知意 就可以知道是处理二进制位的运算符。

补充知识： 

Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位

1 字节 = 8 比特位

位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(二进制：01构成的序列), 按位运算就是在按照 二进制位 的每一位依次进行运算。

位运算符：&        |        ~        ^ 

  • &：按位与
  • | ：按位或 
  • ~：按位取反
  • ^：按位异或

注：位运算符操作数可以是变量也可以是常量 

5.1 按位与 &

&：全一得一，两个比特位都是 1 ，则为 1 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a & b);
        System.out.println(7 & 6);
    }
}

上述代码运行结果：

代码分析： 

a = 10，b = 20，然后 a & b。 首先将 a 和 b 都转换成二进制的形式，因为 a，b 是 int 类型所以转换为 32 位二进制位：

a：00000000 00000000 00000000 00001010

b：00000000 00000000 00000000 00010100

然后进行按位与，全一得一，则结果为：

00000000 00000000 00000000 00000000，结果就为 0

7 & 6, 7 和 6 默认都是 int 类型的，首先将 7 和 6 都转换为 32 位二进制位：

7：00000000 00000000 00000000 00000111

6：00000000 00000000 00000000 00000110 

然后进行按位与，全一得一，则结果为：

00000000 00000000 00000000 00000110 ，就为 6

5.2 按位或 |

| ：见一得一，两个比特位只要有一个是 1 ，则为 1 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a | b);
        System.out.println(7 | 6);
    }
}

上述代码运行结果： 

代码解析： 

a = 10，b = 20，然后 a | b。 首先将 a 和 b 都转换成二进制的形式，因为 a，b 是 int 类型所以转换为 32 位二进制位：

a：00000000 00000000 00000000 00001010

b：00000000 00000000 00000000 00010100

然后进行按位与，见一得一，则结果为：

00000000 00000000 00000000 00011110，结果就为 30

7 & 6, 7 和 6 默认都是 int 类型的，首先将 7 和 6 都转换为 32 位二进制位：

7：00000000 00000000 00000000 00000111

6：00000000 00000000 00000000 00000110 

然后进行按位与，见一得一，则结果为：

00000000 00000000 00000000 00000111 ，就为 7

5.3 按位取反 ~

~ ： 1 变 0 , 0 变1

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(~a);
    }
}

上述代码运行结果：

 代码解析：

a = 10，然后 ~a 。 首先将 a  转换成二进制的形式，因为 a 是 int 类型所以转换为 32 位二进制位： 

a：00000000 00000000 00000000 00001010

然后按位取反得，1 变 0 , 0 变 1，得：

11111111 11111111 11111111 11110101

计算机只会存储二进制补码的形式，所以计算机会认为这是补码，在用户进行读取的时候计算机会自动将补码转换成原码，然后进行读取出来

补码转原码有两种方法

方法一：补码除了符号位，其他位按位取反，然后加1，的原码

方法二：补码减一得反码，反码符号位不变其他位按位取反得原码 

则 ~a 的结果就是 -11 

补充知识：

正数的原 反 补相同

负数的反码等于原码符号位不变，然后按位取反；负数的补码就是负数的反码加1 

5.4 按位异或 ^

^ ：相同为 0，不同为 1 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a ^ b);
    }
}

上述代码运行结果 ：

代码解析：

 a = 10，b = 20，然后 a ^ b。 首先将 a 和 b 都转换成二进制的形式，因为 a，b 是 int 类型所以转换为 32 位二进制位：

a：00000000 00000000 00000000 00001010

b：00000000 00000000 00000000 00010100

然后进行按位异或，相同为 0，不同为 1 则结果为：

00000000 00000000 00000000 00011110，结果就为 30

6.移位运算

移位运算符，见名知意 肯定又是对二进制位的运算

移位运算符：<<         >>         >>>

  • <<：左移
  • >>：右移
  • >>>：无符号右移 

6.1 左移  <<

<< ：最左侧位不要了, 最右侧补 0 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a << 1);
    }
}

上述代码运行结果： 

代码解析： 

a = 10，然后 a << 1 。 首先将 a  转换成二进制的形式，因为 a 是 int 类型所以转换为 32 位二进制位： 

a：00000000 00000000 00000000 00001010

然后最左侧位不要了, 最右侧补 0 

00000000 00000000 00000000 00010100

将二进制位转换为十进制就是 20 

注：

  • 向左移位时，丢弃的是符号位，因此正数左移可能会变成负数 
  • 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.

5.2 右移 >>

 >>：最右侧位不要了, 最左侧补符号位（正数补0, 负数补1）

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a >> 1);
    }
}

上述代码运行结果： 

代码解析： 

a = 10，然后 a >> 1 。 首先将  a  转换成二进制的形式，因为 a 是 int 类型所以转换为 32 位二进制位： 

a：00000000 00000000 00000000 00001010

然后最右边侧位不要了, 左边正数补0, 负数补1

00000000 00000000 00000000 00001010

将二进制位转换为十进制就是 20 

注：右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方. 

5.3 无符号右移 >>> 

>>>：最右侧位不要了, 最左侧补 0 

public class Test {
    public static void main(String[] args) {
        int a = -10;
        System.out.println(a >>> 1);
    }
}

上述代码运行结果：  

代码解析： 

a = -10，然后 a >>> 1 。 首先将  a  转换成二进制的形式，因为 a 是 int 类型所以转换为 32 位二进制位： 

a：10000000 00000000 00000000 00001010

如果是负数，则需要转为补码然后存储在计算机内进行运算 

原码：10000000 00000000 00000000 00001010 

反码：11111111 11111111 11111111 11110101 

补码：11111111 11111111 11111111 11110110

然后无符号左移： 01111111 11111111 11111111 11111011

结果就为：2147483643

6.条件运算符

条件运算符只要一个：？： 

条件运算符的格式：表达式1 ? 表达式2 : 表达式3

表达式1 的结果必须是 boolean 类型 

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值; 当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.

条件运算符也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法. 

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = (a > b) ? a : b;
        System.out.println(c);
    }
}

 上述代码运行结果：

 代码解析：

如果 a > b 为 true ,则把 a 的值赋值给 c，如果 a > b 为 false ，则把 b 的值赋值给 c 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/405889.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

什么是异步

什么是异步

文章目录 前言一、异步是什么&#xff1f;二、举个例子来理解异步 1.异步最典型的例子就是“回调函数”总结前言 在vue的过程中&#xff0c;我们一定会遇到诸如&#xff1a; function&#xff08;参数&#xff09;.then(res>{}) 形式的代码。到底怎么编译执行的呢 &#xf…
阅读更多...
【Jetpack】ViewModel 架构组件 ( 视图 View 和 数据模型 Model | ViewModel 作用 | ViewModel 生命周期 | 代码示例 | 使用注意事项 )

【Jetpack】ViewModel 架构组件 ( 视图 View 和 数据模型 Model | ViewModel 作用 | ViewModel 生命周期 | 代码示例 | 使用注意事项 )

文章目录一、Activity 遇到的问题二、视图 View 和 数据模型 Model三、ViewModel 架构组件作用四、ViewModel 代码示例1、ViewModel 视图模型2、Activity 组件3、UI 布局文件4、运行效果五、ViewModel 生命周期六、ViewModel 使用注意事项一、Activity 遇到的问题 Activity 遇到…
阅读更多...
宝塔部署nodejs项目

宝塔部署nodejs项目

前言 部署操作很简单&#xff0c;网上也有很多教程&#xff0c;不过我还是踩坑了&#xff0c;这里记录一下&#xff0c;给其他人也避避坑吧。 步骤 首先你已经有了服务器&#xff0c;并且打开了宝塔面板&#xff0c;其次准备好你的nodejs项目。 在宝塔安装pm2管理器&#xf…
阅读更多...
Nginx 调整文件上传大小限制

Nginx 调整文件上传大小限制

使用3A服务器做了网页&#xff0c;感觉挺不错的&#xff0c;使用LNMP环境 用Nginx部署了前端&#xff0c;发现上传附件大一点就会报错&#xff0c;查看配置文件&#xff0c;发现spring的附件配置已经配置了。那么就看下Nginx的body设置。nginx文件上传默认是1MB。 在 server 模…
阅读更多...
VUE3TS: Vue3+TS的项目搭建

VUE3TS: Vue3+TS的项目搭建

简介 通过 Vue-cli4 创建的 Vue3TS 的项目&#xff0c;并进行一些基础使用的举例。 此例是以 VSCode编辑器 进行的编码。 一、项目搭建 1. 进入命令提示符窗口 在要搭建项目的文件夹中&#xff0c;点击路径&#xff0c;输入CMD并按回车 2. 查看node版本、Vue-cli版本 2…
阅读更多...
Android 架构之长连接技术

Android 架构之长连接技术

上文中我们提到了HttpDNS&#xff0c;虽然它比系统DNS更优&#xff0c;但终归还是要做DNS操作。而长连接都是IP直接连接&#xff0c;因此没有DNS相关的开销和耗时。 3. 如果有大量网络请求&#xff0c;可以明显减少网络延时&#xff0c;节省带宽 对于大型App而言&#xff0c;…
阅读更多...
npm——安装、卸载与更新

npm——安装、卸载与更新

npm 官方文档&#xff1a;https://docs.npmjs.com/ 什么是npm npm&#xff08;“Node 包管理器”&#xff09;是 JavaScript 运行时 Node.js 的默认程序包管理器。 它也被称为“Ninja Pumpkin Mutants”&#xff0c;“Nonprofit Pizza Makers”&#xff0c;以及许多其他随机…
阅读更多...
Vue通知提醒框（Notification）

Vue通知提醒框（Notification）

项目相关依赖版本信息 可自定义设置以下属性&#xff1a; 自动关闭的延时时长&#xff08;duration&#xff09;&#xff0c;单位ms&#xff0c;默认4500ms消息从顶部弹出时&#xff0c;距离顶部的位置&#xff08;top&#xff09;&#xff0c;单位像素px&#xff0c;默认24p…
阅读更多...
WebSocket开发（心跳监测）功能

WebSocket开发（心跳监测）功能

前言 在之前的文章中完成了客服对话的Demo功能&#xff0c;但是现在的连接是无限制的长时间连接没有做心跳、失活、超时断连等功能&#xff0c;心跳的实现方法有很多种&#xff0c;并且WebSocket就提供了ping/pong类型的消息。 心跳的触发方式也分两种&#xff1a; 客户端触…
阅读更多...
微信小程序实现图片上传

微信小程序实现图片上传

前言 手机上传图片的功能大家一定都用过吧&#xff0c;今天教你用微信小程序实现这个小功能。 实现效果如下&#xff1a; 实现思路&#xff1a; 首先我们需要定义一个存放图片的数组&#xff0c;通过方法拿取图片的详细信息&#xff0c;然后调用微信小程序的 wx.uploadFile 方…
阅读更多...
element ui datepicker时间控件实现范围选择周，季，年。

element ui datepicker时间控件实现范围选择周，季，年。

因项目要求&#xff0c;需日&#xff0c;周&#xff0c;月&#xff0c;季&#xff0c;年五种日期范围选择器&#xff0c;故参考文章&#xff08;在末尾&#xff09;后分享 一.效果图 二、版本及下载 1.实现需要修改源码&#xff0c;目前修改的版本为2.15.3&#xff0c;所以想要…
阅读更多...
Vue3路由配置createRouter、createWebHistory、useRouter,useRoute

Vue3路由配置createRouter、createWebHistory、useRouter,useRoute

目录 手动配置Vue-router环境&#xff1a; 组件内部跳转路由、传参useRouter,useRoute Vue3和Vue2基本差不多&#xff0c;只不过需要将createRouter、createWebHistory从vue-router中引入&#xff0c;再进行使用。 手动配置Vue-router环境&#xff1a; 1、下载包&#xff1a…
阅读更多...
Uncaught (in promise) TypeError: Cannot read properties of undefined (reading ‘result‘)

Uncaught (in promise) TypeError: Cannot read properties of undefined (reading ‘result‘)

Uncaught (in promise) TypeError: Cannot read properties of undefined (reading result) 如题所示问题&#xff0c;耽误三天寻找bug&#xff0c;终于在我睡意朦胧之际发现了一道光&#xff0c;发现 await 出现的三个点&#xff1a; 于是打开 findAllCategory()这个函数 对应…
阅读更多...
电商后台管理系统简介

电商后台管理系统简介

项目介绍 黑马后台管理系统是一个电商后台管理系统的前端项目&#xff0c;基于VueElement实现。 主要包括商品管理、订单管理、会员管理、促销管理、运营管理、内容管理、统计报表、财务管理、权限管理、设置等功能 开发技术 此项目开发我用到的技术有&#xff1a;vue2node.…
阅读更多...
Vant 2 - 移动端 Vue 组件库 _ 问题记录

Vant 2 - 移动端 Vue 组件库 _ 问题记录

目录 Popup 弹出层 DatetimePicker 时间选择 Field 输入框 Picker 选择器 List 列表 Tab 标签页 发布初衷 &#xff1a; 记录在移动端项目中使用 Vant 2 组件库时遇到的各种问题 &#xff0c; 方便以后再次遇到类似问题 &#xff0c; 能够快时查阅解决 &#xff0c; …
阅读更多...
Vue3+TypeScript+Vite如何使用require动态引入类似于图片等静态资源

Vue3+TypeScript+Vite如何使用require动态引入类似于图片等静态资源

问题&#xff1a;Vue3TypeScriptVite的项目中如何使用require动态引入类似于图片等静态资源&#xff01; 描述&#xff1a;今天在开发项目时&#xff08;项目框架为Vue3TypeScriptVite&#xff09;需要 动态引入静态资源&#xff0c;也就是img标签的src属性值为动态获取&#…
阅读更多...
Lodash 使用及常用方法

Lodash 使用及常用方法

简介 Lodash 是一个一致性、模块化、高性能的 JavaScript 实用工具库。它内部封装了诸多对字符串、数组、对象等常见数据类型的处理函数,Lodash 通过降低 array、number、objects、string 等等的使用难度从而让 JavaScript 变得更简单。 官网 Lodash 简介 | Lodash 中文文档…
阅读更多...
TypeScript详解十六：类型声明（declare）

TypeScript详解十六：类型声明（declare）

目录前言一、类型声明的作用&#xff1f;1.1 declare 关键字1.2 示例二、常见的几种类型声明2.1 普通类型声明2.2 外部枚举2.3 命名空间三、类型声明文件3.1 模拟类型声明文件&#xff0c;以 jquery 为例3.2 使用手动实现的jquery.d.ts声明文件3.3 第三方声明文件&#xff08;以…
阅读更多...
Django web 开发(三) - Django的使用

Django web 开发(三) - Django的使用

文章目录Django安装Django安装Pythonpip加速安装Django创建项目文件介绍简单访问APP添加新的app注册app创建blog的页面templates模板templates模板语法单一变量列表循环(列表)字典循环(字典)列表套字典条件判断请求和响应案例: 用户登录数据库操作安装第三方模块ORM创建数据库D…
阅读更多...
node版本、npm版本随意切换

node版本、npm版本随意切换

前言 随着项目越做越多&#xff0c;难免会有a项目需要12.x的node版本&#xff0c;b项目需要>16.0.0的情况。 为了避免出现node版本切换的繁琐&#xff0c;特意找了这么一个工具&#xff0c;主要是方便管理node版本。 请按照以下步骤来实现 官方地址: 传送门 1、下载软件 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023