MyLisp项目日志：S表达式

已于 2024-05-02 20:22:11 修改
阅读量758 收藏 13
点赞数 22
分类专栏： MyLisp项目 文章标签： C lisp 项目 C++
于 2024-03-19 14:12:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ye_yumo/article/details/136841271
版权

文章目录

S表达式

Lisp列表

Lisp的程序代码也是数据形式的一种，这个结构被称之为S表达式，他存在一个Lisp列表中，我们需要用这个列表结构递归的表示出数字、操作符号和其他的列表，因此我们需要扩展MLval的内容，同时会重构之前写过的函数

我们需要将求值过程分为读取存入，求值两个过程

解析表达式

这里就要由波兰表达式扩展到S表达式，因此首先需要更新一下语法解析器，这里笔者在创建的时候会有一部分内存泄漏的问题，但是重新写一遍这个解析器问题就消失了，也不会报错，可能是正则表达式的部分有出问题

除此之外我们需要把operator操作重命名为symbol，以便之后添加更多的操作符、变量、函数做准备

// 创建解析器
mpc_parser_t* Number = mpc_new("number");
mpc_parser_t* Symbol = mpc_new("symbol");
mpc_parser_t* Sexpr = mpc_new("sexpr");
mpc_parser_t* Expr = mpc_new("expr");
mpc_parser_t* MyLisp = mpc_new("mylisp");

// 定义
mpca_lang(MPCA_LANG_DEFAULT,
    "                                          \
  number : /-?[0-9]+(\\.[0-9]*)?/ ;                    \
  symbol   : '+' | '-' | '*' | '/' | '%' | '^' | /add|sub|mul|div|min|max|mod/ ;  \
  sexpr  : '(' <expr>* ')' ;               \
  expr   : <number> | <symbol> | <sexpr> ; \
  mylisp : /^/ <expr>* /$/ ;               \
",
    Number, Symbol, Sexpr, Expr, MyLisp);

mpc_cleanup(5, Number, Symbol, Sexpr, Expr, MyLisp);

表达式结构

之前我们只有数字和错误两个类型，这里我们直接将这些全部整合起来

如下

// 数据类型
enum
{
    MLVAL_ERR, // 表示错误
    MLVAL_NUM, // 表示数字
    MLVAL_SYM, // 表示符号
    MLVAL_SEXPR // 表示S表达式
};

这样的话，那我们的结构体也要重新设计了，除了之前的类型和数字，把错误直接改成了char*，可以存储具体的错误内容，符号也可以直接存储，最后的cell表示列表结构，使用count表示列表元素的数量

typedef struct MLval 
{
    int type; // 表示类型
    double num; 

    char* err;
    char* sym;

    int count; //列表元素数量
    struct MLval** cell;
} MLval;

构造函数与析构函数

构造函数

因为这里我们没有C++中好用的内存管理和对象管理内容，只能用最原始的手搓方法了

首先要分别写四种类型的构造函数，返回值是MLval*这样外部调用函数就可以直接用了

MLval* MLval_num(double x)
{ // 数字类型初始化
    MLval* v = (MLval*)malloc(sizeof(MLval));
    assert(v);
    v->type = MLVAL_NUM;
    v->num = x;
    return v;
}


MLval* MLval_err(char* m) 
{ // 错误类型初始化
    MLval* v = (MLval*)malloc(sizeof(MLval));
    assert(v);
    v->type = MLVAL_ERR;
    v->err = (char*)malloc(strlen(m) + 1);
    assert(v->err);
    strcpy(v->err, m);
    return v;
}


MLval* MLval_sym(char* s) 
{ // 符号类型初始化
    MLval* v = (MLval*)malloc(sizeof(MLval));
    assert(v);
    v->type = MLVAL_SYM;
    v->sym = (char*)malloc(strlen(s) + 1);
    assert(v->sym);
    strcpy(v->sym, s);
    return v;
}

MLval* MLval_sexpr()
{ // S表达式初始化
    MLval* v = (MLval*)malloc(sizeof(MLval));
    assert(v);
    v->type = MLVAL_SEXPR;
    v->count = 0;
    v->cell = NULL;
    return v;
}

这里需要注意在malloc或者realloc之后需要判断是否申请内存成功，我这里直接暴力assert了，一般情况下可以温和提示然后直接返回就行，当然我们这个小项目也不涉及太大的内存申请

析构函数

在内存申请之后，如果我们不进行内存释放，就会出现内存泄漏的问题，还有空指针野指针，这里我们需要手动写一个

void MLval_del(MLval* v) // 析构函数
{

    switch (v->type) 
    {
    case MLVAL_NUM: break;

    case MLVAL_ERR: free(v->err); break;
    case MLVAL_SYM: free(v->sym); break;

    case MLVAL_SEXPR:
        for (int i = 0; i < v->count; i++) 
        {
            MLval_del(v->cell[i]);
        }
        free(v->cell);
        break;
    default:
        break;
    }
    free(v);
}

读取表达式

整个程序的过程分成两个阶段，第一阶段负责把AST转化为S表达式，第二段根据我们定义的规则对S表达式遍历求值

这一整个S表达式全部存在一个MLisp*结构中，我们还是像之前一样查看语法分析树种的每个节点，然后根据tag和contents构造出不同的MLisp*

如果节点被标记为root或者sexpr，那么就要构造出一个空的MLisp*然后继续导入内容

如果节点被标记为number或者symbol，那么我们直接调用对应的构造函数即可

为了方便向S表达式种添加元素，我们可以写一个MLval_add函数，功能是直接新增一个节点并且初始化

如下

MLval* MLval_add(MLval* v, MLval* x) // 列表添加元素
{
    v->count++;
    MLval** temp = (MLval**)realloc(v->cell, sizeof(MLval*) * v->count);
    if (temp == NULL) {
        printf("realloc fail!!\n");
        free(v->cell);
        return NULL;
    }
    v->cell = temp;
    v->cell[v->count - 1] = x;
    return v;
}


MLval* MLval_read_num(mpc_ast_t* t) 
{
    errno = 0;
    double x = strtod(t->contents, NULL);
    return errno != ERANGE ?
        MLval_num(x) : MLval_err("invalid number");
}

MLval* MLval_read(mpc_ast_t* t)
{

    if (strstr(t->tag, "number")) { return MLval_read_num(t); }
    if (strstr(t->tag, "symbol")) { return MLval_sym(t->contents); }

    MLval* x = NULL;
    if (strcmp(t->tag, ">") == 0) { x = MLval_sexpr(); }
    if (strstr(t->tag, "sexpr")) { x = MLval_sexpr(); }

    for (int i = 0; i < t->children_num; i++)
    {
        if (strcmp(t->children[i]->contents, "(") == 0) { continue; }
        if (strcmp(t->children[i]->contents, ")") == 0) { continue; }
        if (strcmp(t->children[i]->tag, "regex") == 0) { continue; }
        x = MLval_add(x, MLval_read(t->children[i]));
    }

    return x;
}

打印表达式

最后我们需要修改打印函数，使其能够正确打印出S表达式

void MLval_print(MLval* v);

void MLval_expr_print(MLval* v, char open, char close) 
{
    putchar(open);
    for (int i = 0; i < v->count; i++)
    {
        MLval_print(v->cell[i]);

        if (i != (v->count - 1)) {
            putchar(' ');
        }
    }
    putchar(close);
}

void MLval_print(MLval* v) 
{
    switch (v->type) 
    {
    case MLVAL_NUM:   printf("%g", v->num); break;
    case MLVAL_ERR:   printf("Error: %s", v->err); break;
    case MLVAL_SYM:   printf("%s", v->sym); break;
    case MLVAL_SEXPR: MLval_expr_print(v, '(', ')'); break;
    default:
        break;
    }
}

void MLval_println(MLval* v) { MLval_print(v); putchar('\n'); }

表达式求值

表达式求值和之前的差异不大，但是具体思路需要想清楚

首先读取一个MLisp*作为输入，通过运算之后，再作为MLisp*返回，需要注意的是，我们需要将原来的MLisp*释放，否则会内存泄漏

对于不同的输入类型，处理的方式也不同

如果输入的是S表达式，遍历所有子节点，如果遇到错误，则报错，如果没有子节点，则直接返回他的内容即可

在遍历子节点的过程中，将元素从表达式中取出，传入计算函数求值

MLval* MLval_eval(MLval* v);

MLval* MLval_eval_sexpr(MLval* v) 
{

    for (int i = 0; i < v->count; i++) // 遍历所有子节点
    {
        v->cell[i] = MLval_eval(v->cell[i]);
    }

    for (int i = 0; i < v->count; i++) // 遇到错误则报错
    {
        if (v->cell[i]->type == MLVAL_ERR) { return MLval_take(v, i); }
    }

    if (v->count == 0) { return v; } // 没有子节点则直接返回

    if (v->count == 1) { return MLval_take(v, 0); }

    MLval* f = MLval_pop(v, 0);
    if (f->type != MLVAL_SYM) 
    {
        MLval_del(f); MLval_del(v);
        return MLval_err("S-expression Does not start with symbol.");
    }

    MLval* result = builtin_op(v, f->sym);
    MLval_del(f);
    return result;
}

MLval* MLval_eval(MLval* v)
{
    if (v->type == MLVAL_SEXPR) { return MLval_eval_sexpr(v); }
    return v;
}

这上面有一些函数我们还没有定义，我们先看他们的功能

MLval_pop这个函数就是将S表达式第i个元素取出，将取出的元素返回，需要注意的是，他只是取出元素，并不删除申请的空间

MLval_take函数与pop类似，只是在取出之后会删除

MLval* MLval_pop(MLval* v, int i) // 列表删除元素
{
    // 找到第i个元素
    MLval* x = v->cell[i];

    memmove(&v->cell[i], &v->cell[i + 1],
        sizeof(MLval*) * (v->count - i - 1));

    v->count--;
    v->cell = (MLval**)realloc(v->cell, sizeof(MLval*) * v->count);
    return x;
}

MLval* MLval_take(MLval* v, int i) // 取出元素
{
    MLval* x = MLval_pop(v, i);
    MLval_del(v);
    return x;
}

builtin_op函数是用于计算的函数，与之前的计算函数类似

MLval* builtin_op(MLval* a, char* op) 
{

    // 确保操作数为数字
    for (int i = 0; i < a->count; i++) 
    {
        if (a->cell[i]->type != MLVAL_NUM) {
            MLval_del(a);
            return MLval_err("Cannot operate on non-number!");
        }
    }

    // 得到第一个操作数
    MLval* x = MLval_pop(a, 0);

    // 如果只有一个负号则为负数
    if ((strcmp(op, "-") == 0) && a->count == 0) 
    {
        x->num = -x->num;
    }

    
    while (a->count > 0) 
    {

        // 得到第二个操作数
        MLval* y = MLval_pop(a, 0);

        // 计算
        if (strcmp(op, "+") == 0 || strcmp(op, "add") == 0) { x->num += y->num; }
        if (strcmp(op, "-") == 0 || strcmp(op, "sub") == 0) { x->num -= y->num; }
        if (strcmp(op, "*") == 0 || strcmp(op, "mul") == 0) { x->num *= y->num; }
        if (strcmp(op, "/") == 0 || strcmp(op, "div") == 0)
        {
            if (y->num == 0)
            {
                MLval_del(x);
                MLval_del(y);
                x = MLval_err("Division By Zero.");
            }
            x->num /= y->num;
        }

        if (strcmp(op, "%") == 0 || strcmp(op, "mod") == 0)
        {
            if (y->num == 0)
            {
                MLval_del(x);
                MLval_del(y);
                x = MLval_err("Division By Zero.");
                break;
            }
            x->num = fmod(x->num, y->num);
        }

        if (strcmp(op, "^") == 0) { x->num = pow(x->num, y->num); }
        if (strcmp(op, "min") == 0) { x->num = (x->num < y->num) ? x->num : y->num; }
        if (strcmp(op, "max") == 0) { x->num = (x->num > y->num) ? x->num : y->num; }

        MLval_del(y);
    }

    MLval_del(a);

    return x;
}

v0.2.1

#define _CRT_SECURE_NO_WARNINGS 1
#include "mpc.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<assert.h>
void PrintPrompt()
{
    printf("MyLisp Version 0.2.1\n");
    printf("By jasmine-leaf\n");
    printf("Press Ctrl+c to Exit\n\n\n");
}

// v0.0.1
// 实现了用户输入和读取功能
// v0.0.2
// 增加了波兰表达式的解析功能
// v0.1.0
// 增加了波兰表达式的求值功能
// 增加了min、max、乘方运算
// v0.1.1
// 增加了运算报错
// v0.2.0
// 增加了S表达式
// v0.2.1
// 修复了mpca_lang内存泄漏的bug

#ifdef _WIN32 

// 为实现跨平台功能
// 在windows平台下定义实现editline和history的同名函数

#define INPUT_MAX 2048 // 缓冲区最大值

static char Buffer[INPUT_MAX]; // Buffer输入缓冲区


char* readline(char* prompt) // 模拟实现readline
{
    fputs(prompt, stdout);
    fgets(Buffer, INPUT_MAX, stdin);


    char* tmp = malloc(strlen(Buffer) + 1);
    if (tmp != NULL)
    {
        strcpy(tmp, Buffer);
        tmp[strlen(tmp) - 1] = '\0';
    }
    return tmp;
}

void add_history(char* unused)
{}

#else
#ifdef __linux__ // 在linux平台下
#include<editline/readline.h>
#include<editline.history.h>
#endif

#ifdef __MACH__ // 在mac平台下
#include<editline/readline.h>
#endif
#endif 

// 数据类型
enum
{
    MLVAL_ERR, // 表示错误
    MLVAL_NUM, // 表示数字
    MLVAL_SYM, // 表示符号
    MLVAL_SEXPR // 表示S表达式
};

typedef struct MLval 
{
    int type; // 表示类型
    double num; 

    char* err;
    char* sym;

    int count; //列表元素数量
    struct MLval** cell;
} MLval;


MLval* MLval_num(double x)
{ // 数字类型初始化
    MLval* v = (MLval*)malloc(sizeof(MLval));
    assert(v);
    v->type = MLVAL_NUM;
    v->num = x;
    return v;
}


MLval* MLval_err(char* m) 
{ // 错误类型初始化
    MLval* v = (MLval*)malloc(sizeof(MLval));
    assert(v);
    v->type = MLVAL_ERR;
    v->err = (char*)malloc(strlen(m) + 1);
    assert(v->err);
    strcpy(v->err, m);
    return v;
}


MLval* MLval_sym(char* s) 
{ // 符号类型初始化
    MLval* v = (MLval*)malloc(sizeof(MLval));
    assert(v);
    v->type = MLVAL_SYM;
    v->sym = (char*)malloc(strlen(s) + 1);
    assert(v->sym);
    strcpy(v->sym, s);
    return v;
}

MLval* MLval_sexpr()
{ // S表达式初始化
    MLval* v = (MLval*)malloc(sizeof(MLval));
    assert(v);
    v->type = MLVAL_SEXPR;
    v->count = 0;
    v->cell = NULL;
    return v;
}

void MLval_del(MLval* v) // 析构函数
{

    switch (v->type) 
    {
    case MLVAL_NUM: break; 

    case MLVAL_ERR: free(v->err); break;
    case MLVAL_SYM: free(v->sym); break;

    case MLVAL_SEXPR:
        for (int i = 0; i < v->count; i++) 
        {
            MLval_del(v->cell[i]);
        }
        free(v->cell);
        break;
    default:
        break;
    }
    free(v);
}

MLval* MLval_add(MLval* v, MLval* x) // 列表添加元素
{
    v->count++;
    MLval** temp = (MLval**)realloc(v->cell, sizeof(MLval*) * v->count);
    if (temp == NULL) 
    {
        printf("realloc fail!!\n");
        free(v->cell);
        return NULL;
    }
    v->cell = temp;
    v->cell[v->count - 1] = x;
    return v;
}


MLval* MLval_pop(MLval* v, int i) // 列表删除元素
{
    // 找到第i个元素
    MLval* x = v->cell[i];

    memmove(&v->cell[i], &v->cell[i + 1],
        sizeof(MLval*) * (v->count - i - 1));

    v->count--;
    v->cell = (MLval**)realloc(v->cell, sizeof(MLval*) * v->count);
    return x;
}

MLval* MLval_take(MLval* v, int i) // 取出元素
{
    MLval* x = MLval_pop(v, i);
    MLval_del(v);
    return x;
}

void MLval_print(MLval* v);

void MLval_expr_print(MLval* v, char open, char close) 
{
    putchar(open);
    for (int i = 0; i < v->count; i++)
    {
        MLval_print(v->cell[i]);

        if (i != (v->count - 1)) {
            putchar(' ');
        }
    }
    putchar(close);
}

void MLval_print(MLval* v) 
{
    switch (v->type) 
    {
    case MLVAL_NUM:   printf("%g", v->num); break;
    case MLVAL_ERR:   printf("Error: %s", v->err); break;
    case MLVAL_SYM:   printf("%s", v->sym); break;
    case MLVAL_SEXPR: MLval_expr_print(v, '(', ')'); break;
    default:
        break;
    }
}

void MLval_println(MLval* v) { MLval_print(v); putchar('\n'); }

MLval* builtin_op(MLval* a, char* op) 
{

    // 确保操作数为数字
    for (int i = 0; i < a->count; i++) 
    {
        if (a->cell[i]->type != MLVAL_NUM) {
            MLval_del(a);
            return MLval_err("Cannot operate on non-number!");
        }
    }

    // 得到第一个操作数
    MLval* x = MLval_pop(a, 0);

    // 如果只有一个负号则为负数
    if ((strcmp(op, "-") == 0) && a->count == 0) 
    {
        x->num = -x->num;
    }

    
    while (a->count > 0) 
    {

        // 得到第二个操作数
        MLval* y = MLval_pop(a, 0);

        // 计算
        if (strcmp(op, "+") == 0 || strcmp(op, "add") == 0) { x->num += y->num; }
        if (strcmp(op, "-") == 0 || strcmp(op, "sub") == 0) { x->num -= y->num; }
        if (strcmp(op, "*") == 0 || strcmp(op, "mul") == 0) { x->num *= y->num; }
        if (strcmp(op, "/") == 0 || strcmp(op, "div") == 0)
        {
            if (y->num == 0)
            {
                MLval_del(x);
                MLval_del(y);
                x = MLval_err("Division By Zero.");
            }
            x->num /= y->num;
        }

        if (strcmp(op, "%") == 0 || strcmp(op, "mod") == 0)
        {
            if (y->num == 0)
            {
                MLval_del(x);
                MLval_del(y);
                x = MLval_err("Division By Zero.");
                break;
            }
            x->num = fmod(x->num, y->num);
        }

        if (strcmp(op, "^") == 0) { x->num = pow(x->num, y->num); }
        if (strcmp(op, "min") == 0) { x->num = (x->num < y->num) ? x->num : y->num; }
        if (strcmp(op, "max") == 0) { x->num = (x->num > y->num) ? x->num : y->num; }

        MLval_del(y);
    }

    MLval_del(a);

    return x;
}

MLval* MLval_eval(MLval* v);

MLval* MLval_eval_sexpr(MLval* v) 
{

    for (int i = 0; i < v->count; i++)
    {
        v->cell[i] = MLval_eval(v->cell[i]);
    }

    for (int i = 0; i < v->count; i++)
    {
        if (v->cell[i]->type == MLVAL_ERR) { return MLval_take(v, i); }
    }

    if (v->count == 0) { return v; }

    if (v->count == 1) { return MLval_take(v, 0); }

    MLval* f = MLval_pop(v, 0);
    if (f->type != MLVAL_SYM) 
    {
        MLval_del(f); MLval_del(v);
        return MLval_err("S-expression Does not start with symbol.");
    }

    MLval* result = builtin_op(v, f->sym);
    MLval_del(f);
    return result;
}

MLval* MLval_eval(MLval* v)
{
    if (v->type == MLVAL_SEXPR) { return MLval_eval_sexpr(v); }
    return v;
}

MLval* MLval_read_num(mpc_ast_t* t) 
{
    errno = 0;
    double x = strtod(t->contents, NULL);
    return errno != ERANGE ?
        MLval_num(x) : MLval_err("invalid number");
}

MLval* MLval_read(mpc_ast_t* t)
{

    if (strstr(t->tag, "number")) { return MLval_read_num(t); }
    if (strstr(t->tag, "symbol")) { return MLval_sym(t->contents); }

    MLval* x = NULL;
    if (strcmp(t->tag, ">") == 0) { x = MLval_sexpr(); }
    if (strstr(t->tag, "sexpr")) { x = MLval_sexpr(); }

    for (int i = 0; i < t->children_num; i++)
    {
        if (strcmp(t->children[i]->contents, "(") == 0) { continue; }
        if (strcmp(t->children[i]->contents, ")") == 0) { continue; }
        if (strcmp(t->children[i]->tag, "regex") == 0) { continue; }
        x = MLval_add(x, MLval_read(t->children[i]));
    }

    return x;
}

void Lisp()
{
    // 创建解析器
    mpc_parser_t* Number = mpc_new("number");
    mpc_parser_t* Symbol = mpc_new("symbol");
    mpc_parser_t* Sexpr = mpc_new("sexpr");
    mpc_parser_t* Expr = mpc_new("expr");
    mpc_parser_t* MyLisp = mpc_new("mylisp");

    // 定义
    mpca_lang(MPCA_LANG_DEFAULT,
        "                                          \
      number : /-?[0-9]+(\\.[0-9]*)?/ ;                    \
      symbol   : '+' | '-' | '*' | '/' | '%' | '^' | /add|sub|mul|div|min|max|mod/ ;  \
      sexpr  : '(' <expr>* ')' ;               \
      expr   : <number> | <symbol> | <sexpr> ; \
      mylisp : /^/ <expr>* /$/ ;               \
    ",
        Number, Symbol, Sexpr, Expr, MyLisp);

    while (1) 
    {

        char* input = readline("MyLisp> ");
        add_history(input);

        // 分析用户输入
        mpc_result_t r;
        if (mpc_parse("<stdin>", input, MyLisp, &r)) 
        {
            MLval* x = MLval_eval(MLval_read(r.output));
            MLval_println(x);
            MLval_del(x);
            mpc_ast_delete(r.output);
        }
        else 
        {
            // 打印其他失败情况
            mpc_err_print(r.error);
            mpc_err_delete(r.error);
        }

        free(input);

    }

    mpc_cleanup(5, Number, Symbol, Sexpr, Expr, MyLisp);
}

int main()
{

    PrintPrompt();
    Lisp();
    return 0;
}
栖林_
关注
专栏目录
头歌教学实践平台 Web前端开发基础 JavaScript学习手册十：正则表达式
01-20
在JavaScript中，正则表达式（Regular Expression）是一种强大的文本处理工具，用于执行模式匹配和字符串操作。本篇教程将深入探讨JavaScript中的正则表达式，帮助你理解和掌握这一核心概念。 一、正则表达式基础 ...
258_基础的lisp S表达值小结
小灰笔记
02-20 467
完整的emacs and lisp的学习集合整理如下： https://github.com/GreyZhang/g_lisp 继续学习，借助于lispbox看一部分简单的lisp s表达式的常用方式。 先做了一个比较有意思的操作，我直接输入了一个中文的字符串，结果没有正常显示。错误信息我没有截取，提示的信息似乎是跟字体有关，使用的相应的unix某个字符集的一些编码符号覆...
如何在JavaScript中解析S表达式
最新发布
晓风晓浪
04-07 591
这是一种数据格式，其中所有内容都由括号包围的原子或列表创建（其他列表的原子之间由空格分隔）。数字字符串符号 - 它们类似于字符串，但没有引号，可以被解释为不同语言的变量名。此外，您还可以使用特殊的点运算符来创建一对。(1 . b)您可以将列表表示为点对（表示它们实际上是一个链接列表数据结构）。(1 2 3 4)nil是表示空列表的列表的末尾的特殊符号。使用这种格式，您可以创建任何二叉树。但我们在解析器中不使用这种点记法，以免复杂化问题。
lisp基本语法——（一）
archer的技术故事
10-07 1万+
lisp基本语法——（一） 本文主要参考： http://www.gigamonkeys.com/book/syntax-and-semantics.html 好，下面看一个截图 这里面有基本的语法。 1、函数调用 (function-name argument*) 2、if判断 (if x (format t "yes") (format t
sexp_pretty:S表达式漂亮打印机
05-22
**S表达式（S-Expression）**是一种在...总的来说，`sexp_pretty`库是OCaml社区对S表达式美化打印的一个贡献，它提升了代码的可读性和调试的便利性，尤其对于需要频繁处理S表达式的项目来说，是一个非常有价值的工具。
avalanche:正则表达式日志库
07-08
流的最小滑动窗口正则表达式模式匹配器 例子 var Avalanche = require('avalanche'); var patterns = [{ regexp: new RegExp(/hello/), event: 'hello' }, { regexp: new RegExp(/world/), event: 'world' }]; ...
issue-regex:正则表达式，用于匹配问题参考
05-26
正则表达式 正则表达式，用于匹配问题参考 安装 $ npm install issue-regex 用法 const issueRegex = require ( 'issue-regex' ) ; 'Fixes #143 and avajs/ava#1023' . match ( issueRegex ( ) ) ; //=> ['#143', ...
多项式表达式：多项式表达式
02-11
多项式表达式 在数学中，多项式是由变量和系数组成的表达式，仅涉及变量的加，减，乘和非负整数幂运算。 一个单个不确定x的多项式的示例是x²− 4x + 7 这是用于Polynomial Expressions的C++程序。 您可以 添加表达...
LISP 学习笔记 （一）－初识LISP，表达式写法
xiejianming的专栏
06-13 1997
因为在学习LISP。写写笔记，希望能持之以恒。 *声明：所有参考资料均出自网络，版权归原作者所有 参考：LISP Tutorial 1: Basic LISP Programming：http://www.cs.sfu.ca/CC/310/pwfong/Lisp/1/tutorial1.html首先，当然是建立环境，本来想着这个会有点麻烦，谁知道直接到http://sourceforg
lisp表达式
冰影随风的专栏
08-18 1363
每个Lisp表达式会返回一个值，一个函数总是返回最后一个表达式的结果——即使是NIL，NULL在Java或C++中的对等值也是这样。因此在Lisp中显示“Hello World”相当简单： [3]&gt; "Hello World" "Hello World" 如果你希望在屏幕上打印一些内容，并返回其它内容，你应该使用打印函数： [4]&gt; (print "Hello World") ...
lisp表达式求值【详细解析版】
Jay98的博客
02-22 2807
Description: lisp是一种非常古老的计算机语言，是由约翰·麦卡锡在1960年左右创造的一种基于λ演算的函数式编程语言，其语法如下： (+ 2 3 4 5) 表示2+3+4+5，其值为14 (* 2 3 5) 表示235，其值为30 减法可以表示为： (- 2 3 4) 表示：2-3-4=-5 即括弧中第一个符号为运算符，后面是操作数，改运算也可以嵌套，比如 (* (+ 2 3) 6) 表示先计算2+3=5，然后再5*6=30 麦卡锡当初提出了一套理论，其核心是一个eval函数，1958年年底，
Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小
当代野生程序猿
02-25 5888
通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例： 实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。 注意Rect Transform中Pivot轴心点的设置
新唐NUC972 Linux（一）：USB烧写linux出厂镜像
小破孩的博客
02-20 3431
USB烧写出厂镜像 文章目录USB烧写出厂镜像前言一、硬件连接二、安装驱动三、烧写linux程序四、运行程序 前言 今天开始进军linux，学了那么久单片机，也摸得七七八八，至少点个灯还是会的。本人之所以买酷客的linux开发板主要是便宜，资料也算齐全，虽然没有原子那么好，不过也够了，找那么多借口，其实就是qiong。今天先从USB烧录官方提供的linux相关程序到芯片开始吧。 一、硬件连接 1、连接电源线 2、RS232转USB，需要安装CH340驱动，用于在电脑串口超级终端中查看调试信息。 3、U
WeChall CTF Writeup（一）
weixin_43211186的博客
02-25 1571
以下题目标题组成： [Score] [Title] [Author] 文章目录0x01 1 Training: Get Sourced by Gizmore0x02 1 Training: Stegano I by Gizmore0x03 1 Training: Crypto - Caesar I by Gizmore0x04 1 Training: WWW-Robots by Gizmore0x05 1 Training: ASCII by Gizmore 0x01 1 Training: Get Sou
C语言每日一练——第126天：佩奇借书问题
热门推荐
Edison's 小宇宙
02-25 2万+
史上最强借书方案问题讲解（代码详解+思路分析+动图演示+特性总结）
CS5261与CS5265功能应用|CS5261替代RTD2171|CS5265替代RTD2172
qq1659747718的博客
02-25 1337
CS5261可以完全替代兼容停产RTD2171,CS5265可以完全替代兼容RTD2172，芯片单价低，整体方案设计简单，整体BOM成本较RTD2171、RTD2172低。
Hello Kafka（八）——Confluent Kafka简介
天山老妖
02-24 9022
一、Confluent Kafka简介 1、Confluent Kafka简介 2014年，Kafka的创始人Jay Kreps、NahaNarkhede和饶军离开LinkedIn创立Confluent公司，专注于提供基于Kafka的企业级流处理解决方案，并发布了Confluent Kafka。Confluent Kafka分为开源版和企业版，企业版收费。 2、Confluent Kafka特性 Confluent Kafka开源版特性如下： （1）Confluent Kafka Connecto
K8s Apache 日志解析：正则表达式实战
该文档主要讨论了在 Kubernetes (k8s) 环境下，Apache 服务器如何解析日志中的正则表达式，特别是针对三种不同格式的日志：Python 的 API.log 形式、Python 的 access.log 形式以及自定义形式。Apache 日志解析是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

栖林_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值