标签: destructuring

我的airbnb 风格指南告诉我我应该在下面的任务中使用数组解构。

const splittedArr  = [1, 2, 3, 4, 5]
const result = splittedArr[1];

所以我使用 skipping values 像这样编写它，以获得第二个元素。

const splittedArr  = [1, 2, 3, 4, 5]
const [, result] = splittedArr;

const splittedArr  = [1, 2, 3, 4, 5]
const result = splittedArr[1];

但是例如当我有一个更高的指数要破坏时

const splittedArr  = [1, 2, 3, 4, 5]
const result = splittedArr[5];

这意味着我必须像这样写

const splittedArr  = [1, 2, 3, 4, 5]
const [,,,, result] = splittedArr;

const splittedArr  = …

我无法想象,有没有办法在erlang中输入_之类的东西,在destructuring-bind中使用"未使用的值"？

例如,我们有类似的东西:

(destructuring-bind ((_SNIPPET
                               (_TITLE . title)
                               (_DESCRIPTION . description)
                               _RESOURCE-ID (_VIDEO-ID . video-id)))) entry
                (declare (ignore 
                          _SNIPPET _TITLE _DESCRIPTION _RESOURCE-ID _VIDEO-ID))
                (list video-id title description)))

如果不为每个未使用的值放置特定变量,那就太棒了,写下这样的东西:

 (destructuring-bind ((_
                         (_ . title)
                         (_ . description)
                         (_ (_ . video-id)))) entry
                    (list video-id title description)))

有没有办法通过标准解构 - 绑定或任何其他标准宏来获得这种行为？或者我必须使用一些类似ML的模式匹配库,如果是这样 - 哪一个？

所以基本的desctucturing是好的,{a, b} = obj转化为a = obj.a; b = obj.b.

我的问题是我偶然遇到的一些奇怪的语法,我想知道是否有人可以指出我的规格,因为我找不到它:

({a, b} = obj).c

这样就做了两个a,b分配然后返回obj.c.对我来说,字节流解码器实际上非常有用,我可以写:

let width = ({bytes} = intDecode(bytes)).number;

我的问题是我没有在任何地方看到过这种语法,也不想依赖于错误实现或提案阶段的内容.

我知道我可以像这样"从前面"构建一个矢量:

(fn [[a b & rest]] (+ a b))

是否有(短)方式来访问最后两个元素？

(fn [[rest & a b]] (+ a b)) ;;Not legal

我目前的替代方案是

(fn [my-vector] (let [[a b] (take-last 2 my-vector)] (+ a b))) 

它试图找出是否有办法直接在函数参数中以更方便的方式做到这一点.

open System

let x = (1, 2)
let (p, q) = x
printfn "A %A" x
printfn "B %A %A" p q

let y = Some(1, 2)
try
  let None = y
  ()
with
  | ex -> printfn "C %A" ex
let Some(r, s) = y
printfn "D %A" y
// printfn "E %A %A" r s

• http://ideone.com/cS9bK0

当我取消注释最后一行时,编译器拒绝代码抱怨

/home/rRiy1O/prog.fs(16,19):错误FS0039:值或构造函数'r'未定义
/home/rRiy1O/prog.fs(16,21):错误FS0039:值或构造函数的' 没有定义

是不允许在解构中使用枚举let？

但首先,甚至当我注释掉最后一行...什么我在这里干什么？这是输出:

A (1, 2)
B 1 2
D Some (1, 2)

更新

为了记录,这是固定版本: …

写完这个答案之后,我受到启发,尝试使用以下方法指定Clojure的解构语言spec:

(require '[clojure.spec :as s])

(s/def ::binding (s/or :sym ::sym :assoc ::assoc :seq ::seq))

(s/def ::sym (s/and simple-symbol? (complement #{'&})))

顺序解构部分很容易用正则表达式进行规范(所以我在这里忽略它),但我陷入了联想解构.最基本的情况是从绑定表单到键表达式的映射:

(s/def ::mappings (s/map-of ::binding ::s/any :conform-keys true))

但Clojure也提供了几个特殊键:

(s/def ::as ::sym)
(s/def ::or ::mappings)

(s/def ::ident-vec (s/coll-of ident? :kind vector?))
(s/def ::keys ::ident-vec)
(s/def ::strs ::ident-vec)
(s/def ::syms ::ident-vec)

(s/def ::opts (s/keys :opt-un [::as ::or ::keys ::strs ::syms]))

如何::assoc为可以通过将符合::mappings的地图和符合的地图合并在一起创建的地图创建规范::opts？我知道有merge:

(s/def ::assoc (s/merge ::opts ::mappings))

但这不起作用,因为merge …

在es6中,如何使用解构来简化以下行？:

const array0 = someArray[0].data;
const array1 = someArray[1].data;
const array2 = someArray[2].data;

如果我有这两个对象

interface Input {
    one?: string;
    two?: string;
    c?: string
}

interface Data {
    one?: string;
    a?: string;
    b?: string;
    c?: string
}

目前我必须做类似的事情

const { one, two, ...restOfData } = input;
const data: Data = {...restOfData};

可以...restOfData直接打字吗？

我希望能够做到这一点

const { one, two, ...data } = input;
data.one = 'test' + one;
data.a = one;

销毁很酷，但是在销毁嵌套对象时我开始遇到严重的问题。我有以下代码：

const {
      credit: { amont },
    } = userProfile

这很危险，因为如果信用为空怎么办？整个应用中断了。我该如何预防？我知道一种方法是使用Typescript，但我宁愿不这样做。我开始怀疑对嵌套的破坏与使用点没有什么区别。

我有一个嵌套的对象可能有缺少的东西:

const unreliableObject = {
    id: 10,
    nestedObject: { // may be missing
        id: 11 // may also be missing
    }
}

现在说我想得到内心的id.我可以做以下事情

const { nestedObject: { id: key = -1 } = {key: -1} } = unreliableObject;
console.log(key);

有没有更好的办法？我没有定义{key: -1}两次的东西,也没有使用空对象(我们有lint规则),在这种情况下我仍然想要默认密钥.