@tsdotnet/linq
    TypeScript icon, indicating that this package has built-in type declarations

    1.4.3 • Public • Published

    alt text tsdotnet / linq

    GitHub license 100% code coverage npm-publish npm version

    A familiar set of functions that operate on JavaScript iterables (ES2015+) in a similar way to .NET's LINQ does with enumerables.

    Docs

    tsdotnet.github.io/linq

    Source

    GitHub

    API

    linq<T> vs linqExtended<T>

    It is possible to do everything with just linq but linqExtended offers more functionality for those expecting to use common resolutions like .count, .first, .last, etc. Using linq will save you some bytes when your common use cases do not need resolutions.

    Iterating

    for(const e of linq(source).filter(a)) {
        // Iterate filtered results.
    }
    for(const e of linq(source)
        .filterWith(a, b, c)
        .transform(x)) {
        // Iterate filtered and then transformed results.
    }
    for(const e of linq(source)
        .where(predicate)
        .skip(10).take(10)
        .select(mapping)) {
        // Iterate filtered and mapped results.
    }

    Resolving

    const result = linq(source)
        .filterWith(a, b, c)
        .transform(x)
        .resolve(r);
    const firstElement = linqExtended(source)
        .where(predicate)
        .select(mapping)
        .first();

    Examples

    linq<T> with imported filters

    import linq from '@tsdotnet/linq/dist/linq';
    import range from '@tsdotnet/linq/dist/iterables/range';
    import where from '@tsdotnet/linq/dist/filters/where';
    import descending from '@tsdotnet/linq/dist/filters/descending';
    
    const source = range(1,100); // Iterable<number>
    const filtered = linq(source).filters(
         where(n => n%2===1),
         descending);
    
    for(const o of filtered) {
    
        // Emit all odd numbers in descending order.
        console.log(o);  // 99, 97, 95 ...
    }

    linq<T> with simplified imports

    import linq, {iterables, resolutions} from '@tsdotnet/linq';
    
    const source = iterables.range(1,100); // Iterable<number>
    const result = linq(source)
        .where(n => n%2===1) // odd numbers only
        .resolve(resolutions.sum); // 2500

    or

    import linq from '@tsdotnet/linq';
    import {range} from '@tsdotnet/linq/dist/iterables';
    import {sum} from '@tsdotnet/linq/dist/resolutions';
    
    const source = range(1, 100); // Iterable<number>
    const result = linqExtended(source)
        .where(n => n%2===1) // odd numbers only
        .resolve(sum); // 2500

    Concepts

    Iterables

    ES2015 enables full support for the iteration protocol.

    Iterables are a significant leap forward in operating with data sequences. Instead of loading entire sets into arrays or other collections, iterables allow for progressive iteration or synchronous streaming of data.

    tsdotnet/linq is designed around iterables but also optimized for arrays.

    Generators

    Iterable<T> helpers are provided as sources. Calling for an Iterator<T> should always start from the beginning and iterators are not shared. Same behavior as LINQ in .NET.

    empty, range, and repeat to name a few. See the docs for a full list.

    Filters

    linq(source).filter(a, b);
    linq(source).filter(a).filter(b);
    linq(source).filter(a).where(predicate);

    Any function that receives an Iterable<T> and returns an Iterable<T> is considered an IterableFilter<T>. A filter may result in a different order or ultimately a completely different set than the input but must be of the same type.

    There are an extensive set of filters. See the docs for a full list.

    Transforms

    linq(source).transform(x);
    linq(source).filter(a).transform(x);
    linq(source).where(predicate).transform(x);
    linq(source).where(predicate).select(mapping);

    Any function that receives an Iterable<T> and returns an Iterable<TResult> is considered an IterableValueTransform<T, TResult>.

    Any filter can be used as a transform, but not every transform can be used as a filter.

    notNull, rows, select, selectMany and groupBy to name a few. See the docs for a full list.

    Resolutions

    sequence = linq(source);
    
    sequence.resolve(r);
    sequence.transform(x).resolve(r);
    sequence.filter(a).transform(x).resolve(r);
    sequence.where(predicate).resolve(r);
    sequence.filterWith(a, b).transform(x).resolve(r);
    sequence = linqExtended(source);
    
    // Examples: 
    sequence.any(predicate);
    sequence.any(); // resolution predicates are optional.
    
    sequence.count(predicate);
    sequence.first(predicate);
    sequence.last(predicate);
    sequence.singleOrDefault(defaultValue, predicate);
    sequence.firstOrUndefined(predicate);
    sequence.lastOrNull(predicate);

    A resolution is a transform that takes an Iterable<T> and returns TResult. Unlike .filter(a) and .transform(x), .resolve(r) does not wrap the result in another Linq<T>.

    There are an extensive set of resolutions. See the docs for a full list.

    History

    Originally this was a port of linq.js converted to full TypeScript under the name TypeScript.NET Library and then TypeScript.NET-Core with full module support but potentially more than a user might want for a simple task. Instead of .NET style extensions, Enumerables incurred a heavy cost of all the extensions under one module.

    Modern web standards and practices demanded more granular access to classes and functions. Hence tsdotnet was born. tsdotnet/linq functionally allows for all the features of its predecessor as well as providing type-safety, and most of the features of LINQ in .NET while not forcing the consumer to download unneeded/undesired modules (extensions).

    Install

    npm i @tsdotnet/linq

    DownloadsWeekly Downloads

    85

    Version

    1.4.3

    License

    MIT

    Unpacked Size

    384 kB

    Total Files

    435

    Last publish

    Collaborators

    • electricessence