Javascript 如何将一个数组中的初始值转换为与第二个数组中的值匹配

我有两个阵列：

array1 = ['bob', 's', 'paul'];
array2 = ['bob', 'sue', 'paul'];

我想将array1:s中的首字母转换为array2:sue中的对应名称

我还想让它反过来工作，其中：

array1 = ['bob', 'sue', 'paul'];
array2 = ['bob', 's', 'paul'];

因此array1中的“sue”将转换为匹配array2的“s”

到目前为止，我有这个功能：

function findName(arr1, arr2) {
        for (let initial of arr1) {
            if (initial.length === 1) {
                return arr2.findIndex(name => name[0] === initial) != -1
            }
        }
    }

如果首字母找到匹配的名称，则返回true，但我需要函数实际创建array3，以便转换首字母

换言之：

array1 = ['bob', 's', 'paul'];
array2 = ['bob', 'sue', 'paul'];
// array3 = ['bob', 'sue', 'paul']; //array 3 maintains the same sequence order as array 1

array1 = ['b', 'sue', 'paul'];
array2 = ['s', 'paul', 'bob'];
// array3 = ['bob', 's', 'paul']; //array 3 maintains the same sequence order as array 1

array1 = ['b', 'sue', 'paul', 'robert'];
array2 = ['s', 'paul', 'bob'];
// array3 = ['bob', 's', 'paul', 'robert']; //array 3 maintains the same sequence order as array 1

array1 = ['b', 'sue', 'paul'];
array2 = ['s', 'paul', 'bob', 'robert'];
// array3 = ['bob', 's', 'paul']; //array 3 maintains the same sequence order as array 1

如果存在多个相同首字母，只需转换第一个首字母并保留第二个：

array1 = ['b', 'b', 'sue', 'paul'];
array2 = ['s', 'paul', 'bob', 'robert'];
// array3 = ['bob', 'b', 's', 'paul']; //array 3 maintains the same sequence order as array 1

除非首字母找到匹配集，否则按顺序转换：

array1 = ['b', 'b', 'sue', 'paul'];
array2 = ['s', 'paul', 'bob', 'robert', 'bill'];
// array3 = ['bob', 'bill', 's', 'paul']; //array 3 maintains the same sequence order as array 1

---

我需要能够在此函数之外使用array3。

将一个数组中的首字母转换为第二个数组中的值

让数组1=['b'，'b'，'sue'，'paul']；
设array2=['s'，'paul'，'bob'，'robert'，'bill']；
设数组3=[]；
数组1.forEach（函数（元素）{
让item=array2.find（（el）=>el.startsWith（元素[0]）；
阵列3.推送（项目）；
var指数=array2.indexOf（项目）；
如果（索引>-1）{
阵列2.拼接（索引1）；
}
});
控制台日志（array3）

您已经在使用

findIndex

来定位元素在数组中的位置；因此，与其扔掉它，只返回一个布尔值来判断它是否为-1，不如使用它来索引数组（当然，如果它不是-1）

---

您可以将映射到第一个数组上，然后像这样使用和：

函数getArray3（array1，array2）{ 设array3=array1.map（a=>{ 让发现； 如果（a.length==1）{ find=array2.findIndex（b=>b.startsWith（a）） }否则{ find=array2.findIndex（b=>b.length==1&&a.startsWith（b）） } 返回find==-1？a:array2.splice（find，1）[0] }) 返回阵列3 } log（getArray3（['bob'，'s'，'paul']，['bob'，'sue'，'paul']）） //[‘鲍勃’、‘苏’、‘保罗’]； log（getArray3（['b'，'sue'，'paul']，['s'，'paul'，'bob']）） //[‘鲍勃’、‘s’、‘保罗’]//数组3与数组1保持相同的序列顺序 log（getArray3（['b'，'sue'，'paul'，'robert']，['s'，'paul'，'bob']）） //['bob'，'s'，'paul'，'robert'] log（getArray3（['b'，'b'，'sue'，'paul']，['s'，'paul'，'bob'，'robert']）） //['bob'，'b'，'s'，'paul'] log（getArray3（['b'，'b'，'sue'，'paul']，['s'，'paul'，'bob'，'robert'，'bill']））

---

//['bob'，'bill'，'s'，'paul']您可以使用地图查找

这里的想法是-

• 首先，我们循环通过

  一个
  参数

• 对于

  A

  的每个值，我们将其与参数

  B

  中的首字母匹配。alreadyUsed是一个用于跟踪以前使用的替换的对象
• 如果我们发现一个值不存在错误，也不用于以前的任何替换，那么我们将其映射到最终输出。如果不是，我们保持价值不变

let switcher=（A，B）=>{
设alreadyUsed={}
返回A.map（e=>{
设value=B.find（B=>B.startsWith（e[0]）&&！alreadyUsed[B]）|e
如果（值&！已使用[值]）{
alreadyUsed[值]=真
}
返回值
})
}
设array1=['bob'，'s'，'paul']；
让array2=['bob'，'sue'，'paul']；
控制台日志（交换机（阵列1、阵列2））
设a1=['b'，'b'，'sue'，'paul']；
设a2=['s'，'paul'，'bob'，'robert'，'bill']；
console.log（切换器（a1、a2））

这里有一个结合了和的解决方案：

const-mapInitials=（a1，a2）=>{
a2=[…a2]；//克隆，因为我们要修改这个
返回a1.map（（s1）=>{
常数i=a2.findIndex（s2=>s2[0]==s1[0]）；
返回i<0？s1:a2.拼接（i，1）[0]；
})
};
const test=（a1，a2）=>console.log（…mapInitials（a1，a2））；
测试（['bob'，'s'，'paul']，
[‘鲍勃’、‘苏’、‘保罗’）；
//[“鲍勃”、“苏”、“保罗”]
测试（['b'，'sue'，'paul']，
[‘s’、‘paul’、‘bob’]）；
//['bob'，'s'，'paul']
测试（['b'，'sue'，'paul'，'robert']，
[‘s’、‘paul’、‘bob’]）；
//['bob'，'s'，'paul'，'robert']
测试（['b'，'sue'，'paul']，
[‘s’、‘保罗’、‘鲍勃’、‘罗伯特’]）；
//['bob'，'s'，'paul']
测试（['b'，'b'，'sue'，'paul']，
[‘s’、‘保罗’、‘鲍勃’、‘罗伯特’]）；
//['bob'，'b'，'s'，'paul']
测试（['b'，'b'，'sue'，'paul']，
[‘s’、‘保罗’、‘鲍勃’、‘罗伯特’、‘比尔’]）；
//['bob'，'bill'，'s'，'paul']

使用

返回arr1.map（…）

？您可能应该避免重复的

array2.find（（el）=>el.startsWith（元素[0]）

调用

i = arr2.findIndex(...);
result = (i > -1)? arr2[i] : initial;