javascript example icon

Home

Index

search icon

How to use the isExpressionStatement function from @babel/types

Find comprehensive JavaScript @babel/types.isExpressionStatement code examples handpicked from public code repositorys.

@babel/types.isExpressionStatement is a function that checks if a given AST node is an ExpressionStatement.

transformJS.js

GitHub: baidu/wx2

baidu profile picture
74
75
76
77
78
79
80
81
82
83
    return generateResult.code;
};


function isAopBlock(path, block, AOP, cb) {
    t.isExpressionStatement(block)
    && t.isCallExpression(block.expression)
    && t.isMemberExpression(get(block, 'expression.callee'))
    && get(block, 'expression.callee.property.name') === 'after'
    && cb(path, block, AOP);
fork icon17
star icon123
watch icon10

+ 7 other calls in file

vue-ast-helpers.js

GitHub: icai/vue-to-react

icai profile picture
89
90
91
92
93
94
95
96
97
98
    `);
}
path.traverse({
    ThisExpression (thisPath) {
        const parentNode = thisPath.parentPath.parentPath.parent;
        const isValid = t.isExpressionStatement(parentNode) || 
            t.isVariableDeclaration(parentNode) ||
            t.isBlockStatement(parentNode) || 
            t.isJSXElement(parentNode) || 
            t.isCallExpression(parentNode) ||
fork icon65
star icon1
watch icon1

How does @babel/types.isExpressionStatement work?

@babel/types.isExpressionStatement is a function that takes an AST node and returns true if the node is an ExpressionStatement or false otherwise. The function first checks if the node is an object and has a type property, which is a string indicating the type of the node. If the type property is "ExpressionStatement", then the function returns true. If the type property is not "ExpressionStatement", then the function returns false. The purpose of this function is to allow developers to easily check whether a given node in an abstract syntax tree (AST) represents an expression statement, which is a statement that consists of an expression that is evaluated for its side effects, such as assigning a value to a variable or calling a function.

Ast_code.js

GitHub: polestar-HF/Spider-project

polestar-HF profile picture
148
149
150
151
152
153
154
155
156
157
//当前case下的所有节点
var targetBody = case_list[i].consequent;

// 删除break节点，和break节点的上一个节点的一些无用代码
if (t.isBreakStatement(targetBody[targetBody.length - 1])
    && t.isExpressionStatement(targetBody[targetBody.length - 2])
    && targetBody[targetBody.length - 2].expression.right.object.object.callee.object.name == "khCTZ") {

    // 提取break节点的上一个节点AJgjJ.EMf()后面的两个索引值
    var change_arg_f = targetBody[targetBody.length - 2].expression.right.object.property.value;
fork icon5
star icon11
watch icon1

move-cursor.ts

GitHub: suchipi/tofu

suchipi profile picture
8
9
10
11
12
13
14
15
16
    t.isTemplateLiteral,
    t.isTemplateElement,
    t.isIdentifier,
    t.isNumericLiteral,
    t.isCallExpression,
    t.isExpressionStatement
  ].some(check => check(node));

export type Cursor = [number, number];
fork icon4
star icon0
watch icon1

+ 13 other calls in file

Ai Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
const t = require("@babel/types");

const ast = t.file(
  t.program([
    t.expressionStatement(
      t.callExpression(t.identifier("console.log"), [
        t.stringLiteral("Hello World!"),
      ])
    ),
  ])
);

const node = ast.program.body[0];

console.log(t.isExpressionStatement(node)); // true
console.log(t.isVariableDeclaration(node)); // false

In the above example, we create an abstract syntax tree (AST) using @babel/types, and then we use t.isExpressionStatement to check whether a node inside the AST is an expression statement. The function returns true because the node is indeed an expression statement.

utils.js

GitHub: Ahaochan/js_deobfuscation

Ahaochan profile picture
187
188
189
190
191
192
193
194
195
196
simple1: function (ast) {
    // 对象合并
    traverse(ast, {
        VariableDeclarator(path) {
            if (types.isObjectExpression(path.node.init)) {
                // path.getAllNextSiblings().filter(s => types.isExpressionStatement(s));
                for (let expressionStatementPath of path.parentPath.getAllNextSiblings().filter(s => types.isExpressionStatement(s))) {
                    let expression = expressionStatementPath.node.expression;
                    if (types.isAssignmentExpression(expression) && expression.operator === '=') {
                        if (types.isMemberExpression(expression.left) && expression.left.object.name === path.node.id.name && types.isIdentifier(expression.left.property)) {
fork icon2
star icon1
watch icon1

+ 248 other calls in file

event.js

GitHub: yusongjohn/mock-uniapp-for-wxmp

yusongjohn profile picture
279
280
281
282
283
284
285
286
287
288
// "click":function($event) {click1(item);click2(item);}
const body = funcPath.node.body && funcPath.node.body.body
const funcParams = funcPath.node.params
if (body && body.length && funcParams && funcParams.length === 1) {
  const exprStatements = body.filter(node => {
    return t.isExpressionStatement(node) && t.isCallExpression(node.expression)
  })
  if (exprStatements.length === body.length) {
    const paramPath = funcPath.get('params')[0]
    const paramName = paramPath.node.name
fork icon0
star icon1
watch icon1

+ 3 other calls in file

react-annotated.js

GitHub: eniolam1000752/babel-plugin-react-annotated

eniolam1000752 profile picture
495
496
497
498
499
500
501
502
503
504
505


function initAnnotationParser(annotation) {
  var params = annotation.match(/(?<=(\()).*(?=(\)))/g)[0].split(",");
  params = params.length === 1 && params[0] === "" ? [] : params;
  params = params.filter(function (item, index) {
    return types.isExpressionStatement(template(item)());
  }).map(function (item) {
    return template(item)().expression;
  }); // console.log("PARAMETERS TO BE PARSED: ", params);
fork icon0
star icon0
watch icon1

test.js

GitHub: c323fff25/Spider

c323fff25 profile picture
291
292
293
294
295
296
297
298
299
300
AssignmentExpression(path){
    let obj_name = path.get('right.callee')
    if (!t.isMemberExpression(obj_name)) return;
    if (!t.isStringLiteral(obj_name.node.object) && !t.isStringLiteral(obj_name.node.property, {value: 'split'})) return;
    let var_path =  path.findParent(function (p){
        return t.isExpressionStatement(p)
    })
    let while_path = var_path.getNextSibling()
    let my_arr = []
    while_path.node.body.body[0].cases.map(function(p){
fork icon0
star icon0
watch icon0

+ 2 other calls in file

parentheses.js

GitHub: ds-sampaio/ClicouChegouApp

ds-sampaio profile picture
255
256
257
258
259
260
261
262
263
264
let node = printStack[i];
i--;
let parent = printStack[i];

while (i >= 0) {
  if (expressionStatement && t.isExpressionStatement(parent, {
    expression: node
  }) || exportDefault && t.isExportDefaultDeclaration(parent, {
    declaration: node
  }) || arrowBody && t.isArrowFunctionExpression(parent, {
fork icon0
star icon0
watch icon0

+ 2 other calls in file

Other functions in @babel/types

Sorted by popularity

function icon

@babel/types.identifier is the most popular function in @babel/types (20936 examples)

Other popular packages:

Home

About

Privacy Policy

Example Javascript © 2024