LinuxC编程——进程

目录

  • 一、概念
    • 1.1 程序
    • 1.2 进程
  • 二、特点⭐⭐⭐
  • 三、进程段
  • 四、进程分类
  • 五、进程状态
  • 六、进程状态转换图
  • 七、函数接口
    • 1. 创建子进程
    • 2. 回收进程资源
    • 3. 退出进程
    • 4. 获取进程号
  • 八、守护进程

一、概念

进程和程序是密不可分的两组概念，相对比，便于理解。

1.1 程序

简单来说，程序即编译好的可执行文件

展开来说：

  • 编译好的可执行文件
  • 存放在磁盘上的指令和数据的有序集合（文件）
  • 静态的，没有执行的概念

1.2 进程

程序一次执行过程，是动态的，包括创建、调度、执行以及消亡，它是一个独立的可调度的任务
展开来说：

  • 进程是程序的一次执行过程。
  • 进程是动态的，包含创建、调度、执行、消亡。
  • 进程是执行一个程序分配资源的总称。
  • 独立的可调度的任务

二、特点⭐⭐⭐

  1. 系统会为每一个进程分配0-4g的虚拟空间，其中0-3g(用户空间)是每个进程所独有的，3g-4g(内核空间)是所有进程共有的。
  2. CPU调度进程时会给进程分配时间片（几毫秒 ~ 十几毫秒），当时间片用完后，cpu再进行其他进程的调度，实现进程的轮转，从而实现多任务的操作。

三、进程段

Linux中的进程包含三个段：

  1. “数据段”存放的是全局变量、常数以及动态数据分配的数据空间(如malloc函数取得的空间)等。
  2. “正文段”存放的是程序中的代码
  3. “堆栈段”存放的是函数的返回地址、函数的参数以及程序中的局部变量

四、进程分类

  1. 交互进程：该类进程是由shell控制和运行的。交互进程既可以在前台运行，也可以在后台运行。该类进程经常与用户进行交互，需要等待用户的输入，当接收到用户的输入后，该类进程会立刻响应，典型的交互式进程有：shell命令进程、文本编辑器等
  2. 批处理进程：该类进程不属于某个终端，它被提交到一个队列中以便顺序执行。
  3. 守护进程：该类进程在后台运行。它一般在Linux启动时开始执行，系统关闭时才结束。

五、进程状态

  1. 运行态（TASK_RUNNING）R：指正在被CPU运行或者就绪的状态。这样的进程被成为runnning进程。
  2. 睡眠态(等待态)：
  • 可中断睡眠态（TASK_INTERRUPTIBLE）S：处于等待状态中的进程，一旦被该进程等待的资源被释放，那么该进程就会进入运行状态。
  • 不可中断睡眠态（TASK_UNINTERRUPTIBLE）D：该状态的进程只能用wake_up()函数唤醒。
  1. 暂停态（TASK_STOPPED）T：当进程收到信号SIGSTOP、SIGTSTP、SIGTTIN或SIGTTOU时就会进入暂停状态。可向其发送SIGCONT信号让进程转换到可运行状态。
  2. 死亡态X：进程结束
  3. 僵尸态（TASK_ZOMBIE）Z：当进程已经终止运行，但还占用系统资源，要避免僵尸态的产生（例如：在父子进程中，子进程比父进程先结束，而父进程没有对子进程及时回收，释放子进程占用的资源，此时子进程将变成一个僵尸进程）。

六、进程状态转换图

进程创建后，进程进入就绪态，当CPU调度到此进程时进入运行态，当时间片用完时，此进程会进入就绪态，如果此进程正在执行一些IO操作(阻塞操作)会进入阻塞态，完成IO操作（阻塞结束）后又可进入就绪态，等待CPU的调度，当进程运行结束即进入结束态。
在这里插入图片描述

七、函数接口

1. 创建子进程

pid_t fork(void);

  • 功能：创建子进程

  • 参数：无

  • 返回值

    • 成功：在父进程中：返回子进程的进程号 >0；在子进程中：返回值为0
    • 失败：-1并设置errno

  • 特点⭐⭐⭐

    1. 子进程几乎拷贝了父进程的全部内容，包括：代码、数据、系统数据段中的pc值、栈中的数据、父进程中打开的文件等；但它们的PID、PPID是不同的。
    2. 父子进程有独立的地址空间，互不影响；当在相应的进程中改变全局变量、静态变量，都互不影响。
    3. 若父进程先结束，子进程成为孤儿进程，被init进程收养，子进程变成后台进程。
    4. 若子进程先结束，父进程如果没有及时回收，子进程变成僵尸进程（要避免僵尸进程产生）

  • 拓展：

    1. fork之前的代码被复制，但是不会重新执行一遍；fork之后的代码被复制，并且再被执行一遍。
    2. fork之后两个进程相互独立，子进程拷贝了父进程的所有代码，但内存空间独立
    3. fork之前打开文件，fork之后拿到的是同一个文件描述符，操作的是同一个文件指针。（而不同的进程打开相同的文件，操作的是不同的文件指针）
    4. fork函数创建父子进程后各自执行顺序不一定（vfork：先执行完子进程，再执行父进程）

  • 例子：

#include <stdio.h>
#include <unistd.h>
// 若父进程先结束，子进程将变成孤儿进程 且被init进程收养，变成孤儿进程
// 若子进程先结束，父进程如果没与及时回收，子进程将变成僵尸进程
int main(int argc, char const *argv[])
{
    int a =0;
    pid_t pid = fork();
    if(pid<0){
        perror("fork err");
        return -1;
    }
    else if(pid == 0){ // 运行子进程
        printf("child a:%d\n",a);
        while(1);
    }
    else{  // 运行父进程
        a=3;
        printf("parent a:%d\n",a);
        //while(1);
    }
    return 0;
}

2. 回收进程资源

  • wait：pid_t wait(int *status);
    • 功能：回收子进程资源(阻塞)
    • 参数
      • status：子进程退出状态，不接受子进程状态设为NULL
    • 返回值
      • 成功：回收的子进程的进程号
      • 失败：-1
  • waitpid：pid_t waitpid(pid_t pid, int *status, int options);
    • 功能：回收子进程资源
    • 参数：
      • pid：
        在这里插入图片描述
      • status：子进程退出状态
      • options：
        • 0：阻塞
        • WNOHANG：非阻塞
    • 返回值
      • 正常：结束的子进程的进程号
      • 当使用选项WNOHANG且没有子进程结束时：0
      • 出错：-1
  • 例
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(int argc, char const *argv[])
{
    int a = 0;
    pid_t pid = fork();
    if(pid<0){
        perror("fork err");
        return -1;
    }
    else if(pid == 0){
        printf("in child a=%d\n",a);
        // while(1);
        sleep(1);
    }
    else{
        a = 3;
        // wait(NULL); //阻塞回收所有子进程
        // waitpid(-1,NULL,0); //阻塞回收所有子进程
        waitpid(pid,NULL,0); // 阻塞回收pid进程
        // waitpid(pid,NULL,WNOHANG); //不阻塞回收进程号为pid的进程
        printf("in parent a = %d\n",a);
        // while(1);
        wait(NULL);
        printf("parent end...\n");
    }
    return 0;
}

3. 退出进程

  • exit ：void exit(int status);
    • 功能：结束进程，刷新缓存
    • 参数：退出的状态
  • _exit：void _exit(int status);
    • 功能：结束进程，不刷新缓存
    • 参数：status是一个整型的参数，可以利用这个参数传递进程结束时的状态。
      通常0表示正常结束；其他的数值表示出现了错误，进程非正常结束

注：exit与return的区别⭐⭐

  • exit：函数，不管在子函数还是主函数，都可以结束进程（进程的退出）
  • return：关键字，当子函数中有return时返回到函数调用位置，并不结束进程（函数的退出）
    例子：
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>

void fun(int a, int b)
{
    printf("a+b=%d",a+b);
    // exit(0); // 结束进程，刷新缓存
    _exit(0); // 结束进程，不刷新缓存
    return;
}

int main(int argc, char const *argv[])
{
    pid_t pid = fork();
    if(pid<0){
        perror("fork err");
        return -1;
    }
    else if(pid == 0){
        printf("in child\n");
        fun(3,4);
        sleep(1);
    }
    else{
        printf("in parent\n");
        // while(1);
        wait(NULL);
        printf("parent end...\n");
    }
    return 0;
}

运行结果：
exit：会刷新缓存
在这里插入图片描述
_exit：不会刷新缓存
在这里插入图片描述

4. 获取进程号

  • getpid：pid_t getpid(void);
    • 功能：获取当前进程的进程号
  • getppid：pid_t getppid(void);
    • 功能：获取当前进程的父进程号
      例：
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
    pid_t pid = fork();
    if(pid<0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0)
    {
        printf("childpid:%d ppid:%d pid:%d\n",getpid(),getppid(),pid);
        exit(0);
    }
    else
    {
        printf("parentpid:%d ppid:%d pid:%d\n",getpid(),getppid(),pid);
        wait(NULL);
    }
    return 0;
}

运行：
在这里插入图片描述

练习：通过父子进程完成对文件的拷贝(cp)，父进程从文件开始到文件的一半开始拷贝，子进程从文件的一半到文件末尾。要求：文件IO cp src dest

  • 方法一
    这里先执行子进程来进行源文件后半部分的复制，然后执行父进程来进行源文件前半部分的复制
    在这里插入图片描述
    方法二：
    这里先执行父进程来进行源文件前半部分的复制，后执行子进程来进行源文件后半部分的复制
//通过父子进程完成对文件的拷贝(cp)，父进程从文件开始到文件
//的一半开始拷贝，子进程从文件的一半到文件末尾。要求：文件IO cp src dest
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        printf("Please input:%s <srcfile> <destfile>\n", argv[0]);
        return -1;
    }
    int src = open(argv[1], O_RDONLY);
    if (src < 0)
    {
        perror("srcfile open err");
        return -1;
    }
    int dest = open(argv[2], O_WRONLY | O_TRUNC | O_CREAT, 0666);
    if (dest < 0)
    {
        perror("destfile open err");
        return -1;
    }
    off_t half = lseek(src, 0, SEEK_END) / 2; // 文件长度的一半
    int flag = 0;                             // 控制下面父子进程执行顺序，让父进程先执行
    ssize_t s;
    char buf[32] = {0};

    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0) // 子进程 复制源文件后半部分
    {
        while (flag == 1) // 父进程已复制完毕，子进程可以执行
        {
            lseek(src, half, SEEK_SET);
            lseek(dest, half, SEEK_SET);
            while ((s = read(src, buf, 32)) != 0)
                write(dest, buf, s);
        }
    }
    else // 父进程 复制源文件前半部分（先执行）
    {
        lseek(src, 0, SEEK_SET);
        lseek(dest, 0, SEEK_SET);
        int n = half;
        if (n < 32)
        {
            read(src, buf, n);
            write(dest, buf, n);
            flag = 1;
            wait(NULL);
        }
        else
        {
            while ((s = read(src, buf, 32)) != 0)
            {
                write(dest, buf, s);
                n = n - s;
                if (n < 32)
                {
                    read(src, buf, n);
                    write(dest, buf, n);
                    flag = 1;
                    wait(NULL);
                }
            }
        }
    }
    close(src);
    close(dest);
    return 0;
}

//通过父子进程完成对文件的拷贝(cp)，父进程从文件开始到文件
//的一半开始拷贝，子进程从文件的一半到文件末尾。要求：文件IO cp src dest
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
int main(int argc, char const *argv[])
{
    if (argc != 3)
    {
        printf("Please input:%s <srcfile> <destfile>\n", argv[0]);
        return -1;
    }
    int src = open(argv[1], O_RDONLY);
    if (src < 0)
    {
        perror("srcfile open err");
        return -1;
    }
    int dest = open(argv[2], O_WRONLY | O_TRUNC | O_CREAT, 0666);
    if (dest < 0)
    {
        perror("destfile open err");
        return -1;
    }
    off_t half = lseek(src, 0, SEEK_END) / 2; // 文件长度的一半
    int flag = 0;                             // 控制下面父子进程执行顺序，让父进程先执行
    ssize_t s;
    char buf[32] = {0};

    pid_t pid = fork();
    if (pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if (pid == 0) // 子进程 复制源文件后半部分
    {
        while (flag == 1) // 父进程已复制完毕，子进程可以执行
        {
            lseek(src, half, SEEK_SET);
            lseek(dest, half, SEEK_SET);
            while ((s = read(src, buf, 32)) != 0)
                write(dest, buf, s);
        }
    }
    else // 父进程 复制源文件前半部分（先执行）
    {
        lseek(src, 0, SEEK_SET);
        lseek(dest, 0, SEEK_SET);
        int n = half;
        if (n < 32)
        {
            read(src, buf, n);
            write(dest, buf, n);
            flag = 1;
            wait(NULL);
        }
        else
        {
            while ((s = read(src, buf, 32)) != 0)
            {
                write(dest, buf, s);
                n = n - s;
                if (n < 32)
                {
                    read(src, buf, n);
                    write(dest, buf, n);
                    flag = 1;
                    wait(NULL);
                }
            }
        }
    }
    close(src);
    close(dest);
    return 0;
}

八、守护进程

  1. 特点
    守护进程是后台进程；生命周期比较长，从系统启动时开启，系统关闭时结束；它是脱离控制终端且周期执行的进程。
  2. 实现步骤
    1. 创建子进程，父进程退出
      让子进程成为孤儿进程，成为后台进程。fork
    2. 在子进程中创建新会话
      让子进程成为会话组组长，为了让子进程脱离控制终端。setsid()
    3. 改变运行路径为根目录。chdir
      原因：提高权限，让运行路径不能被删除或卸载。chdir
    4. 重设权限掩码。umask
      目的：增大进程创建文件的权限，提高灵活性。umask
    5. 关闭不必要的文件描述符
      目的：关闭不必要的文件描述符。close
  • 练习：创建一个守护进程，循环间隔1s向文件中写入一串字符“hello”
/*创建守护进程实现往日志文件中循环写入hello,间隔时间为1秒*/
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>

int main(int argc, char const *argv[])
{
    //1.创建父子进程
    pid_t pid = fork();
    if(pid < 0)
    {
        perror("fork err");
        return -1;
    }
    else if(pid == 0) //子进程进入
    {
        setsid(); //2.在子进程中创建新会话，让子进程成为会话组组长
        chdir("/"); //3.改变运行目录为根目录
        umask(0); //4.重设文件掩码
        close(0);//5.关闭文件描述符->0 1 2
        close(1);
        
        int fd = open("/tmp/c.log",O_WRONLY|O_CREAT|O_APPEND,0666);
        if(fd < 0)
        {
            perror("open err");
            return -1;
        }
    }
    else
    {
        exit(0);  //1.父进程退出
    }
    return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Qt画波浪球（小费力）

Qt画波浪球（小费力）

画流动波浪 #ifndef WIDGET3_H #define WIDGET3_H#include <QWidget> #include <QtMath> class widget3 : public QWidget {Q_OBJECT public:explicit widget3(QWidget *parent nullptr);void set_value(int v){valuev;}int get_value(){return value;} protecte…
阅读更多...
第四章，向量组，1-向量组与线性组合、线性表示

第四章，向量组，1-向量组与线性组合、线性表示

第四章&#xff0c;向量组&#xff0c;1-向量组与线性组合、线性表示 向量方程向量与向量组向量向量组 线性组合与线性表示线性组合 线性表示定理定义 多表多&#xff08;单向&#xff09;定理推论 定义 等价&#xff08;多表多&#xff1a;双向&#xff09; 知识回顾 玩转线性…
阅读更多...
NIO 非阻塞式IO

NIO 非阻塞式IO

NIO Java NIO 基本介绍 Java NIO 全称 Java non-blocking IO&#xff0c;是指 JDK 提供的新 API。从 JDK1.4 开始&#xff0c;Java 提供了一系列改进的输入/输出的新特性&#xff0c;被统称为 NIO&#xff08;即 NewIO&#xff09;&#xff0c;是同步非阻塞的。NIO 相关类都被…
阅读更多...
END-TO-END、SCALE HYPERPRIOR、Checkerboard梳理总结

END-TO-END、SCALE HYPERPRIOR、Checkerboard梳理总结

8.9-8.15学习汇报 阅读《END-TO-END OPTIMIZED IMAGE COMPRESSION》、《VARIATIONAL IMAGE COMPRESSION WITH A SCALE HYPERPRIOR》、《Checkerboard Context Model for Efficient Learned Image Compression》 传统的图像或视频压缩方法通常分为多个步骤&#xff0c;包括变换…
阅读更多...
工业以太网交换机-SCALANCE X200 环网组态

工业以太网交换机-SCALANCE X200 环网组态

1.概述 SCALANCE X200 系列交换机自从2004年8月推入市场&#xff0c;当时交换机只能接入环网&#xff0c;不能做环网管理器。在各个工业现场得到了广泛的应用。2007年5月发布了X200系列新的硬件版本平台&#xff0c;普通交换机可以用HSR&#xff08;高速冗余&#xff09;方法做…
阅读更多...
STM32F103C8T6开发笔记1：有线陀螺仪二自由度机械臂

STM32F103C8T6开发笔记1：有线陀螺仪二自由度机械臂

经过之前几天的快速学习&#xff0c;今日尝试组装一款基于MPU6050陀螺仪控制的二自由度机械臂&#xff0c;本文对其使用器材以及基本原理进行介绍~ 组装效果图&#xff1a; 主要元器件如下&#xff1a; 器件个数15 KG以上 舵机3适合舵机的金属夹爪118650电池电源12V1云台支架2…
阅读更多...
[保研/考研机试] KY35 最简真分数 北京大学复试上机题 C++实现

[保研/考研机试] KY35 最简真分数 北京大学复试上机题 C++实现

题目链接&#xff1a; 最简真分数https://www.nowcoder.com/share/jump/437195121691719749588 描述 给出n个正整数&#xff0c;任取两个数分别作为分子和分母组成最简真分数&#xff0c;编程求共有几个这样的组合。 输入描述&#xff1a; 每组包含n&#xff08;n<600&…
阅读更多...
ElasticSearch安装与介绍

ElasticSearch安装与介绍

Elastic Stack简介 如果没有听说过Elastic Stack&#xff0c;那你一定听说过ELK&#xff0c;实际上ELK是三款软件的简称&#xff0c;分别是Elasticsearch、 Logstash、Kibana组成&#xff0c;在发展的过程中&#xff0c;又有新成员Beats的加入&#xff0c;所以就形成了Elastic…
阅读更多...
企业计算机服务器中了Devos勒索病毒怎么办，勒索病毒解密

企业计算机服务器中了Devos勒索病毒怎么办，勒索病毒解密

社会在发展&#xff0c;科技在进步&#xff0c;企业的生产也得到了很大改善&#xff0c;但是随着网络技术的不断发展&#xff0c;越来越多的企业遭到的网络安全威胁开始增多&#xff0c;其中较为明显的就是勒索病毒攻击。预防勒索病毒攻击成为日常生活中不可或缺的一部分工作。…
阅读更多...
对约瑟夫问题的进一步思考

对约瑟夫问题的进一步思考

约瑟夫问题重述&#xff1a; 在计算机编程的算法中&#xff0c;类似问题又称为约瑟夫环 约瑟夫环&#xff1a;N个人围成一圈&#xff0c;从第一个开始报数&#xff0c;第M个将被杀掉&#xff0c;最后剩下一个&#xff0c;其余人都将被杀掉。 例如N6&#xff0c;M5&#xff0…
阅读更多...
数仓建模之维度建模

数仓建模之维度建模

维度建模四步走： 1、选择业务过程 维度建模是紧贴业务的，所以必须以业务为根基进行建模，那么选择业务过程，顾名思义就是在整个业务流程中选取我们需要建模的业务，根据运营提供的需求及日后的易扩展性等进行选择业务。比如商城，整个商城流程分为商家端，用户端，平台端，…
阅读更多...
golang拥有wireshark数据包解析能力

golang拥有wireshark数据包解析能力

golang拥有wireshark数据包解析能力 1. 功能和实现 wireshark拥有世界上最全面的协议解析能力并且还在不断更新中&#xff0c;通过调研&#xff0c;没有办法找到与wireshark同水平的解析工具。 为了使得golang语言可以拥有wireshark一样强大的协议解析能力&#xff0c;库 gowir…
阅读更多...
Effective Java笔记（31）利用有限制通配符来提升 API 的灵活性

Effective Java笔记（31）利用有限制通配符来提升 API 的灵活性

参数化类型是不变的&#xff08; invariant &#xff09; 。 换句话说&#xff0c;对于任何两个截然不同的类型 Typel 和 Type2 而言&#xff0c; List<Type1 &#xff1e;既不是 List<Type 2 &#xff1e; 的子类型&#xff0c;也不是它的超类型 。虽然 L ist<String…
阅读更多...
Django-配置邮箱功能（一）：使用django自带的发送邮件功能

Django-配置邮箱功能（一）：使用django自带的发送邮件功能

一、获取邮箱授权码 以QQ邮箱为例子&#xff1a; 1、进入到设置&#xff0c;找到账户 2、开启POP3等服务&#xff0c;点击管理服务 3、进入管理服务&#xff0c;生成授权码 4、按照要求发送短信就可以了 5、将授权码复制保存&#xff0c;离开界面就看不到了 二、django项目中…
阅读更多...
VMware Workstation中安装了Windows7系统但是VMware Tools选项为灰色及无法安装的解决方法

VMware Workstation中安装了Windows7系统但是VMware Tools选项为灰色及无法安装的解决方法

一、问题描述 当我们在使用VMware Workstation安装好了Windows7系统后；该安装好的Windows7系统并不能自动适配WMware的界面，只能在中间显示很小的一部分内容；此时我们就需要给Windows7系统安装VMware Tools工具； 问题一：WMware中的【安装VMware Tools】选项则是灰色的无法…
阅读更多...
tomcat的多实例，动静分离（web服务基础结束）

tomcat的多实例，动静分离（web服务基础结束）

多实例 多实例就是在一台服务器上有多个tomcat的服务&#xff08;核心是改端口&#xff09; 实验&#xff1a;多实例 安装步骤 1.安装好 jdk 2.安装 tomcat cd /opt tar zxvf apache-tomcat-9.0.16.tar.gz mkdir /usr/local/tomcat mv apache-tomcat-9.0.16 /usr/local/tomca…
阅读更多...
Git简介

Git简介

Git是一个开源的分布式版本控制系统&#xff0c;用于敏捷高效地处理任何或大或小的项目。 Git是Linus Torvalds为了帮助管理Linux内核开发而开发的一个开放源代码的版本控制软件。 Git与常用的版本控制工具CVS、Subversion等不同&#xff0c;它采用了分布式版本库的方式&#x…
阅读更多...
MySQL基本语法总结

MySQL基本语法总结

创建数据库 create database 数据库名&#xff1b; -- 字符集要看mysql 版本&#xff0c; 5.7 Latin&#xff0c; 8.0 utf8 create database 数据库名 character set ‘utf8’&#xff1b;-- 指定数据库的字符集 create database IF NOT EXISTS 数据库名 charac…
阅读更多...
vue-cli前端工程化——创建vue-cli工程 router版本的创建 目录结构 案例初步

vue-cli前端工程化——创建vue-cli工程 router版本的创建 目录结构 案例初步

目录 引出创建vue-cli前端工程vue-cli是什么自动构建创建vue-cli项目选择Vue的版本号 手动安装进行选择创建成功 手动创建router版多了一个router 运行测试bug解决 Vue项目结构main.jspackage.jsonvue.config.js Vue项目初步hello案例 总结 引出 1.vue-cli是啥&#xff0c;创建…
阅读更多...
企业数字化转型与股利分配（2007-2021年）

企业数字化转型与股利分配（2007-2021年）

参照李滟&#xff08;2023&#xff09;的做法&#xff0c;本团队对来自西南大学学报&#xff08;社会科学版&#xff09;《企业数字化转型与股利分配》一文中的基准回归部分进行复刻。 企业数字化转型已成为我国经济增长的新引擎和新动力。为探究数字化转型对企业财务决策的影…
阅读更多...
最新文章

Copyright @ 2022~2023