# simple-java-script

**Repository Path**: cnxfgit/simple-java-script

## Basic Information

- **Project Name**: simple-java-script
- **Description**: 基于c语言编写的类js解释器。
- **Primary Language**: C
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 1
- **Created**: 2021-12-20
- **Last Updated**: 2023-02-09

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# simple-java-script

## 介绍
simpleJS是一款玩具语言，基于 c99标准 c语言编写的类js解释器，适合c语言新手。

## 软件架构

- **chunk** 字节码块 字节码定义
- **scanner** 源码扫描 生成TOKEN
- **compiler** 编译器 TOKEN编译字节码 
- **vm** 虚拟机 执行编译后的字节码块
- **memory** 内存管理  gc 对象分配
- **debug** 调试  打印字节码
- **sjs** 程序启动入口
- **native** 本地函数  c原生函数
- **value** 值类型  值类型定义
- **object** 对象类型   对象类型定义
- **table** 哈希表
- **array** 数组原生方法
- **string** 字符串原生方法
- **utf8** unicode支持(未实现)

## 安装教程

**windows：**

通过cmake编译出 sjs.exe 可执行文件
执行命令 sjs.exe  sjs源码文件
例如：sjs.exe  C:\Users\CQT\CLionProjects\simple-java-script\example\demo.sjs
直接执行 sjs.exe 进入repl 模式


**linux:**

复制/src中的代码到 linux中
cmake .
make
编译出可执行文件sjs
./sjs  进入repl模式
./sjs  sjs源码路径
例如：./sjs /home/sjs/demo.sjs

## 使用说明

### 使用sjs做leetcode题

因为功能有限，只能实现一些简单的题目

**两数之和**

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

```sjs
# 构建数组和target
var nums = [2,7,11,15];
var target = 9;

# 定义两数之和函数
function twoSun(nums,target){
    var n = nums.length();
    for(var i = 0; i < n; i=i+1){
        for(var j = 0; j < n; j=j+1){
            if(nums[i] + nums[j] == target){
                return [i,j];
            }
        }
    }
    return [];
}

# 执行并打印结果
print(twoSun(nums,target));
```

控制台打印结果: `[0, 1]`

**翻转二叉树**

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

```sjs

# 定义数据结构
class TreeNode{
    val = null;
    left = null;
    right = null;
    static new(val){
        var treeNode = TreeNode();
        treeNode.val = val;
        return treeNode;
    }
}


# 伪造链表
var root = TreeNode.new(2);
var left = TreeNode.new(1);
var right = TreeNode.new(3);
root.left = left;
root.right = right;

# 定义函数 递归翻转函数
function invertTree(root) {
    if (root == null) return null;
    var temp = root.left;
    root.left = root.right;
    root.right = temp;
    invertTree(root.left);
    invertTree(root.right);
    return root;
}

# 打印结果
print(invertTree(root));
```

控制台打印结果: `TreeNode {"left": TreeNode {"left": null, "val": 3, "right": null}, "val": 2, "right": TreeNode {"left": null, "val": 1, "right": null}}`

**经典二分**

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

```sjs
# 构建假数据
var nums = [1,3,5,6];
var target = 5;

# 二分法函数
function searchInsert(nums, target){
    var left = 0;
    var right = nums.length();
    for(left < right){
        var mid = (left + right) / 2;
        if (target <= nums[mid]) {
        	right = mid;
        }else {
        	left = mid+1;
        }
    }
    return left;
}

# 执行并打印结果
print(searchInsert(nums, target));
```

控制台打印结果:`2`


**strStr()**

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

```sjs
# 构建数据
var haystack = "hello";
var needle = "ll";

# 定义函数
function strStr(haystack, needle) {
    var left = 0;
    var right = needle.length();
    for (right < haystack.length()){
        if (needle == (haystack.substring(left,right))) return left;
        left=left+1;
        right=right+1;
    }
    return -1;
}

# 输出结果
print(strStr(haystack,needle));
```

控制台打印结果:`2`

**用栈实现队列**


```sjs

# 双栈实现队列
class MyQueue {

    stack1;# 顺序栈
    stack2;# 逆序栈

    static new() {
        var queue = MyQueue();
        queue.stack1 = [];
        queue.stack2 = [];
        return queue;
    }

    push(x) {
        this.stack1.push(x);# 顺序插入栈顶
        this.stack2 = [];# 更新逆序栈
        for (var i = this.stack1.length()-1; i >= 0; i=i-1)
            this.stack2.push(this.stack1[i]);
    }

    pop() {
        var val = this.stack2.pop();# 移除逆序栈的栈顶
        this.stack1 = [];# 更新顺序栈
        for (var i = this.stack2.length()-1; i >= 0; i=i-1)
            this.stack1.push(this.stack2[i]);
        return val;
    }

    peek() {
        return this.stack2[this.stack2.length()-1];
    }

    empty() {
        return this.stack1.length() == 0;
    }
}

# 测试栈
var queue = MyQueue.new();
queue.push(123);
print(queue.peek());
print(queue.empty());
print(queue.pop());
```

控制台打印：
```text
123
false
123
```