小编ama*_*iny的帖子

我正在使用官方的反应导航来处理我的导航.我有一个主要的TabNavigator用于整个应用程序,有两个选项卡(称为HitchhikingMapNavigator和SettingsNavigator下面),每个选项卡都有一个嵌套的StackNavigator:

const HitchhikingMapNavigator = StackNavigator({
  hitchhikingMap: { screen: HitchhikingMapViewContainer },
  spotDetails: { screen: SpotDetailsViewContainer }
}, {
  navigationOptions: {
    header: {
      visible: false
    }
  }
});

const SettingsNavigator = StackNavigator({
  // some other routes
});

export default AppNavigator = TabNavigator({
  hitchhikingMap: { screen: HitchhikingMapNavigator },
  settings: { screen: SettingsNavigator }
}, {
  navigationOptions: {
    header: {
      visible: false,
    },
 },
});

正如你所看到的那样,即使在我看来,我也把标题的可见性放在了虚假的地方HitchhikingMapViewContainer:

class HitchhikingMapView extends React.Component {

  static navigationOptions = {
    title: …

让我留下来通过API调用加载myObject:

myObject = {
  fieldA: { details: 'OK', message: 'HELLO' },
  fieldB: { details: 'NOT_OK', message: 'ERROR' },
}

只有每个字段的详细信息和消息都可以更改.我希望这个对象在MobX存储中是可观察的(属性？将在下面定义).我有一个简单的React组件,它从商店中读取两个字段:

@observer
class App extends Component {
  store = new Store();

  componentWillMount() {
    this.store.load();
  }

  render() {
    return (
      <div>
        {this.store.fieldA && <p>{this.store.fieldA.details}</p>}
        {this.store.fieldB && <p>{this.store.fieldB.details}</p>}
      </div>
    );
  }
}

我阅读本页试图了解MobX的反应,但仍然没有明确的想法.具体来说,下面4家商店中哪一家可以使用,为什么？

1 /

class Store1 = {
  @observable myObject = {};

  @action setMyObject = object => {
    this.myObject = object;
  }

  load = () => someAsyncStuff().then(this.setMyObject);
}

2 / …

我有两个HashMap<&str, String>具有相同键的，我希望创建一个HashMap具有相同键的值组合在一起。我不想保留对前两个HashMaps 的引用，而是想将Strings移动到新的HashMap.

use std::collections::HashMap;

#[derive(Debug)]
struct Contact {
    phone: String,
    address: String,
}

fn main() {
    let mut phones: HashMap<&str, String> = HashMap::new();
    phones.insert("Daniel", "798-1364".into());
    phones.insert("Ashley", "645-7689".into());
    phones.insert("Katie", "435-8291".into());
    phones.insert("Robert", "956-1745".into());

    let mut addresses: HashMap<&str, String> = HashMap::new();
    addresses.insert("Daniel", "12 A Street".into());
    addresses.insert("Ashley", "12 B Street".into());
    addresses.insert("Katie", "12 C Street".into());
    addresses.insert("Robert", "12 D Street".into());

    let contacts: HashMap<&str, Contact> = phones.keys().fold(HashMap::new(), |mut acc, value| {
        acc.entry(value).or_insert(Contact {
            phone: *phones.get(value).unwrap(),
            address: …

我有两个服务:AuthService和MonBanquetService,AuthService依赖于MyService.以下是这两项服务的基本代码:

AuthService.ts:

import {Inject, Injectable} from 'angular2/core';
import {MonBanquetService} from '../monbanquet.service'

@Injectable()
export class AuthService {

    public username: string;

    constructor(protected _monBanquetService: MonBanquetService) {
        // do something()
    }

}

MonBanquetService.ts

import {Injectable, Component} from 'angular2/core';
import {Http, Headers, Response} from 'angular2/http';
import {Router} from 'angular2/router';

@Injectable()
export class MonBanquetService {

    constructor(public http: Http, private _router: Router) {
        console.log('MonBanquetServices created');
    }
}

我把这两个服务作为提供者放在boot.ts中:

bootstrap(AppComponent, [
    ROUTER_PROVIDERS,
    provide(LocationStrategy, {useClass: HashLocationStrategy}),
    HTTP_PROVIDERS,
    MonBanquetService,
    AuthService
]);

但是,当我运行应用程序时,我看到两个控制台日志'MonBanquetServices created'.我认为服务应该是单身,怎么会有两个实例呢？

谢谢.

在我monorepo,我有3个包package1,package2,package3,每个包中包含一个名为NPM脚本build.

但是,这些包没有链接在一起.即require(),任何链接到兄弟包的包中都没有.

从根文件夹,我运行lerna run build.它似乎build按字母顺序运行包.

有没有办法指定运行build这些包的命令的顺序？

--sort 不起作用,因为它们没有联系.

我有一个组件，它需要一个balance道具，这个平衡道具会随着时间的推移而改变。

然后我有一个 React Final Form 来发送交易，通常的字段是发送金额，接收者......在我的 . 中validate，我只是检查用户是否有足够的余额来发送交易。

但是，如果我的余额在用户输入内容时发生变化，则整个表单将重置。你将如何只重置表单状态的一部分？

请参阅此代码和框示例：https : //codesandbox.io/s/jn69xql7y3 ：

• 输入东西
• 等待 5 秒
• 再次看到表单状态为空白

是否可以根据参数返回函数的类型？

我看到了基于字符串文字类型参数的变量返回类型，但它使用了重载。在这里，我有 100 多种类型，所以我不想进行重载。

interface Registry {
    A: number,
    B: string,
    C: boolean,
    // ... 100 more types like this
}

function createType<T = Registry[typeof myType]>(myType: keyof Registry, value: any): T {
    // do some magic
    // ...
    return value;
}

const a = createType('A', 2); // Expected type: number. Actual: error above

游乐场链接

我的问题类似于来自 Typescript 中对象的键和值的类型，但有一个额外的嵌套层：

interface Outer {
  a: {
    b: number
  },
  c: {
    d: string
  }
}

我只想在此处检索所有值的联合类型number | string。

这是我的刺：

type Values<T extends Record<string, any>> = T[keyof T]; // From previous SO answer

type InnerValues<
  T extends Record<string, Record<string, any>>,
  K extends keyof T
> = T[K][keyof T[K]];

type All = Values<Outer>;
type In = InnerValues<Outer, keyof Outer>; // expected number|string

但我有一个错误说Outer没有索引类型。

游乐场链接。

如何使用Jest测试Observable？

我有一个每秒触发〜的Observable，我想测试一下第一个事件是否在异常超时之前正确触发。

const myObservable = timer(0, 1000); // Example here

it('should fire', () => {
  const event = myObservable.subscribe(data => {
    expect(data).toBe(0);
  });
});

该测试通过了，但是如果我替换为toBe('anything')，它也通过了，所以我想我做错了。

我尝试使用expect.assertions(1)，但它似乎仅适用于Promises。

我在扩展 Array 的自定义类方面遇到了一些麻烦。我基本上只是想在 Array 类上添加一些辅助方法，这里我添加了一个logMe方法，并为数组添加了前缀。

class AAA extends Array {
  _prefix: string;

  constructor(prefix: string, values: number[]) {
    console.log('AAA contructor', values);

    // Use hack
    // /sf/ask/2497113041/
    super();
    this.push(...values);

    this._prefix = prefix;
  }

  logMe() {
    console.log('The prefix is:', this._prefix);
    console.log('The values are:');
    this.map(x => x * 2).forEach(console.log);
  }
}

这是我的测试：

const a = new AAA('PREFIX-A', [1, 2, 3]);
a.logMe();

预期结果：

AAA contructor [ 1, 2, 3 ]
The prefix is: PREFIX-A
The values are: 1, 2, 3

实际结果：

AAA contructor …