install :  package 설치할때 사용하는 명령어, 가장 많이 쓰이고 대표적이다. 

npm install --save react-native-device-info

link

react-native link react-native-device-info

A modern JavaScript utility library delivering modularity, performance & extras. 

모듈성, 성능 및 추가 기능을 제공하는 최신 자바스크립트 유틸리티 라이브러리입니다.

다운로드 | Download

• Core build (~4kB gzipped)
• Full build (~24kB gzipped)
• CDN copies

Lodash is released under the MIT license & supports modern environments.Review the build differences & pick one that’s right for you.

Lodash는 MIT 라이선스에 따라 출시되었으며 최신 환경을 지원합니다. 빌드 차이점을 검토하고 적합한 것을 선택하십시오.

설치 방법 | Installation

브라우저에서 바로 사용하기 | In a browser:

<script src="lodash.js"></script>

NPM 사용하기 | Using npm:

$ npm i -g npm
$ npm i --save lodash

Node에서 사용하기 | In Node.js:

// Load the full build.
var _ = require('lodash');
// Load the core build.
var _ = require('lodash/core');
// Load the FP build for immutable auto-curried iteratee-first data-last methods.
var fp = require('lodash/fp');

// Load method categories.
var array = require('lodash/array');
var object = require('lodash/fp/object');

// Cherry-pick methods for smaller browserify/rollup/webpack bundles.
var at = require('lodash/at');
var curryN = require('lodash/fp/curryN');

노트 | Note:
Node.js < 6 REPL 에서 Lodash 사용을 위해 n_를 설치합니다.  

왜 Lodash 인가? | Why Lodash?

Lodash makes JavaScript easier by taking the hassle out of working with arrays, numbers, objects, strings, etc.Lodash’s modular methods are great for:

Lodash는 배열, 숫자, 객체, 문자열 등으로 작업하는 번거로움을 없애 JavaScript를 더 쉽게 만듭니다.Lodash의 모듈식 메서드는 다음과 같은 경우에 적합합니다.

• Iterating arrays, objects, & strings 배열, 객체 및 문자열 반복
• Manipulating & testing values 값 조작 및 테스트
• Creating composite functions 복합 함수 만들기

모듈 형식 | Module Formats

Lodash is available in a variety of builds & module formats.

Lodash는 다양한 빌드 및 모듈 형식으로 제공됩니다.

• lodash & per method packages
• lodash-es, babel-plugin-lodash, & lodash-webpack-plugin
• lodash/fp
• lodash-amd

보완 도구 | Complementary Tools

• futil-js is a set of functional utilities designed to complement lodash

futil-js는 lodash를 보완하도록 설계된 기능 유틸리티 세트입니다.

추가 자료 | Further Reading

• Contributing
• Release Notes
• Wiki (Changelog, Roadmap, etc.)

지원 | Support

Chrome 74-75, Firefox 66-67, IE 11, Edge 18, Safari 11-12, & Node.js 8-12에서 테스트 되었습니다. 

#제공 데이터 중 최신컨텐츠 우선으로 정렬하고, 정렬순번으로 오름차순으로 정렬하기

d.list.sort((a,b) => a.newYn > b.newYn ? -1 : (a.sortNum > b.sortNum ? 1:-1));

- 사용방법

[].sort(conditionFunction);

//1,2,3,8,9 오름차순
var arr = [2, 9, 8, 3, 1]
print(arr.sort()); 
 
//9,8,3,2,1 내림차순
//#1
var arr = [2, 9, 8, 3, 1];
console.log(arr.sort(function(a,b){
	return b-a;
})); 

//#2
var arr = [2, 9, 8, 3, 1];
console.log(arr.sort(orderByDesc)); 

function orderByDesc(a,b){
	return b-a;
} 

//#3
var arr = [2, 9, 8, 3, 1];
console.log(arr.sort((a,b)=> b-a));
 

http://lesscss.org/

@base: #f938ab;

.box-shadow(@style, @c) when (iscolor(@c)) {
  -webkit-box-shadow: @style @c;
  box-shadow:         @style @c;
}
.box-shadow(@style, @alpha: 50%) when (isnumber(@alpha)) {
  .box-shadow(@style, rgba(0, 0, 0, @alpha));
}
.box {
  color: saturate(@base, 5%);
  border-color: lighten(@base, 30%);
  div { .box-shadow(0 0 5px, 30%) }
}

.box {
  color: #fe33ac;
  border-color: #fdcdea;
}
.box div {
  -webkit-box-shadow: 0 0 5px rgba(0, 0, 0, 0.3);
  box-shadow: 0 0 5px rgba(0, 0, 0, 0.3);
}

$ npm install -g less

$ lessc styles.less

$ lessc styles.less > styles.css

var less = require('less');

less.render('.class { width: (1 + 1) }', function (e, css) {
  console.log(css);
});

.class {
  width: 2;
}

var parser = new(less.Parser);

parser.parse('.class { width: (1 + 1) }', function (err, tree) {
  if (err) {
    return console.error(err)
  }
  console.log(tree.toCSS());
});

var parser = new(less.Parser)({
  paths: ['.', './lib'], // Specify search paths for @import directives
  filename: 'style.less' // Specify a filename, for better error messages
});

parser.parse('.class { width: (1 + 1) }', function (e, tree) {
  tree.toCSS({
    // Minify CSS output
    compress: true
  });
});

java -jar js.jar -f less-rhino-<version>.js lessc-rhino-<version>.js styles.less styles.css

<link rel="stylesheet/less" type="text/css" href="styles.less" />

<script src="less.js" type="text/javascript"></script>

<!-- set options before less.js script -->
<script>
  less = {
    env: "development",
    async: false,
    fileAsync: false,
    poll: 1000,
    functions: {},
    dumpLineNumbers: "comments",
    relativeUrls: false,
    rootpath: ":/a.com/"
  };
</script>
<script src="less.js"></script>

bower install less

<script src="//cdnjs.cloudflare.com/ajax/libs/less.js/1.7.4/less.min.js"></script>

Compiling CSS and JavaScript

Bootstrap uses Grunt for its build system, with convenient methods for working with the framework. It's how we compile our code, run tests, and more.

bootstrap은 프레임워크 동작의 편리를 위해 Grunt 의 빌드시스템을 사용한다. 아래는, 우리가 어떻게 코드를 컴파일하고, 테스트와 기타 외작업을 어떻게 하는지 설명한다. 

Installing Grunt

To install Grunt, you must first download and install node.js (which includes npm). npm stands for node packaged modules and is a way to manage development dependencies through node.js.

Then, from the command line:

1. Install grunt-cli globally with npm install -g grunt-cli.
2. Navigate to the root /bootstrap/ directory, then run npm install. npm will look at the package.json file and automatically install the necessary local dependencies listed there.

When completed, you'll be able to run the various Grunt commands provided from the command line.

Grunt 설치하기

Available Grunt commands

grunt dist (Just compile CSS and JavaScript)

Regenerates the /dist/ directory with compiled and minified CSS and JavaScript files. As a Bootstrap user, this is normally the command you want.

grunt watch (Watch)

Watches the Less source files and automatically recompiles them to CSS whenever you save a change.

grunt test (Run tests)

Runs JSHint and runs the QUnit tests headlessly in PhantomJS.

grunt (Build absolutely everything and run tests)

Compiles and minifies CSS and JavaScript, builds the documentation website, runs the HTML5 validator against the docs, regenerates the Customizer assets, and more. Usually only necessary if you're hacking on Bootstrap itself.

Troubleshooting

Should you encounter problems with installing dependencies or running Grunt commands, first delete the /node_modules/ directory generated by npm. Then, rerun npm install.

http://gruntjs.com/

Getting started

Grunt and Grunt plugins are installed and managed via npm, the Node.js package manager. Grunt 0.4.x requires stable Node.js versions >= 0.8.0. Odd version numbers of Node.js are considered unstable development versions.

Before setting up Grunt ensure that your npm is up-to-date by running npm update -g npm (this might requiresudo on certain systems).

Installing the CLI

Using Grunt 0.3? Please see Grunt 0.3 Notes

In order to get started, you'll want to install Grunt's command line interface (CLI) globally. You may need to use sudo (for OSX, *nix, BSD etc) or run your command shell as Administrator (for Windows) to do this.

npm install -g grunt-cli

This will put the grunt command in your system path, allowing it to be run from any directory.

Note that installing grunt-cli does not install the Grunt task runner! The job of the Grunt CLI is simple: run the version of Grunt which has been installed next to a Gruntfile. This allows multiple versions of Grunt to be installed on the same machine simultaneously.

1. node.js 설치

2. cmd에서 명령어 입력

How the CLI works

Each time grunt is run, it looks for a locally installed Grunt using node's require() system. Because of this, you can run grunt from any subfolder in your project.

If a locally installed Grunt is found, the CLI loads the local installation of the Grunt library, applies the configuration from your Gruntfile, and executes any tasks you've requested for it to run. To really understand what is happening, read the code. 

Working with an existing Grunt project

Assuming that the Grunt CLI has been installed and that the project has already been configured with apackage.json and a Gruntfile, it's very easy to start working with Grunt:

1. Change to the project's root directory.
2. Install project dependencies with npm install.
3. Run Grunt with grunt.

That's really all there is to it. Installed Grunt tasks can be listed by running grunt --help but it's usually a good idea to start with the project's documentation.  

Preparing a new Grunt project

A typical setup will involve adding two files to your project: package.json and the Gruntfile.

package.json: This file is used by npm to store metadata for projects published as npm modules. You will list grunt and the Grunt plugins your project needs as devDependencies in this file.

Gruntfile: This file is named Gruntfile.js or Gruntfile.coffee and is used to configure or define tasks and load Grunt plugins. When this documentation mentions a Gruntfile it is talking about a file, which is either a Gruntfile.js or a Gruntfile.coffee.

package.json

The package.json file belongs in the root directory of your project, next to the Gruntfile, and should be committed with your project source. Running npm install in the same folder as a package.json file will install the correct version of each dependency listed therein.

There are a few ways to create a package.json file for your project:

• Most grunt-init templates will automatically create a project-specific package.json file.
• The npm init command will create a basic package.json file.
• Start with the example below, and expand as needed, following this specification.

{
  "name": "my-project-name",
  "version": "0.1.0",
  "devDependencies": {
    "grunt": "~0.4.5",
    "grunt-contrib-jshint": "~0.10.0",
    "grunt-contrib-nodeunit": "~0.4.1",
    "grunt-contrib-uglify": "~0.5.0"
  }
}

Installing Grunt and gruntplugins

The easiest way to add Grunt and gruntplugins to an existing package.json is with the commandnpm install <module> --save-dev. Not only will this install <module> locally, but it will automatically be added to the devDependencies section, using a tilde version range.

For example, this will install the latest version of Grunt in your project folder, adding it to your devDependencies:

npm install grunt --save-dev

The same can be done for gruntplugins and other node modules. Be sure to commit the updatedpackage.json file with your project when you're done!

프로젝트 파일의 root 지점으로 이동한 뒤, Grunt를 설치한다. 

그럼, node_modules 이라는 폴더가 생성되고, 그 안에 생성된 Grunt라는 폴더에는 다음과 같은 파일들이 함께 생성된다.

The Gruntfile

The Gruntfile.js or Gruntfile.coffee file is a valid JavaScript or CoffeeScript file that belongs in the root directory of your project, next to the package.json file, and should be committed with your project source.

A Gruntfile is comprised of the following parts:

• The "wrapper" function
• Project and task configuration
• Loading Grunt plugins and tasks
• Custom tasks

An example Gruntfile

In the following Gruntfile, project metadata is imported into the Grunt config from the project'spackage.json file and the grunt-contrib-uglify plugin's uglify task is configured to minify a source file and generate a banner comment dynamically using that metadata. When grunt is run on the command line, theuglify task will be run by default.

module.exports = function(grunt) {

  // Project configuration.
  grunt.initConfig({
    pkg: grunt.file.readJSON('package.json'),
    uglify: {
      options: {
        banner: '/*! <%= pkg.name %> <%= grunt.template.today("yyyy-mm-dd") %> */\n'
      },
      build: {
        src: 'src/<%= pkg.name %>.js',
        dest: 'build/<%= pkg.name %>.min.js'
      }
    }
  });

  // Load the plugin that provides the "uglify" task.
  grunt.loadNpmTasks('grunt-contrib-uglify');

  // Default task(s).
  grunt.registerTask('default', ['uglify']);

};

Now that you've seen the whole Gruntfile, let's look at its component parts.

The "wrapper" function

Every Gruntfile (and gruntplugin) uses this basic format, and all of your Grunt code must be specified inside this function:

module.exports = function(grunt) {
  // Do grunt-related things in here
};

Project and task configuration

Most Grunt tasks rely on configuration data defined in an object passed to the grunt.initConfig method.

In this example, grunt.file.readJSON('package.json') imports the JSON metadata stored in package.jsoninto the grunt config. Because <% %> template strings may reference any config properties, configuration data like filepaths and file lists may be specified this way to reduce repetition.

You may store any arbitrary data inside of the configuration object, and as long as it doesn't conflict with properties your tasks require, it will be otherwise ignored. Also, because this is JavaScript, you're not limited to JSON; you may use any valid JS here. You can even programmatically generate the configuration if necessary.

Like most tasks, the grunt-contrib-uglify plugin's uglify task expects its configuration to be specified in a property of the same name. Here, the banner option is specified, along with a single uglify target namedbuild that minifies a single source file to a single destination file.

// Project configuration.
grunt.initConfig({
  pkg: grunt.file.readJSON('package.json'),
  uglify: {
    options: {
      banner: '/*! <%= pkg.name %> <%= grunt.template.today("yyyy-mm-dd") %> */\n'
    },
    build: {
      src: 'src/<%= pkg.name %>.js',
      dest: 'build/<%= pkg.name %>.min.js'
    }
  }
});

Loading Grunt plugins and tasks

Many commonly used tasks like concatenation, minification and linting are available as grunt plugins. As long as a plugin is specified in package.json as a dependency, and has been installed via npm install, it may be enabled inside your Gruntfile with a simple command:

// Load the plugin that provides the "uglify" task.
grunt.loadNpmTasks('grunt-contrib-uglify');

Note: the grunt --help command will list all available tasks.

Custom tasks

You can configure Grunt to run one or more tasks by default by defining a default task. In the following example, running grunt at the command line without specifying a task will run the uglify task. This is functionally the same as explicitly running grunt uglify or even grunt default. Any number of tasks (with or without arguments) may be specified in the array.

// Default task(s).
grunt.registerTask('default', ['uglify']);

If your project requires tasks not provided by a Grunt plugin, you may define custom tasks right inside theGruntfile. For example, this Gruntfile defines a completely custom default task that doesn't even utilize task configuration:

module.exports = function(grunt) {

  // A very basic default task.
  grunt.registerTask('default', 'Log some stuff.', function() {
    grunt.log.write('Logging some stuff...').ok();
  });

};

Custom project-specific tasks don't need to be defined in the Gruntfile; they may be defined in external.js files and loaded via the grunt.loadTasks method.

Further Reading

• The Installing grunt guide has detailed information about installing specific, production or in-development, versions of Grunt and grunt-cli.
• The Configuring Tasks guide has an in-depth explanation on how to configure tasks, targets, options and files inside the Gruntfile, along with an explanation of templates, globbing patterns and importing external data.
• The Creating Tasks guide lists the differences between the types of Grunt tasks and shows a number of sample tasks and configurations.
• For more information about writing custom tasks or Grunt plugins, check out the developer documentation.

http://gruntjs.com/getting-started

Create a new li element  : $('<li>');

Select the h2 element nested insind the <div class="article"> ... </div> element. : $('.article h2');

1. Click on the first article.
2. Use the n keyboard shortcut to go to the next article.
3. Then use the o keyboard shortcut to open the article description.
4. If you have issues, check out the hint!
5. Click Save & Submit Code to get started!

Program skeleton

var main = function() {

};


$(document).ready(main);

Event Handlers
We can write a function that specifies what to do when an event occurs. This function is called anevent handler.

When a user clicks the .like-button element, the event handler toggles the "active" class. This alternates the button between the normal gray view and the selected blue view.

.click()

In the page to the right, click the three share buttons at the top of the page.

One common user event is the click event. A click event occurs when a user clicks on an HTML element.

The .click() method attaches an event handler to an HTML element so that it can respond to a click event.

$('.social li') selects each share button at the top of the web page.

The .click() method attaches an event handler to each button.

The event handler adds the CSS class .active, which changes the button's background-color to red. We use $(this) to refer to the HTML element that was clicked on. We can now operate on this element using .toggleClass().

Putting it all together, when you click on a share button at the top of the page, a click event is triggered by the browser.

When the click event occurs, the .click() method runs the event handler. In this code, the event handler changes the button color to red.

.keypress()

In the page to the right, click inside the page, and then press any letter or number key.

Another common user event is the keypress event. A keypress event occurs when a user types a key on the keyboard.

The .keypress() method attaches an event handler to an HTML element so that it can respond to a keypress event.

$(document) selects the whole web page.The .keypress() method attaches an event handler to document

When any keyboard key is pressed, the event handler toggles the dropdown menu.

Putting it all together, when you press any keyboard key, a keypress event is triggered by the browser.

When the keypress event occurs, the .keypress()method runs the event handler.

Here, the event handler toggles the dropdown menu. Putting it all together, when you press any keyboard key, a keypress event is triggered by the browser.

When the keypress event occurs, the .keypress()method runs the event handler.

Here, the event handler toggles the dropdown menu.

event

In the page to the right, click inside the page, and then press the m key.

Triggering a keypress event handler when any key is typed isn't particularly useful. For more control, we can use the event object.

The event object contains more information about an event, such as which mouse button was clicked or which key was pressed.

Comparisons

It's possible to compare variables using comparisons.

• > - Greater than

• < - Less than

• >= Greater than or equal to

• <= Less than or equal to

• === Equal to score1 === score2;

• !== Not equal to

Functions

A function is run by calling its name and giving it input values.

1. Click on the menu icon. The menu displays by pushing the page's body over to the right.
2. Then click on the X icon. The menu closes by pulling the body back to where it was.
3. Click Save & Submit Code to get started!

/*Inside the app.js file, use the keyword var and create a function called main.*/

var main = function(){
    
};

/*Use jQuery to run the main function once the web page has fully loaded.*/
$(document).ready(main);

1. In app.js, find the main function.
2. Inside the main function, use jQuery to select the class 'icon-menu'.  $('.icon-menu');
3. Small hint: jQuery is all about the dollars! And to select a class, use a period (ie. full stop).

1. Start with a $( ) to tell the computer we're using jQuery.
2. To use CSS to select the class 'icon-menu', we type in '.icon-menu'.

After $('.icon-menu'), add the .click()method.

1. Add a function inside the .click()method.
2. Select the 'menu' class and animate it.

3. Right now, the menu is 285px past the left edge of the screen. That's why it is not visible! Inside the animate method:

   a move it 0px to the left
   b. make this happen over 200 milliseconds.

4. We now want to push the rest of the page to the left 285px. Use jQuery to select the body HTML element, animate it, and move it left 285px over 200 milliseconds.

Make an Interactive Website

<div class="container">

  <div class="row">
    <div class="col-md-4">
      ...
    </div>

    <div class="col-md-4">
      ...
    </div>

    <div class="col-md-4">
      ...
    </div>

  </div>
</div>

<div class="row">
  <div class="col-md-4">
     <img src="http://goo.gl/0sX3jq" >
  </div>

  <div class="col-md-4">
    <div class="thumbnail">
      <img src="http://goo.gl/Av1pac" >
    </div>
    <div class="thumbnail">
      <img src="http://goo.gl/vw43v1">
    </div>
  </div>

  <div class="col-md-4">
    <div class="thumbnail">
      <img src="http://goo.gl/0Kd7UO" >
    </div>
  </div>

</div>

Navigation

Bootstrap's grid is made up of 12 equal-sized columns. Each piece of content is aligned to this grid by specifying the number of columns to span.

The code to the right uses Bootstrap's grid to create a layout with two pieces of content.

Here each piece of content spans six columns, so it uses the .col-md-6 class.

Both columns are wrapped in a .row class to create a horizontal group.

<ul class="nav nav-tabs">

<li><a href="#">Primary</a></li>

<li class="active"><a href="#">Social</a></li>

<li><a href="#">Promotions</a></li>

<li><a href="#">Updates</a></li>

</ul>

<ul class="nav nav-pills">

<li><a href="#">Primary</a></li>

<li class="active"><a href="#">Social</a></li>

<li><a href="#">Promotions</a></li>

<li><a href="#">Updates</a></li>

</ul>