index({object}, {expr} [, {start} [, {ic}]]) *index()*
Find {expr} in {object} and return its index. See
- |filterof()| for using a lambda to select the item.
+ |indexof()| for using a lambda to select the item.
If {object} is a |List| return the lowest index where the item
has a value equal to {expr}. There is no automatic
< Can also be used as a |method|: >
GetObject()->index(what)
-indexof({object}, {expr} [, {opt}]) *indexof()*
- {object} must be a |List| or a |Blob|.
+indexof({object}, {expr} [, {opts}]) *indexof()*
+ Returns the index of an item in {object} where {expr} is
+ v:true. {object} must be a |List| or a |Blob|.
+
If {object} is a |List|, evaluate {expr} for each item in the
- List until the expression returns v:true and return the index
- of this item.
+ List until the expression is v:true and return the index of
+ this item.
If {object} is a |Blob| evaluate {expr} for each byte in the
- Blob until the expression returns v:true and return the index
- of this byte.
+ Blob until the expression is v:true and return the index of
+ this byte.
{expr} must be a |string| or |Funcref|.
The function must return |TRUE| if the item is found and the
search should stop.
- The optional argument {opt} is a Dict and supports the
+ The optional argument {opts} is a Dict and supports the
following items:
- start start evaluating {expr} at the item with index
- {start} (may be negative for an item relative
- to the end).
+ startidx start evaluating {expr} at the item with this
+ index; may be negative for an item relative to
+ the end
Returns -1 when {expr} evaluates to v:false for all the items.
Example: >
- :let l = [#{n: 10}, #{n: 20}, #{n: 30]]
- :let idx = indexof(l, "v:val.n == 20")
- :let idx = indexof(l, {i, v -> v.n == 30})
+ :let l = [#{n: 10}, #{n: 20}, #{n: 30}]
+ :echo indexof(l, "v:val.n == 20")
+ :echo indexof(l, {i, v -> v.n == 30})
+ :echo indexof(l, "v:val.n == 20", #{startidx: 1})
< Can also be used as a |method|: >
mylist->indexof(expr)
return error ? FALSE : found;
}
+/*
+ * Evaluate 'expr' for each byte in the Blob 'b' starting with the byte at
+ * 'startidx' and return the index of the byte where 'expr' is TRUE. Returns
+ * -1 if 'expr' doesn't evaluate to TRUE for any of the bytes.
+ */
+ static int
+indexof_blob(blob_T *b, long startidx, typval_T *expr)
+{
+ long idx = 0;
+
+ if (b == NULL)
+ return -1;
+
+ if (startidx < 0)
+ {
+ // negative index: index from the last byte
+ startidx = blob_len(b) + startidx;
+ if (startidx < 0)
+ startidx = 0;
+ }
+
+ set_vim_var_type(VV_KEY, VAR_NUMBER);
+ set_vim_var_type(VV_VAL, VAR_NUMBER);
+
+ for (idx = startidx; idx < blob_len(b); ++idx)
+ {
+ set_vim_var_nr(VV_KEY, idx);
+ set_vim_var_nr(VV_VAL, blob_get(b, idx));
+
+ if (indexof_eval_expr(expr))
+ return idx;
+ }
+
+ return -1;
+}
+
+/*
+ * Evaluate 'expr' for each item in the List 'l' starting with the item at
+ * 'startidx' and return the index of the item where 'expr' is TRUE. Returns
+ * -1 if 'expr' doesn't evaluate to TRUE for any of the items.
+ */
+ static int
+indexof_list(list_T *l, long startidx, typval_T *expr)
+{
+ listitem_T *item;
+ long idx = 0;
+
+ if (l == NULL)
+ return -1;
+
+ CHECK_LIST_MATERIALIZE(l);
+
+ if (startidx == 0)
+ item = l->lv_first;
+ else
+ {
+ // Start at specified item. Use the cached index that list_find()
+ // sets, so that a negative number also works.
+ item = list_find(l, startidx);
+ if (item != NULL)
+ idx = l->lv_u.mat.lv_idx;
+ }
+
+ set_vim_var_type(VV_KEY, VAR_NUMBER);
+
+ for ( ; item != NULL; item = item->li_next, ++idx)
+ {
+ set_vim_var_nr(VV_KEY, idx);
+ copy_tv(&item->li_tv, get_vim_var_tv(VV_VAL));
+
+ if (indexof_eval_expr(expr))
+ return idx;
+ }
+
+ return -1;
+}
+
/*
* "indexof()" function
*/
static void
f_indexof(typval_T *argvars, typval_T *rettv)
{
- list_T *l;
- listitem_T *item;
- blob_T *b;
long startidx = 0;
- long idx = 0;
typval_T save_val;
typval_T save_key;
int save_did_emsg;
did_emsg = FALSE;
if (argvars[0].v_type == VAR_BLOB)
- {
- b = argvars[0].vval.v_blob;
- if (b == NULL)
- goto theend;
- if (startidx < 0)
- {
- startidx = blob_len(b) + startidx;
- if (startidx < 0)
- startidx = 0;
- }
-
- set_vim_var_type(VV_KEY, VAR_NUMBER);
- set_vim_var_type(VV_VAL, VAR_NUMBER);
-
- for (idx = startidx; idx < blob_len(b); ++idx)
- {
- set_vim_var_nr(VV_KEY, idx);
- set_vim_var_nr(VV_VAL, blob_get(b, idx));
-
- if (indexof_eval_expr(&argvars[1]))
- {
- rettv->vval.v_number = idx;
- break;
- }
- }
- }
+ rettv->vval.v_number = indexof_blob(argvars[0].vval.v_blob, startidx,
+ &argvars[1]);
else
- {
- l = argvars[0].vval.v_list;
- if (l == NULL)
- goto theend;
-
- CHECK_LIST_MATERIALIZE(l);
-
- if (startidx == 0)
- item = l->lv_first;
- else
- {
- // Start at specified item. Use the cached index that list_find()
- // sets, so that a negative number also works.
- item = list_find(l, startidx);
- if (item != NULL)
- idx = l->lv_u.mat.lv_idx;
- }
-
- set_vim_var_type(VV_KEY, VAR_NUMBER);
+ rettv->vval.v_number = indexof_list(argvars[0].vval.v_list, startidx,
+ &argvars[1]);
- for ( ; item != NULL; item = item->li_next, ++idx)
- {
- set_vim_var_nr(VV_KEY, idx);
- copy_tv(&item->li_tv, get_vim_var_tv(VV_VAL));
-
- if (indexof_eval_expr(&argvars[1]))
- {
- rettv->vval.v_number = idx;
- break;
- }
- }
- }
-
-theend:
restore_vimvar(VV_KEY, &save_key);
restore_vimvar(VV_VAL, &save_val);
did_emsg |= save_did_emsg;
enddef
def Test_indexof()
- var l = [{color: 'red'}, {color: 'blue'}, {color: 'green'}]
- indexof(l, (i, v) => v.color == 'green')->assert_equal(2)
+ var l = [{color: 'red'}, {color: 'blue'}, {color: 'green'}, {color: 'blue'}]
+ indexof(l, (i, v) => v.color == 'blue')->assert_equal(1)
+ indexof(l, (i, v) => v.color == 'blue', {startidx: 1})->assert_equal(1)
+ indexof(l, (i, v) => v.color == 'blue', {startidx: 2})->assert_equal(3)
var b = 0zdeadbeef
indexof(b, "v:val == 0xef")->assert_equal(3)
+
+ def TestIdx(k: number, v: dict<any>): bool
+ return v.color == 'blue'
+ enddef
+ indexof(l, TestIdx)->assert_equal(1)
enddef
def Test_input()
projects / vim / commitdiff