爆款云主机2核4G限时秒杀,88元/年起!
查看详情

活动

天翼云最新优惠活动,涵盖免费试用,产品折扣等,助您降本增效!
热门活动
  • 618智算钜惠季 爆款云主机2核4G限时秒杀,88元/年起!
  • 免费体验DeepSeek,上天翼云息壤 NEW 新老用户均可免费体验2500万Tokens,限时两周
  • 云上钜惠 HOT 爆款云主机全场特惠,更有万元锦鲤券等你来领!
  • 算力套餐 HOT 让算力触手可及
  • 天翼云脑AOne NEW 连接、保护、办公,All-in-One!
  • 中小企业应用上云专场 产品组合下单即享折上9折起,助力企业快速上云
  • 息壤高校钜惠活动 NEW 天翼云息壤杯高校AI大赛,数款产品享受线上订购超值特惠
  • 天翼云电脑专场 HOT 移动办公新选择,爆款4核8G畅享1年3.5折起,快来抢购!
  • 天翼云奖励推广计划 加入成为云推官,推荐新用户注册下单得现金奖励
免费活动
  • 免费试用中心 HOT 多款云产品免费试用,快来开启云上之旅
  • 天翼云用户体验官 NEW 您的洞察,重塑科技边界

智算服务

打造统一的产品能力,实现算网调度、训练推理、技术架构、资源管理一体化智算服务
智算云(DeepSeek专区)
科研助手
  • 算力商城
  • 应用商城
  • 开发机
  • 并行计算
算力互联调度平台
  • 应用市场
  • 算力市场
  • 算力调度推荐
一站式智算服务平台
  • 模型广场
  • 体验中心
  • 服务接入
智算一体机
  • 智算一体机
大模型
  • DeepSeek-R1-昇腾版(671B)
  • DeepSeek-R1-英伟达版(671B)
  • DeepSeek-V3-昇腾版(671B)
  • DeepSeek-R1-Distill-Llama-70B
  • DeepSeek-R1-Distill-Qwen-32B
  • Qwen2-72B-Instruct
  • StableDiffusion-V2.1
  • TeleChat-12B

应用商城

天翼云精选行业优秀合作伙伴及千余款商品,提供一站式云上应用服务
进入甄选商城进入云市场创新解决方案
办公协同
  • WPS云文档
  • 安全邮箱
  • EMM手机管家
  • 智能商业平台
财务管理
  • 工资条
  • 税务风控云
企业应用
  • 翼信息化运维服务
  • 翼视频云归档解决方案
工业能源
  • 智慧工厂_生产流程管理解决方案
  • 智慧工地
建站工具
  • SSL证书
  • 新域名服务
网络工具
  • 翼云加速
灾备迁移
  • 云管家2.0
  • 翼备份
资源管理
  • 全栈混合云敏捷版(软件)
  • 全栈混合云敏捷版(一体机)
行业应用
  • 翼电子教室
  • 翼智慧显示一体化解决方案

合作伙伴

天翼云携手合作伙伴,共创云上生态,合作共赢
天翼云生态合作中心
  • 天翼云生态合作中心
天翼云渠道合作伙伴
  • 天翼云代理渠道合作伙伴
天翼云服务合作伙伴
  • 天翼云集成商交付能力认证
天翼云应用合作伙伴
  • 天翼云云市场合作伙伴
  • 天翼云甄选商城合作伙伴
天翼云技术合作伙伴
  • 天翼云OpenAPI中心
  • 天翼云EasyCoding平台
天翼云培训认证
  • 天翼云学堂
  • 天翼云市场商学院
天翼云合作计划
  • 云汇计划
天翼云东升计划
  • 适配中心
  • 东升计划
  • 适配互认证

开发者

开发者相关功能入口汇聚
技术社区
  • 专栏文章
  • 互动问答
  • 技术视频
资源与工具
  • OpenAPI中心
开放能力
  • EasyCoding敏捷开发平台
培训与认证
  • 天翼云学堂
  • 天翼云认证
魔乐社区
  • 魔乐社区

支持与服务

为您提供全方位支持与服务,全流程技术保障,助您轻松上云,安全无忧
文档与工具
  • 文档中心
  • 新手上云
  • 自助服务
  • OpenAPI中心
定价
  • 价格计算器
  • 定价策略
基础服务
  • 售前咨询
  • 在线支持
  • 在线支持
  • 工单服务
  • 建议与反馈
  • 用户体验官
  • 服务保障
  • 客户公告
  • 会员中心
增值服务
  • 红心服务
  • 首保服务
  • 客户支持计划
  • 专家技术服务
  • 备案管家

了解天翼云

天翼云秉承央企使命,致力于成为数字经济主力军,投身科技强国伟大事业,为用户提供安全、普惠云服务
品牌介绍
  • 关于天翼云
  • 智算云
  • 天翼云4.0
  • 新闻资讯
  • 天翼云APP
基础设施
  • 全球基础设施
  • 信任中心
最佳实践
  • 精选案例
  • 超级探访
  • 云杂志
  • 分析师和白皮书
  • 天翼云·创新直播间
市场活动
  • 2025智能云生态大会
  • 2024智算云生态大会
  • 2023云生态大会
  • 2022云生态大会
  • 天翼云中国行
天翼云
  • 活动
  • 智算服务
  • 产品
  • 解决方案
  • 应用商城
  • 合作伙伴
  • 开发者
  • 支持与服务
  • 了解天翼云
      • 文档
      • 控制中心
      • 备案
      • 管理中心

      实验一 词法分析器+【编译原理】

      首页 知识中心 其他 文章详情页

      实验一 词法分析器+【编译原理】

      2024-03-22 08:15:20 阅读次数:49

      运算符

      实验一 词法分析器+

      要求:代码的高级功能

      更多的关键字(运算符)
      需要编写keywords.txt

      更多的常数(科学计数法 浮点数 字符串常量)
      需要重写analyzer

      更多的功能(过滤无效字符、数值转换、宏展开、预包含处理)
      需要重写analyzer

      还有
      出错位置没有行数
      需要修改loadInput()逻辑
      使其每读入一行,就进行语法分析处理
      并且需要row行数属性来配合

      下面实现C语言的词法分析

      keywords.txt

      除了32个关键字,还有用户预编译单词

      有可能仍有遗漏

      1      include
      2      define
      3      ifdef
      4      ifndef
      5      auto
      6      break
      7      case
      8      char
      9      const
      10     continue
      11     default
      12     do
      13     double
      14     else
      15     enum
      16     extern
      17     float
      18     for
      19     goto
      20     if
      21     int
      22     long
      23     register
      24     return
      25     short
      26     signed
      27     sizeof
      28     static
      29     struct
      30     switch
      31     typedef
      32     union
      33     unsigned
      34     void
      35     volatile
      36     while
      37	   identifierList
      38     constantList
      

      operators.txt

      新建一个运算符表
      并加入34种运算符

      注意:
      虽然有重复的但是他们的功能不一样
      需要根据上下文环境确定具体功能

      1         #
      2         $
      3         ‘
      4         “
      5         \
      6         {
      7         }
      8         ;
      9         (
      10        )
      11        [
      12        ]
      13        ->
      14        .
      15        !
      16        ~
      17        ++
      18        --
      19        +
      20        -
      21        *
      22        &
      23        *
      24        /
      25        %
      26        +
      27        -
      28        <<
      29        >>
      30        <
      31        <=
      32        >
      33        >=
      34        ==
      35        !=
      36        &
      37        ^
      38        |
      39        &&
      40        ||
      41        ?
      42        :
      43        =
      44        +=
      45        -=
      46        *=
      47        /=
      48        %=
      49        <<=
      50        >>=
      51        &=
      52        ^=
      53        |=
      54        ,
      

      测试操作符表

      package s1;
      
      import java.io.BufferedReader;
      import java.io.File;
      import java.io.FileReader;
      import java.io.IOException;
      import java.util.ArrayList;
      import java.util.List;
      
      public class SeniorLexicalAnalyzer extends AbstractLexicalAnalyzer{
      
          public List<Symbol> operatorList=new ArrayList<>();//运算符表
      
          //创建关键字表 根据表3.1实现
          {
              File file = new File("operators.txt");
              if (file.exists()) {
                  System.out.println("operators.txt文件存在");
                  System.out.println("读取文件,加载运算符表");
                  loadOperatorList();
              } else {
                  System.out.println("operators.txt文件不存在");
                  System.out.println("采用默认的运算符表");
                  initOperatorList();
              }
          }
      
          //读取operators.txt文件的内容加载到operatorList中
          public void loadOperatorList() {
              try {
                  BufferedReader reader = new BufferedReader(new FileReader("operators.txt"));
                  String line;
                  while ((line = reader.readLine()) != null) {
                      String[] arr = line.split("\\s+");
                      operatorList.add(new Symbol(Integer.parseInt(arr[0]), arr[1]));
                  }
                  reader.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
      
          }
      
          //默认的运算符表
          public void initOperatorList(){
              keywordList.add(new Symbol(1,"="));
              keywordList.add(new Symbol(2,"+"));
              keywordList.add(new Symbol(3,"*"));
              keywordList.add(new Symbol(4,"**"));
              keywordList.add(new Symbol(5,","));
              keywordList.add(new Symbol(6,"("));
              keywordList.add(new Symbol(7,")"));
          }
      
          //重写 状态转移图实现
          @Override
          public void analyzer() {
      
          }
      
          //测试词法分析器
          private void testAnalyzers(){
      
          }
      
          //重写出错处理,跳过1下,继续分析
          @Override
          public void procError(){
              System.out.println("词法分析出错"+"\n"+"出错位置为"+position);
              System.out.println("跳过错误,继续分析");
              position++;
              if(ch!=EOF){
                  ch=' ';
              }
          }
          //测试关键词表的赋值
          private void testKeywordList(){
      
              for (Symbol s:keywordList) {
                  System.out.println(s);
              }
          }
          
          //测试运算符表的赋值
          private void testOperatorList(){
              for (Symbol s:operatorList) {
                  System.out.println(s);
              }
          }
      
      
          public static void main(String[] args) {
              SeniorLexicalAnalyzer lex = new SeniorLexicalAnalyzer();
              //测试
              lex.testKeywordList();
              lex.testOperatorList();
      
              //测试
      //        new SeniorLexicalAnalyzer().testAnalyzers();
          }
      }
      
      

      重申:
      关键词表中的code没有什么意义
      只有单词表中的code有意义
      所以运算符表中就没有设置code

      测试结果

      keywords.txt文件存在
      读取文件,加载关键词表
      operators.txt文件存在
      读取文件,加载运算符表
      Symbol{id=1, value='include', code=0}
      Symbol{id=2, value='define', code=1}
      Symbol{id=3, value='ifdef', code=2}
      Symbol{id=4, value='ifndef', code=3}
      Symbol{id=5, value='auto', code=4}
      Symbol{id=6, value='break', code=5}
      Symbol{id=7, value='case', code=6}
      Symbol{id=8, value='char', code=7}
      Symbol{id=9, value='const', code=8}
      Symbol{id=10, value='continue', code=9}
      Symbol{id=11, value='default', code=10}
      Symbol{id=12, value='do', code=11}
      Symbol{id=13, value='double', code=12}
      Symbol{id=14, value='else', code=13}
      Symbol{id=15, value='enum', code=14}
      Symbol{id=16, value='extern', code=15}
      Symbol{id=17, value='float', code=16}
      Symbol{id=18, value='for', code=17}
      Symbol{id=19, value='goto', code=18}
      Symbol{id=20, value='if', code=19}
      Symbol{id=21, value='int', code=20}
      Symbol{id=22, value='long', code=21}
      Symbol{id=23, value='register', code=22}
      Symbol{id=24, value='return', code=23}
      Symbol{id=25, value='short', code=24}
      Symbol{id=26, value='signed', code=25}
      Symbol{id=27, value='sizeof', code=26}
      Symbol{id=28, value='static', code=27}
      Symbol{id=29, value='struct', code=28}
      Symbol{id=30, value='switch', code=29}
      Symbol{id=31, value='typedef', code=30}
      Symbol{id=32, value='union', code=31}
      Symbol{id=33, value='unsigned', code=32}
      Symbol{id=34, value='void', code=33}
      Symbol{id=35, value='volatile', code=34}
      Symbol{id=36, value='while', code=35}
      Symbol{id=1, value='#', code=0}
      Symbol{id=2, value='$', code=0}
      Symbol{id=3, value='‘', code=0}
      Symbol{id=4, value='“', code=0}
      Symbol{id=5, value='\', code=0}
      Symbol{id=6, value='{', code=0}
      Symbol{id=7, value='}', code=0}
      Symbol{id=8, value=';', code=0}
      Symbol{id=9, value='(', code=0}
      Symbol{id=10, value=')', code=0}
      Symbol{id=11, value='[', code=0}
      Symbol{id=12, value=']', code=0}
      Symbol{id=13, value='->', code=0}
      Symbol{id=14, value='.', code=0}
      Symbol{id=15, value='!', code=0}
      Symbol{id=16, value='~', code=0}
      Symbol{id=17, value='++', code=0}
      Symbol{id=18, value='--', code=0}
      Symbol{id=19, value='+', code=0}
      Symbol{id=20, value='-', code=0}
      Symbol{id=21, value='*', code=0}
      Symbol{id=22, value='&', code=0}
      Symbol{id=23, value='*', code=0}
      Symbol{id=24, value='/', code=0}
      Symbol{id=25, value='%', code=0}
      Symbol{id=26, value='+', code=0}
      Symbol{id=27, value='-', code=0}
      Symbol{id=28, value='<<', code=0}
      Symbol{id=29, value='>>', code=0}
      Symbol{id=30, value='<', code=0}
      Symbol{id=31, value='<=', code=0}
      Symbol{id=32, value='>', code=0}
      Symbol{id=33, value='>=', code=0}
      Symbol{id=34, value='==', code=0}
      Symbol{id=35, value='!=', code=0}
      Symbol{id=36, value='&', code=0}
      Symbol{id=37, value='^', code=0}
      Symbol{id=38, value='|', code=0}
      Symbol{id=39, value='&&', code=0}
      Symbol{id=40, value='||', code=0}
      Symbol{id=41, value='?', code=0}
      Symbol{id=42, value=':', code=0}
      Symbol{id=43, value='=', code=0}
      Symbol{id=44, value='+=', code=0}
      Symbol{id=45, value='-=', code=0}
      Symbol{id=46, value='*=', code=0}
      Symbol{id=47, value='/=', code=0}
      Symbol{id=48, value='%=', code=0}
      Symbol{id=49, value='<<=', code=0}
      Symbol{id=50, value='>>=', code=0}
      Symbol{id=51, value='&=', code=0}
      Symbol{id=52, value='^=', code=0}
      Symbol{id=53, value='|=', code=0}
      Symbol{id=54, value=',', code=0}
      
      

      词法分析器的状态转移图

      需知

      C语言的标识符由字母、数字、下划线组成,并且首字母不能是数字(美元符号$也可以作为标识符)

      C语言的常量

      C语言中的运算符大全(内附优先级表)

      状态转移图

      代码实现

      AbstractSeniorLexicalAnalyzer

      高级词法分析器继承基础的词法分析器

      另外

      新定义了两个属性

      	 List<String> inputList=new ArrayList<>();//输入串 按行
      	 public static int row=1;//行号
      

      新增对inputList初始化的方法

      	//初始化inputList
      	public  List<String> initInputList(){
          }
          //读入input.txt到input
          public List<String> loadInputList(){
      	}
          //没有input.txt随机初始化input
          public List<String> randomInputList(){
          }
      

      以及对ch的判断

      设计思想
      重写了analyzers方法

      遍历inputList
      借用了input属性
      对其按行编译
      analyzer()分析input

          @Override
          public void analyzers() {
              for (String input : inputList) {
                  this.input=input;//给对象的input赋值
                  ch=' ';
                  analyzer();
                  row++;
                  position=0;
              }
              System.out.println("词法分析结束");
      
          }
      

      AbstractSeniorLexicalAnalyzer

      package s1;
      
      import java.io.*;
      import java.util.ArrayList;
      import java.util.List;
      import java.util.Random;
      
      /**
       * 词法分析器抽象类
       */
      public abstract  class AbstractSeniorLexicalAnalyzer extends AbstractLexicalAnalyzer{
      
          List<String> inputList=new ArrayList<>();//输入串 按行
      
      
          public List<Symbol> operatorList=new ArrayList<>();//运算符表
      
          protected AbstractSeniorLexicalAnalyzer() {
          }
      
          public AbstractSeniorLexicalAnalyzer(List<String> inputList) {
              this.inputList = inputList;
          }
      
          public void setInputList(List<String> inputList) {
              this.inputList = inputList;
          }
      
          //创建运算符表
          {
              File file = new File("operators.txt");
              if (file.exists()) {
                  System.out.println("operators.txt文件存在");
                  System.out.println("读取文件,加载运算符表");
                  loadOperatorList();
              } else {
                  System.out.println("operators.txt文件不存在");
                  System.out.println("采用默认的运算符表");
                  initOperatorList();
              }
          }
      
          //读取operators.txt文件的内容加载到operatorList中
          public void loadOperatorList() {
              try {
                  BufferedReader reader = new BufferedReader(new FileReader("operators.txt"));
                  String line;
                  while ((line = reader.readLine()) != null) {
                      String[] arr = line.split("\\s+");
                      operatorList.add(new Symbol(Integer.parseInt(arr[0]), arr[1]));
                  }
                  reader.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
      
          }
      
          //默认的运算符表
          public void initOperatorList(){
              operatorList.add(new Symbol(1,"="));
              operatorList.add(new Symbol(2,"+"));
              operatorList.add(new Symbol(3,"*"));
              operatorList.add(new Symbol(4,"**"));
              operatorList.add(new Symbol(5,","));
              operatorList.add(new Symbol(6,"("));
              operatorList.add(new Symbol(7,")"));
          }
      
          public void toStringSymbolList(){
              for (Symbol s:symbolList) {
      //            System.out.println(s.toStringIdCode());
                  System.out.println(s.toString());
              }
          }
      
          public static int row=1;//行号
      
          //其余函数
      
          //当调用了getChar(positiop已经+1)之后 取到下一个字符 但不偏移扫描指针
          public char getAfterChar() {
              if(position<input.length()){
                  return input.charAt(position);
              }
              return EOF;
          }
      
      
          public boolean AfterCharisDigit(char ch) {
              return ch >= '0' && ch <= '9';
          }
      
          public boolean is_(){
              return ch =='_';
          }
          public boolean is$(){
              return ch =='$';
          }
          public boolean isPlus(){
              return ch =='+';
          }
          public boolean isSub(){
              return ch =='-';
          }
          public boolean isPoint(){
              return ch =='.';
          }
      
          public boolean isE(){
              return ch =='E';
          }
          public boolean isD(){
              return ch =='D';
          }
      
          public boolean isDigitEx0(){
              return ch >'0' && ch<='9';
          }
      
          public boolean isDigitB0A7(){
              return ch >='0' && ch<='7';
          }
      
          public boolean is0(){
              return ch =='0';
          }
      
          public boolean isx(){
              return ch=='x'||ch=='X';
          }
      
          public boolean isHex(){
              return (ch>='0' && ch<='9')||(ch>='a'&&ch<='f')||(ch>='A'&&ch<='F');
          }
      
          public boolean escape(){
              return ch=='n'||ch=='t'||ch=='b'||ch=='r'||ch=='f'||ch=='\\'||ch=='\''||ch=='"';
          }
      
      
      
      
          @Override
          public void analyzers() {
              for (String input : inputList) {
                  this.input=input;//给对象的input赋值
                  ch=' ';
                  analyzer();
                  row++;
                  position=0;
              }
              System.out.println("词法分析结束");
      
          }
      
          //状态转移图由子类实现
          public abstract void analyzer();
      
      
          //初始化inputList
          public  List<String> initInputList(){
              File file = new File("input.txt");
              if (file.exists()) {
                  System.out.println("input.txt文件存在");
                  System.out.println("读取文件,input");
                  return loadInputList();
              } else {
                  System.out.println("input.txt文件不存在");
                  System.out.println("随机初始化input");
                  return randomInputList();
              }
          }
      
          //读入input.txt到input
          public List<String> loadInputList(){
              List<String> inputList=new ArrayList<>();
      
              try {
                  File file = new File("input.txt");
                  BufferedReader reader = new BufferedReader(new FileReader(file));
                  String line;
                  StringBuilder sb = new StringBuilder();
                  while ((line = reader.readLine()) != null) {
                      inputList.add(line);
                  }
      
                  reader.close();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return inputList;
          }
      
      
          //没有input.txt随机初始化input
          public List<String> randomInputList(){
              List<String> inputList=new ArrayList<>();
      
              final String ERROR="~~";//错误字符
      
              Random rand=new Random();
      
      
              List<Symbol> wordList=new ArrayList<>();//现有词表 (关键词+符号表)
      
              wordList.addAll(keywordList);
      
              wordList.addAll(operatorList);
      
              for (int r = 0; r < 20; r++) {//共20行
                  StringBuilder input= new StringBuilder();
      
                  for(int i=0;i<10;i++){//每行10个
                      String value;
                      int index=rand.nextInt(wordList.size()+1);//故意+1 人为使其出现错误单词
                      if(index>=wordList.size()){
                          value=ERROR;//错误单词
                      }else{
                          value=wordList.get(index).getValue();
                          if(value.equals("constantList")){//常数
                              StringBuilder constant= new StringBuilder();
                              for(int j=0;j<3;j++){
                                  constant.append(rand.nextInt(10));
                              }
                              value= constant.toString();
                          }else if("identifierList".equals(value)){//标识符
                              StringBuilder letter= new StringBuilder();
                              for(int j=0;j<3;j++){
                                  char c=(char)(rand.nextInt(26)+'a');
                                  letter.append(c);
                              }
                              value= letter.toString();
                          }
                      }
      
                      input.append(value).append(" ");
                  }
                  inputList.add(input.toString());
              }
      
              return inputList;
      
          }
      
          void testInitInputList(){
              List<String> strings = initInputList();
              for (String s :
                      strings) {
                  System.out.println(s);
              }
          }
      
          public static void main(String[] args) {
              SeniorLexicalAnalyzer lex=new SeniorLexicalAnalyzer();
              lex.testInitInputList();
          }
      
      
      }
      
      

      SeniorLexicalAnalyzer

      继承AbstractLexicalAnalyzer

      重写analyzer方法
      对input进行分析

          public void analyzer(){
          }
      

      重载procError(String msg)方法
      错误处理
      跳到空格或结尾处

          //出错处理,跳过到空白处,继续分析
          public void procError(String msg){
              System.out.println("词法分析出错"+"\n"+"出错行号为"+row+"出错位置为"+position);
              System.out.println("错误原因:"+msg);
              System.out.println("跳过错误,继续分析");
              while (!isEOF()&&!isSpace()){
                  getChar();
              }
              if(ch!=EOF){
                   ch=' ';
              }
          }
      
      

      SeniorLexicalAnalyzer

      package s1;
      
      
      import java.util.ArrayList;
      import java.util.Arrays;
      import java.util.List;
      
      /**
       * 词法分析器类
       */
      public class SeniorLexicalAnalyzer extends AbstractSeniorLexicalAnalyzer{
      
      
      
          public SeniorLexicalAnalyzer() {
      
          }
          public SeniorLexicalAnalyzer(List<String> inputList) {
              super(inputList);
          }
      
      
      
      
          //根据状态转移图实现
          @Override
          public void analyzer(){
              while (!isEOF()){
                  int id,code;
                  strToken="";
                  getChar();//初始ch=' '
                  getBC();
                  if(isEOF()){//面对不用回退的状态
                      break;
                  }
                  if(isLetter()||is_()){//判断是否是标识符 1.1
                      concat();
                      getChar();
                      while ((isLetter()||isDigit()||is$()||is_())&&ch!=EOF){//1.2
                          concat();
                          getChar();
                      }
                      if(!isSpace()&&!isEOF()){
                          procError("标识符定义不正确");
                          continue;
                      }
                      retract();
                      id =reserve();
                      //0是标识符 不是0就是保留字
                      if(id ==0){
                          code=insertId(strToken);
                          Symbol symbol=keywordList.get(keywordList.indexOf(new Symbol("identifierList")));
                          //<id,value,code> 编码 符号 索引
                          int idId=symbol.getId();//标识符在关键字中的编码
                          symbolList.add(new Symbol(idId,strToken,code));
                      }else{
                          int keyCode= keywordList.indexOf(new Symbol(id,strToken));//关键字的索引
                          symbolList.add(new Symbol(id,strToken,keyCode));
                      }
                  }
                  else if((isPlus()||isSub()||isDigit()||isPoint())&&AfterCharisDigit(getAfterChar())){//浮点常数 2.1
                      if(isPlus()||isSub()){
                          concat();
                          getChar();
                      }
      
                      if(isDigit()){
                          concat();
                          getChar();
      
                          while (isDigit()){//2.2
                              concat();
                              getChar();
                          }
      
                          if (isPoint()) {
                              concat();
                              getChar();
                              while (isDigit()) {//2.4
                                  concat();
                                  getChar();
                              }
                              if (!(isD() || isE())) {
                                  retract();
                                  code = insertConst(strToken);
                                  id = keywordList.get(keywordList.indexOf(new Symbol("constantList"))).getId();
                                  symbolList.add(new Symbol(id, strToken, code));
                                  return;
                              }
                          }
      
                      }else if (isPoint()) { //2.3
                          strToken+="0";
                          concat();
                          getChar();
                          if(isDigit()){
                              concat();
                              getChar();
                          }
                          while (isDigit()){//2.4
                              concat();
                              getChar();
                          }
                          if(!(isD()||isE())){//2.8
                              retract();
                              code=insertConst(strToken);
                              id=keywordList.get(keywordList.indexOf(new Symbol("constantList"))).getId();
                              symbolList.add(new Symbol(id,strToken,code));
                              return;
                          }
                      }
      
                      if(isE()||isD()){//2.5 之前
                          concat();
                          getChar();
                          if(isPlus()|| isSub()){//2.5
                              concat();
                              getChar();
                              if(isDigit()){//2.6
                                  while (isDigit()){//2.7
                                      concat();
                                      getChar();
                                  }
                                  retract();//2.8
                                  code=insertConst(strToken);
                                  id=keywordList.get(keywordList.indexOf(new Symbol("constantList"))).getId();
                                  symbolList.add(new Symbol(id,strToken,code));
                                  return;
                              }
                          }
                      }else{
                          retract();
                          code=insertConst(strToken);
                          id=keywordList.get(keywordList.indexOf(new Symbol("constantList"))).getId();
                          symbolList.add(new Symbol(id,strToken,code));
                          return;
                      }
      
                  }
                  else if (isDigitEx0()){//十进制整型 3.1
                      if(isDigit()){
                          concat();
                          getChar();
                          while (isDigit()){
                              concat();
                              getChar();
                          }
                          retract();
                          code=insertConst(strToken);
                          id=keywordList.get(keywordList.indexOf(new Symbol("constantList"))).getId();
                          symbolList.add(new Symbol(id,strToken,code));
                      }
      
                  } else if (is0()) {//4.1
                      if (isDigitB0A7()){//八进制整数 4.2
                          concat();
                          getChar();
                          while (isDigitB0A7()){//4.3
                              concat();
                              getChar();
                          }
                          retract();
                          code=insertConst(strToken);
                          id=keywordList.get(keywordList.indexOf(new Symbol("constantList"))).getId();
                          symbolList.add(new Symbol(id,strToken,code));
                      }else if(isx()){//16进制整数
                          if(isHex()){//5.2
                              concat();
                              getChar();
                              while (isHex()){//5.3
                                  concat();
                                  getChar();
                              }//5.4
                              retract();
                              code=insertConst(strToken);
                              id=keywordList.get(keywordList.indexOf(new Symbol("constantList"))).getId();
                              symbolList.add(new Symbol(id,strToken,code));
                          }
                      }
                  } else if (ch=='\'') {//字符常量 6.1
      
                      concat();
      
                      getChar();
      
                      if(ch=='\\'){//转义字符6.3
                          concat();
                          getChar();
                          if(escape()){
                              concat();
                          }else {
                              procError("转义字符常量定义不正确");
                              continue;
                          }
                      }else{//具体字符 6.2
                          concat();
                      }
      
                      getChar();
      
                      if(ch!='\''){
                          procError("字符常量定义不正确");
                          continue;
                      }
      
                      concat();//6.5
      
                      code=insertConst(strToken);
                      id=keywordList.get(keywordList.indexOf(new Symbol("constantList"))).getId();
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch=='"') {//字符串常量 7.1
                      concat();
      
                      getChar();
                      while(ch!='"'&&!isEOF()){//7.2
                          concat();
                          getChar();//具体字符
                      }
      
                      if(isEOF()){
                          procError("字符串没有右\"");
                          continue;
                      }
                      concat();
      
                      code=insertConst(strToken);
                      id=keywordList.get(keywordList.indexOf(new Symbol("constantList"))).getId();
                      symbolList.add(new Symbol(id,strToken,code));
      
      
                  } else if (ch=='/') {//8.1
                      concat();
                      getChar();
                      if(ch=='='){// 12.1/=
                          concat();
                          code=operatorList.indexOf(new Symbol(strToken));
                          id=operatorList.get(code).getId()+ keywordList.size();
                          symbolList.add(new Symbol(id,strToken,code));
                      }else if (ch=='/'){//单行注释 8.2
                          concat();
                          getChar();
                          while (!isEOF()){
                              concat();
                              getChar();
                          }
                          System.out.println("注释内容:"+strToken);
                      }else if(ch=='*'){//多行注释 /*  功能不完善
                          concat();
                          getChar();
                          while (!(ch=='*'&&getAfterChar()=='/')){ //9.2 */
                              concat();
                              getChar();
                          }
      
                          concat();
      
                          getChar();
                          concat();
                          System.out.println("注释内容:"+strToken);
                      }else {// 12.2/
                          retract();
                          code=operatorList.indexOf(new Symbol(strToken));
                          id=operatorList.get(code).getId()+ keywordList.size();
                          symbolList.add(new Symbol(id,strToken,code));
                      }
      
                  } else if (ch=='{'||ch=='}'||ch=='('||ch==')'||ch=='['||ch==']') {//1-7
                      concat();
      
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();//全局id
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch=='='||ch=='!'||ch=='%') {//8= 15% 16!
                      concat();
                      getChar();
                      if(ch=='='){//8.1== 15.1%= 16.1!=
                          concat();
                      }else {//8.2= 15.2% 16.2!
                          retract();
                      }
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch=='+') {
                      concat();
                      getChar();
                      if(ch=='+'||ch=='='){ //9.1++ 9.2+=
                          concat();
                      }else {
                          retract();
                      }
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch=='-') {
                      concat();
                      getChar();
                      if(ch=='-'||ch=='='||ch=='>'){//10.1-- 10.2-= 10.3->
                          concat();
                      }else {
                          retract();
                      }
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch=='*') {
                      concat();
                      getChar();
                      if(ch=='='){//11.1 *=
                          concat();
                      }else{//* 11.2
                          retract();
                      }
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch=='.'||ch=='~') {//13 17
                      concat();
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch=='&'||ch=='|') {//15 18
                      concat();
                      getChar();
                      if (ch=='&'){
                          concat();
                      } else if(ch=='='){//15.2 &=
                          concat();
                      }else{//& 15.3
                          retract();
                      }
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch=='^') {//19
                      concat();
                      getChar();
                      if (ch=='='){//^=
                          concat();
                      } else{//^
                          retract();
                      }
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch=='<') {//20
                      concat();
                      getChar();
                      if (ch=='<'){
                          concat();
                          getChar();
                          if(ch=='='){//<<=
                              concat();
                          }else {//<<
                              retract();
                          }
                      }else{//<
                          retract();
                      }
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
      
                  } else if (ch=='>') {//21
                      concat();
                      getChar();
                      if (ch=='>'){
                          concat();
                          getChar();
                          if(ch=='='){//>>=
                              concat();
                          }else {//>>
                              retract();
                          }
                      }else{//>
                          retract();
                      }
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
      
                  } else if(ch=='?'||ch==':'){
                      concat();
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
                  } else if (ch==',') {
                      concat();
                      code=operatorList.indexOf(new Symbol(strToken));
                      id=operatorList.get(code).getId()+ keywordList.size();
                      symbolList.add(new Symbol(id,strToken,code));
                  }else{
                      procError("未识别的字符");//出错处理
                  }
              }
          }
      
      
          //重写出错处理,跳过到空白处,继续分析
          public void procError(){
              System.out.println("词法分析出错"+"\n"+"出错行号为"+row+"出错位置为"+position);
              System.out.println("跳过错误,继续分析");
              while (!isEOF()&&!isSpace()){
                  getChar();
              }
              if(ch!=EOF){
                  ch=' ';
              }
          }
      
          //出错处理,跳过到空白处,继续分析
          public void procError(String msg){
              System.out.println("词法分析出错"+"\n"+"出错行号为"+row+"出错位置为"+position);
              System.out.println("错误原因:"+msg);
              System.out.println("跳过错误,继续分析");
              while (!isEOF()&&!isSpace()){
                  getChar();
              }
              if(ch!=EOF){
                   ch=' ';
              }
          }
      
      
      
          //测试关键词表的赋值
          private void testKeywordList(){
              for (Symbol s:keywordList) {
                  System.out.println(s);
              }
          }
      
      
          //测试运算符表的赋值
          private void testOperatorList(){
              for (Symbol s:operatorList) {
                  System.out.println(s);
              }
          }
          //测试词法分析器
          private void testAnalyzers(){
      
              SeniorLexicalAnalyzer lex = new SeniorLexicalAnalyzer();
      
              List<String> inputList=lex.initInputList();
      
              System.out.println("输出input串");
              inputList.forEach(System.out::println);
      
      
              lex.setInputList(inputList);
              lex.analyzers();
              System.out.println("输出单词表");
              lex.toStringSymbolList();
              System.out.println("正在把单词表存入symbols.txt");
              lex.storeSymbols();
      
      
          }
      
      
          public static void main(String[] args) {
              SeniorLexicalAnalyzer lex = new SeniorLexicalAnalyzer();
              //测试
      //        lex.testKeywordList();
      //        lex.testOperatorList();
              //测试
              lex.testAnalyzers();
      
          }
      
      }
      
      

      相关文件

      keywords.txt

      1      include
      2      define
      3      ifdef
      4      ifndef
      5      auto
      6      break
      7      case
      8      char
      9      const
      10     continue
      11     default
      12     do
      13     double
      14     else
      15     enum
      16     extern
      17     float
      18     for
      19     goto
      20     if
      21     int
      22     long
      23     register
      24     return
      25     short
      26     signed
      27     sizeof
      28     static
      29     struct
      30     switch
      31     typedef
      32     union
      33     unsigned
      34     void
      35     volatile
      36     while
      37     constantList
      38     identifierList
      

      operators.txt

      1         #
      2         $
      3         ‘
      4         “
      5         \
      6         {
      7         }
      8         ;
      9         (
      10        )
      11        [
      12        ]
      13        ->
      14        .
      15        !
      16        ~
      17        ++
      18        --
      19        +
      20        -
      21        *
      22        &
      23        *
      24        /
      25        %
      26        +
      27        -
      28        <<
      29        >>
      30        <
      31        <=
      32        >
      33        >=
      34        ==
      35        !=
      36        &
      37        ^
      38        |
      39        &&
      40        ||
      41        ?
      42        :
      43        =
      44        +=
      45        -=
      46        *=
      47        /=
      48        %=
      49        <<=
      50        >>=
      51        &=
      52        ^=
      53        |=
      54        ,
      

      input.txt

      if else while do while dowhile
      as123_123 _1$23       _12*23      _12_12
      +12 -34  12E+10  12.3E-9 .123
      123 12-12  12345 1232s12 12  23 12  12
      'a'  't'  'tt'
      '\n' '\\' '\'' '\"' '\d' '\'
      "abc"  "asd"  "tt
      //abc //as  //bi
      /*abc*/  /*a*sd*/  /*as1*/ /*as2*/
      {}  () [] []
      =  ==
      +  ++  +=
      -  --  -=  ->
      *  *=
      /  /=
      .  .
      %  %=
      &&  &  &=
      <  <<  <<=
      >  >>  >>=
      ?:  ?:
      ,
      
      
      

      结果

      程序输出

      keywords.txt文件存在
      读取文件,加载关键词表
      operators.txt文件存在
      读取文件,加载运算符表
      keywords.txt文件存在
      读取文件,加载关键词表
      operators.txt文件存在
      读取文件,加载运算符表
      input.txt文件存在
      读取文件,input
      输出input串
      if else while do while dowhile
      as123_123 _1$23       _12*23      _12_12
      +12 -34  12E+10  12.3E-9 .123
      123 12-12  12345 1232s12 12  23 12  12
      'a'  't'  'tt'
      '\n' '\\' '\'' '\"' '\d' '\'
      "abc"  "asd"  "tt
      //abc //as  //bi
      /*abc*/  /*a*sd*/  /*as1*/ /*as2*/
      {}  () [] []
      =  ==
      +  ++  +=
      -  --  -=  ->
      *  *=
      /  /=
      .  .
      %  %=
      &&  &  &=
      <  <<  <<=
      >  >>  >>=
      ?:  ?:
      ,
      
      词法分析出错
      出错行号为2出错位置为26
      错误原因:标识符定义不正确
      跳过错误,继续分析
      词法分析出错
      出错行号为5出错位置为13
      错误原因:字符常量定义不正确
      跳过错误,继续分析
      词法分析出错
      出错行号为6出错位置为23
      错误原因:转义字符常量定义不正确
      跳过错误,继续分析
      词法分析出错
      出错行号为6出错位置为28
      错误原因:字符常量定义不正确
      跳过错误,继续分析
      词法分析出错
      出错行号为7出错位置为17
      错误原因:字符串没有右"
      跳过错误,继续分析
      注释内容://abc //as  //bi
      注释内容:/*abc*/
      注释内容:/*a*sd*/
      注释内容:/*as1*/
      注释内容:/*as2*/
      词法分析结束
      输出单词表
      Symbol{id=20		 value: if		 code=19}
      Symbol{id=14		 value: else		 code=13}
      Symbol{id=36		 value: while		 code=35}
      Symbol{id=12		 value: do		 code=11}
      Symbol{id=36		 value: while		 code=35}
      Symbol{id=38		 value: dowhile		 code=0}
      Symbol{id=38		 value: as123_123		 code=1}
      Symbol{id=38		 value: _1$23		 code=2}
      Symbol{id=38		 value: _12_12		 code=3}
      Symbol{id=37		 value: +12		 code=0}
      Symbol{id=37		 value: 123		 code=1}
      Symbol{id=37		 value: 'a'		 code=2}
      Symbol{id=37		 value: 't'		 code=3}
      Symbol{id=37		 value: '\n'		 code=4}
      Symbol{id=37		 value: '\\'		 code=5}
      Symbol{id=37		 value: '\''		 code=6}
      Symbol{id=37		 value: '\"'		 code=7}
      Symbol{id=37		 value: "abc"		 code=8}
      Symbol{id=37		 value: "asd"		 code=9}
      Symbol{id=44		 value: {		 code=5}
      Symbol{id=45		 value: }		 code=6}
      Symbol{id=47		 value: (		 code=8}
      Symbol{id=48		 value: )		 code=9}
      Symbol{id=49		 value: [		 code=10}
      Symbol{id=50		 value: ]		 code=11}
      Symbol{id=49		 value: [		 code=10}
      Symbol{id=50		 value: ]		 code=11}
      Symbol{id=81		 value: =		 code=42}
      Symbol{id=72		 value: ==		 code=33}
      Symbol{id=57		 value: +		 code=18}
      Symbol{id=55		 value: ++		 code=16}
      Symbol{id=82		 value: +=		 code=43}
      Symbol{id=58		 value: -		 code=19}
      Symbol{id=56		 value: --		 code=17}
      Symbol{id=83		 value: -=		 code=44}
      Symbol{id=51		 value: ->		 code=12}
      Symbol{id=59		 value: *		 code=20}
      Symbol{id=84		 value: *=		 code=45}
      Symbol{id=62		 value: /		 code=23}
      Symbol{id=85		 value: /=		 code=46}
      Symbol{id=52		 value: .		 code=13}
      Symbol{id=52		 value: .		 code=13}
      Symbol{id=63		 value: %		 code=24}
      Symbol{id=86		 value: %=		 code=47}
      Symbol{id=77		 value: &&		 code=38}
      Symbol{id=60		 value: &		 code=21}
      Symbol{id=89		 value: &=		 code=50}
      Symbol{id=68		 value: <		 code=29}
      Symbol{id=66		 value: <<		 code=27}
      Symbol{id=87		 value: <<=		 code=48}
      Symbol{id=70		 value: >		 code=31}
      Symbol{id=67		 value: >>		 code=28}
      Symbol{id=88		 value: >>=		 code=49}
      Symbol{id=79		 value: ?		 code=40}
      Symbol{id=80		 value: :		 code=41}
      Symbol{id=79		 value: ?		 code=40}
      Symbol{id=80		 value: :		 code=41}
      Symbol{id=92		 value: ,		 code=53}
      正在把单词表存入symbols.txt
      Disconnected from the target VM, address: '127.0.0.1:1027', transport: 'socket'
      
      Process finished with exit code 0
      
      

      symbols.txt

      Symbol{id=20		 value: if		 code=19}
      Symbol{id=14		 value: else		 code=13}
      Symbol{id=36		 value: while		 code=35}
      Symbol{id=12		 value: do		 code=11}
      Symbol{id=36		 value: while		 code=35}
      Symbol{id=38		 value: dowhile		 code=0}
      Symbol{id=38		 value: as123_123		 code=1}
      Symbol{id=38		 value: _1$23		 code=2}
      Symbol{id=38		 value: _12_12		 code=3}
      Symbol{id=37		 value: +12		 code=0}
      Symbol{id=37		 value: 123		 code=1}
      Symbol{id=37		 value: 'a'		 code=2}
      Symbol{id=37		 value: 't'		 code=3}
      Symbol{id=37		 value: '\n'		 code=4}
      Symbol{id=37		 value: '\\'		 code=5}
      Symbol{id=37		 value: '\''		 code=6}
      Symbol{id=37		 value: '\"'		 code=7}
      Symbol{id=37		 value: "abc"		 code=8}
      Symbol{id=37		 value: "asd"		 code=9}
      Symbol{id=44		 value: {		 code=5}
      Symbol{id=45		 value: }		 code=6}
      Symbol{id=47		 value: (		 code=8}
      Symbol{id=48		 value: )		 code=9}
      Symbol{id=49		 value: [		 code=10}
      Symbol{id=50		 value: ]		 code=11}
      Symbol{id=49		 value: [		 code=10}
      Symbol{id=50		 value: ]		 code=11}
      Symbol{id=81		 value: =		 code=42}
      Symbol{id=72		 value: ==		 code=33}
      Symbol{id=57		 value: +		 code=18}
      Symbol{id=55		 value: ++		 code=16}
      Symbol{id=82		 value: +=		 code=43}
      Symbol{id=58		 value: -		 code=19}
      Symbol{id=56		 value: --		 code=17}
      Symbol{id=83		 value: -=		 code=44}
      Symbol{id=51		 value: ->		 code=12}
      Symbol{id=59		 value: *		 code=20}
      Symbol{id=84		 value: *=		 code=45}
      Symbol{id=62		 value: /		 code=23}
      Symbol{id=85		 value: /=		 code=46}
      Symbol{id=52		 value: .		 code=13}
      Symbol{id=52		 value: .		 code=13}
      Symbol{id=63		 value: %		 code=24}
      Symbol{id=86		 value: %=		 code=47}
      Symbol{id=77		 value: &&		 code=38}
      Symbol{id=60		 value: &		 code=21}
      Symbol{id=89		 value: &=		 code=50}
      Symbol{id=68		 value: <		 code=29}
      Symbol{id=66		 value: <<		 code=27}
      Symbol{id=87		 value: <<=		 code=48}
      Symbol{id=70		 value: >		 code=31}
      Symbol{id=67		 value: >>		 code=28}
      Symbol{id=88		 value: >>=		 code=49}
      Symbol{id=79		 value: ?		 code=40}
      Symbol{id=80		 value: :		 code=41}
      Symbol{id=79		 value: ?		 code=40}
      Symbol{id=80		 value: :		 code=41}
      Symbol{id=92		 value: ,		 code=53}
      
      
      版权声明:本文内容来自第三方投稿或授权转载,原文地址:https://jsss-1.blog.csdn.net/article/details/129915801,作者:日星月云,版权归原作者所有。本网站转在其作品的目的在于传递更多信息,不拥有版权,亦不承担相应法律责任。如因作品内容、版权等问题需要同本网站联系,请发邮件至ctyunbbs@chinatelecom.cn沟通。

      上一篇:linux文件合并、去重、拆分

      下一篇:防抖和节流

      相关文章

      2025-05-09 08:51:09

      Linux+Docer 容器化部署之 Shell 语法入门篇 【Shell基本运算符】

      Linux+Docer 容器化部署之 Shell 语法入门篇 【Shell基本运算符】

      2025-05-09 08:51:09
      Linux , Shell , 语法 , 运算符
      2025-05-09 08:20:32

      C++:类与对象(2)

      C++:类与对象(2)                                                      

      2025-05-09 08:20:32
      函数 , 拷贝 , 构造函数 , 类型 , 编译器 , 运算符 , 重载
      2025-05-06 09:19:39

      C语言中 * 和 ++ 结合的优先级(*++i、*i++) 你还记得吗?(配具体栈内存地址 和 实际测试代码)

      C语言中 * 和 ++ 结合的优先级(*++i、*i++) 你还记得吗?(配具体栈内存地址 和 实际测试代码)

      2025-05-06 09:19:39
      优先级 , 后缀 , 执行 , 运算符
      2025-05-06 08:30:38

      【30天玩转python】运算符与表达式

      运算符是用于执行各种操作的符号。操作数是运算符作用的对象。

      2025-05-06 08:30:38
      gt , True , 示例 , 赋值 , 运算符
      2025-04-23 08:18:32

      C语言中的数据类型和运算符

      C语言中的数据类型和运算符

      2025-04-23 08:18:32
      gt , 数据类型 , 表达式 , 赋值 , 运算符
      2025-04-18 07:10:44

      shell编程-数组与运算符详解(超详细)

      Shell数组是一种用于存储多个值的数据结构。它可以将多个元素组合在一起,并通过索引访问和操作这些元素。在Shell脚本中,数组提供了一种方便的方式来处理和管理一组相关的数据。

      2025-04-18 07:10:44
      数组 , 文件 , 是否 , 检查 , 示例 , 输出 , 运算符
      2025-04-15 09:18:54

      一篇搞定C语言操作符(详解含示例)

      指令系统的每一条指令都有一个操作符,它表示该指令应进行什么性质的操作。不同的指令用操作符这个字段的不同编码来表示,每一种编码代表一种指令。

      2025-04-15 09:18:54
      amp , gt , 优先级 , 操作符 , 运算符
      2025-04-14 09:27:25

      31天Python入门——第4天:判断语句精讲

      31天Python入门——第4天:判断语句精讲

      2025-04-14 09:27:25
      False , True , 语句 , 运算符 , 返回
      2025-04-11 07:12:29

      JavaScrip条件语句

      条件语句就是通过条件来控制程序的走向

      2025-04-11 07:12:29
      amp , false , true , 代码 , 条件 , 语句 , 运算符
      2025-04-11 07:08:33

      Java运算符优先级

      Java运算符优先级

      2025-04-11 07:08:33
      取值 , 大于 , 天才 , 自增 , 运算 , 运算符
      查看更多
      推荐标签

      作者介绍

      天翼云小翼
      天翼云用户

      文章

      33561

      阅读量

      5252121

      查看更多

      最新文章

      【30天玩转python】运算符与表达式

      2025-05-06 08:30:38

      C 语分支初启航,循环开篇韵悠长--逻辑操作符

      2025-03-06 09:21:12

      C 语分支初启航,循环开篇韵悠长--关系,条件操作符

      2025-03-06 09:20:55

      操作符义初解详,运算开篇韵悠长

      2025-03-05 09:11:15

      MYSQL中的增删改查操作(如果想知道MYSQL中有关增删改查操作的知识,那么只看这一篇就足够了!)

      2025-03-04 09:05:20

      ES6中数组新增了哪些扩展?

      2025-02-21 08:56:02

      查看更多

      热门文章

      C primer plus 学习笔记 第5章 运算符、表达式和语句

      2023-02-13 07:44:18

      java运算符

      2023-05-29 10:47:59

      js数组的方法和扩展运算符

      2023-05-18 09:20:18

      null undefined NaN的区别和事件

      2023-05-30 07:49:37

      less中的条件判断

      2023-05-31 08:43:18

      TypeScript-可辨识联合

      2023-05-31 08:42:36

      查看更多

      热门标签

      linux java python javascript 数组 前端 docker Linux vue 函数 shell git 节点 容器 示例
      查看更多

      相关产品

      弹性云主机

      随时自助获取、弹性伸缩的云服务器资源

      天翼云电脑(公众版)

      便捷、安全、高效的云电脑服务

      对象存储

      高品质、低成本的云上存储服务

      云硬盘

      为云上计算资源提供持久性块存储

      查看更多

      随机文章

      sql语句中exist的用法

      null undefined NaN的区别和事件

      关于逻辑运算符书写效率问题 和数组 处理问题

      c++运算符重载的一些理解

      C 语分支初启航,循环开篇韵悠长--逻辑操作符

      运算符与表达式

      • 7*24小时售后
      • 无忧退款
      • 免费备案
      • 专家服务
      售前咨询热线
      400-810-9889转1
      关注天翼云
      • 旗舰店
      • 天翼云APP
      • 天翼云微信公众号
      服务与支持
      • 备案中心
      • 售前咨询
      • 智能客服
      • 自助服务
      • 工单管理
      • 客户公告
      • 涉诈举报
      账户管理
      • 管理中心
      • 订单管理
      • 余额管理
      • 发票管理
      • 充值汇款
      • 续费管理
      快速入口
      • 天翼云旗舰店
      • 文档中心
      • 最新活动
      • 免费试用
      • 信任中心
      • 天翼云学堂
      云网生态
      • 甄选商城
      • 渠道合作
      • 云市场合作
      了解天翼云
      • 关于天翼云
      • 天翼云APP
      • 服务案例
      • 新闻资讯
      • 联系我们
      热门产品
      • 云电脑
      • 弹性云主机
      • 云电脑政企版
      • 天翼云手机
      • 云数据库
      • 对象存储
      • 云硬盘
      • Web应用防火墙
      • 服务器安全卫士
      • CDN加速
      热门推荐
      • 云服务备份
      • 边缘安全加速平台
      • 全站加速
      • 安全加速
      • 云服务器
      • 云主机
      • 智能边缘云
      • 应用编排服务
      • 微服务引擎
      • 共享流量包
      更多推荐
      • web应用防火墙
      • 密钥管理
      • 等保咨询
      • 安全专区
      • 应用运维管理
      • 云日志服务
      • 文档数据库服务
      • 云搜索服务
      • 数据湖探索
      • 数据仓库服务
      友情链接
      • 中国电信集团
      • 189邮箱
      • 天翼企业云盘
      • 天翼云盘
      ©2025 天翼云科技有限公司版权所有 增值电信业务经营许可证A2.B1.B2-20090001
      公司地址:北京市东城区青龙胡同甲1号、3号2幢2层205-32室
      • 用户协议
      • 隐私政策
      • 个人信息保护
      • 法律声明
      备案 京公网安备11010802043424号 京ICP备 2021034386号