Javascript 将字符串转换为二维数组

例如，我得到一个字符串（example=“.| x”），每当一个x弹出时，我必须将true推送到我的数组，每当一个“.”弹出时，我必须将false推送到我的数组。我的问题在于，每当出现“|”时，我必须开始一行新的布尔值，使其成为2d数组

function parse(str) {
    let result = [];
    let array = [];
    for (let char of str){
        if (char === "x") {
            result.push(true);
        } if (char === "."){
            result.push(false);
        } if (char === "|"){
            result.push(array);

        }
    }
    return [result];
}

this code just returns [[false, [], true]]

这是我应该得到的

[[假]，[真]]

function parse(str) {
    let result = [];
    let array = [];
    for (let char of str){
        if (char === "x") {
            array.push(true);
        } if (char === "."){
            array.push(false);
        } if (char === "|"){
            result.push(array);
            array = []
        }
    }
    return result;
}

这将创建一个新行，以便您可以添加更多bool值，如果这是我从您的问题中理解的话

这将创建一个新行，以便您可以添加更多布尔值，如果我从您的问题中了解到这一点的话。

试试这个：

function parse(str) {
    let result = [];
    for (let char of str){
        if (char === "x") {
            result.push(true);
        } if (char === "."){
            result.push(false);
        } if (char === "|"){
            result = result.map( e => [e]);
        }
    }
    return result;
}

console.log(parse('.|x')); // logs [ [ false ], true ]

试试这个：

function parse(str) {
    let result = [];
    for (let char of str){
        if (char === "x") {
            result.push(true);
        } if (char === "."){
            result.push(false);
        } if (char === "|"){
            result = result.map( e => [e]);
        }
    }
    return result;
}

console.log(parse('.|x')); // logs [ [ false ], true ]

迭代解法

function parse(str) {
  const result = [];
  let array = [];
  for (const char of str) {
    switch (char) {
      case 'x':
      case '.':
        array.push(char === 'x');
        break;
      case '|':
        result.push(array);
        array = [];
    }
  }
  return result;
}

const parse = (str) => str.split('').reduce((acc, char) => {
  switch (char) {
    case 'x':
    case '.':
      acc[acc.length-1].push(char === 'x');
      break;
    case '|':
      acc.push([]);
  }
  return acc;
}, []).slice(0, -1);

功能解决方案

function parse(str) {
  const result = [];
  let array = [];
  for (const char of str) {
    switch (char) {
      case 'x':
      case '.':
        array.push(char === 'x');
        break;
      case '|':
        result.push(array);
        array = [];
    }
  }
  return result;
}

const parse = (str) => str.split('').reduce((acc, char) => {
  switch (char) {
    case 'x':
    case '.':
      acc[acc.length-1].push(char === 'x');
      break;
    case '|':
      acc.push([]);
  }
  return acc;
}, []).slice(0, -1);

两种解决方案都在O（n）时间内运行。我编写这些代码的前提是，如果字符串包含另一个字符（它可能抛出一个

错误

？），则函数不应执行任何操作；如果至少存在

“|”

，则函数只应将任何子数组推送到2D列表。如果字符串不包含

“|”

，则它将返回空数组。

迭代解决方案

function parse(str) {
  const result = [];
  let array = [];
  for (const char of str) {
    switch (char) {
      case 'x':
      case '.':
        array.push(char === 'x');
        break;
      case '|':
        result.push(array);
        array = [];
    }
  }
  return result;
}

const parse = (str) => str.split('').reduce((acc, char) => {
  switch (char) {
    case 'x':
    case '.':
      acc[acc.length-1].push(char === 'x');
      break;
    case '|':
      acc.push([]);
  }
  return acc;
}, []).slice(0, -1);

功能解决方案

function parse(str) {
  const result = [];
  let array = [];
  for (const char of str) {
    switch (char) {
      case 'x':
      case '.':
        array.push(char === 'x');
        break;
      case '|':
        result.push(array);
        array = [];
    }
  }
  return result;
}

const parse = (str) => str.split('').reduce((acc, char) => {
  switch (char) {
    case 'x':
    case '.':
      acc[acc.length-1].push(char === 'x');
      break;
    case '|':
      acc.push([]);
  }
  return acc;
}, []).slice(0, -1);

两种解决方案都在O（n）时间内运行。我编写这些代码的前提是，如果字符串包含另一个字符（它可能抛出一个

错误

？），则函数不应执行任何操作；如果至少存在

“|”

，则函数只应将任何子数组推送到2D列表。如果字符串不包含

“|”

，则它将返回空数组

在每个管道处拆分字符串：

|

string.split（“|”）

遍历生成的数组，其中

.map（）

方法的回调获取每个字符串并将其转换为字符数组

string.split（“|”）

.map（str=>[…[…str]

步骤3

]）

外部括号和扩展运算符：[…

[…str]步骤3

]将

步骤3

返回的值转换为数组。内括号和扩展运算符：

[…

[…str]

步骤3]

将字符串拆分为字符

然后使用方法对步骤2中的每个字符数组进行迭代，该方法是

.map（）

和

.flat（）

方法的组合。在回调中，返回应该作为一个单独的子数组返回——此外，如果需要省略返回，只需传递一个空数组即可。在此回调中，它会将每个字符与一个

'x'

进行比较，并返回

[true]

或

[false]

（注意：返回的数组是平坦的）

string.split（“|”）.map（str=>[…[…str]

.flatMap（chr=>chr==='x'？[true]：[false]）

]

//6x8表的原始数据
常数数据=`……。|……..xxxxxxxx | x.x.x.x.x | x..xx..x | xx..xx.`；
const bool2D=string=>string.split（“|”）.map（str=>[…[…]str].flatMap（chr=>chr==='x'？[true]：[false]）；
log（JSON.stringify（bool2D（data））
在每个管道处拆分字符串：
|

string.split（“|”）

遍历生成的数组，其中
.map（）
方法的回调获取每个字符串并将其转换为字符数组

string.split（“|”）
.map（str=>[…[…str]
步骤3
]）

外部括号和扩展运算符：[…
[…str]步骤3
]将
步骤3
返回的值转换为数组。内括号和扩展运算符：
[…
[…str]
步骤3]
将字符串拆分为字符

然后使用方法对步骤2中的每个字符数组进行迭代，该方法是
.map（）
和
.flat（）
方法的组合。在回调中，返回应该作为一个单独的子数组返回——此外，如果需要省略返回，只需传递一个空数组即可。在此回调中，它会将每个字符与一个
'x'
进行比较，并返回
[true]
或
[false]
（注意：返回的数组是平坦的）

string.split（“|”）.map（str=>[…[…str]
.flatMap（chr=>chr==='x'？[true]：[false]）
]


//6x8表的原始数据
常数数据=`……。|……..xxxxxxxx | x.x.x.x.x | x..xx..x | xx..xx.`；
const bool2D=string=>string.split（“|”）.map（str=>[…[…]str].flatMap（chr=>chr==='x'？[true]：[false]）；
log（JSON.stringify（bool2D（data））此代码实现了此功能

function parse(str) {
    let result = [];
    let array = [];
    for (let char of str){
        if (char === "x") {
            array.push(true);
        } if (char === "."){
            array.push(false);
        } if (char === "|"){
            result.push(array);
            array = []
        }


    }
    result.push(array);
    return result;
}

这段代码实现了这一点

function parse(str) {
    let result = [];
    let array = [];
    for (let char of str){
        if (char === "x") {
            array.push(true);
        } if (char === "."){
            array.push(false);
        } if (char === "|"){
            result.push(array);
            array = []
        }


    }
    result.push(array);
    return result;
}