npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

@writetome51/public-array-replacer

v3.0.0

Published

A TypeScript/JavaScript class for replacing array items

Downloads

9

Readme

PublicArrayReplacer

An array-manipulating TypeScript/JavaScript class with methods that replace
items in the array.

Constructor

constructor(data? = [])  // 'data' is assigned to this.data .

You can reset the array by accessing the class .data property:

this.data = [1,2,3,4];

Properties

data : any[]  // the actual array

className: string (read-only)

Methods

at(index, newValue): this
    // Replaces item at index with newValue.  index can be negative or positive.

adjacentAt(startingIndex, newValues: any[]): this
    // Replaces adjacent items beginning at startingIndex with newValues.
    // Number of adjacent items that are replaced is same as number of items in 
    // newValues.  startingIndex can be negative or positive.
    
between(numItemsToKeepAtEachEnd, newValues: any[]): this
    // Replaces everything between numItemsToKeepAtEachEnd with newValues.
    // Example: if this.data is [1,2,3,4,5,6,7] , and you call .between(2, [9,10])
    // this.data will be [1,2,9,10,6,7] .  It preserves the first 2 items and 
    // the last 2.

NOTICE: For all the functions below, any parameter called value cannot be an object,
and any parameter called values cannot contain an object.
This does not include arrays. Arrays are OK, as long as they don't contain objects.

adjacentToValue(info: IAdjacentToValueInfo, newValues: any[]): this
    /**********
    Replaces adjacent items including, or near a particular value, with newValues.
    Only applies to the first instance of value found in array.
    The parameter 'info' is an object that looks like this:
    {
        value: any except object (the value to search for in the array),
        offset: integer (tells function where, in relation to value, to begin 
               selecting adjacent items to replace.  If offset is zero, the 
               selection will begin with value.)
       	howMany: integer greater than zero (it's how many adjacent items to replace)
    }
    Example:
	//  this.data is [1,2,3,4,5,6,7,8] .
	//  let newValues = [20,30,40];
	//  this.adjacentToValue({value: 5, offset: -1, howMany: 2},  newValues);
	//  this.data is now [1,2,3,20,30,40,6,7,8]
    **********/

    
firstOf(value, newValue): this
    // Replaces first instance of value with newValue.
    
firstOfEach(values: any[], newValues: any[]): this
    // First instance of values[i] found in array gets replaced with newValues[i].
    
allOf(value, newValue): this
    // Replaces all instances of value with newValue.
    
allOfEach(values: any[], newValues: any[]): this
    // All instances of values[i] found in array get replaced with newValues[i].
    
each(replacementFunction: (item, index?, array?) => any): this
    /**********
    Loops thru array, passing each item into replacementFunction.
    replacementFunction signature:  function(item, index?, array?): any
    replacementFunction must return the new value you want to give to that item 
    in the array.  Even if you don't want to replace that item, the function 
    must return something or that item will become undefined.
    Example:
    //  this.data is [1,2,3,4,5,6] .
    //  this.each((item) => {
    //      if (item === 2 || item === 6) return item * 3;
    //      else return item;
    //  });
    //  this.data is now [1,6,3,4,5,18]
    **********/
    
    
allWithOne(values: any[], newValue): this
    // Replaces all instances of each value in values with newValue.

The methods below are not important to know about in order to use this
class. They're inherited from BaseClass .

protected   _createGetterAndOrSetterForEach(
		propertyNames: string[],
		configuration: IGetterSetterConfiguration
	   ) : void
    /*********************
    Use this method when you have a bunch of properties that need getter and/or 
    setter functions that all do the same thing. You pass in an array of string 
    names of those properties, and the method attaches the same getter and/or 
    setter function to each property.
    IGetterSetterConfiguration is this object:
    {
        get_setterFunction?: (
             propertyName: string, index?: number, propertyNames?: string[]
        ) => Function,
	    // get_setterFunction takes the property name as first argument and 
	    // returns the setter function.  The setter function must take one 
	    // parameter and return void.
	    
        get_getterFunction?: (
             propertyName: string, index?: number, propertyNames?: string[]
        ) => Function
	    // get_getterFunction takes the property name as first argument and 
	    // returns the getter function.  The getter function must return something.
    }
    *********************/ 


protected   _returnThis_after(voidExpression: any) : this
    // voidExpression is executed, then function returns this.
    // Even if voidExpression returns something, the returned data isn't used.

protected   _errorIfPropertyHasNoValue(
                property: string, // can contain dot-notation, i.e., 'property.subproperty'
                propertyNameInError? = ''
            ) : void
    // If value of this[property] is undefined or null, it triggers fatal error:
    // `The property "${propertyNameInError}" has no value.`

Usage Examples

// changing the array content:
replace.data = [1,2,3,4,5,6,7];

// replacing 3 adjacent items starting at index 2:
replace.adjacentAt(2, [6, 8, 10]); // replace.data is now [1, 2, 6, 8, 10, 6, 7]

replace.allWithOne([1,2,6,7], '?'); 
// replace.data is now ['?', '?', '?', 8, 10, '?', '?']

replace.firstOf(10, {value:10, index: 4});
// replace.data is now ['?', '?', '?', 8, {value:10, index: 4}, '?', '?']

// Replacing all question marks with zeros, then returning Array:
let arr = replace.allOf('?', 0).data;
// arr is now [0, 0, 0, 8, {value:10, index: 4}, 0, 0]

Inheritance Chain

PublicArrayReplacer<--PublicArrayContainer<--BaseClass

Installation

npm i  @writetome51/public-array-replacer

Loading

// If using TypeScript:
import {PublicArrayReplacer} from '@writetome51/public-array-replacer';
// If using ES5 JavaScript:
var PublicArrayReplacer = 
        require('@writetome51/public-array-replacer').PublicArrayReplacer;

License

MIT