Home

Index

How to use the upperFirst function from lodash

Find comprehensive JavaScript lodash.upperFirst code examples handpicked from public code repositorys.

lodash.upperFirst is a function in the lodash library that capitalizes the first character of a string.

lodash-contrib.commonjs.js

425
426
427
428
429
430
431
432
433
434
module.exports.unzipWith           = _.unzipWith;
module.exports.update              = _.update;
module.exports.updatePath          = _.updatePath;
module.exports.updateWith          = _.updateWith;
module.exports.upperCase           = _.upperCase;
module.exports.upperFirst          = _.upperFirst;
module.exports.values              = _.values;
module.exports.valuesAt            = _.valuesAt;
module.exports.valuesIn            = _.valuesIn;
module.exports.walk                = _.walk;

122

+ 92 other calls in file

prompts.js

GitHub: entando/generator-jhipster-entando

565
566
567
568
569
570
571
572
573
];
return this.prompt(prompts).then(props => {
  if (props.fieldAdd) {
    if (props.fieldIsEnum) {
      // eslint-disable-next-line no-param-reassign
      props.fieldType = _.upperFirst(props.fieldType);
      // eslint-disable-next-line no-param-reassign
      props.fieldValues = props.fieldValues.toUpperCase();
    }

How does lodash.upperFirst work?

In the lodash library, lodash.upperFirst is a function that takes a string as its argument and returns a new string with the first character capitalized. If the input string is empty or already has a capitalized first character, the function returns the input string unchanged. The lodash.upperFirst function works by converting the input string to an array of individual characters using the split method, capitalizing the first character using the toUpperCase method, and then joining the array back into a string using the join method. This can be accomplished using a combination of string methods and array methods, as shown in the following example: javascript Copy code {{{{{{{ function upperFirst(str) { if (typeof str !== 'string') { return ''; } return str.charAt(0).toUpperCase() + str.slice(1); } In this example, we define a function upperFirst that takes a string str as its argument. We first check if the input is actually a string using the typeof operator, and return an empty string if it's not. If it is a string, we capitalize the first character using the charAt method to retrieve the first character and the toUpperCase method to capitalize it. We then concatenate this capitalized first character with the rest of the string using the slice method to extract the remainder of the string starting from the second character. For example, if we call upperFirst('hello'), the function will return 'Hello', with the first character capitalized. If we call upperFirst('World'), the function will return 'World', since the first character is already capitalized. Overall, lodash.upperFirst is a simple but useful function in the lodash library that can help you manipulate and format strings in various ways.

liquid.js

GitHub: department-of-veterans-affairs/content-build

1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
formattedTitle = he.decode(formattedTitle);

// Ensure every word is capitalized.
formattedTitle = formattedTitle
  ?.split(' ')
  ?.map(word => _.upperFirst(word))
  ?.join(' ');

// Ensure every word is capitalized following a hyphen.
formattedTitle = formattedTitle

yaml2fhir-config-test.js

GitHub: AHRQ-CDS/CQL-Testing-Framework

111
112
113
114
115
116
117
118
119
120
  if (e.path === targetPath) {
    return true;
  }
  // Handle the case of choices (e.g., medicationCodeableConcept should match on path medication[x])
  if (e.path.endsWith('[x]')) {
    return e.type.some(t => e.path.replace(/\[x]$/, _.upperFirst(t.code)) === targetPath);
  }
  return false;
});
expect(element, `${sd.id} config refers to an invalid field: ${name}`).to.exist;

Ai Example

1
2
3
4
5
6
const _ = require("lodash");

const str = "hello world";
const capitalizedStr = _.upperFirst(str);

console.log(capitalizedStr);

In this example, we're first importing the lodash library and assigning it to the variable _. We then define a string str containing the value 'hello world'. We call _.upperFirst with the str argument to create a new string capitalizedStr with the first character capitalized. We then log capitalizedStr to the console, which will output 'Hello world'. Overall, lodash.upperFirst is a simple function that can help you easily capitalize the first character of a string, without having to manually manipulate the string using JavaScript's built-in string methods.

yaml2fhir.js

GitHub: AHRQ-CDS/CQL-Testing-Framework

101
102
103
104
105
106
107
108
109
110
let element = scopedElements.find(e => e.path === wantedPath);
if (element == null) {
  // This may be a choice property (e.g., valueQuantity for value[x] element).
  // Try to find a match on choices
  for (const choiceEl of scopedElements.filter(e => e.path.endsWith('[x]'))) {
    const typeMatch = choiceEl.type.find(t => choiceEl.path.replace(/\[x]$/, _.upperFirst(t.code)) === wantedPath);
    if (typeMatch) {
      // To ease the further processing, reduce the type array to only the one that matches
      element = _.cloneDeep(choiceEl);
      element.type = [typeMatch];

transformers.js

GitHub: uktrade/data-hub-frontend

39
40
41
42
43
44
45
46
47
48
49
}


function transformContactToOption({ id, first_name, last_name, job_title }) {
  return {
    value: id,
    label: upperFirst(
      filter([`${first_name} ${last_name}`, job_title]).join(', ')
    ),
  }
}

index.js

GitHub: Arxivar/PluginGenerator

331
332
333
334
335
336
337
338
339
340

var prompts = [{
  type: 'input',
  name: 'pluginname',
  message: 'Your plugin name',
  // default: _.upperFirst(_.replace(_(this.appname).toString().trim().toLowerCase().replace(/ /g, '-').replace(/([^a-zA-Z0-9\._-]+)/, ''), '.', '')), // Default to current folder name
  validate: function (pluginname) {
    if (_.isEmpty(_.trim(pluginname)) === true) {
      return 'Empty plugin name. Type a plugin name';
    }

+ 3 other calls in file

lodash.js

GitHub: mdmarufsarker/lodash

868
869
870
871
872
873
874
875
876
877
878
879
880
console.log(unescape); // => 'fred, barney, & pebbles'


const upperCase = _.upperCase('--foo-bar--');
console.log(upperCase); // => 'FOO BAR'


const upperFirst = _.upperFirst('fred');
console.log(upperFirst); // => 'Fred'


const words = _.words('fred, barney, & pebbles');
console.log(words); // => ['fred', 'barney', 'pebbles']

+ 15 other calls in file

index.js

GitHub: bitfinexcom/grenache-nodejs-link

264
265
266
267
268
269
270
271
272
273
}

this._monitorItv = setInterval(this.monitor.bind(this), this.conf.monitorTimeout)

_.each(['lookup'], fld => {
  const cfld = _.upperFirst(fld)

  const opts = {
    max: this.conf[`lruMaxSize${cfld}`],
    maxAge: this.conf[`lruMaxAge${cfld}`]

mount-models.js

GitHub: Akemona/strapi

28
29
30
31
32
33
34
35
36

function mountModel(model) {
  const definition = models[model];
  definition.orm = 'mongoose';
  definition.associations = [];
  definition.globalName = _.upperFirst(_.camelCase(definition.globalId));
  definition.loadedModel = {};

  const hasDraftAndPublish = contentTypesUtils.hasDraftAndPublish(definition);

+ 5 other calls in file

gtm.js

GitHub: harichu/SFRA

258
259
260
261
262
263
264
265
266
if (event && event.target && event.target.getAttribute("data-gtm")) {
    let node = event.target,
        data = GTMController.parseJSON(node.getAttribute("data-gtm"));
    if (data.eventTypes.indexOf("click") != -1) {

        data.event = "click" + lo.upperFirst(data.event);
        if (!data.action) {
            data.action = "click";
        }

+ 5 other calls in file

generate-entity.sh

GitHub: joktec/joktec-monorepo

27
28
29
30
31
32
33
34
35
36
const dir = `./src/entities/${entityPrefix}`;
if (!fs.existsSync(dir)) fs.mkdirSync(dir);
const filePath = `${dir}/${kebabCase(tableName)}.entity.ts`;

const columns = await inspector.columnInfo(tableName);
const className = upperFirst(camelCase(tableName + 'Entity'));
const classMapper = upperFirst(camelCase(tableName + 'Mapper'));

const lines = [
  `import { BaseEntity, MysqlMapper, linkTransform, toBool } from '@joktec/core';`,

+ 9 other calls in file

app.js

GitHub: iGreenapple/To-Do-List

135
136
137
138
139
140
141
142
143
144
145
  
});


// vytvoření custom stránky s to do Listem
app.get("/:customListName", (req,res) => {
  const customListName = _.upperFirst(req.params.customListName);
  // findOne() vrací object podle podmínky
  List.findOne({ name: customListName}).then((foundList) => { 
      // console.log(foundList) 
      if(!foundList) { // !foundList vrátí true pokud je undefined, neboli neexistuje v databázi

+ 14 other calls in file

loop-content-type-names.js

GitHub: umahendrap/odek-strapi-repo

24
25
26
27
28
29
30
31
32
33

// Continue to next iteration if routeInfo is undefined
if (!routeInfo) continue;

// Uppercase the first letter of the api name
const apiName = _.upperFirst(api.name);

// Create a unique name if the api name and contentType name don't match
const uniqueName =
  api.name === contentTypeName ? apiName : `${apiName} - ${_.upperFirst(contentTypeName)}`;

core-api.js

GitHub: mariaborjaarteaga/constructorAPI

225
226
227
228
229
230
231
232
233
234
};

// add locale arguments in the existing queries
if (isSingleType(contentType)) {
  const queryName = toSingular(modelName);
  const mutationSuffix = _.upperFirst(queryName);

  addGraphqlSchema({
    resolver: {
      Query: {

index.js

GitHub: AdmiralCloud/ac-logger

80
81
82
83
84
85
86
87
88
89
90
    const fill = _.get(params, 'headFill', '_')
    acLogger.info('%s', _.pad(' ' + _.toUpper(_.get(params, 'headline')) + ' ', headLength, fill))
  }


  const listing = (params) => {
    const field = _.upperFirst(_.get(params, 'field'))
    const value = _.get(params, 'value')
    const level = _.get(params, 'level', 'info')
//    const padField = _.get(meta, 'padField') ? (_.padEnd((_.get(meta, 'padField.field') + ': '), _.get(meta, 'padField.padLength', padLength)) + (_.get(meta, 'padField.value') === 200 ? '\x1b[32mSuccessful\x1b[0m' : _.get(meta, 'padField.value'))) : ''
    const message = _.padEnd((field + _.get(params, 'separator', '')), _.get(params, 'padLength', padLength)) + (value === 200 ? '\x1b[32mSuccessful\x1b[0m' : value)

Other functions in lodash

Sorted by popularity

lodash.get is the most popular function in lodash (7670 examples)

Other popular packages:

Home

About