Puvvl's questions

我试图在字符之间的字符串中获取一个值，但我在编写 RegExp 方面有点缺乏经验。我会很高兴得到任何帮助。

我Hello ___world___从她那里得到了一只独脚金，我需要得到_world_。world可以是任何其他值。例如：

Hello ______-> 应该返回 null/undefined

Hello ___world__-> 应该返回_world_

Hello ___wor_l_d___-> 应该返回_wor_l_d_

Hello __*$world__-> 应该返回_*$world_

Hello world__-> 应该返回 null/undefined

现在我得到它是这样的：

const reg = /(?<=_)(.*)(?=_)/;
const string1 = "Hello ___world___";
const string2 = "Hello ______";
const string3 = "Hello ___wor_l_d___";
const string4 = "Hello ___*$world___";
const string5 = "Hello world__";

console.log(string1.match(reg));
console.log(string2.match(reg));
console.log(string3.match(reg));
console.log(string4.match(reg));
console.log(string5.match(reg));

有一行有链接和主题标签。您需要将这些链接包装在标签<a href=""></a>之类的标签中。但我不明白为什么它不能与链接正常工作，并且一个标签找不到没有空格的标签。这是我的例子：

var link = /(https?:\/\/|ftp:\/\/|www\.)((?![.,?!;:()]*(\s|$))[^\s]){2,}/gim
var hashTag = /(^|\s)(#[a-z\d-]+)/ig

function rebaseText(text) {
  if (typeof text === 'string') {
    if (text.match(link)) {
      text = text.replace(link, "$1<a href={$2} class='link'>$2</a>");
    }
    if (text.match(hashTag)) {
      text = text.replace(hashTag, "$1<a href='https://google.com/search?q=$2' class='hashtag'>$2</a>");
    }
  }
  return text;
}

console.log(rebaseText('Hello world!!! https://google.com/ some text http://myweb.com/ lorem #hashTag1#hashTag2 qweqwewqeqweq #hashTag3'));

您需要找到所有重复项products.id并合并quantity。结果应该是这样的：

products = [{id: 5, quantity: 25}, {id: 3, quantity: 15}, {id: 4, quantity: 164}]

const arr = [{
    id: 1,
    products: [{
      id: 5,
      quantity: 5
    }, {
      id: 3,
      quantity: 2
    }]
  },
  {
    id: 2,
    products: [{
      id: 4,
      quantity: 75
    }, {
      id: 5,
      quantity: 20
    }]
  },
  {
    id: 3,
    products: [{
      id: 3,
      quantity: 13
    }, {
      id: 4,
      quantity: 89
    }]
  },
]

let allProducts = [];
let products = [];

function getAllProducts() {
  arr.forEach(value => {
    value.products.forEach(product => allProducts.push(product))
  })
  concatProducts(allProducts)
}

function concatProducts(arr) {
  arr.reduce(function(a, b) {
    return a.id === b.id ? products.push({
      id: a.id,
      quantity: a.quantity + b.quantity
    }) : products.push(b);
  });
  console.log(products)
}

getAllProducts()

有一个带有角色类别userByRoles的数组和一个带有角色的用户数组users。将用户users塞进userByRoles.children. 在我看来，我的方法不是很漂亮而且不可读，我想以某种方式对其进行重构。

PS中userByRoles您可以更改任何数据，除了title & children

let userByRoles = [{
    title: 'Role 1',
    value: '0',
    key: 'role_1',
    children: []
  },
  {
    title: 'Role 2',
    value: '1',
    key: 'role_2',
    children: []
  },
  {
    title: 'Role 3',
    value: '2',
    key: 'role_3',
    children: []
  },
  {
    title: 'All users',
    value: '3',
    key: 'all_users',
    children: []
  }
];

const users = [{
  name: 'user 1',
  role: 'role_1'
}, {
  name: 'user 2',
  role: 'role_1'
}, {
  name: 'user 3',
  role: 'role_2'
}, {
  name: 'user 4',
  role: 'role_2'
}, {
  name: 'user 5',
  role: 'role_3'
}, {
  name: 'user 6',
  role: 'role_4'
}, {
  name: 'user 7',
  role: 'role_5'
}, {
  name: 'user 9',
  role: 'role_4'
}, {
  name: 'user 10',
  role: 'role_3'
}, {
  name: 'user 11',
  role: 'role_2'
}, ]

function myFunc() {
  users.forEach((value) => {
    if (value.role === 'role_1') {
      userByRoles[0].children.push({
        name: value.name
      })
    } else if (value.role === 'role_2') {
      userByRoles[1].children.push({
        name: value.name
      })
    } else if (value.role === 'role_3') {
      userByRoles[2].children.push({
        name: value.name
      })
    } else {
      userByRoles[3].children.push({
        name: value.name
      })
    }
  });
  return userByRoles;
}

console.log(myFunc())

有一个条件是检查字段是否存在，如果字段存在，我们处理它，但是我们遇到了一个非常令人惊讶的结果。在示例中，您将了解一切:)

事实上，如果有data.visible，它应该返回VISIBLE，但既然它进来了false，它就会跳过它。谁能为这项任务提出最佳解决方案？

function result(data) {
  if (data.visible) {
    return 'VISIBLE: ' + data.visible;
  } else {
    return 'NOT VISIBLE';
  }
}

console.log('OK', result({
  visible: true
}))
console.log('OK', result({
  visible: false
}))
console.log('FAIL', result({}))

有一个数字256.52，如何获得点后的剩余数字？

var number = 256.52;

console.log(parseInt(number)) // тут получили целое число

如何最好地整理签到myFunc。我想用它，typeof obj.files === 'obj'但我可以进去null，然后一切都会被打破。

var obj1 = {
  files: null
}
var obj2 = {
  files: {
    video: 'video_link'
  }
}
var obj3 = {
  files: {
    file: 'link_to_download'
  }
}
var obj4 = {}

function myFunc(obj) {
  return obj.files ? obj.files !== null ? obj.files.video ?
    obj.files.video : obj.files.file ?
    obj.files.file : null : null : null
}

console.log(myFunc(obj1))
console.log(myFunc(obj2))
console.log(myFunc(obj3))
console.log(myFunc(obj4))

函数中有一个对象和一个类型。举例来说，你会明白我想要什么。有可能实现这一点吗？如何获取链接？

let obj = {
  m1: [{
    message: 'Hello world!'
  }],
  m2: [],
  m3: []
}

function getElementFromObj(type) {
  this.method(type, obj.type.length >= 1)
}

function method(type, value) {
  switch (type) {
    case 'm1':
      return value ? 'post' : 'patch'
      break;
    case 'm2':
      return value ? 'post' : 'patch'
      break;
    case 'm3':
      return value ? 'post' : 'patch'
      break
    default:
      return 'post'
      break;
  }
}

console.log(getElementFromObj('m1'))
console.log(getElementFromObj('m2'))
console.log(getElementFromObj('m3'))

例如，有数字13121313176781和1537275。在第一个数字中，您需要获取6and，81因为分隔符7是 ，而在第二个数字中，您需要获取2and 5。RegExp 不强，请帮助。直到这个出来。

var number1 = 13121313176781;
var number2 = 1537275;

function getNumbers(number) {
  console.log(number.toString().match(/7[^d+]/g))
}
getNumbers(number1)
getNumbers(number2)

请帮帮我。有 2 个数组，一个是对象，另一个是数字。在数字中number，从带有对象的数组中存储。

如何使用数字数组正确找到对象的索引并在对象中更改它selected: true？

现在newArr奇迹正在发生，但它arr改变了它的意义selected

var arr = [{
  name: 'Hello',
  selected: false,
  number: 14
}, {
  name: 'World',
  selected: false,
  number: 18
}, {
  name: '!',
  selected: false,
  number: 31
}]

var numbers = [14, 31];

var newArr = arr.map((item, index) => numbers.map((number) => item.number == number ? arr[index].selected = true : arr[index]))

console.log(newArr)

帮助重写代码，使其看起来更合乎逻辑和易于理解，或者告诉我可以使用什么方法。代码的逻辑是这样的：

如果有一个对象，orderStatus: 'ACCEPTED'那么它activeOrder应该接受这个对象，如果有orderStatus: 'ACCEPTED' && orderStatus: 'WAITING'，那么这个对象会更优先orderStatus: 'ACCEPTED'，如果没有，orderStatus: 'ACCEPTED'但是有，orderStatus: 'WAITING'带走这个对象orderStatus: 'WAITING'。如果这些都不在对象数组中，则离开activeOrder = false。

let order = [{
    orderStatus: 'ACCEPTED'
  },
  {
    orderStatus: 'WAITING'
  },
  {
    orderStatus: 'INCOMPLETE'
  },
];

let activeOrder = false,
  accepted = false,
  waiting = false;

order.forEach((value) => {
  if (value.orderStatus === 'ACCEPTED') {
    accepted = value;
  }
  if (value.orderStatus === 'WAITING') {
    waiting = value;
  }
})

if (accepted !== false && waiting !== false || waiting === false) {
  activeOrder = accepted;
}
if (accepted === false && waiting !== false) {
  activeOrder = waiting;
}
if (accepted === false && waiting === false) {
  activeOrder = false;
}

console.log(activeOrder)

下午好，我正在使用该库编写本机应用程序，react-native-maps问题是 Google 地图在 Android 上显示，而在 iPhone 上显示不正确，显示标记、位置和 Google 徽标，但地图本身没有。可能是什么问题呢？

如果您删除provider={PROVIDER_GOOGLE}iPhone 的标准地图将显示。一切都会好起来的，但我需要一张谷歌地图。

import React, { Component } from 'react';
import { StyleSheet, View, Text, Dimensions, Platform, Image } from 'react-native';
import MapView, { PROVIDER_GOOGLE, PROVIDER_DEFAULT } from 'react-native-maps';
import { Input } from 'native-base';

const {width, height} = Dimensions.get('window');

const SCREEN_HEIGHT = height;
const SCREEN_WIDTH = width;
const ASPECT_RATION = width / height;
const LATITUDE_DELTA = 0.0922;
const LONGTITUDE_DELTA = LATITUDE_DELTA * ASPECT_RATION;

const GOOGLE_MAPS_APIKEY = 'Тут мой ключик)';

class Map extends Component {
  constructor(props) {
    super(props);
    this.state = {
      initialPosition: {
        latitude: 0,
        longitude: 0,
        latitudeDelta: 0,
        longitudeDelta: 0,
      },
      markerPosition: {
        latitude: 0,
        longitude: 0,
      },
      driverPosition: {
        latitude: 0,
        longitude: 0,
      },
      destination: {
        dist: false,
        latitude: 0,
        longitude: 0
      }
    }
  }

  componentDidMount() {
    const options = {
      enableHighAccuracy: true,
      timeout: 10000,
      maximumAge: 0
    }
    this.watchId = navigator.geolocation.getCurrentPosition((position) => {
        let lat = parseFloat(position.coords.latitude);
        let long = parseFloat(position.coords.longitude);
        let initialRegion = {
          latitude: lat,
          longitude: long,
          latitudeDelta: LATITUDE_DELTA,
          longitudeDelta: LONGTITUDE_DELTA,
        }
        let driversRegion = {
          latitude: lat - 0.001,
          longitude: long - 0.0009,
          latitudeDelta: LATITUDE_DELTA,
          longitudeDelta: LONGTITUDE_DELTA,
        }
        this.setState({
          initialPosition: initialRegion,
          markerPosition: initialRegion,
          driverPosition: driversRegion
        })
      },
      (error) => alert(JSON.stringify(error)),options);
  }

  componentWillUnmount() {
    navigator.geolocation.clearWatch(this.watchID);
  }

  render() {
    return (
        <MapView
          provider={PROVIDER_GOOGLE}
          style={styles.map}
          initialRegion={this.state.initialPosition}
          zoomEnabled={true}
          pitchEnabled={true}
          showsUserLocation={true}
          followsUserLocation={true}
          showsCompass={true}
          showsIndoors={true}
          showsBuildings={true}>
          <MapView.Marker
            coordinate={this.state.markerPosition}
            >
            <View style={styles.radius}>
            </View>
          </MapView.Marker>
          {this.state.destination.dist == true ? (
            <MapViewDirections
              origin={this.state.markerPosition}
              destination={this.state.destination}
              apikey={GOOGLE_MAPS_APIKEY}
              strokeWidth={3}
              strokeColor='rgb(255, 0, 0)'
            />
          ) : []}
        </MapView>
    );
  }
}

const styles = StyleSheet.create({
  map: {
    ...StyleSheet.absoluteFillObject,
  },
  marker: {
  },
  radius: {
  },
  driver: {
  },
  searchText: {
    textAlign: 'center'
  }
});

export default Map;

一天中的好时光，出现了将数组元素移动到开头的任务。好像已经完成了，但也许有更漂亮的方式将元素移到开头？

var arr = [0, 1, 2, 3, 4, 5];
console.log(arr);
var removed = arr.splice(3, 1);
arr.unshift(removed[0]);
console.log(arr);

下午好，帮我使用 JavaScript 找到页面上最近的元素。现在我只找到 X 最接近的元素。一个得分为 75 的机器人会跑起来，因为 X 更接近它，​​但实际上，页面上完全不同的元素更接近（右边的硬币）。这是代码：

const closest = (a,g) => a.reduce((p,c) => Math.abs(c-g) < Math.abs(p-g) ? c : p);

let botPositionX = parseInt(64);
let botPositionY = parseInt(64);
const data = [{x: 500, y: 285}, {x: 200, y: 324}, {x: 700, y: 200}];
const dataX = [500, 200, 700];
const dataY = [285, 324, 200];
const rightOrLeft = closest(dataX, botPositionX);
const topOrBottom = closest(dataY, botPositionY);

let found = data.find((loc) => {
  return loc.x === rightOrLeft;
});

let coinPosX = parseInt(found.x);
let coinPosY = parseInt(found.y);

你好，我有一个表单中的字符串100 ($50)。请帮我从这条线上得到号码50。

下午好，有一个数据数组，我需要将此数据输出到 FEname但将其发送到 BE code。codeBE 上的相同可能需要几个：

[
  {
    "name": "RAILCARD",
    "code": "HMF"
  },
  {
    "name": "16-25 RAILCARD",
    "code": "YNG"
  },
  {
    "name": "NETWORK RAILCARD",
    "code": "NEW"
  },
  {
    "name": "SENIOR RAILCARD",
    "code": "SRN"
  },
  {
    "name": "ANNUAL GOLD CARD",
    "code": "NGC"
  },
  {
    "name": "JCP DISCOUNT CARD",
    "code": "JCP"
  },
  {
    "name": "FAMILY & FRIENDS RCD",
    "code": "FAM"
  },
  {
    "name": "DISABLED ADULT",
    "code": "DIS"
  },
  {
    "name": "DISABLED CHILD",
    "code": "DIC"
  },
  {
    "name": "TWO TOGETHER R/CARD",
    "code": "2TR"
  }
]

这是我的状态：

constructor(props) {
    super(props);
    this.state = {
        railcards: railcards.map((key) => key.name),
        chipData: [],
        chipCode: [],
    };

    this.search = this.search.bind(this);
}

添加脚本+发送到BE，在这里我们在我们的数据中找到一个字段name并将其写入一个单独的状态code：

async search() {

    let chipsFound = railcards.find((e) => {
        let result;
        self.state.chipData.map((key) => key.label).forEach(function(item, index) {
            result = e.name[index] === item[index];
        });
        return result;
    });
    let chips = chipsFound ? chipsFound.code : undefined;
    self.setState({chipCode: self.state.chipCode.concat(chips)})
}

以下是删除脚本：

handleRequestDelete = (key) => {
    this.chipData = this.state.chipData;
    const chipToDelete = this.chipData.map((chip) => chip.key).indexOf(key);
    this.chipData.splice(chipToDelete, 1);
    this.setState({
        chipData: this.chipData,
    });
    this.search()
};

帮助删除，如果有更好的解决方案，添加到数组中，也告诉我:-)

我注意到一个小问题，例如：如果我们从数组 c 中删除一个元素key: 3并尝试再次添加一个元素，那么该元素就会出现重复key. （即添加与具有相同键的数组的最后一个元素相同的元素）

你好，我有这种格式的数据：

[
  {
    "name": "Alexandra Palace",
    "code": "AAP",
    "lat": 51.59793,
    "lon": -0.12023
  },
  {
    "name": "Achanalt",
    "code": "AAT",
    "lat": 57.60958,
    "lon": -4.91386
  },
  {
    "name": "Aberdare",
    "code": "ABA",
    "lat": 51.71506,
    "lon": -3.4431
  }
]

我想用code: ABAwrite:找到元素locations.map((key) => key.code).indexOf('ABA') > -1。true一切正常时的问题。在数据中找到这个后code，我需要显示name这个code（应该显示Aberdare）。告诉我怎么做？

下午好，我收到字符串格式的数据：'11:43' 和 '13:14' 帮助我正确编写脚本来计算这两个数字之间的差异，应该是 01:31。可以通过 Moment JS

数组的形式为：

tagsList: [
  0: "horm"
  1: "MENEGHELLO PAOLELLI ASSOCIATI"
  2: "Sideboards"
  3: "Lacquered Sideboards"
  4: "Contemporary Style Sideboards"
  5: "Sideboards with doors"
];

如何通过 JavaScript 将此数组转换为另一种形式？

tagsList: [
   {
     id: 0,
     text: "horm"
   }
   {
     id: 1,
     text: "MENEGHELLO PAOLELLI ASSOCIATI"
   }
   {
     id: 2,
     text: "Sideboards"
   }
   {
     id: 3,
     text: "Lacquered Sideboards"
   }
   {
     id: 4,
     text: "Contemporary Style Sideboards"
   }
   {
     id: 4,
     text: "Sideboards with doors"
   }
];

没有它array.map((item, index) => [{id: index, text: item}]) 就会[]产生错误。出现此响应：

下午好，有一个对象，其中还有 1 个包含数据的数组，它是这样的：

{
    name: "Material"
    tagsName: [0: "ikea", 1: "Street furniture", 2: "restoration hardware"]
}

告诉我如何正确解析 tagsName 以便可以分别提取每个标签？我的变体，但将所有标签拉到一行：

                {[this.state.funnelData].map((funnel, index) => {
                    return (
                        <div key={index}>
                            // name: "Material"
                            <span>{funnel.name}:</span>

                            //tagsName: [0: "ikea", 1: "Street furniture", 2: "restoration hardware"]
                            {[funnel.tagsName].map((value, ind) => {
                                return (
                                    <span key={ind}>{value}</span>
                                )
                            })}
                        </div>
                    )
                })}

现在结果是这样的（您需要将每个标签写在一个单独的标签中<span>）：